507 files changed, 55054 insertions, 57497 deletions

diff --git a/.gdbinit b/.gdbinit
index b14b03da9f..dab03bbdb2 100644
--- a/.gdbinit
+++ b/.gdbinit
@@ -173,19 +173,20 @@ define ____printzv_contents
 	set $zvalue = $arg0
 	set $type = $zvalue->type
 
-	printf "(refcount=%d", $zvalue->refcount__gc
-	if $zvalue->is_ref__gc
-		printf ",is_ref"
-	end
-	printf ") "
+	if $type >= 7
+		printf "(refcount=%d", $zvalue->value.counted->refcount
+		printf ") "
+    else 
+		printf "(refcount=NaN)"
+    end
 	if $type == 0
-		printf "NULL"
+		printf "UNDEF"
 	end
 	if $type == 1
-		printf "long: %ld", $zvalue->value.lval
+        printf "NULL"
 	end
 	if $type == 2
-		printf "double: %f", $zvalue->value.dval
+		printf "indirect: %p", (void*)$zvalue->value.zv
 	end
 	if $type == 3
 		printf "bool: "
@@ -195,10 +196,20 @@ define ____printzv_contents
 			printf "false"
 		end
 	end
-	if $type == 4
-		printf "array(%d): ", $zvalue->value.ht->nNumOfElements
+    if $type == 4
+		printf "long: %ld", $zvalue->value.lval
+    end
+    if $type == 5
+        printf "double: %f", $zvalue->value.dval
+    end
+    if $type == 6
+    end
+    if $type == 7
+       printf "string: %s", $zvalue->value.str->val
+    end
+	if $type == 8 
+		printf "array: ", $zvalue->value.arr->ht.nNumUsed
 		if ! $arg1
-			printf "{\n"
 			set $ind = $ind + 1
 			____print_ht $zvalue->value.ht 1
 			set $ind = $ind - 1
@@ -207,32 +218,21 @@ define ____printzv_contents
 				printf "  "
 				set $i = $i - 1
 			end
-			printf "}"
 		end
 		set $type = 0
 	end
-	if $type == 5
+	if $type == 9
 		printf "object"
 		____executor_globals
 		set $handle = $zvalue->value.obj.handle
 		set $handlers = $zvalue->value.obj.handlers
-		if basic_functions_module.zts
-			set $zobj = zend_objects_get_address($zvalue, $tsrm_ls)
-		else
-			set $zobj = zend_objects_get_address($zvalue)
-		end
-		if $handlers->get_class_entry == &zend_std_object_get_class
-			set $cname = $zobj->ce.name
-		else
-			set $cname = "Unknown"
-		end
+        set $zobj = $zvalue->value.obj
+        set $cname = $zobj->ce->name->val
 		printf "(%s) #%d", $cname, $handle
 		if ! $arg1
 			if $handlers->get_properties == &zend_std_get_properties
 				set $ht = $zobj->properties
 				if $ht
-					printf "(%d): ", $ht->nNumOfElements
-					printf "{\n"
 					set $ind = $ind + 1
 					____print_ht $ht 1
 					set $ind = $ind - 1
@@ -241,7 +241,6 @@ define ____printzv_contents
 						printf "  "
 						set $i = $i - 1
 					end
-					printf "}"
 				else
 					echo "no properties found"
 				end
@@ -249,20 +248,31 @@ define ____printzv_contents
 		end
 		set $type = 0
 	end
-	if $type == 6
-		printf "string(%d): ", $zvalue->value.str.len
-		____print_str $zvalue->value.str.val $zvalue->value.str.len
+	if $type == 10
+		printf "resource: #%d", $zvalue->value.res->handle
 	end
-	if $type == 7
-		printf "resource: #%d", $zvalue->value.lval
+	if $type == 11
+		printf "reference: %p", $zvalue->value.ref
 	end
-	if $type == 8 
-		printf "constant"
+	if $type == 12
+		printf "const: %s", $zvalue->value.str->val
 	end
-	if $type == 9
+	if $type == 13
 		printf "const_array"
 	end
-	if $type > 9
+	if $type == 14
+		printf "const_ast"
+	end
+	if $type == 15
+		printf "callable"
+	end
+	if $type == 16
+		printf "string_offset"
+	end
+	if $type == 17
+		printf "pointer: %p", $zvalue->value.ptr
+	end
+	if $type > 17
 		printf "unknown type %d", $type
 	end
 	printf "\n"
@@ -274,10 +284,6 @@ define ____printzv
 
 	printf "[%p] ", $zvalue
 
-	if $zvalue == $eg.uninitialized_zval_ptr
-		printf "*uninitialized* "
-	end
-
 	set $zcontents = (zval*) $zvalue
 	if $arg1
 		____printzv_contents $zcontents $arg1
@@ -320,42 +326,92 @@ end
 
 define ____print_ht
 	set $ht = (HashTable*)$arg0
-	set $p = $ht->pListHead
-
-	while $p != 0
-		set $i = $ind
-		while $i > 0
-			printf "  "
-			set $i = $i - 1
-		end
-
-		if $p->nKeyLength > 0
-			____print_str $p->arKey $p->nKeyLength
-			printf " => "
-		else
-			printf "%d => ", $p->h
-		end
-		
-		if $arg1 == 0
-			printf "%p\n", (void*)$p->pData
-		end
-		if $arg1 == 1
-			set $zval = *(zval **)$p->pData
-			____printzv $zval 1
-		end
-		if $arg1 == 2
-			printf "%s\n", (char*)$p->pData
-		end
-
-		set $p = $p->pListNext
-	end
+	set $n = $ind
+	while $n > 0
+		printf "  "
+		set $n = $n - 1
+	end
+    if $ht->flags & 4
+        set $num = $ht->nNumUsed
+        set $i = 0
+    	printf "Packed(%d)[%p]: {\n", $ht->nNumOfElements, $ht
+		set $ind = $ind + 1
+        while $i < $num
+	    	set $p = (Bucket*)($ht->arData + $i)
+			set $n = $ind
+            if $p->val.type > 0
+				while $n > 0
+					printf "  "
+					set $n = $n - 1
+				end
+				printf "[%d]", $i
+				printf "%d => ", $p->h
+				if $arg1 == 0
+					printf "%p\n", (zval *)&$p->val
+				end
+				if $arg1 == 1
+					set $zval = (zval *)&$p->val
+					____printzv $zval 1
+				end
+				if $arg1 == 2
+					printf "%s\n", (char*)$p->val.value.ptr
+				end
+				if $arg1 == 3
+					set $func = (zend_function*)$p->val.value.ptr
+					printf "\"%s\"\n", $func->common.function_name->val
+				end
+			end
+			set $i = $i + 1
+        end
+		set $ind = $ind - 1
+		printf "}\n"
+    else
+		set $num = $ht->nTableSize
+        set $i = 0
+    	printf "Hash(%d)[%p]: {\n", $ht->nNumOfElements, $ht
+		set $ind = $ind + 1
+        while $i < $num
+	    	set $hash = $ht->arHash[$i]
+			if $hash != -1
+				set $p = (Bucket*)($ht->arData + $hash)
+				if $p->val.type > 0
+					set $n = $ind
+					while $n > 0
+						printf "  "
+						set $n = $n - 1
+					end
+					printf "[%d]", $i
+					if $p->key 
+						printf "%s => ", $p->key->val
+					else
+						printf "%d => ", $p->h
+					end
+					if $arg1 == 0
+						printf "%p\n", (zval *)&$p->val
+					end
+					if $arg1 == 1
+						set $zval = (zval *)&$p->val
+						____printzv $zval 1
+					end
+					if $arg1 == 2
+						printf "%s\n", (char*)$p->val.value.ptr
+					end
+					if $arg1 == 3
+						set $func = (zend_function*)$p->val.value.ptr
+						printf "\"%s\"\n", $func->common.function_name->val
+					end
+				end
+			end
+			set $i = $i + 1
+        end
+		set $ind = $ind - 1
+		printf "}\n"
+    end
 end
 
 define print_ht
-	set $ind = 1
-	printf "[%p] {\n", $arg0
+	set $ind = 0
 	____print_ht $arg0 1
-	printf "}\n"
 end
 
 document print_ht
@@ -363,10 +419,8 @@ document print_ht
 end
 
 define print_htptr
-	set $ind = 1
-	printf "[%p] {\n", $arg0
+	set $ind = 0
 	____print_ht $arg0 0
-	printf "}\n"
 end
 
 document print_htptr
@@ -374,46 +428,17 @@ document print_htptr
 end
 
 define print_htstr
-	set $ind = 1
-	printf "[%p] {\n", $arg0
+	set $ind = 0 
 	____print_ht $arg0 2
-	printf "}\n"
 end
 
 document print_htstr
 	dumps elements of HashTable made of strings
 end
 
-define ____print_ft
-	set $ht = $arg0
-	set $p = $ht->pListHead
-
-	while $p != 0
-		set $func = (zend_function*)$p->pData
-
-		set $i = $ind
-		while $i > 0
-			printf "  "
-			set $i = $i - 1
-		end
-
-		if $p->nKeyLength > 0
-			____print_str $p->arKey $p->nKeyLength
-			printf " => "
-		else
-			printf "%d => ", $p->h
-		end
-
-		printf "\"%s\"\n", $func->common.function_name
-		set $p = $p->pListNext
-	end
-end
-
 define print_ft
-	set $ind = 1
-	printf "[%p] {\n", $arg0
-	____print_ft $arg0
-	printf "}\n"
+	set $ind = 0
+	____print_ht $arg0 3
 end
 
 document print_ft
@@ -429,15 +454,15 @@ define ____print_inh_class
 			printf "final "
 		end
 	end
-	printf "class %s", $ce->name
+	printf "class %s", $ce->name->val
 	if $ce->parent != 0
-		printf " extends %s", $ce->parent->name
+		printf " extends %s", $ce->parent->name->val
 	end
 	if $ce->num_interfaces != 0
 		printf " implements"
 		set $tmp = 0
 		while $tmp < $ce->num_interfaces
-			printf " %s", $ce->interfaces[$tmp]->name
+			printf " %s", $ce->interfaces[$tmp]->name->val
 			set $tmp = $tmp + 1
 			if $tmp < $ce->num_interfaces
 				printf ","
@@ -449,10 +474,10 @@ end
 
 define ____print_inh_iface
 	set $ce = $arg0
-	printf "interface %s", $ce->name
+	printf "interface %s", $ce->name->val
 	if $ce->num_interfaces != 0
 		set $ce = $ce->interfaces[0]
-		printf " extends %s", $ce->name
+		printf " extends %s", $ce->name->val
 	else
 		set $ce = 0
 	end
@@ -618,9 +643,9 @@ define zmemcheck
 			if $p->magic == 0xfb8277dc
 				set $stat = "CACHED"
 			end
-			set $filename = strrchr($p->filename, '/')
+			set $filename = strrchr($p->filename->val, '/')
 			if !$filename
-				set $filename = $p->filename
+				set $filename = $p->filename->val
 			else
 				set $filename = $filename + 1
 			end
diff --git a/Zend/tests/bug24773.phpt b/Zend/tests/bug24773.phpt
index c0bb632f19..e8c2aa8395 100644
--- a/Zend/tests/bug24773.phpt
+++ b/Zend/tests/bug24773.phpt
@@ -6,4 +6,4 @@ Bug #24773 (unset() of integers treated as arrays causes a crash)
 	unset($array["lvl1"]["lvl2"]["b"]);
 ?>
 --EXPECTF--
-Fatal error: Cannot unset string offsets in %s on line %d
+Fatal error: Cannot use string offset as an array in %s on line %d
diff --git a/Zend/tests/bug64896.phpt b/Zend/tests/bug64896.phpt
index 3e955bbece..573fa1242d 100644
--- a/Zend/tests/bug64896.phpt
+++ b/Zend/tests/bug64896.phpt
@@ -1,7 +1,5 @@
 --TEST--
 Bug #64896 (Segfault with gc_collect_cycles using unserialize on certain objects)
---XFAIL--
-We can not fix this bug without a significant (performace slow down) change to gc
 --FILE--
 <?php
 $bar = NULL;
@@ -38,7 +36,7 @@ object(bad)#4 (1) {
 */
 ?>
 --EXPECTF--
-bject(bad)#%d (1) {
+object(bad)#%d (1) {
   ["_private":"bad":private]=>
   array(1) {
     [0]=>
diff --git a/Zend/tests/errmsg_040.phpt b/Zend/tests/errmsg_040.phpt
index c3a007f8c1..f3d0afcf0a 100644
--- a/Zend/tests/errmsg_040.phpt
+++ b/Zend/tests/errmsg_040.phpt
@@ -7,9 +7,7 @@ class test {
 	const TEST = array(1,2,3);
 }
 
-var_dump(test::TEST);
-
 echo "Done\n";
 ?>
 --EXPECTF--	
-Fatal error: Arrays are not allowed in constants at run-time in %s on line %d
+Fatal error: Arrays are not allowed in class constants in %s on line %d
diff --git a/Zend/tests/gc_014.phpt b/Zend/tests/gc_014.phpt
index 9f43fc8505..cd5a15e681 100644
--- a/Zend/tests/gc_014.phpt
+++ b/Zend/tests/gc_014.phpt
@@ -16,5 +16,5 @@ var_dump(gc_collect_cycles());
 echo "ok\n";
 ?>
 --EXPECT--
-int(10002)
+int(2)
 ok
diff --git a/Zend/tests/ns_059.phpt b/Zend/tests/ns_059.phpt
index 48da40b3f6..ea66037b43 100644
--- a/Zend/tests/ns_059.phpt
+++ b/Zend/tests/ns_059.phpt
@@ -3,9 +3,6 @@
 --FILE--
 <?php
 const C = array();
-
-var_dump(C);
-?>
 --EXPECTF--
-Fatal error: Arrays are not allowed in constants at run-time in %sns_059.php on line 4
+Fatal error: Arrays are not allowed as constants in %sns_059.php on line 2
 
diff --git a/Zend/zend.c b/Zend/zend.c
index acbbcbebc7..465446d663 100644
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -123,8 +123,6 @@ static HashTable *global_persistent_list = NULL;
 
 ZEND_API zend_utility_values zend_uv;
 
-ZEND_API zval zval_used_for_init; /* True global variable */
-
 /* version information */
 static char *zend_version_info;
 static uint zend_version_info_length;
@@ -133,11 +131,9 @@ static uint zend_version_info_length;
 
 static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent, zend_bool is_object TSRMLS_DC) /* {{{ */
 {
-	zval **tmp;
-	char *string_key;
-	HashPosition iterator;
+	zval *tmp;
+	zend_string *string_key;
 	ulong num_key;
-	uint str_len;
 	int i;
 
 	for (i = 0; i < indent; i++) {
@@ -145,46 +141,45 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent,
 	}
 	ZEND_PUTS_EX("(\n");
 	indent += PRINT_ZVAL_INDENT;
-	zend_hash_internal_pointer_reset_ex(ht, &iterator);
-	while (zend_hash_get_current_data_ex(ht, (void **) &tmp, &iterator) == SUCCESS) {
+	ZEND_HASH_FOREACH_KEY_VAL(ht, num_key, string_key, tmp) {
+		if (Z_TYPE_P(tmp) == IS_INDIRECT) {
+			tmp = Z_INDIRECT_P(tmp);
+			if (Z_TYPE_P(tmp) == IS_UNDEF) {
+				continue;
+			}
+		}
 		for (i = 0; i < indent; i++) {
 			ZEND_PUTS_EX(" ");
 		}
 		ZEND_PUTS_EX("[");
-		switch (zend_hash_get_current_key_ex(ht, &string_key, &str_len, &num_key, 0, &iterator)) {
-			case HASH_KEY_IS_STRING:
-				if (is_object) {
-					const char *prop_name, *class_name;
-					int prop_len;
-					int mangled = zend_unmangle_property_name_ex(string_key, str_len - 1, &class_name, &prop_name, &prop_len);
-
-					ZEND_WRITE_EX(prop_name, prop_len);
-					if (class_name && mangled == SUCCESS) {
-						if (class_name[0]=='*') {
-							ZEND_PUTS_EX(":protected");
-						} else {
-							ZEND_PUTS_EX(":");
-							ZEND_PUTS_EX(class_name);
-							ZEND_PUTS_EX(":private");
-						}
+		if (string_key) {
+			if (is_object) {
+				const char *prop_name, *class_name;
+				int prop_len;
+				int mangled = zend_unmangle_property_name_ex(string_key->val, string_key->len, &class_name, &prop_name, &prop_len);
+
+				ZEND_WRITE_EX(prop_name, prop_len);
+				if (class_name && mangled == SUCCESS) {
+					if (class_name[0]=='*') {
+						ZEND_PUTS_EX(":protected");
+					} else {
+						ZEND_PUTS_EX(":");
+						ZEND_PUTS_EX(class_name);
+						ZEND_PUTS_EX(":private");
 					}
-				} else {
-					ZEND_WRITE_EX(string_key, str_len-1);
 				}
-				break;
-			case HASH_KEY_IS_LONG:
-				{
-					char key[25];
-					snprintf(key, sizeof(key), "%ld", num_key);
-					ZEND_PUTS_EX(key);
-				}
-				break;
+			} else {
+				ZEND_WRITE_EX(string_key->val, string_key->len);
+			}
+		} else {
+			char key[25];
+			snprintf(key, sizeof(key), "%ld", num_key);
+			ZEND_PUTS_EX(key);
 		}
 		ZEND_PUTS_EX("] => ");
-		zend_print_zval_r_ex(write_func, *tmp, indent+PRINT_ZVAL_INDENT TSRMLS_CC);
+		zend_print_zval_r_ex(write_func, tmp, indent+PRINT_ZVAL_INDENT TSRMLS_CC);
 		ZEND_PUTS_EX("\n");
-		zend_hash_move_forward_ex(ht, &iterator);
-	}
+	} ZEND_HASH_FOREACH_END();
 	indent -= PRINT_ZVAL_INDENT;
 	for (i = 0; i < indent; i++) {
 		ZEND_PUTS_EX(" ");
@@ -195,62 +190,62 @@ static void print_hash(zend_write_func_t write_func, HashTable *ht, int indent,
 
 static void print_flat_hash(HashTable *ht TSRMLS_DC) /* {{{ */
 {
-	zval **tmp;
-	char *string_key;
-	HashPosition iterator;
+	zval *tmp;
+	zend_string *string_key;
 	ulong num_key;
-	uint str_len;
 	int i = 0;
 
-	zend_hash_internal_pointer_reset_ex(ht, &iterator);
-	while (zend_hash_get_current_data_ex(ht, (void **) &tmp, &iterator) == SUCCESS) {
+	ZEND_HASH_FOREACH_KEY_VAL(ht, num_key, string_key, tmp) {
 		if (i++ > 0) {
 			ZEND_PUTS(",");
 		}
 		ZEND_PUTS("[");
-		switch (zend_hash_get_current_key_ex(ht, &string_key, &str_len, &num_key, 0, &iterator)) {
-			case HASH_KEY_IS_STRING:
-				ZEND_PUTS(string_key);
-				break;
-			case HASH_KEY_IS_LONG:
-				zend_printf("%ld", num_key);
-				break;
+		if (string_key) {
+			ZEND_WRITE(string_key->val, string_key->len);
+		} else {
+			zend_printf("%ld", num_key);
 		}
 		ZEND_PUTS("] => ");
-		zend_print_flat_zval_r(*tmp TSRMLS_CC);
-		zend_hash_move_forward_ex(ht, &iterator);
-	}
+		zend_print_flat_zval_r(tmp TSRMLS_CC);
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
 ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy) /* {{{ */
 {
-	if (Z_TYPE_P(expr)==IS_STRING) {
+	if (Z_TYPE_P(expr) == IS_STRING) {
 		*use_copy = 0;
 		return;
 	}
+
+again:
 	switch (Z_TYPE_P(expr)) {
-		case IS_NULL:
-			Z_STRLEN_P(expr_copy) = 0;
-			Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
+		case IS_NULL: {
+			TSRMLS_FETCH();
+			ZVAL_EMPTY_STRING(expr_copy);
 			break;
+		}
 		case IS_BOOL:
 			if (Z_LVAL_P(expr)) {
-				Z_STRLEN_P(expr_copy) = 1;
-				Z_STRVAL_P(expr_copy) = estrndup("1", 1);
+				// TODO: use interned string ???
+				ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
 			} else {
-				Z_STRLEN_P(expr_copy) = 0;
-				Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
+				TSRMLS_FETCH();
+				ZVAL_EMPTY_STRING(expr_copy);
 			}
 			break;
-		case IS_RESOURCE:
-			Z_STRVAL_P(expr_copy) = (char *) emalloc(sizeof("Resource id #") - 1 + MAX_LENGTH_OF_LONG);
-			Z_STRLEN_P(expr_copy) = snprintf(Z_STRVAL_P(expr_copy), sizeof("Resource id #") - 1 + MAX_LENGTH_OF_LONG, "Resource id #%ld", Z_LVAL_P(expr));
+		case IS_RESOURCE: {
+				char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
+				int len;
+
+				len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(expr));
+				ZVAL_NEW_STR(expr_copy, STR_INIT(buf, len, 0));
+			}
 			break;
 		case IS_ARRAY:
 			zend_error(E_NOTICE, "Array to string conversion");
-			Z_STRLEN_P(expr_copy) = sizeof("Array") - 1;
-			Z_STRVAL_P(expr_copy) = estrndup("Array", Z_STRLEN_P(expr_copy));
+			// TODO: use interned string ???
+			ZVAL_NEW_STR(expr_copy, STR_INIT("Array", sizeof("Array") - 1, 0));
 			break;
 		case IS_OBJECT:
 			{
@@ -260,80 +255,75 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 					break;
 				}
 				if (Z_OBJ_HANDLER_P(expr, cast_object)) {
-					zval *val;
+					zval val;
 
-					ALLOC_ZVAL(val);
-					INIT_PZVAL_COPY(val, expr);
-					zval_copy_ctor(val);
-					if (Z_OBJ_HANDLER_P(expr, cast_object)(val, expr_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
+					ZVAL_DUP_DEREF(&val, expr);
+					if (Z_OBJ_HANDLER_P(expr, cast_object)(&val, expr_copy, IS_STRING TSRMLS_CC) == SUCCESS) {
 						zval_ptr_dtor(&val);
 						break;
 					}
 					zval_ptr_dtor(&val);
 				}
 				if (!Z_OBJ_HANDLER_P(expr, cast_object) && Z_OBJ_HANDLER_P(expr, get)) {
-					zval *z = Z_OBJ_HANDLER_P(expr, get)(expr TSRMLS_CC);
+					zval rv;
+					zval *z = Z_OBJ_HANDLER_P(expr, get)(expr, &rv TSRMLS_CC);
 
 					Z_ADDREF_P(z);
 					if (Z_TYPE_P(z) != IS_OBJECT) {
 						zend_make_printable_zval(z, expr_copy, use_copy);
 						if (*use_copy) {
-							zval_ptr_dtor(&z);
+							zval_ptr_dtor(z);
 						} else {
 							ZVAL_ZVAL(expr_copy, z, 0, 1);
 							*use_copy = 1;
 						}
 						return;
 					}
-					zval_ptr_dtor(&z);
+					zval_ptr_dtor(z);
 				}
-				zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(expr)->name);
-				Z_STRLEN_P(expr_copy) = 0;
-				Z_STRVAL_P(expr_copy) = STR_EMPTY_ALLOC();
+				zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(expr)->name->val);
+				ZVAL_EMPTY_STRING(expr_copy);
 			}
 			break;
 		case IS_DOUBLE:
-			*expr_copy = *expr;
-			zval_copy_ctor(expr_copy);
+			ZVAL_DUP(expr_copy, expr);
 			zend_locale_sprintf_double(expr_copy ZEND_FILE_LINE_CC);
 			break;
+		case IS_REFERENCE:
+			expr = Z_REFVAL_P(expr);
+			if (Z_TYPE_P(expr) == IS_STRING) {
+				ZVAL_STR(expr_copy, STR_COPY(Z_STR_P(expr)));
+				*use_copy = 1;
+				return;
+			}
+			goto again;
+			break;
 		default:
-			*expr_copy = *expr;
-			zval_copy_ctor(expr_copy);
+			ZVAL_DUP(expr_copy, expr);
 			convert_to_string(expr_copy);
 			break;
 	}
-	Z_TYPE_P(expr_copy) = IS_STRING;
 	*use_copy = 1;
 }
 /* }}} */
 
-ZEND_API int zend_print_zval(zval *expr, int indent) /* {{{ */
+ZEND_API int zend_print_zval(zval *expr, int indent TSRMLS_DC) /* {{{ */
 {
-	return zend_print_zval_ex(zend_write, expr, indent);
+	return zend_print_zval_ex(zend_write, expr, indent TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent) /* {{{ */
+ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC) /* {{{ */
 {
-	zval expr_copy;
-	int use_copy;
+	zend_string *str = zval_get_string(expr);
+	int len = str->len;
 
-	zend_make_printable_zval(expr, &expr_copy, &use_copy);
-	if (use_copy) {
-		expr = &expr_copy;
-	}
-	if (Z_STRLEN_P(expr) == 0) { /* optimize away empty strings */
-		if (use_copy) {
-			zval_dtor(expr);
-		}
-		return 0;
-	}
-	write_func(Z_STRVAL_P(expr), Z_STRLEN_P(expr));
-	if (use_copy) {
-		zval_dtor(expr);
+	if (len != 0) {
+		write_func(str->val, len);
 	}
-	return Z_STRLEN_P(expr);
+
+	STR_RELEASE(str);
+	return len;
 }
 /* }}} */
 
@@ -342,49 +332,48 @@ ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC) /* {{{ */
 	switch (Z_TYPE_P(expr)) {
 		case IS_ARRAY:
 			ZEND_PUTS("Array (");
-			if (++Z_ARRVAL_P(expr)->nApplyCount>1) {
+			if (++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {
 				ZEND_PUTS(" *RECURSION*");
-				Z_ARRVAL_P(expr)->nApplyCount--;
+				Z_ARRVAL_P(expr)->u.v.nApplyCount--;
 				return;
 			}
 			print_flat_hash(Z_ARRVAL_P(expr) TSRMLS_CC);
 			ZEND_PUTS(")");
-			Z_ARRVAL_P(expr)->nApplyCount--;
+			Z_ARRVAL_P(expr)->u.v.nApplyCount--;
 			break;
 		case IS_OBJECT:
 		{
 			HashTable *properties = NULL;
-			const char *class_name = NULL;
-			zend_uint clen;
+			zend_string *class_name = NULL;
 
 			if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
-				Z_OBJ_HANDLER_P(expr, get_class_name)(expr, &class_name, &clen, 0 TSRMLS_CC);
+				class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr), 0 TSRMLS_CC);
 			}
 			if (class_name) {
-				zend_printf("%s Object (", class_name);
+				zend_printf("%s Object (", class_name->val);
 			} else {
 				zend_printf("%s Object (", "Unknown Class");
 			}
 			if (class_name) {
-				efree((char*)class_name);
+				STR_RELEASE(class_name);
 			}
 			if (Z_OBJ_HANDLER_P(expr, get_properties)) {
 				properties = Z_OBJPROP_P(expr);
 			}
 			if (properties) {
-				if (++properties->nApplyCount>1) {
+				if (++properties->u.v.nApplyCount>1) {
 					ZEND_PUTS(" *RECURSION*");
-					properties->nApplyCount--;
+					properties->u.v.nApplyCount--;
 					return;
 				}
 				print_flat_hash(properties TSRMLS_CC);
-				properties->nApplyCount--;
+				properties->u.v.nApplyCount--;
 			}
 			ZEND_PUTS(")");
 			break;
 		}
 		default:
-			zend_print_variable(expr);
+			zend_print_variable(expr TSRMLS_CC);
 			break;
 	}
 }
@@ -398,54 +387,54 @@ ZEND_API void zend_print_zval_r(zval *expr, int indent TSRMLS_DC) /* {{{ */
 
 ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC) /* {{{ */
 {
+	ZVAL_DEREF(expr);
 	switch (Z_TYPE_P(expr)) {
 		case IS_ARRAY:
 			ZEND_PUTS_EX("Array\n");
-			if (++Z_ARRVAL_P(expr)->nApplyCount>1) {
+			if (++Z_ARRVAL_P(expr)->u.v.nApplyCount>1) {
 				ZEND_PUTS_EX(" *RECURSION*");
-				Z_ARRVAL_P(expr)->nApplyCount--;
+				Z_ARRVAL_P(expr)->u.v.nApplyCount--;
 				return;
 			}
 			print_hash(write_func, Z_ARRVAL_P(expr), indent, 0 TSRMLS_CC);
-			Z_ARRVAL_P(expr)->nApplyCount--;
+			Z_ARRVAL_P(expr)->u.v.nApplyCount--;
 			break;
 		case IS_OBJECT:
 			{
 				HashTable *properties;
-				const char *class_name = NULL;
-				zend_uint clen;
+				zend_string *class_name = NULL;
 				int is_temp;
 
 				if (Z_OBJ_HANDLER_P(expr, get_class_name)) {
-					Z_OBJ_HANDLER_P(expr, get_class_name)(expr, &class_name, &clen, 0 TSRMLS_CC);
+					class_name = Z_OBJ_HANDLER_P(expr, get_class_name)(Z_OBJ_P(expr), 0 TSRMLS_CC);
 				}
 				if (class_name) {
-					ZEND_PUTS_EX(class_name);
+					ZEND_PUTS_EX(class_name->val);
 				} else {
 					ZEND_PUTS_EX("Unknown Class");
 				}
 				ZEND_PUTS_EX(" Object\n");
 				if (class_name) {
-					efree((char*)class_name);
+					STR_RELEASE(class_name);
 				}
 				if ((properties = Z_OBJDEBUG_P(expr, is_temp)) == NULL) {
 					break;
 				}
-				if (++properties->nApplyCount>1) {
+				if (++properties->u.v.nApplyCount>1) {
 					ZEND_PUTS_EX(" *RECURSION*");
-					properties->nApplyCount--;
+					properties->u.v.nApplyCount--;
 					return;
 				}
 				print_hash(write_func, properties, indent, 1 TSRMLS_CC);
-				properties->nApplyCount--;
+				properties->u.v.nApplyCount--;
 				if (is_temp) {
 					zend_hash_destroy(properties);
-					efree(properties);
+					FREE_HASHTABLE(properties);
 				}
 				break;
 			}
 		default:
-			zend_print_zval_ex(write_func, expr, indent);
+			zend_print_zval_ex(write_func, expr, indent TSRMLS_CC);
 			break;
 	}
 }
@@ -501,20 +490,25 @@ static void zend_init_exception_op(TSRMLS_D) /* {{{ */
 /* }}} */
 
 #ifdef ZTS
-static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS_DC) /* {{{ */
+static void function_copy_ctor(zval *zv)
 {
-	zend_function tmp_func;
-	zend_class_entry *tmp_class;
+	zend_function *old_func = Z_FUNC_P(zv);
+	Z_FUNC_P(zv) = pemalloc(sizeof(zend_internal_function), 1);
+	memcpy(Z_FUNC_P(zv), old_func, sizeof(zend_internal_function));
+	function_add_ref(Z_FUNC_P(zv));
+}
 
+static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS_DC) /* {{{ */
+{
 	compiler_globals->compiled_filename = NULL;
 
 	compiler_globals->function_table = (HashTable *) malloc(sizeof(HashTable));
-	zend_hash_init_ex(compiler_globals->function_table, 100, NULL, ZEND_FUNCTION_DTOR, 1, 0);
-	zend_hash_copy(compiler_globals->function_table, global_function_table, NULL, &tmp_func, sizeof(zend_function));
+	zend_hash_init_ex(compiler_globals->function_table, 1024, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_hash_copy(compiler_globals->function_table, global_function_table, function_copy_ctor);
 
 	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_init_ex(compiler_globals->class_table, 64, NULL, ZEND_CLASS_DTOR, 1, 0);
+	zend_hash_copy(compiler_globals->class_table, global_class_table, zend_class_add_ref);
 
 	zend_set_default_compile_time_values(TSRMLS_C);
 
@@ -522,7 +516,7 @@ static void compiler_globals_ctor(zend_compiler_globals *compiler_globals TSRMLS
 
 	compiler_globals->auto_globals = (HashTable *) malloc(sizeof(HashTable));
 	zend_hash_init_ex(compiler_globals->auto_globals, 8, NULL, NULL, 1, 0);
-	zend_hash_copy(compiler_globals->auto_globals, global_auto_globals_table, NULL, NULL, sizeof(zend_auto_global) /* empty element */);
+	zend_hash_copy(compiler_globals->auto_globals, global_auto_globals_table, NULL /* empty element */);
 
 	compiler_globals->last_static_member = zend_hash_num_elements(compiler_globals->class_table);
 	if (compiler_globals->last_static_member) {
@@ -565,8 +559,8 @@ static void executor_globals_ctor(zend_executor_globals *executor_globals TSRMLS
 	zend_init_rsrc_plist(TSRMLS_C);
 	zend_init_exception_op(TSRMLS_C);
 	EG(lambda_count) = 0;
-	EG(user_error_handler) = NULL;
-	EG(user_exception_handler) = NULL;
+	ZVAL_UNDEF(&EG(user_error_handler));
+	ZVAL_UNDEF(&EG(user_exception_handler));
 	EG(in_execution) = 0;
 	EG(in_autoload) = NULL;
 	EG(current_execute_data) = NULL;
@@ -621,16 +615,28 @@ static void php_scanner_globals_ctor(zend_php_scanner_globals *scanner_globals_p
 
 void zend_init_opcodes_handlers(void);
 
-static zend_bool php_auto_globals_create_globals(const char *name, uint name_len TSRMLS_DC) /* {{{ */
+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;
-
-	ALLOC_ZVAL(globals);
-	Z_SET_REFCOUNT_P(globals, 1);
-	Z_SET_ISREF_P(globals);
-	Z_TYPE_P(globals) = IS_ARRAY;
-	Z_ARRVAL_P(globals) = &EG(symbol_table);
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &globals, sizeof(zval *), NULL);
+	zval globals;
+
+	ZVAL_ARR(&globals, &EG(symbol_table));
+	ZVAL_NEW_REF(&globals, &globals);
+	zend_hash_update(&EG(symbol_table).ht, name, &globals);
 	return 0;
 }
 /* }}} */
@@ -704,19 +710,14 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS
 	GLOBAL_AUTO_GLOBALS_TABLE = (HashTable *) malloc(sizeof(HashTable));
 	GLOBAL_CONSTANTS_TABLE = (HashTable *) malloc(sizeof(HashTable));
 
-	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_CONSTANTS_TABLE, 20, NULL, ZEND_CONSTANT_DTOR, 1, 0);
+	zend_hash_init_ex(GLOBAL_FUNCTION_TABLE, 1024, NULL, ZEND_FUNCTION_DTOR, 1, 0);
+	zend_hash_init_ex(GLOBAL_CLASS_TABLE, 64, NULL, ZEND_CLASS_DTOR, 1, 0);
+	zend_hash_init_ex(GLOBAL_AUTO_GLOBALS_TABLE, 8, NULL, auto_global_dtor, 1, 0);
+	zend_hash_init_ex(GLOBAL_CONSTANTS_TABLE, 128, 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, 32, NULL, module_destructor_zval, 1, 0);
 	zend_init_rsrc_list_dtors();
 
-	/* This zval can be used to initialize allocate zval's to an uninit'ed value */
-	Z_UNSET_ISREF(zval_used_for_init);
-	Z_SET_REFCOUNT(zval_used_for_init, 1);
-	Z_TYPE(zval_used_for_init) = IS_NULL;
-
 #ifdef ZTS
 	ts_allocate_id(&compiler_globals_id, sizeof(zend_compiler_globals), (ts_allocate_ctor) compiler_globals_ctor, (ts_allocate_dtor) compiler_globals_dtor);
 	ts_allocate_id(&executor_globals_id, sizeof(zend_executor_globals), (ts_allocate_ctor) executor_globals_ctor, (ts_allocate_dtor) executor_globals_dtor);
@@ -740,14 +741,14 @@ int zend_startup(zend_utility_functions *utility_functions, char **extensions TS
 	ini_scanner_globals_ctor(&ini_scanner_globals TSRMLS_CC);
 	php_scanner_globals_ctor(&language_scanner_globals TSRMLS_CC);
 	zend_set_default_compile_time_values(TSRMLS_C);
-	EG(user_error_handler) = NULL;
-	EG(user_exception_handler) = NULL;
+	ZVAL_UNDEF(&EG(user_error_handler));
+	ZVAL_UNDEF(&EG(user_exception_handler));
 #endif
 
 	zend_interned_strings_init(TSRMLS_C);
 	zend_startup_builtin_functions(TSRMLS_C);
 	zend_register_standard_constants(TSRMLS_C);
-	zend_register_auto_global("GLOBALS", sizeof("GLOBALS") - 1, 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);
@@ -1019,14 +1020,15 @@ ZEND_API int zend_get_configuration_directive(const char *name, uint name_length
 
 ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 {
+	char *str;
+	int len;
 	va_list args;
 	va_list usr_copy;
-	zval ***params;
-	zval *retval;
-	zval *z_error_type, *z_error_message, *z_error_filename, *z_error_lineno, *z_context;
+	zval params[5];
+	zval retval;
 	const char *error_filename;
-	uint error_lineno;
-	zval *orig_user_error_handler;
+	uint error_lineno = 0;
+	zval orig_user_error_handler;
 	zend_bool in_compilation;
 	zend_class_entry *saved_class_entry;
 	zend_stack bp_stack;
@@ -1083,7 +1085,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 		case E_USER_DEPRECATED:
 		case E_RECOVERABLE_ERROR:
 			if (zend_is_compiling(TSRMLS_C)) {
-				error_filename = zend_get_compiled_filename(TSRMLS_C);
+				error_filename = zend_get_compiled_filename(TSRMLS_C)->val;
 				error_lineno = zend_get_compiled_lineno(TSRMLS_C);
 			} else if (zend_is_executing(TSRMLS_C)) {
 				error_filename = zend_get_executed_filename(TSRMLS_C);
@@ -1116,7 +1118,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 	va_start(args, format);
 
 	/* if we don't have a user defined error handler */
-	if (!EG(user_error_handler)
+	if (Z_TYPE(EG(user_error_handler)) == IS_UNDEF
 		|| !(EG(user_error_handler_error_reporting) & type)
 		|| EG(error_handling) != EH_NORMAL) {
 		zend_error_cb(type, error_filename, error_lineno, format, args);
@@ -1132,12 +1134,6 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 			break;
 		default:
 			/* Handle the error in user space */
-			ALLOC_INIT_ZVAL(z_error_message);
-			ALLOC_INIT_ZVAL(z_error_type);
-			ALLOC_INIT_ZVAL(z_error_filename);
-			ALLOC_INIT_ZVAL(z_error_lineno);
-			ALLOC_INIT_ZVAL(z_context);
-
 /* va_copy() is __va_copy() in old gcc versions.
  * According to the autoconf manual, using
  * memcpy(&dst, &src, sizeof(va_list))
@@ -1150,21 +1146,22 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 # endif
 #endif
 			va_copy(usr_copy, args);
-			Z_STRLEN_P(z_error_message) = zend_vspprintf(&Z_STRVAL_P(z_error_message), 0, format, usr_copy);
+			len = zend_vspprintf(&str, 0, format, usr_copy);
+			ZVAL_NEW_STR(&params[1], STR_INIT(str, len, 0));
+			efree(str);
 #ifdef va_copy
 			va_end(usr_copy);
 #endif
-			Z_TYPE_P(z_error_message) = IS_STRING;
 
-			Z_LVAL_P(z_error_type) = type;
-			Z_TYPE_P(z_error_type) = IS_LONG;
+			ZVAL_LONG(&params[0], type);
 
 			if (error_filename) {
-				ZVAL_STRING(z_error_filename, error_filename, 1);
+				ZVAL_STRING(&params[2], error_filename);
+			} else {
+				ZVAL_NULL(&params[2]);
 			}
 
-			Z_LVAL_P(z_error_lineno) = error_lineno;
-			Z_TYPE_P(z_error_lineno) = IS_LONG;
+			ZVAL_LONG(&params[3], error_lineno);
 
 			if (!EG(active_symbol_table)) {
 				zend_rebuild_symbol_table(TSRMLS_C);
@@ -1172,22 +1169,14 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 
 			/* during shutdown the symbol table table can be still null */
 			if (!EG(active_symbol_table)) {
-				Z_TYPE_P(z_context) = IS_NULL;
+				ZVAL_NULL(&params[4]);
 			} else {
-				Z_ARRVAL_P(z_context) = EG(active_symbol_table);
-				Z_TYPE_P(z_context) = IS_ARRAY;
-				zval_copy_ctor(z_context);
+				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);
 			}
 
-			params = (zval ***) emalloc(sizeof(zval **)*5);
-			params[0] = &z_error_type;
-			params[1] = &z_error_message;
-			params[2] = &z_error_filename;
-			params[3] = &z_error_lineno;
-			params[4] = &z_context;
-
-			orig_user_error_handler = EG(user_error_handler);
-			EG(user_error_handler) = NULL;
+			ZVAL_COPY_VALUE(&orig_user_error_handler, &EG(user_error_handler));
+			ZVAL_UNDEF(&EG(user_error_handler));
 
 			/* User error handler may include() additinal PHP files.
 			 * If an error was generated during comilation PHP will compile
@@ -1209,9 +1198,10 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 				CG(in_compilation) = 0;
 			}
 
-			if (call_user_function_ex(CG(function_table), NULL, orig_user_error_handler, &retval, 5, params, 1, NULL TSRMLS_CC) == SUCCESS) {
-				if (retval) {
-					if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
+			ZVAL_UNDEF(&retval);
+			if (call_user_function_ex(CG(function_table), NULL, &orig_user_error_handler, &retval, 5, params, 1, NULL TSRMLS_CC) == SUCCESS) {
+				if (Z_TYPE(retval) != IS_UNDEF) {
+					if (Z_TYPE(retval) == IS_BOOL && Z_LVAL(retval) == 0) {
 						zend_error_cb(type, error_filename, error_lineno, format, args);
 					}
 					zval_ptr_dtor(&retval);
@@ -1234,19 +1224,17 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
 				CG(in_compilation) = 1;
 			}
 
-			if (!EG(user_error_handler)) {
-				EG(user_error_handler) = orig_user_error_handler;
-			}
-			else {
+			zval_ptr_dtor(&params[4]);
+			zval_ptr_dtor(&params[3]);
+			zval_ptr_dtor(&params[2]);
+			zval_ptr_dtor(&params[1]);
+			zval_ptr_dtor(&params[0]);
+
+			if (Z_TYPE(EG(user_error_handler)) == IS_UNDEF) {
+				ZVAL_COPY_VALUE(&EG(user_error_handler), &orig_user_error_handler);
+			} else {
 				zval_ptr_dtor(&orig_user_error_handler);
 			}
-
-			efree(params);
-			zval_ptr_dtor(&z_error_message);
-			zval_ptr_dtor(&z_error_type);
-			zval_ptr_dtor(&z_error_filename);
-			zval_ptr_dtor(&z_error_lineno);
-			zval_ptr_dtor(&z_context);
 			break;
 	}
 
@@ -1295,13 +1283,12 @@ ZEND_API void zend_output_debug_string(zend_bool trigger_break, const char *form
 }
 /* }}} */
 
-ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_count, ...) /* {{{ */
+ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval *retval, int file_count, ...) /* {{{ */
 {
 	va_list files;
 	int i;
 	zend_file_handle *file_handle;
 	zend_op_array *orig_op_array = EG(active_op_array);
-	zval **orig_retval_ptr_ptr = EG(return_value_ptr_ptr);
     long orig_interactive = CG(interactive);
 
 	va_start(files, file_count);
@@ -1321,31 +1308,29 @@ ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_co
        
 		EG(active_op_array) = zend_compile_file(file_handle, type TSRMLS_CC);
 		if (file_handle->opened_path) {
-			int dummy = 1;
-			zend_hash_add(&EG(included_files), file_handle->opened_path, strlen(file_handle->opened_path) + 1, (void *)&dummy, sizeof(int), NULL);
+			zend_hash_str_add_empty_element(&EG(included_files), file_handle->opened_path, strlen(file_handle->opened_path));
 		}
 		zend_destroy_file_handle(file_handle TSRMLS_CC);
 		if (EG(active_op_array)) {
-			EG(return_value_ptr_ptr) = retval ? retval : NULL;
-			zend_execute(EG(active_op_array) TSRMLS_CC);
+			zend_execute(EG(active_op_array), retval TSRMLS_CC);
 			zend_exception_restore(TSRMLS_C);
 			if (EG(exception)) {
-				if (EG(user_exception_handler)) {
-					zval *orig_user_exception_handler;
-					zval **params[1], *retval2, *old_exception;
+				if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) {
+					zval orig_user_exception_handler;
+					zval params[1], retval2;
+					zend_object *old_exception;
 					old_exception = EG(exception);
 					EG(exception) = NULL;
-					params[0] = &old_exception;
-					orig_user_exception_handler = EG(user_exception_handler);
-					if (call_user_function_ex(CG(function_table), NULL, orig_user_exception_handler, &retval2, 1, params, 1, NULL TSRMLS_CC) == SUCCESS) {
-						if (retval2 != NULL) {
-							zval_ptr_dtor(&retval2);
-						}
+					ZVAL_OBJ(&params[0], old_exception);
+					ZVAL_COPY_VALUE(&orig_user_exception_handler, &EG(user_exception_handler));
+					ZVAL_UNDEF(&retval2);
+					if (call_user_function_ex(CG(function_table), NULL, &orig_user_exception_handler, &retval2, 1, params, 1, NULL TSRMLS_CC) == SUCCESS) {
+						zval_ptr_dtor(&retval2);
 						if (EG(exception)) {
-							zval_ptr_dtor(&EG(exception));
+							OBJ_RELEASE(EG(exception));
 							EG(exception) = NULL;
 						}
-						zval_ptr_dtor(&old_exception);
+						OBJ_RELEASE(old_exception);
 					} else {
 						EG(exception) = old_exception;
 						zend_exception_error(EG(exception), E_ERROR TSRMLS_CC);
@@ -1359,14 +1344,12 @@ ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_co
 		} else if (type==ZEND_REQUIRE) {
 			va_end(files);
 			EG(active_op_array) = orig_op_array;
-			EG(return_value_ptr_ptr) = orig_retval_ptr_ptr;
             CG(interactive) = orig_interactive;
 			return FAILURE;
 		}
 	}
 	va_end(files);
 	EG(active_op_array) = orig_op_array;
-	EG(return_value_ptr_ptr) = orig_retval_ptr_ptr;
     CG(interactive) = orig_interactive;
 
 	return SUCCESS;
@@ -1382,7 +1365,7 @@ ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC)
 	char *compiled_string_description;
 
 	if (zend_is_compiling(TSRMLS_C)) {
-		cur_filename = zend_get_compiled_filename(TSRMLS_C);
+		cur_filename = zend_get_compiled_filename(TSRMLS_C)->val;
 		cur_lineno = zend_get_compiled_lineno(TSRMLS_C);
 	} else if (zend_is_executing(TSRMLS_C)) {
 		cur_filename = zend_get_executed_filename(TSRMLS_C);
@@ -1401,6 +1384,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 a226e11c60..cabe64a56a 100644
--- a/Zend/zend.h
+++ b/Zend/zend.h
@@ -66,6 +66,7 @@
 /* all HAVE_XXX test have to be after the include of zend_config above */
 
 #include <stdio.h>
+#include <assert.h>
 
 #ifdef HAVE_UNIX_H
 # include <unix.h>
@@ -252,7 +253,6 @@ char *alloca ();
 #include "zend_alloc.h"
 
 #include "zend_types.h"
-#include "zend_string.h"
 
 #ifdef HAVE_LIMITS_H
 # include <limits.h>
@@ -284,11 +284,15 @@ typedef enum {
 } ZEND_RESULT_CODE;
 
 #include "zend_hash.h"
-#include "zend_ts_hash.h"
 #include "zend_llist.h"
 
-#define INTERNAL_FUNCTION_PARAMETERS int ht, zval *return_value, zval **return_value_ptr, zval *this_ptr, int return_value_used TSRMLS_DC
-#define INTERNAL_FUNCTION_PARAM_PASSTHRU ht, return_value, return_value_ptr, this_ptr, return_value_used TSRMLS_CC
+#define INTERNAL_FUNCTION_PARAMETERS zend_uint param_count, zval *return_value TSRMLS_DC
+#define INTERNAL_FUNCTION_PARAM_PASSTHRU param_count, return_value TSRMLS_CC
+
+#define USED_RET() \
+	(!EG(current_execute_data) || \
+	 !EG(current_execute_data)->opline || \
+	 !(EG(current_execute_data)->opline->result_type & EXT_TYPE_UNUSED))
 
 #if defined(__GNUC__) && __GNUC__ >= 3 && !defined(__INTEL_COMPILER) && !defined(DARWIN) && !defined(__hpux) && !defined(_AIX) && !defined(__osf__)
 void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((noreturn));
@@ -296,75 +300,23 @@ void zend_error_noreturn(int type, const char *format, ...) __attribute__ ((nore
 #  define zend_error_noreturn zend_error
 #endif
 
-/*
- * zval
- */
-typedef struct _zend_class_entry zend_class_entry;
-
-typedef struct _zend_guard {
-	zend_bool in_get;
-	zend_bool in_set;
-	zend_bool in_unset;
-	zend_bool in_isset;
-	zend_bool dummy; /* sizeof(zend_guard) must not be equal to sizeof(void*) */
-} zend_guard;
-
-typedef struct _zend_object {
-	zend_class_entry *ce;
-	HashTable *properties;
-	zval **properties_table;
-	HashTable *guards; /* protects from __get/__set ... recursion */
-} zend_object;
-
 #include "zend_object_handlers.h"
 #include "zend_ast.h"
 
-typedef union _zvalue_value {
-	long lval;					/* long value */
-	double dval;				/* double value */
-	struct {
-		char *val;
-		int len;
-	} str;
-	HashTable *ht;				/* hash table value */
-	zend_object_value obj;
-	zend_ast *ast;
-} zvalue_value;
-
-struct _zval_struct {
-	/* Variable information */
-	zvalue_value value;		/* value */
-	zend_uint refcount__gc;
-	zend_uchar type;	/* active type */
-	zend_uchar is_ref__gc;
-};
-
-#define Z_REFCOUNT_PP(ppz)		Z_REFCOUNT_P(*(ppz))
-#define Z_SET_REFCOUNT_PP(ppz, rc)	Z_SET_REFCOUNT_P(*(ppz), rc)
-#define Z_ADDREF_PP(ppz)		Z_ADDREF_P(*(ppz))
-#define Z_DELREF_PP(ppz)		Z_DELREF_P(*(ppz))
-#define Z_ISREF_PP(ppz)			Z_ISREF_P(*(ppz))
-#define Z_SET_ISREF_PP(ppz)		Z_SET_ISREF_P(*(ppz))
-#define Z_UNSET_ISREF_PP(ppz)		Z_UNSET_ISREF_P(*(ppz))
-#define Z_SET_ISREF_TO_PP(ppz, isref)	Z_SET_ISREF_TO_P(*(ppz), isref)
+/* overloaded elements data types */
+#define OE_IS_ARRAY					(1<<0)
+#define OE_IS_OBJECT				(1<<1)
+#define OE_IS_METHOD				(1<<2)
 
-#define Z_REFCOUNT_P(pz)		zval_refcount_p(pz)
+#define Z_REFCOUNT_P(pz)			zval_refcount_p(pz)
 #define Z_SET_REFCOUNT_P(pz, rc)	zval_set_refcount_p(pz, rc)
-#define Z_ADDREF_P(pz)			zval_addref_p(pz)
-#define Z_DELREF_P(pz)			zval_delref_p(pz)
-#define Z_ISREF_P(pz)			zval_isref_p(pz)
-#define Z_SET_ISREF_P(pz)		zval_set_isref_p(pz)
-#define Z_UNSET_ISREF_P(pz)		zval_unset_isref_p(pz)
-#define Z_SET_ISREF_TO_P(pz, isref)	zval_set_isref_to_p(pz, isref)
-
-#define Z_REFCOUNT(z)			Z_REFCOUNT_P(&(z))
+#define Z_ADDREF_P(pz)				zval_addref_p(pz)
+#define Z_DELREF_P(pz)				zval_delref_p(pz)
+
+#define Z_REFCOUNT(z)				Z_REFCOUNT_P(&(z))
 #define Z_SET_REFCOUNT(z, rc)		Z_SET_REFCOUNT_P(&(z), rc)
-#define Z_ADDREF(z)			Z_ADDREF_P(&(z))
-#define Z_DELREF(z)			Z_DELREF_P(&(z))
-#define Z_ISREF(z)			Z_ISREF_P(&(z))
-#define Z_SET_ISREF(z)			Z_SET_ISREF_P(&(z))
-#define Z_UNSET_ISREF(z)		Z_UNSET_ISREF_P(&(z))
-#define Z_SET_ISREF_TO(z, isref)	Z_SET_ISREF_TO_P(&(z), isref)
+#define Z_ADDREF(z)					Z_ADDREF_P(&(z))
+#define Z_DELREF(z)					Z_DELREF_P(&(z))
 
 #if ZEND_DEBUG
 #define zend_always_inline inline
@@ -395,36 +347,56 @@ struct _zval_struct {
 # define UNEXPECTED(condition) (condition)
 #endif
 
-static zend_always_inline zend_uint zval_refcount_p(zval* pz) {
-	return pz->refcount__gc;
-}
+#ifndef XtOffsetOf
+# if defined(CRAY) || (defined(__ARMCC_VERSION) && !defined(LINUX))
+# ifdef __STDC__
+# define XtOffset(p_type, field) _Offsetof(p_type, field)
+# else
+# ifdef CRAY2
+# define XtOffset(p_type, field) \
+    (sizeof(int)*((unsigned int)&(((p_type)NULL)->field)))
 
-static zend_always_inline zend_uint zval_set_refcount_p(zval* pz, zend_uint rc) {
-	return pz->refcount__gc = rc;
-}
+# else /* !CRAY2 */
 
-static zend_always_inline zend_uint zval_addref_p(zval* pz) {
-	return ++pz->refcount__gc;
-}
+# define XtOffset(p_type, field) ((unsigned int)&(((p_type)NULL)->field))
 
-static zend_always_inline zend_uint zval_delref_p(zval* pz) {
-	return --pz->refcount__gc;
-}
+# endif /* !CRAY2 */
+# endif /* __STDC__ */
+# else /* ! (CRAY || __arm) */
+
+# define XtOffset(p_type, field) \
+    ((long) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
 
-static zend_always_inline zend_bool zval_isref_p(zval* pz) {
-	return pz->is_ref__gc;
+# endif /* !CRAY */
+
+# ifdef offsetof
+# define XtOffsetOf(s_type, field) offsetof(s_type, field)
+# else
+# define XtOffsetOf(s_type, field) XtOffset(s_type*, field)
+# endif
+
+#endif
+
+#include "zend_string.h"
+
+static zend_always_inline zend_uint zval_refcount_p(zval* pz) {
+	ZEND_ASSERT(Z_REFCOUNTED_P(pz));
+	return GC_REFCOUNT(Z_COUNTED_P(pz));
 }
 
-static zend_always_inline zend_bool zval_set_isref_p(zval* pz) {
-	return pz->is_ref__gc = 1;
+static zend_always_inline zend_uint zval_set_refcount_p(zval* pz, zend_uint rc) {
+	ZEND_ASSERT(Z_REFCOUNTED_P(pz));
+	return GC_REFCOUNT(Z_COUNTED_P(pz)) = rc;
 }
 
-static zend_always_inline zend_bool zval_unset_isref_p(zval* pz) {
-	return pz->is_ref__gc = 0;
+static zend_always_inline zend_uint zval_addref_p(zval* pz) {
+	ZEND_ASSERT(Z_REFCOUNTED_P(pz));
+	return ++GC_REFCOUNT(Z_COUNTED_P(pz));
 }
 
-static zend_always_inline zend_bool zval_set_isref_to_p(zval* pz, zend_bool isref) {
-	return pz->is_ref__gc = isref;
+static zend_always_inline zend_uint zval_delref_p(zval* pz) {
+	ZEND_ASSERT(Z_REFCOUNTED_P(pz));
+	return --GC_REFCOUNT(Z_COUNTED_P(pz));
 }
 
 /* excpt.h on Digital Unix 4.0 defines function_table */
@@ -442,20 +414,18 @@ typedef struct _zend_serialize_data zend_serialize_data;
 typedef struct _zend_unserialize_data zend_unserialize_data;
 
 struct _zend_trait_method_reference {
-	const char* method_name;
-	unsigned int mname_len;
-	
+	zend_string *method_name;	
 	zend_class_entry *ce;
-	
-	const char* class_name;
-	unsigned int cname_len;
+	zend_string *class_name;
 };
 typedef struct _zend_trait_method_reference	zend_trait_method_reference;
 
 struct _zend_trait_precedence {
-	zend_trait_method_reference *trait_method;
-	
-	zend_class_entry** exclude_from_classes;
+	zend_trait_method_reference *trait_method;	
+	union {
+		zend_class_entry  *ce;
+		zend_string       *class_name;
+	} *exclude_from_classes;
 };
 typedef struct _zend_trait_precedence zend_trait_precedence;
 
@@ -465,8 +435,7 @@ struct _zend_trait_alias {
 	/**
 	* name for method to be added
 	*/
-	const char* alias;
-	unsigned int alias_len;
+	zend_string *alias;
 	
 	/**
 	* modifiers to be set on trait method
@@ -477,17 +446,16 @@ typedef struct _zend_trait_alias zend_trait_alias;
 
 struct _zend_class_entry {
 	char type;
-	const char *name;
-	zend_uint name_length;
+	zend_string *name;
 	struct _zend_class_entry *parent;
 	int refcount;
 	zend_uint ce_flags;
 
 	HashTable function_table;
 	HashTable properties_info;
-	zval **default_properties_table;
-	zval **default_static_members_table;
-	zval **static_members_table;
+	zval *default_properties_table;
+	zval *default_static_members_table;
+	zval *static_members_table;
 	HashTable constants_table;
 	int default_properties_count;
 	int default_static_members_count;
@@ -509,14 +477,14 @@ struct _zend_class_entry {
 	zend_class_iterator_funcs iterator_funcs;
 
 	/* handlers */
-	zend_object_value (*create_object)(zend_class_entry *class_type TSRMLS_DC);
+	zend_object* (*create_object)(zend_class_entry *class_type TSRMLS_DC);
 	zend_object_iterator *(*get_iterator)(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 	int (*interface_gets_implemented)(zend_class_entry *iface, zend_class_entry *class_type TSRMLS_DC); /* a class implements this interface */
-	union _zend_function *(*get_static_method)(zend_class_entry *ce, char* method, int method_len TSRMLS_DC);
+	union _zend_function *(*get_static_method)(zend_class_entry *ce, zend_string* method TSRMLS_DC);
 
 	/* serializer callbacks */
 	int (*serialize)(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC);
-	int (*unserialize)(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
+	int (*unserialize)(zval *object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
 
 	zend_class_entry **interfaces;
 	zend_uint num_interfaces;
@@ -528,11 +496,10 @@ struct _zend_class_entry {
 
 	union {
 		struct {
-			const char *filename;
+			zend_string *filename;
 			zend_uint line_start;
 			zend_uint line_end;
-			const char *doc_comment;
-			zend_uint doc_comment_len;
+			zend_string *doc_comment;
 		} user;
 		struct {
 			const struct _zend_function_entry *builtin_functions;
@@ -578,33 +545,6 @@ typedef int (*zend_write_func_t)(const char *str, uint str_length);
 #define ZEND_TRUTH(x)		((x) ? 1 : 0)
 #define ZEND_LOG_XOR(a, b)		(ZEND_TRUTH(a) ^ ZEND_TRUTH(b))
 
-/* data types */
-/* All data types <= IS_BOOL have their constructor/destructors skipped */
-#define IS_NULL		0
-#define IS_LONG		1
-#define IS_DOUBLE	2
-#define IS_BOOL		3
-#define IS_ARRAY	4
-#define IS_OBJECT	5
-#define IS_STRING	6
-#define IS_RESOURCE	7
-#define IS_CONSTANT	8
-#define IS_CONSTANT_AST	9
-#define IS_CALLABLE	10
-
-#define IS_CONSTANT_TYPE_MASK		0x00f
-#define IS_CONSTANT_UNQUALIFIED		0x010
-#define IS_LEXICAL_VAR				0x020
-#define IS_LEXICAL_REF				0x040
-#define IS_CONSTANT_IN_NAMESPACE	0x100
-
-#define IS_CONSTANT_TYPE(type) (((type) & IS_CONSTANT_TYPE_MASK) >= IS_CONSTANT && ((type) & IS_CONSTANT_TYPE_MASK) <= IS_CONSTANT_AST)
-
-/* overloaded elements data types */
-#define OE_IS_ARRAY		(1<<0)
-#define OE_IS_OBJECT	(1<<1)
-#define OE_IS_METHOD	(1<<2)
-
 int zend_startup(zend_utility_functions *utility_functions, char **extensions TSRMLS_DC);
 void zend_shutdown(TSRMLS_D);
 void zend_register_standard_ini_entries(TSRMLS_D);
@@ -646,8 +586,8 @@ END_EXTERN_C()
 BEGIN_EXTERN_C()
 ZEND_API char *get_zend_version(void);
 ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_copy);
-ZEND_API int zend_print_zval(zval *expr, int indent);
-ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent);
+ZEND_API int zend_print_zval(zval *expr, int indent TSRMLS_DC);
+ZEND_API int zend_print_zval_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC);
 ZEND_API void zend_print_zval_r(zval *expr, int indent TSRMLS_DC);
 ZEND_API void zend_print_flat_zval_r(zval *expr TSRMLS_DC);
 ZEND_API void zend_print_zval_r_ex(zend_write_func_t write_func, zval *expr, int indent TSRMLS_DC);
@@ -671,22 +611,9 @@ 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 */
-
-#define STR_FREE(ptr) if (ptr) { str_efree(ptr); }
-#define STR_FREE_REL(ptr) if (ptr) { str_efree_rel(ptr); }
-
-#ifndef ZTS
-#define STR_EMPTY_ALLOC() CG(interned_empty_string)? CG(interned_empty_string) : estrndup("", sizeof("")-1)
-#else
-#define STR_EMPTY_ALLOC() estrndup("", sizeof("")-1)
-#endif
-
-#define STR_REALLOC(ptr, size) \
-			ptr = (char *) erealloc(ptr, size);
-
 /* output support */
 #define ZEND_WRITE(str, str_len)		zend_write((str), (str_len))
 #define ZEND_WRITE_EX(str, str_len)		write_func((str), (str_len))
@@ -747,101 +674,120 @@ END_EXTERN_C()
 #define ZMSG_LOG_SCRIPT_NAME			6L
 #define ZMSG_MEMORY_LEAKS_GRAND_TOTAL	7L
 
-#define INIT_PZVAL(z)		\
-	(z)->refcount__gc = 1;	\
-	(z)->is_ref__gc = 0;
-
-#define INIT_ZVAL(z) z = zval_used_for_init;
+#define ZVAL_COPY_VALUE(z, v)							\
+	do {												\
+		zval *_z1 = (z);								\
+		zval *_z2 = (v);								\
+		(_z1)->value = (_z2)->value;					\
+		Z_TYPE_INFO_P(_z1) = Z_TYPE_INFO_P(_z2);		\
+	} while (0)
 
-#define ALLOC_INIT_ZVAL(zp)						\
-	ALLOC_ZVAL(zp);		\
-	INIT_ZVAL(*zp);
+#define ZVAL_COPY(z, v)									\
+	do {												\
+		zval *__z1 = (z);								\
+		zval *__z2 = (v);								\
+		ZVAL_COPY_VALUE(__z1, __z2);					\
+		if (Z_OPT_REFCOUNTED_P(__z1)) {					\
+			Z_ADDREF_P(__z1);							\
+		}												\
+	} while (0)
 
-#define MAKE_STD_ZVAL(zv)				 \
-	ALLOC_ZVAL(zv); \
-	INIT_PZVAL(zv);
+#define ZVAL_DUP(z, v)									\
+	do {												\
+		zval *__z1 = (z);								\
+		zval *__z2 = (v);								\
+		ZVAL_COPY_VALUE(__z1, __z2);					\
+		zval_opt_copy_ctor(__z1);						\
+	} while (0)
 
-#define PZVAL_IS_REF(z)		Z_ISREF_P(z)
+#define ZVAL_DEREF(z) do {								\
+		if (UNEXPECTED(Z_ISREF_P(z))) {					\
+			(z) = Z_REFVAL_P(z);						\
+		}												\
+	} while (0)
 
-#define ZVAL_COPY_VALUE(z, v)					\
-	do {										\
-		(z)->value = (v)->value;				\
-		Z_TYPE_P(z) = Z_TYPE_P(v);				\
+#define ZVAL_DUP_DEREF(z, v)							\
+	do {												\
+		zval *__z1 = (z);								\
+		zval *__z2 = (v);								\
+		ZVAL_DEREF(__z2);								\
+		ZVAL_COPY_VALUE(__z1, __z2);					\
+		zval_opt_copy_ctor(__z1);						\
 	} while (0)
 
-#define INIT_PZVAL_COPY(z, v)					\
-	do {										\
-		ZVAL_COPY_VALUE(z, v);					\
-		Z_SET_REFCOUNT_P(z, 1);					\
-		Z_UNSET_ISREF_P(z);						\
+#define ZVAL_UNREF(z) do {								\
+		zval *_z = (z);									\
+		zend_reference *ref;							\
+		ZEND_ASSERT(Z_ISREF_P(_z));						\
+		ref = Z_REF_P(_z);								\
+		ZVAL_COPY_VALUE(_z, &ref->val);					\
+		efree(ref);										\
 	} while (0)
 
-#define SEPARATE_ZVAL(ppzv)						\
-	do {										\
-		if (Z_REFCOUNT_PP((ppzv)) > 1) {		\
-			zval *new_zv;						\
-			Z_DELREF_PP(ppzv);					\
-			ALLOC_ZVAL(new_zv);					\
-			INIT_PZVAL_COPY(new_zv, *(ppzv));	\
-			*(ppzv) = new_zv;					\
-			zval_copy_ctor(new_zv);				\
-		}										\
+#define SEPARATE_ZVAL(zv) do {							\
+		zval *_zv = (zv);								\
+		if (Z_REFCOUNTED_P(_zv)) {						\
+			if (Z_REFCOUNT_P(_zv) > 1) {				\
+				if (Z_ISREF_P(_zv)) {					\
+					Z_DELREF_P(_zv);					\
+					ZVAL_DUP(_zv, Z_REFVAL_P(_zv));		\
+				} else if (Z_COPYABLE_P(_zv)) {			\
+					Z_DELREF_P(_zv);					\
+					zval_copy_ctor_func(_zv);			\
+				}										\
+			}											\
+		}												\
 	} while (0)
 
-#define SEPARATE_ZVAL_IF_NOT_REF(ppzv)		\
-	if (!PZVAL_IS_REF(*ppzv)) {				\
-		SEPARATE_ZVAL(ppzv);				\
-	}
+#define SEPARATE_ZVAL_IF_NOT_REF(zv) do {				\
+		zval *_zv = (zv);								\
+		if (!Z_ISREF_P(_zv) &&							\
+		    Z_COPYABLE_P(_zv) &&						\
+		    Z_REFCOUNT_P(_zv) > 1) {					\
+			Z_DELREF_P(_zv);							\
+			zval_copy_ctor_func(_zv);					\
+		}      											\
+	} while (0)
 
-#define SEPARATE_ZVAL_TO_MAKE_IS_REF(ppzv)	\
-	if (!PZVAL_IS_REF(*ppzv)) {				\
-		SEPARATE_ZVAL(ppzv);				\
-		Z_SET_ISREF_PP((ppzv));				\
-	}
+#define SEPARATE_ZVAL_IF_REF(zv) do {					\
+		zval *__zv = (zv);								\
+		if (Z_ISREF_P(__zv)) {							\
+			if (Z_REFCOUNT_P(__zv) == 1) {				\
+				ZVAL_UNREF(__zv);						\
+			} else {									\
+				Z_DELREF_P(__zv);						\
+				ZVAL_DUP(__zv, Z_REFVAL_P(__zv));		\
+			}											\
+		}												\
+	} while (0)
 
-#define COPY_PZVAL_TO_ZVAL(zv, pzv)			\
-	(zv) = *(pzv);							\
-	if (Z_REFCOUNT_P(pzv)>1) {				\
-		zval_copy_ctor(&(zv));				\
-		Z_DELREF_P((pzv));					\
-	} else {								\
-		FREE_ZVAL(pzv);						\
-	}										\
-	INIT_PZVAL(&(zv));
-	
-#define MAKE_COPY_ZVAL(ppzv, pzv) 	\
-	INIT_PZVAL_COPY(pzv, *(ppzv));	\
-	zval_copy_ctor((pzv));
-
-#define REPLACE_ZVAL_VALUE(ppzv_dest, pzv_src, copy) {	\
-	int is_ref, refcount;						\
-												\
-	SEPARATE_ZVAL_IF_NOT_REF(ppzv_dest);		\
-	is_ref = Z_ISREF_PP(ppzv_dest);				\
-	refcount = Z_REFCOUNT_PP(ppzv_dest);		\
-	zval_dtor(*ppzv_dest);						\
-	ZVAL_COPY_VALUE(*ppzv_dest, pzv_src);		\
-	if (copy) {                                 \
-		zval_copy_ctor(*ppzv_dest);				\
-    }		                                    \
-	Z_SET_ISREF_TO_PP(ppzv_dest, is_ref);		\
-	Z_SET_REFCOUNT_PP(ppzv_dest, refcount);		\
-}
+#define SEPARATE_ZVAL_TO_MAKE_IS_REF(zv) do {			\
+		zval *__zv = (zv);								\
+		if (!Z_ISREF_P(__zv)) {							\
+		    if (!Z_COPYABLE_P(__zv) ||					\
+			    Z_REFCOUNT_P(__zv) == 1) {				\
+				ZVAL_NEW_REF(__zv, __zv);				\
+			} else {									\
+				Z_DELREF_P(__zv);						\
+				ZVAL_NEW_REF(__zv, __zv);				\
+				zval_copy_ctor_func(Z_REFVAL_P(__zv));	\
+			}											\
+		}												\
+	} while (0)
 
-#define SEPARATE_ARG_IF_REF(varptr) \
-	if (PZVAL_IS_REF(varptr)) { \
-		zval *original_var = varptr; \
-		ALLOC_ZVAL(varptr); \
-		INIT_PZVAL_COPY(varptr, original_var); \
-		zval_copy_ctor(varptr); \
-	} else { \
-		Z_ADDREF_P(varptr); \
-	}
+#define SEPARATE_ARG_IF_REF(varptr) do { 				\
+		zval *_varptr = (varptr);						\
+		if (Z_ISREF_P(_varptr)) { 						\
+			zval tmp;									\
+			ZVAL_DUP(&tmp, Z_REFVAL_P(_varptr));		\
+			varptr = &tmp;								\
+		} else if (Z_REFCOUNTED_P(_varptr)) { 			\
+			Z_ADDREF_P(_varptr); 						\
+		}												\
+	} while (0)
 
 #define READY_TO_DESTROY(zv) \
-	(Z_REFCOUNT_P(zv) == 1 && \
-	 (Z_TYPE_P(zv) != IS_OBJECT || \
-	  zend_objects_store_get_refcount(zv TSRMLS_CC) == 1))
+	(Z_REFCOUNTED_P(zv) && Z_REFCOUNT_P(zv) == 1)
 
 #define ZEND_MAX_RESERVED_RESOURCES	4
 
@@ -858,7 +804,7 @@ typedef enum {
 typedef struct {
 	zend_error_handling_t  handling;
 	zend_class_entry       *exception;
-	zval                   *user_handler;
+	zval                   user_handler;
 } zend_error_handling;
 
 ZEND_API void zend_save_error_handling(zend_error_handling *current TSRMLS_DC);
diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 2d845d357e..60ef092bb1 100644
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -44,14 +44,14 @@ static zend_class_entry  **class_cleanup_handlers;
 /* this function doesn't check for too many parameters */
 ZEND_API int zend_get_parameters(int ht, int param_count, ...) /* {{{ */
 {
-	void **p;
+	zval *p;
 	int arg_count;
 	va_list ptr;
 	zval **param, *param_ptr;
 	TSRMLS_FETCH();
 
 	p = zend_vm_stack_top(TSRMLS_C) - 1;
-	arg_count = (int)(zend_uintptr_t) *p;
+	arg_count = Z_LVAL_P(p);
 
 	if (param_count>arg_count) {
 		return FAILURE;
@@ -61,17 +61,13 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...) /* {{{ */
 
 	while (param_count-->0) {
 		param = va_arg(ptr, zval **);
-		param_ptr = *(p-arg_count);
-		if (!PZVAL_IS_REF(param_ptr) && Z_REFCOUNT_P(param_ptr) > 1) {
-			zval *new_tmp;
-
-			ALLOC_ZVAL(new_tmp);
-			*new_tmp = *param_ptr;
-			zval_copy_ctor(new_tmp);
-			INIT_PZVAL(new_tmp);
-			param_ptr = new_tmp;
-			Z_DELREF_P((zval *) *(p-arg_count));
-			*(p-arg_count) = param_ptr;
+		param_ptr = (p-arg_count);
+		if (!Z_ISREF_P(param_ptr) && Z_REFCOUNT_P(param_ptr) > 1) {
+			zval new_tmp;
+
+			ZVAL_DUP(&new_tmp, param_ptr);
+			Z_DELREF_P(param_ptr);
+			ZVAL_COPY_VALUE(param_ptr, &new_tmp);
 		}
 		*param = param_ptr;
 		arg_count--;
@@ -82,33 +78,33 @@ ZEND_API int zend_get_parameters(int ht, int param_count, ...) /* {{{ */
 }
 /* }}} */
 
-ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument_array TSRMLS_DC) /* {{{ */
+ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval *argument_array TSRMLS_DC) /* {{{ */
 {
-	void **p;
+	zval *p;
 	int arg_count;
 	zval *param_ptr;
 
 	p = zend_vm_stack_top(TSRMLS_C) - 1;
-	arg_count = (int)(zend_uintptr_t) *p;
+	arg_count = Z_LVAL_P(p);
 
 	if (param_count>arg_count) {
 		return FAILURE;
 	}
 
 	while (param_count-->0) {
-		param_ptr = *(p-arg_count);
-		if (!PZVAL_IS_REF(param_ptr) && Z_REFCOUNT_P(param_ptr) > 1) {
-			zval *new_tmp;
-
-			ALLOC_ZVAL(new_tmp);
-			*new_tmp = *param_ptr;
-			zval_copy_ctor(new_tmp);
-			INIT_PZVAL(new_tmp);
-			param_ptr = new_tmp;
-			Z_DELREF_P((zval *) *(p-arg_count));
-			*(p-arg_count) = param_ptr;
-		}
-		*(argument_array++) = param_ptr;
+		param_ptr = (p-arg_count);
+		if (Z_REFCOUNTED_P(param_ptr) && 
+		    !Z_ISREF_P(param_ptr) &&		    
+		    Z_REFCOUNT_P(param_ptr) > 1) {
+			zval new_tmp;
+
+			ZVAL_DUP(&new_tmp, param_ptr);
+			Z_DELREF_P(param_ptr);
+			ZVAL_COPY_VALUE(argument_array, &new_tmp);
+		} else {
+			ZVAL_COPY_VALUE(argument_array, param_ptr);
+		}
+		argument_array++;
 		arg_count--;
 	}
 
@@ -120,14 +116,14 @@ ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument
 /* this function doesn't check for too many parameters */
 ZEND_API int zend_get_parameters_ex(int param_count, ...) /* {{{ */
 {
-	void **p;
+	zval *p;
 	int arg_count;
 	va_list ptr;
-	zval ***param;
+	zval **param;
 	TSRMLS_FETCH();
 
 	p = zend_vm_stack_top(TSRMLS_C) - 1;
-	arg_count = (int)(zend_uintptr_t) *p;
+	arg_count = Z_LVAL_P(p);
 
 	if (param_count>arg_count) {
 		return FAILURE;
@@ -135,8 +131,8 @@ ZEND_API int zend_get_parameters_ex(int param_count, ...) /* {{{ */
 
 	va_start(ptr, param_count);
 	while (param_count-->0) {
-		param = va_arg(ptr, zval ***);
-		*param = (zval **) p-(arg_count--);
+		param = va_arg(ptr, zval **);
+		*param = p-(arg_count--);
 	}
 	va_end(ptr);
 
@@ -144,22 +140,23 @@ ZEND_API int zend_get_parameters_ex(int param_count, ...) /* {{{ */
 }
 /* }}} */
 
-ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_array TSRMLS_DC) /* {{{ */
+ZEND_API int _zend_get_parameters_array_ex(int param_count, zval *argument_array TSRMLS_DC) /* {{{ */
 {
-	void **p;
+	zval *p;
 	int arg_count;
 
 	p = zend_vm_stack_top(TSRMLS_C) - 1;
-	arg_count = (int)(zend_uintptr_t) *p;
+	arg_count = Z_LVAL_P(p);
 
 	if (param_count>arg_count) {
 		return FAILURE;
 	}
 
 	while (param_count-->0) {
-		zval **value = (zval**)(p-arg_count);
+		zval *value = (p-arg_count);
 
-		*(argument_array++) = value;
+		ZVAL_COPY_VALUE(argument_array, value);
+		argument_array++;
 		arg_count--;
 	}
 
@@ -169,20 +166,22 @@ ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_arr
 
 ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array TSRMLS_DC) /* {{{ */
 {
-	void **p;
+	zval *p;
 	int arg_count;
 
 	p = zend_vm_stack_top(TSRMLS_C) - 1;
-	arg_count = (int)(zend_uintptr_t) *p;
+	arg_count = Z_LVAL_P(p);
 
 	if (param_count>arg_count) {
 		return FAILURE;
 	}
 
 	while (param_count-->0) {
-		zval **param = (zval **) p-(arg_count--);
-		zval_add_ref(param);
-		add_next_index_zval(argument_array, *param);
+		zval *param = p-(arg_count--);
+		if (Z_REFCOUNTED_P(param)) {
+			Z_ADDREF_P(param);
+		}
+		add_next_index_zval(argument_array, param);
 	}
 
 	return SUCCESS;
@@ -228,14 +227,15 @@ ZEND_API char *zend_get_type_by_const(int type) /* {{{ */
 
 ZEND_API char *zend_zval_type_name(const zval *arg) /* {{{ */
 {
+	ZVAL_DEREF(arg);
 	return zend_get_type_by_const(Z_TYPE_P(arg));
 }
 /* }}} */
 
-ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *zend_get_class_entry(const zend_object *zobject TSRMLS_DC) /* {{{ */
 {
-	if (Z_OBJ_HT_P(zobject)->get_class_entry) {
-		return Z_OBJ_HT_P(zobject)->get_class_entry(zobject TSRMLS_CC);
+	if (zobject->handlers->get_class_entry) {
+		return zobject->handlers->get_class_entry(zobject TSRMLS_CC);
 	} else {
 		zend_error(E_ERROR, "Class entry requested for an object without PHP class");
 		return NULL;
@@ -244,69 +244,109 @@ ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC) /
 /* }}} */
 
 /* returns 1 if you need to copy result, 0 if it's already a copy */
-ZEND_API int zend_get_object_classname(const zval *object, const char **class_name, zend_uint *class_name_len TSRMLS_DC) /* {{{ */
+ZEND_API zend_string *zend_get_object_classname(const zend_object *object TSRMLS_DC) /* {{{ */
 {
-	if (Z_OBJ_HT_P(object)->get_class_name == NULL ||
-		Z_OBJ_HT_P(object)->get_class_name(object, class_name, class_name_len, 0 TSRMLS_CC) != SUCCESS) {
-		zend_class_entry *ce = Z_OBJCE_P(object);
+	zend_string *ret;
 
-		*class_name = ce->name;
-		*class_name_len = ce->name_length;
-		return 1;
+	if (object->handlers->get_class_name != NULL) {
+		ret = object->handlers->get_class_name(object, 0 TSRMLS_CC);
+		if (ret) {
+			return ret;
+		}
 	}
-	return 0;
+	return zend_get_class_entry(object TSRMLS_CC)->name;
 }
 /* }}} */
 
-static int parse_arg_object_to_string(zval **arg, char **p, int *pl, int type TSRMLS_DC) /* {{{ */
+static int parse_arg_object_to_string(zval *arg, char **p, int *pl, int type TSRMLS_DC) /* {{{ */
 {
-	if (Z_OBJ_HANDLER_PP(arg, cast_object)) {
-		zval *obj;
-		MAKE_STD_ZVAL(obj);
-		if (Z_OBJ_HANDLER_P(*arg, cast_object)(*arg, obj, type TSRMLS_CC) == SUCCESS) {
+	if (Z_OBJ_HANDLER_P(arg, cast_object)) {
+		zval obj;
+		if (Z_OBJ_HANDLER_P(arg, cast_object)(arg, &obj, type TSRMLS_CC) == SUCCESS) {
 			zval_ptr_dtor(arg);
-			*arg = obj;
-			*pl = Z_STRLEN_PP(arg);
-			*p = Z_STRVAL_PP(arg);
+			ZVAL_COPY_VALUE(arg, &obj);
+			*pl = Z_STRLEN_P(arg);
+			*p = Z_STRVAL_P(arg);
 			return SUCCESS;
 		}
-		efree(obj);
 	}
 	/* Standard PHP objects */
-	if (Z_OBJ_HT_PP(arg) == &std_object_handlers || !Z_OBJ_HANDLER_PP(arg, cast_object)) {
+	if (Z_OBJ_HT_P(arg) == &std_object_handlers || !Z_OBJ_HANDLER_P(arg, cast_object)) {
 		SEPARATE_ZVAL_IF_NOT_REF(arg);
-		if (zend_std_cast_object_tostring(*arg, *arg, type TSRMLS_CC) == SUCCESS) {
-			*pl = Z_STRLEN_PP(arg);
-			*p = Z_STRVAL_PP(arg);
+		if (zend_std_cast_object_tostring(arg, arg, type TSRMLS_CC) == SUCCESS) {
+			*pl = Z_STRLEN_P(arg);
+			*p = Z_STRVAL_P(arg);
 			return SUCCESS;
 		}
 	}
-	if (!Z_OBJ_HANDLER_PP(arg, cast_object) && Z_OBJ_HANDLER_PP(arg, get)) {
+	if (!Z_OBJ_HANDLER_P(arg, cast_object) && Z_OBJ_HANDLER_P(arg, get)) {
 		int use_copy;
-		zval *z = Z_OBJ_HANDLER_PP(arg, get)(*arg TSRMLS_CC);
+		zval rv;
+		zval *z = Z_OBJ_HANDLER_P(arg, get)(arg, &rv TSRMLS_CC);
 		Z_ADDREF_P(z);
 		if(Z_TYPE_P(z) != IS_OBJECT) {
-			zval_dtor(*arg);
-			Z_TYPE_P(*arg) = IS_NULL;
-			zend_make_printable_zval(z, *arg, &use_copy);
+			zval_dtor(arg);
+			ZVAL_NULL(arg);
+			zend_make_printable_zval(z, arg, &use_copy);
 			if (!use_copy) {
-				ZVAL_ZVAL(*arg, z, 1, 1);
+				ZVAL_ZVAL(arg, z, 1, 1);
 			}
-			*pl = Z_STRLEN_PP(arg);
-			*p = Z_STRVAL_PP(arg);
+			*pl = Z_STRLEN_P(arg);
+			*p = Z_STRVAL_P(arg);
 			return SUCCESS;
 		}
-		zval_ptr_dtor(&z);
+		zval_ptr_dtor(z);
 	}
 	return FAILURE;
 }
 /* }}} */
 
-static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, const char **spec, char **error, int *severity TSRMLS_DC) /* {{{ */
+static int parse_arg_object_to_str(zval *arg, zend_string **str, int type TSRMLS_DC) /* {{{ */
+{
+	if (Z_OBJ_HANDLER_P(arg, cast_object)) {
+		zval obj;
+		if (Z_OBJ_HANDLER_P(arg, cast_object)(arg, &obj, type TSRMLS_CC) == SUCCESS) {
+			zval_ptr_dtor(arg);
+			ZVAL_COPY_VALUE(arg, &obj);
+			*str = Z_STR_P(arg);
+			return SUCCESS;
+		}
+	}
+	/* Standard PHP objects */
+	if (Z_OBJ_HT_P(arg) == &std_object_handlers || !Z_OBJ_HANDLER_P(arg, cast_object)) {
+		SEPARATE_ZVAL_IF_NOT_REF(arg);
+		if (zend_std_cast_object_tostring(arg, arg, type TSRMLS_CC) == SUCCESS) {
+			*str = Z_STR_P(arg);
+			return SUCCESS;
+		}
+	}
+	if (!Z_OBJ_HANDLER_P(arg, cast_object) && Z_OBJ_HANDLER_P(arg, get)) {
+		int use_copy;
+		zval rv;
+		zval *z = Z_OBJ_HANDLER_P(arg, get)(arg, &rv TSRMLS_CC);
+		Z_ADDREF_P(z);
+		if(Z_TYPE_P(z) != IS_OBJECT) {
+			zval_dtor(arg);
+			ZVAL_NULL(arg);
+			zend_make_printable_zval(z, arg, &use_copy);
+			if (!use_copy) {
+				ZVAL_ZVAL(arg, z, 1, 1);
+			}
+			*str = Z_STR_P(arg);
+			return SUCCESS;
+		}
+		zval_ptr_dtor(z);
+	}
+	return FAILURE;
+}
+/* }}} */
+
+static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, const char **spec, char **error, int *severity TSRMLS_DC) /* {{{ */
 {
 	const char *spec_walk = *spec;
 	char c = *spec_walk++;
 	int check_null = 0;
+	zval *real_arg = arg;
 
 	/* scan through modifiers */
 	while (1) {
@@ -320,6 +360,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 		spec_walk++;
 	}
 
+	ZVAL_DEREF(arg);
+
 	switch (c) {
 		case 'l':
 		case 'L':
@@ -328,16 +370,16 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 
 				if (check_null) {
 					zend_bool *p = va_arg(*va, zend_bool *);
-					*p = (Z_TYPE_PP(arg) == IS_NULL);
+					*p = (Z_TYPE_P(arg) == IS_NULL);
 				}
 
-				switch (Z_TYPE_PP(arg)) {
+				switch (Z_TYPE_P(arg)) {
 					case IS_STRING:
 						{
 							double d;
 							int type;
 
-							if ((type = is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), p, &d, -1)) == 0) {
+							if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), p, &d, -1)) == 0) {
 								return "long";
 							} else if (type == IS_DOUBLE) {
 								if (c == 'L') {
@@ -357,10 +399,10 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 
 					case IS_DOUBLE:
 						if (c == 'L') {
-							if (Z_DVAL_PP(arg) > LONG_MAX) {
+							if (Z_DVAL_P(arg) > LONG_MAX) {
 								*p = LONG_MAX;
 								break;
-							} else if (Z_DVAL_PP(arg) < LONG_MIN) {
+							} else if (Z_DVAL_P(arg) < LONG_MIN) {
 								*p = LONG_MIN;
 								break;
 							}
@@ -369,7 +411,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 					case IS_LONG:
 					case IS_BOOL:
 						convert_to_long_ex(arg);
-						*p = Z_LVAL_PP(arg);
+						*p = Z_LVAL_P(arg);
 						break;
 
 					case IS_ARRAY:
@@ -387,16 +429,16 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 
 				if (check_null) {
 					zend_bool *p = va_arg(*va, zend_bool *);
-					*p = (Z_TYPE_PP(arg) == IS_NULL);
+					*p = (Z_TYPE_P(arg) == IS_NULL);
 				}
 
-				switch (Z_TYPE_PP(arg)) {
+				switch (Z_TYPE_P(arg)) {
 					case IS_STRING:
 						{
 							long l;
 							int type;
 
-							if ((type = is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), &l, p, -1)) == 0) {
+							if ((type = is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &l, p, -1)) == 0) {
 								return "double";
 							} else if (type == IS_LONG) {
 								*p = (double) l;
@@ -409,7 +451,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 					case IS_DOUBLE:
 					case IS_BOOL:
 						convert_to_double_ex(arg);
-						*p = Z_DVAL_PP(arg);
+						*p = Z_DVAL_P(arg);
 						break;
 
 					case IS_ARRAY:
@@ -426,7 +468,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 			{
 				char **p = va_arg(*va, char **);
 				int *pl = va_arg(*va, int *);
-				switch (Z_TYPE_PP(arg)) {
+				switch (Z_TYPE_P(arg)) {
 					case IS_NULL:
 						if (check_null) {
 							*p = NULL;
@@ -440,22 +482,22 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 					case IS_DOUBLE:
 					case IS_BOOL:
 						convert_to_string_ex(arg);
-						if (UNEXPECTED(Z_ISREF_PP(arg) != 0)) {
+						if (UNEXPECTED(Z_ISREF_P(arg))) {
 							/* it's dangerous to return pointers to string
 							   buffer of referenced variable, because it can
 							   be clobbered throug magic callbacks */
 							SEPARATE_ZVAL(arg);
 						}
-						*p = Z_STRVAL_PP(arg);
-						*pl = Z_STRLEN_PP(arg);
-						if (c == 'p' && CHECK_ZVAL_NULL_PATH(*arg)) {
+						*p = Z_STRVAL_P(arg);
+						*pl = Z_STRLEN_P(arg);
+						if (c == 'p' && CHECK_ZVAL_NULL_PATH(arg)) {
 							return "a valid path";
 						}
 						break;
 
 					case IS_OBJECT:
 						if (parse_arg_object_to_string(arg, p, pl, IS_STRING TSRMLS_CC) == SUCCESS) {
-							if (c == 'p' && CHECK_ZVAL_NULL_PATH(*arg)) {
+							if (c == 'p' && CHECK_ZVAL_NULL_PATH(arg)) {
 								return "a valid path";
 							}
 							break;
@@ -469,23 +511,61 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 			}
 			break;
 
+		case 'S':
+			{
+				zend_string **str = va_arg(*va, zend_string **);
+				switch (Z_TYPE_P(arg)) {
+					case IS_NULL:
+						if (check_null) {
+							*str = NULL;
+							break;
+						}
+						/* break omitted intentionally */
+
+					case IS_STRING:
+					case IS_LONG:
+					case IS_DOUBLE:
+					case IS_BOOL:
+						convert_to_string_ex(arg);
+						if (UNEXPECTED(Z_ISREF_P(arg))) {
+							/* it's dangerous to return pointers to string
+							   buffer of referenced variable, because it can
+							   be clobbered throug magic callbacks */
+							SEPARATE_ZVAL(arg);
+						}
+						*str = Z_STR_P(arg);
+						break;
+
+					case IS_OBJECT: {
+						if (parse_arg_object_to_str(arg, str, IS_STRING TSRMLS_CC) == SUCCESS) {
+							break;
+						}
+					}
+					case IS_ARRAY:
+					case IS_RESOURCE:
+					default:
+						return "string";
+				}
+			}
+			break;
+
 		case 'b':
 			{
 				zend_bool *p = va_arg(*va, zend_bool *);
 
 				if (check_null) {
 					zend_bool *p = va_arg(*va, zend_bool *);
-					*p = (Z_TYPE_PP(arg) == IS_NULL);
+					*p = (Z_TYPE_P(arg) == IS_NULL);
 				}
 
-				switch (Z_TYPE_PP(arg)) {
+				switch (Z_TYPE_P(arg)) {
 					case IS_NULL:
 					case IS_STRING:
 					case IS_LONG:
 					case IS_DOUBLE:
 					case IS_BOOL:
 						convert_to_boolean_ex(arg);
-						*p = Z_BVAL_PP(arg);
+						*p = Z_BVAL_P(arg);
 						break;
 
 					case IS_ARRAY:
@@ -500,12 +580,12 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 		case 'r':
 			{
 				zval **p = va_arg(*va, zval **);
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*p = NULL;
 					break;
 				}
-				if (Z_TYPE_PP(arg) == IS_RESOURCE) {
-					*p = *arg;
+				if (Z_TYPE_P(arg) == IS_RESOURCE) {
+					*p = arg;
 				} else {
 					return "resource";
 				}
@@ -515,12 +595,12 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 		case 'a':
 			{
 				zval **p = va_arg(*va, zval **);
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*p = NULL;
 					break;
 				}
-				if (Z_TYPE_PP(arg) == IS_ARRAY || (c == 'A' && Z_TYPE_PP(arg) == IS_OBJECT)) {
-					*p = *arg;
+				if (Z_TYPE_P(arg) == IS_ARRAY || (c == 'A' && Z_TYPE_P(arg) == IS_OBJECT)) {
+					*p = arg;
 				} else {
 					return "array";
 				}
@@ -530,14 +610,14 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 		case 'h':
 			{
 				HashTable **p = va_arg(*va, HashTable **);
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*p = NULL;
 					break;
 				}
-				if (Z_TYPE_PP(arg) == IS_ARRAY) {
-					*p = Z_ARRVAL_PP(arg);
-				} else if(c == 'H' && Z_TYPE_PP(arg) == IS_OBJECT) {
-					*p = HASH_OF(*arg);
+				if (Z_TYPE_P(arg) == IS_ARRAY) {
+					*p = Z_ARRVAL_P(arg);
+				} else if(c == 'H' && Z_TYPE_P(arg) == IS_OBJECT) {
+					*p = HASH_OF(arg);
 					if(*p == NULL) {
 						return "array";
 					}
@@ -550,12 +630,12 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 		case 'o':
 			{
 				zval **p = va_arg(*va, zval **);
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*p = NULL;
 					break;
 				}
-				if (Z_TYPE_PP(arg) == IS_OBJECT) {
-					*p = *arg;
+				if (Z_TYPE_P(arg) == IS_OBJECT) {
+					*p = arg;
 				} else {
 					return "object";
 				}
@@ -567,16 +647,16 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 				zval **p = va_arg(*va, zval **);
 				zend_class_entry *ce = va_arg(*va, zend_class_entry *);
 
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*p = NULL;
 					break;
 				}
-				if (Z_TYPE_PP(arg) == IS_OBJECT &&
-						(!ce || instanceof_function(Z_OBJCE_PP(arg), ce TSRMLS_CC))) {
-					*p = *arg;
+				if (Z_TYPE_P(arg) == IS_OBJECT &&
+						(!ce || instanceof_function(Z_OBJCE_P(arg), ce TSRMLS_CC))) {
+					*p = arg;
 				} else {
 					if (ce) {
-						return ce->name;
+						return ce->name->val;
 					} else {
 						return "object";
 					}
@@ -586,30 +666,30 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 
 		case 'C':
 			{
-				zend_class_entry **lookup, **pce = va_arg(*va, zend_class_entry **);
+				zend_class_entry *lookup, **pce = va_arg(*va, zend_class_entry **);
 				zend_class_entry *ce_base = *pce;
 
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*pce = NULL;
 					break;
 				}
 				convert_to_string_ex(arg);
-				if (zend_lookup_class(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), &lookup TSRMLS_CC) == FAILURE) {
+				if ((lookup = zend_lookup_class(Z_STR_P(arg) TSRMLS_CC)) == NULL) {
 					*pce = NULL;
 				} else {
-					*pce = *lookup;
+					*pce = lookup;
 				}
 				if (ce_base) {
 					if ((!*pce || !instanceof_function(*pce, ce_base TSRMLS_CC))) {
 						zend_spprintf(error, 0, "to be a class name derived from %s, '%s' given",
-							ce_base->name, Z_STRVAL_PP(arg));
+							ce_base->name->val, Z_STRVAL_P(arg));
 						*pce = NULL;
 						return "";
 					}
 				}
 				if (!*pce) {
 					zend_spprintf(error, 0, "to be a valid class name, '%s' given",
-						Z_STRVAL_PP(arg));
+						Z_STRVAL_P(arg));
 					return "";
 				}
 				break;
@@ -623,13 +703,13 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 				zend_fcall_info_cache *fcc = va_arg(*va, zend_fcall_info_cache *);
 				char *is_callable_error = NULL;
 
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					fci->size = 0;
 					fcc->initialized = 0;
 					break;
 				}
 
-				if (zend_fcall_info_init(*arg, 0, fci, fcc, NULL, &is_callable_error TSRMLS_CC) == SUCCESS) {
+				if (zend_fcall_info_init(arg, 0, fci, fcc, NULL, &is_callable_error TSRMLS_CC) == SUCCESS) {
 					if (is_callable_error) {
 						*severity = E_STRICT;
 						zend_spprintf(error, 0, "to be a valid callback, %s", is_callable_error);
@@ -653,25 +733,17 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 		case 'z':
 			{
 				zval **p = va_arg(*va, zval **);
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
+				if (check_null && Z_TYPE_P(arg) == IS_NULL) {
 					*p = NULL;
 				} else {
-					*p = *arg;
+					*p = real_arg;
 				}
 			}
 			break;
 
 		case 'Z':
-			{
-				zval ***p = va_arg(*va, zval ***);
-				if (check_null && Z_TYPE_PP(arg) == IS_NULL) {
-					*p = NULL;
-				} else {
-					*p = arg;
-				}
-			}
-			break;
-
+			/* 'Z' iz not supported anymore and should be replaced with 'z' */
+			ZEND_ASSERT(c != 'Z');
 		default:
 			return "unknown";
 	}
@@ -682,7 +754,7 @@ static const char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, con
 }
 /* }}} */
 
-static int zend_parse_arg(int arg_num, zval **arg, va_list *va, const char **spec, int quiet TSRMLS_DC) /* {{{ */
+static int zend_parse_arg(int arg_num, zval *arg, va_list *va, const char **spec, int quiet TSRMLS_DC) /* {{{ */
 {
 	const char *expected_type = NULL;
 	char *error = NULL;
@@ -701,7 +773,7 @@ static int zend_parse_arg(int arg_num, zval **arg, va_list *va, const char **spe
 			} else {
 				zend_error(severity, "%s%s%s() expects parameter %d to be %s, %s given",
 						class_name, space, get_active_function_name(TSRMLS_C), arg_num, expected_type,
-						zend_zval_type_name(*arg));
+						zend_zval_type_name(arg));
 			}
 		}
 		if (severity != E_STRICT) {
@@ -713,7 +785,7 @@ static int zend_parse_arg(int arg_num, zval **arg, va_list *va, const char **spe
 }
 /* }}} */
 
-ZEND_API int zend_parse_parameter(int flags, int arg_num TSRMLS_DC, zval **arg, const char *spec, ...)
+ZEND_API int zend_parse_parameter(int flags, int arg_num TSRMLS_DC, zval *arg, const char *spec, ...)
 {
 	va_list va;
 	int ret;
@@ -733,11 +805,11 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 	int min_num_args = -1;
 	int max_num_args = 0;
 	int post_varargs = 0;
-	zval **arg;
+	zval *arg;
 	int arg_count;
 	int quiet = flags & ZEND_PARSE_PARAMS_QUIET;
 	zend_bool have_varargs = 0;
-	zval ****varargs = NULL;
+	zval **varargs = NULL;
 	int *n_varargs = NULL;
 
 	for (spec_walk = type_spec; *spec_walk; spec_walk++) {
@@ -751,6 +823,7 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 			case 'C': case 'h':
 			case 'f': case 'A':
 			case 'H': case 'p':
+			case 'S':
 				max_num_args++;
 				break;
 
@@ -768,11 +841,11 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 				if (have_varargs) {
 					if (!quiet) {
 						zend_function *active_function = EG(current_execute_data)->function_state.function;
-						const char *class_name = active_function->common.scope ? active_function->common.scope->name : "";
+						const char *class_name = active_function->common.scope ? active_function->common.scope->name->val : "";
 						zend_error(E_WARNING, "%s%s%s(): only one varargs specifier (* or +) is permitted",
 								class_name,
 								class_name[0] ? "::" : "",
-								active_function->common.function_name);
+								active_function->common.function_name->val);
 					}
 					return FAILURE;
 				}
@@ -788,11 +861,11 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 			default:
 				if (!quiet) {
 					zend_function *active_function = EG(current_execute_data)->function_state.function;
-					const char *class_name = active_function->common.scope ? active_function->common.scope->name : "";
+					const char *class_name = active_function->common.scope ? active_function->common.scope->name->val : "";
 					zend_error(E_WARNING, "%s%s%s(): bad type specifier while parsing parameters",
 							class_name,
 							class_name[0] ? "::" : "",
-							active_function->common.function_name);
+							active_function->common.function_name->val);
 				}
 				return FAILURE;
 		}
@@ -811,11 +884,11 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 	if (num_args < min_num_args || (num_args > max_num_args && max_num_args > 0)) {
 		if (!quiet) {
 			zend_function *active_function = EG(current_execute_data)->function_state.function;
-			const char *class_name = active_function->common.scope ? active_function->common.scope->name : "";
+			const char *class_name = active_function->common.scope ? active_function->common.scope->name->val : "";
 			zend_error(E_WARNING, "%s%s%s() expects %s %d parameter%s, %d given",
 					class_name,
 					class_name[0] ? "::" : "",
-					active_function->common.function_name,
+					active_function->common.function_name->val,
 					min_num_args == max_num_args ? "exactly" : num_args < min_num_args ? "at least" : "at most",
 					num_args < min_num_args ? min_num_args : max_num_args,
 					(num_args < min_num_args ? min_num_args : max_num_args) == 1 ? "" : "s",
@@ -824,7 +897,7 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 		return FAILURE;
 	}
 
-	arg_count = (int)(zend_uintptr_t) *(zend_vm_stack_top(TSRMLS_C) - 1);
+	arg_count = Z_LVAL_P(zend_vm_stack_top(TSRMLS_C) - 1);
 
 	if (num_args > arg_count) {
 		zend_error(E_WARNING, "%s(): could not obtain parameters for parsing",
@@ -842,25 +915,16 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 			int num_varargs = num_args + 1 - post_varargs;
 
 			/* eat up the passed in storage even if it won't be filled in with varargs */
-			varargs = va_arg(*va, zval ****);
+			varargs = va_arg(*va, zval **);
 			n_varargs = va_arg(*va, int *);
 			type_spec++;
 
 			if (num_varargs > 0) {
-				int iv = 0;
-				zval **p = (zval **) (zend_vm_stack_top(TSRMLS_C) - 1 - (arg_count - i));
-
 				*n_varargs = num_varargs;
-
-				/* allocate space for array and store args */
-				*varargs = safe_emalloc(num_varargs, sizeof(zval **), 0);
-				while (num_varargs-- > 0) {
-					(*varargs)[iv++] = p++;
-				}
-
+				*varargs = (zend_vm_stack_top(TSRMLS_C) - 1 - (arg_count - i));
 				/* adjust how many args we have left and restart loop */
-				num_args = num_args + 1 - iv;
-				i += iv;
+				num_args += 1 - num_varargs;
+				i += num_varargs;
 				continue;
 			} else {
 				*varargs = NULL;
@@ -868,12 +932,11 @@ static int zend_parse_va_args(int num_args, const char *type_spec, va_list *va,
 			}
 		}
 
-		arg = (zval **) (zend_vm_stack_top(TSRMLS_C) - 1 - (arg_count-i));
+		arg = zend_vm_stack_top(TSRMLS_C) - 1 - (arg_count-i);
 
 		if (zend_parse_arg(i+1, arg, va, &type_spec, quiet TSRMLS_CC) == FAILURE) {
 			/* clean up varargs array if it was used */
 			if (varargs && *varargs) {
-				efree(*varargs);
 				*varargs = NULL;
 			}
 			return FAILURE;
@@ -936,7 +999,7 @@ ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr
 	zval **object;
 	zend_class_entry *ce;
 
-	if (!this_ptr) {
+	if (!this_ptr || Z_TYPE_P(this_ptr) != IS_OBJECT) {
 		RETURN_IF_ZERO_ARGS(num_args, p, 0);
 
 		va_start(va, type_spec);
@@ -954,7 +1017,7 @@ ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr
 
 		if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) {
 			zend_error(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
-				ce->name, get_active_function_name(TSRMLS_C), Z_OBJCE_P(this_ptr)->name, get_active_function_name(TSRMLS_C));
+				ce->name->val, get_active_function_name(TSRMLS_C), Z_OBJCE_P(this_ptr)->name->val, get_active_function_name(TSRMLS_C));
 		}
 
 		retval = zend_parse_va_args(num_args, p, &va, 0 TSRMLS_CC);
@@ -992,7 +1055,7 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC,
 		if (ce && !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) {
 			if (!quiet) {
 				zend_error(E_CORE_ERROR, "%s::%s() must be derived from %s::%s",
-					ce->name, get_active_function_name(TSRMLS_C), Z_OBJCE_P(this_ptr)->name, get_active_function_name(TSRMLS_C));
+					ce->name->val, get_active_function_name(TSRMLS_C), Z_OBJCE_P(this_ptr)->name->val, get_active_function_name(TSRMLS_C));
 			}
 			va_end(va);
 			return FAILURE;
@@ -1008,25 +1071,22 @@ ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC,
 /* Argument parsing API -- andrei */
 ZEND_API int _array_init(zval *arg, uint size ZEND_FILE_LINE_DC) /* {{{ */
 {
-	ALLOC_HASHTABLE_REL(Z_ARRVAL_P(arg));
-
+	ZVAL_NEW_ARR(arg);
 	_zend_hash_init(Z_ARRVAL_P(arg), size, ZVAL_PTR_DTOR, 0 ZEND_FILE_LINE_RELAY_CC);
-	Z_TYPE_P(arg) = IS_ARRAY;
 	return SUCCESS;
 }
 /* }}} */
 
-static int zend_merge_property(zval **value TSRMLS_DC, int num_args, va_list args, const zend_hash_key *hash_key) /* {{{ */
+static int zend_merge_property(zval *value TSRMLS_DC, int num_args, va_list args, const zend_hash_key *hash_key) /* {{{ */
 {
 	/* which name should a numeric property have ? */
-	if (hash_key->nKeyLength) {
+	if (hash_key->key) {
 		zval *obj = va_arg(args, zval *);
 		zend_object_handlers *obj_ht = va_arg(args, zend_object_handlers *);
-		zval *member;
+		zval member;
 
-		MAKE_STD_ZVAL(member);
-		ZVAL_STRINGL(member, hash_key->arKey, hash_key->nKeyLength-1, 1);
-		obj_ht->write_property(obj, member, *value, 0 TSRMLS_CC);
+		ZVAL_STR(&member, STR_COPY(hash_key->key));
+		obj_ht->write_property(obj, &member, value, -1 TSRMLS_CC);
 		zval_ptr_dtor(&member);
 	}
 	return ZEND_HASH_APPLY_KEEP;
@@ -1051,20 +1111,18 @@ ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destro
 }
 /* }}} */
 
-static int zval_update_class_constant(zval **pp, int is_static, int offset TSRMLS_DC) /* {{{ */
+static int zval_update_class_constant(zval *pp, int is_static, int offset TSRMLS_DC) /* {{{ */
 {
-	if (IS_CONSTANT_TYPE(Z_TYPE_PP(pp))) {
+	ZVAL_DEREF(pp);
+	if (Z_CONSTANT_P(pp)) {
 		zend_class_entry **scope = EG(in_execution)?&EG(scope):&CG(active_class_entry);
 
 		if ((*scope)->parent) {
 			zend_class_entry *ce = *scope;
-			HashPosition pos;
 			zend_property_info *prop_info;
 
 			do {
-				for (zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
-				     zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop_info, &pos) == SUCCESS;
-				     zend_hash_move_forward_ex(&ce->properties_info, &pos)) {
+				ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
 					if (is_static == ((prop_info->flags & ZEND_ACC_STATIC) != 0) &&
 					    offset == prop_info->offset) {
 						int ret;
@@ -1074,7 +1132,7 @@ static int zval_update_class_constant(zval **pp, int is_static, int offset TSRML
 						*scope = old_scope;
 						return ret;
 					}
-				}				
+				} ZEND_HASH_FOREACH_END();
 				ce = ce->parent;
 			} while (ce);
 
@@ -1096,13 +1154,13 @@ ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC
 		zend_hash_apply_with_argument(&class_type->constants_table, (apply_func_arg_t) zval_update_constant, (void *)1 TSRMLS_CC);
 
 		for (i = 0; i < class_type->default_properties_count; i++) {
-			if (class_type->default_properties_table[i]) {
+			if (Z_TYPE(class_type->default_properties_table[i]) != IS_UNDEF) {
 				zval_update_class_constant(&class_type->default_properties_table[i], 0, i TSRMLS_CC);
 			}
 		}
 
 		if (!CE_STATIC_MEMBERS(class_type) && class_type->default_static_members_count) {
-			zval **p;
+			zval *p;
 
 			if (class_type->parent) {
 				zend_update_class_constants(class_type->parent TSRMLS_CC);
@@ -1114,25 +1172,19 @@ ZEND_API void zend_update_class_constants(zend_class_entry *class_type TSRMLS_DC
 #endif
 			for (i = 0; i < class_type->default_static_members_count; i++) {
 				p = &class_type->default_static_members_table[i];
-				if (Z_ISREF_PP(p) &&
+				if (Z_ISREF_P(p) &&
 					class_type->parent &&
 					i < class_type->parent->default_static_members_count &&
-					*p == class_type->parent->default_static_members_table[i] &&
-					CE_STATIC_MEMBERS(class_type->parent)[i]
+					p == &class_type->parent->default_static_members_table[i] &&
+					Z_TYPE(CE_STATIC_MEMBERS(class_type->parent)[i]) != IS_UNDEF
 				) {
-					zval *q = CE_STATIC_MEMBERS(class_type->parent)[i];
+					zval *q = &CE_STATIC_MEMBERS(class_type->parent)[i];
 
+					ZVAL_NEW_REF(q, q);
+					ZVAL_COPY_VALUE(&CE_STATIC_MEMBERS(class_type)[i], q);
 					Z_ADDREF_P(q);
-					Z_SET_ISREF_P(q);
-					CE_STATIC_MEMBERS(class_type)[i] = q;
 				} else {
-					zval *r;
-
-					ALLOC_ZVAL(r);
-					*r = **p;
-					INIT_PZVAL(r);
-					zval_copy_ctor(r);
-					CE_STATIC_MEMBERS(class_type)[i] = r;
+					ZVAL_DUP(&CE_STATIC_MEMBERS(class_type)[i], p);
 				}
 			}
 		}
@@ -1152,51 +1204,94 @@ ZEND_API void object_properties_init(zend_object *object, zend_class_entry *clas
 	int i;
 
 	if (class_type->default_properties_count) {
-		object->properties_table = emalloc(sizeof(zval*) * class_type->default_properties_count);
 		for (i = 0; i < class_type->default_properties_count; i++) {
-			object->properties_table[i] = class_type->default_properties_table[i];
-			if (class_type->default_properties_table[i]) {
 #if ZTS
-				ALLOC_ZVAL( object->properties_table[i]);
-				MAKE_COPY_ZVAL(&class_type->default_properties_table[i], object->properties_table[i]);
+			ZVAL_DUP(&object->properties_table[i], &class_type->default_properties_table[i]);
 #else
-				Z_ADDREF_P(object->properties_table[i]);
+			ZVAL_COPY(&object->properties_table[i], &class_type->default_properties_table[i]);
 #endif
-			}
 		}
 		object->properties = NULL;
 	}
 }
 /* }}} */
 
+ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties TSRMLS_DC) /* {{{ */
+{
+	object->properties = properties;
+	if (object->ce->default_properties_count) {
+	    zval *prop, tmp;
+    	zend_string *key;
+    	zend_property_info *property_info;
+
+    	ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, prop) {
+		    ZVAL_STR(&tmp, key);
+			property_info = zend_get_property_info(object->ce, &tmp, 1 TSRMLS_CC);
+			if (property_info &&
+			    (property_info->flags & ZEND_ACC_STATIC) == 0 &&
+			    property_info->offset >= 0) {
+				ZVAL_COPY_VALUE(&object->properties_table[property_info->offset], prop);
+				ZVAL_INDIRECT(prop, &object->properties_table[property_info->offset]);
+			}
+		} ZEND_HASH_FOREACH_END();
+	}
+}
+/* }}} */
+
+ZEND_API void object_properties_load(zend_object *object, HashTable *properties TSRMLS_DC) /* {{{ */
+{
+    zval *prop, tmp;
+   	zend_string *key;
+   	zend_property_info *property_info;
+
+	ZEND_HASH_FOREACH_STR_KEY_VAL(properties, key, prop) {
+	    ZVAL_STR(&tmp, key);
+		property_info = zend_get_property_info(object->ce, &tmp, 1 TSRMLS_CC);
+		if (property_info &&
+		    (property_info->flags & ZEND_ACC_STATIC) == 0 &&
+		    property_info->offset >= 0) {
+		    zval_ptr_dtor(&object->properties_table[property_info->offset]);
+			ZVAL_COPY_VALUE(&object->properties_table[property_info->offset], prop);
+			zval_add_ref(&object->properties_table[property_info->offset]);
+			if (object->properties) {
+				ZVAL_INDIRECT(&tmp, &object->properties_table[property_info->offset]);
+				prop = zend_hash_update(object->properties, key, &tmp);
+			}
+		} else {
+			if (!object->properties) {
+				rebuild_object_properties(object);
+			}
+			prop = zend_hash_update(object->properties, key, prop);
+			zval_add_ref(prop);
+		}
+	} ZEND_HASH_FOREACH_END();		
+}
+/* }}} */
+
 /* This function requires 'properties' to contain all props declared in the
  * class and all props being public. If only a subset is given or the class
  * has protected members then you need to merge the properties separately by
  * calling zend_merge_properties(). */
 ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *class_type, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC) /* {{{ */
 {
-	zend_object *object;
-
 	if (class_type->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
 		char *what =   (class_type->ce_flags & ZEND_ACC_INTERFACE)                ? "interface"
 					 :((class_type->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) ? "trait"
 					 :                                                              "abstract class";
-		zend_error(E_ERROR, "Cannot instantiate %s %s", what, class_type->name);
+		zend_error(E_ERROR, "Cannot instantiate %s %s", what, class_type->name->val);
 	}
 
 	zend_update_class_constants(class_type TSRMLS_CC);
 
-	Z_TYPE_P(arg) = IS_OBJECT;
 	if (class_type->create_object == NULL) {
-		Z_OBJVAL_P(arg) = zend_objects_new(&object, class_type TSRMLS_CC);
+		ZVAL_OBJ(arg, zend_objects_new(class_type TSRMLS_CC));
 		if (properties) {
-			object->properties = properties;
-			object->properties_table = NULL;
+			object_properties_init_ex(Z_OBJ_P(arg), properties TSRMLS_CC);
 		} else {
-			object_properties_init(object, class_type);
+			object_properties_init(Z_OBJ_P(arg), class_type);
 		}
 	} else {
-		Z_OBJVAL_P(arg) = class_type->create_object(class_type TSRMLS_CC);
+		ZVAL_OBJ(arg, class_type->create_object(class_type TSRMLS_CC));
 	}
 	return SUCCESS;
 }
@@ -1223,365 +1318,360 @@ ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)
 
 ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_LONG(tmp, n);
-
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+	zval *ret, tmp;
+	
+	ZVAL_LONG(&tmp, n);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_NULL(tmp);
-
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+	zval *ret, tmp;
+	
+	ZVAL_NULL(&tmp);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_BOOL(tmp, b);
-
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+	zval *ret, tmp;
+	
+	ZVAL_BOOL(&tmp, b);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r) /* {{{ */
+ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_RESOURCE(tmp, r);
-
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+	zval *ret, tmp;
+	
+	ZVAL_RES(&tmp, r);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_DOUBLE(tmp, d);
-
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+	zval *ret, tmp;
+	
+	ZVAL_DOUBLE(&tmp, d);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate) /* {{{ */
+ZEND_API int add_assoc_str_ex(zval *arg, const char *key, uint key_len, zend_string *str) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRING(tmp, str, duplicate);
+	zval *ret, tmp;
 
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_STR(&tmp, str);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate) /* {{{ */
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRINGL(tmp, str, length, duplicate);
+	zval *ret, tmp;
+	
+	ZVAL_STRING(&tmp, str);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
+}
+/* }}} */
 
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), NULL);
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length) /* {{{ */
+{
+	zval *ret, tmp;
+	
+	ZVAL_STRINGL(&tmp, str, length);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value) /* {{{ */
 {
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &value, sizeof(zval *), NULL);
+	zval *ret;
+	
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, value);
+	return ret ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_index_long(zval *arg, ulong index, long n) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_LONG(tmp, n);
-
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_LONG(&tmp, n);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_index_null(zval *arg, ulong index) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_NULL(tmp);
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_NULL(&tmp);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_index_bool(zval *arg, ulong index, int b) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_BOOL(tmp, b);
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_BOOL(&tmp, b);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_index_resource(zval *arg, ulong index, int r) /* {{{ */
+ZEND_API int add_index_resource(zval *arg, ulong index, zend_resource *r) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_RESOURCE(tmp, r);
-
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_RES(&tmp, r);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_index_double(zval *arg, ulong index, double d) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_DOUBLE(tmp, d);
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_DOUBLE(&tmp, d);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_index_string(zval *arg, ulong index, const char *str, int duplicate) /* {{{ */
+ZEND_API int add_index_str(zval *arg, ulong index, zend_string *str) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRING(tmp, str, duplicate);
-
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_STR(&tmp, str);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint length, int duplicate) /* {{{ */
+ZEND_API int add_index_string(zval *arg, ulong index, const char *str) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRINGL(tmp, str, length, duplicate);
+	ZVAL_STRING(&tmp, str);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
+}
+/* }}} */
+
+ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, uint length) /* {{{ */
+{
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), NULL);
+	ZVAL_STRINGL(&tmp, str, length);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_index_zval(zval *arg, ulong index, zval *value) /* {{{ */
 {
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &value, sizeof(zval *), NULL);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, value) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_next_index_long(zval *arg, long n) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_LONG(tmp, n);
-
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_LONG(&tmp, n);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_next_index_null(zval *arg) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_NULL(tmp);
+	zval tmp;
 
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_NULL(&tmp);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_next_index_bool(zval *arg, int b) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_BOOL(tmp, b);
+	zval tmp;
 
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_BOOL(&tmp, b);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_next_index_resource(zval *arg, int r) /* {{{ */
+ZEND_API int add_next_index_resource(zval *arg, zend_resource *r) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_RESOURCE(tmp, r);
-
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_RES(&tmp, r);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_next_index_double(zval *arg, double d) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_DOUBLE(tmp, d);
+	zval tmp;
 
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_DOUBLE(&tmp, d);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate) /* {{{ */
+ZEND_API int add_next_index_str(zval *arg, zend_string *str) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRING(tmp, str, duplicate);
-
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_STR(&tmp, str);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate) /* {{{ */
+ZEND_API int add_next_index_string(zval *arg, const char *str) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRINGL(tmp, str, length, duplicate);
+	ZVAL_STRING(&tmp, str);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
+}
+/* }}} */
+
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length) /* {{{ */
+{
+	zval tmp;
 
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp, sizeof(zval *), NULL);
+	ZVAL_STRINGL(&tmp, str, length);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &tmp) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int add_next_index_zval(zval *arg, zval *value) /* {{{ */
 {
-	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), &value, sizeof(zval *), NULL);
+	return zend_hash_next_index_insert(Z_ARRVAL_P(arg), value) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate) /* {{{ */
+ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str) /* {{{ */
 {
-	zval *tmp;
+	zval tmp, *ret;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRING(tmp, str, duplicate);
-
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
+	ZVAL_STRING(&tmp, str);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret;
 }
 /* }}} */
 
-ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate) /* {{{ */
+ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRINGL(tmp, str, length, duplicate);
+	zval tmp, *ret;
 
-	return zend_symtable_update(Z_ARRVAL_P(arg), key, key_len, (void *) &tmp, sizeof(zval *), dest);
+	ZVAL_STRINGL(&tmp, str, length);
+	ret = zend_symtable_str_update(Z_ARRVAL_P(arg), key, key_len, &tmp);
+	return ret;
 }
 /* }}} */
 
-ZEND_API int add_get_index_long(zval *arg, ulong index, long l, void **dest) /* {{{ */
+ZEND_API zval *add_get_index_long(zval *arg, ulong index, long l) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_LONG(tmp, l);
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+	ZVAL_LONG(&tmp, l);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
 }
 /* }}} */
 
-ZEND_API int add_get_index_double(zval *arg, ulong index, double d, void **dest) /* {{{ */
+ZEND_API zval *add_get_index_double(zval *arg, ulong index, double d) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_DOUBLE(tmp, d);
-
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+	ZVAL_DOUBLE(&tmp, d);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
 }
 /* }}} */
 
-ZEND_API int add_get_index_string(zval *arg, ulong index, const char *str, void **dest, int duplicate) /* {{{ */
+ZEND_API zval *add_get_index_str(zval *arg, ulong index, zend_string *str) /* {{{ */
 {
-	zval *tmp;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRING(tmp, str, duplicate);
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+	ZVAL_STR(&tmp, str);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
 }
 /* }}} */
 
-ZEND_API int add_get_index_stringl(zval *arg, ulong index, const char *str, uint length, void **dest, int duplicate) /* {{{ */
+ZEND_API zval *add_get_index_string(zval *arg, ulong index, const char *str) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
+
+	ZVAL_STRING(&tmp, str);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
+}
+/* }}} */
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRINGL(tmp, str, length, duplicate);
+ZEND_API zval *add_get_index_stringl(zval *arg, ulong index, const char *str, uint length) /* {{{ */
+{
+	zval tmp;
 
-	return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &tmp, sizeof(zval *), dest);
+	ZVAL_STRINGL(&tmp, str, length);
+	return zend_hash_index_update(Z_ARRVAL_P(arg), index, &tmp);
 }
 /* }}} */
 
-ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value) /* {{{ */
+ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC) /* {{{ */
 {
-	int result;
+	zval *result;
 
 	switch (Z_TYPE_P(key)) {
 		case IS_STRING:
-			result = zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &value, sizeof(zval *), NULL);
+			result = zend_symtable_update(ht, Z_STR_P(key), value);
 			break;
 		case IS_NULL:
-			result = zend_symtable_update(ht, "", 1, &value, sizeof(zval *), NULL);
+			result = zend_symtable_update(ht, STR_EMPTY_ALLOC(), value);
 			break;
 		case IS_RESOURCE:
-			zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(key), Z_LVAL_P(key));
-			/* break missing intentionally */
+			zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(key), Z_RES_HANDLE_P(key));
+			result = zend_hash_index_update(ht, Z_RES_HANDLE_P(key), value);
+			break;
 		case IS_BOOL:
 		case IS_LONG:
-			result = zend_hash_index_update(ht, Z_LVAL_P(key), &value, sizeof(zval *), NULL);
+			result = zend_hash_index_update(ht, Z_LVAL_P(key), value);
 			break;
 		case IS_DOUBLE:
-			result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), &value, sizeof(zval *), NULL);
+			result = zend_hash_index_update(ht, zend_dval_to_lval(Z_DVAL_P(key)), value);
 			break;
 		default:
 			zend_error(E_WARNING, "Illegal offset type");
-			result = FAILURE;
+			result = NULL;
 	}
 
-	if (result == SUCCESS) {
-		Z_ADDREF_P(value);
+	if (result) {
+		if (Z_REFCOUNTED_P(result)) {
+			Z_ADDREF_P(result);
+		}
+		return SUCCESS;
+	} else {
+		return FAILURE;
 	}
-
-	return result;
 }
 /* }}} */
 
 ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long n TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_LONG(tmp, n);
+	zval tmp;
+	zval z_key;
 
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
-
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_LONG(&tmp, n);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
@@ -1590,16 +1680,12 @@ ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long
 
 ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_BOOL(tmp, b);
-
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
+	zval tmp;
+	zval z_key;
 
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_BOOL(&tmp, b);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
@@ -1608,34 +1694,26 @@ ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int
 
 ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_NULL(tmp);
-
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
+	zval tmp;
+	zval z_key;
 
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_NULL(&tmp);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
 }
 /* }}} */
 
-ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long n TSRMLS_DC) /* {{{ */
+ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
+	zval tmp;
+	zval z_key;
 
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_RESOURCE(tmp, n);
-
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
-
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_RES(&tmp, r);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
@@ -1644,52 +1722,40 @@ ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len,
 
 ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_DOUBLE(tmp, d);
+	zval tmp;
+	zval z_key;
 
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
-
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_DOUBLE(&tmp, d);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
 }
 /* }}} */
 
-ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC) /* {{{ */
+ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRING(tmp, str, duplicate);
+	zval tmp;
+	zval z_key;
 
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
-
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_STRING(&tmp, str);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
 }
 /* }}} */
 
-ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, int duplicate TSRMLS_DC) /* {{{ */
+ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-	zval *z_key;
-
-	MAKE_STD_ZVAL(tmp);
-	ZVAL_STRINGL(tmp, str, length, duplicate);
-
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
+	zval tmp;
+	zval z_key;
 
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, tmp, 0 TSRMLS_CC);
+	ZVAL_STRINGL(&tmp, str, length);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, &tmp, -1 TSRMLS_CC);
 	zval_ptr_dtor(&tmp); /* write_property will add 1 to refcount */
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
@@ -1698,12 +1764,10 @@ ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len, c
 
 ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC) /* {{{ */
 {
-	zval *z_key;
+	zval z_key;
 
-	MAKE_STD_ZVAL(z_key);
-	ZVAL_STRINGL(z_key, key, key_len-1, 1);
-
-	Z_OBJ_HANDLER_P(arg, write_property)(arg, z_key, value, 0 TSRMLS_CC);
+	ZVAL_STRINGL(&z_key, key, key_len);
+	Z_OBJ_HANDLER_P(arg, write_property)(arg, &z_key, value, -1 TSRMLS_CC);
 	zval_ptr_dtor(&z_key);
 	return SUCCESS;
 }
@@ -1712,7 +1776,7 @@ ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval
 ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC) /* {{{ */
 {
 	int name_len;
-	char *lcname;
+	zend_string *lcname;
 
 	if (module->module_started) {
 		return SUCCESS;
@@ -1728,16 +1792,17 @@ ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC) /* {{{
 				zend_module_entry *req_mod;
 
 				name_len = strlen(dep->name);
-				lcname = zend_str_tolower_dup(dep->name, name_len);
+				lcname = STR_ALLOC(name_len, 0);
+				zend_str_tolower_copy(lcname->val, dep->name, name_len);
 
-				if (zend_hash_find(&module_registry, lcname, name_len+1, (void**)&req_mod) == FAILURE || !req_mod->module_started) {
-					efree(lcname);
+				if ((req_mod = zend_hash_find_ptr(&module_registry, lcname)) == NULL || !req_mod->module_started) {
+					STR_FREE(lcname);
 					/* TODO: Check version relationship */
 					zend_error(E_CORE_WARNING, "Cannot load module '%s' because required module '%s' is not loaded", module->name, dep->name);
 					module->module_started = 0;
 					return FAILURE;
 				}
-				efree(lcname);
+				STR_FREE(lcname);
 			}
 			++dep;
 		}
@@ -1766,24 +1831,33 @@ ZEND_API int zend_startup_module_ex(zend_module_entry *module TSRMLS_DC) /* {{{
 }
 /* }}} */
 
+static int zend_startup_module_zval(zval *zv TSRMLS_DC) /* {{{ */
+{
+	zend_module_entry *module = Z_PTR_P(zv);
+
+	return zend_startup_module_ex(module TSRMLS_CC);
+}
+/* }}} */
+
+
 static void zend_sort_modules(void *base, size_t count, size_t siz, compare_func_t compare TSRMLS_DC) /* {{{ */
 {
-	Bucket **b1 = base;
-	Bucket **b2;
-	Bucket **end = b1 + count;
-	Bucket *tmp;
+	Bucket *b1 = base;
+	Bucket *b2;
+	Bucket *end = b1 + count;
+	Bucket tmp;
 	zend_module_entry *m, *r;
 
 	while (b1 < end) {
 try_again:
-		m = (zend_module_entry*)(*b1)->pData;
+		m = (zend_module_entry*)Z_PTR(b1->val);
 		if (!m->module_started && m->deps) {
 			const zend_module_dep *dep = m->deps;
 			while (dep->name) {
 				if (dep->type == MODULE_DEP_REQUIRED || dep->type == MODULE_DEP_OPTIONAL) {
 					b2 = b1 + 1;
 					while (b2 < end) {
-						r = (zend_module_entry*)(*b2)->pData;
+						r = (zend_module_entry*)Z_PTR(b2->val);
 						if (strcasecmp(dep->name, r->name) == 0) {
 							tmp = *b1;
 							*b1 = *b2;
@@ -1803,18 +1877,15 @@ try_again:
 
 ZEND_API void zend_collect_module_handlers(TSRMLS_D) /* {{{ */
 {
-	HashPosition pos;
 	zend_module_entry *module;
 	int startup_count = 0;
 	int shutdown_count = 0;
 	int post_deactivate_count = 0;
-	zend_class_entry **pce;
+	zend_class_entry *ce;
 	int class_count = 0;
 
 	/* Collect extensions with request startup/shutdown handlers */
-	for (zend_hash_internal_pointer_reset_ex(&module_registry, &pos);
-	     zend_hash_get_current_data_ex(&module_registry, (void *) &module, &pos) == SUCCESS;
-	     zend_hash_move_forward_ex(&module_registry, &pos)) {
+	ZEND_HASH_FOREACH_PTR(&module_registry, module) {
 		if (module->request_startup_func) {
 			startup_count++;
 		}
@@ -1824,7 +1895,7 @@ ZEND_API void zend_collect_module_handlers(TSRMLS_D) /* {{{ */
 		if (module->post_deactivate_func) {
 			post_deactivate_count++;
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 	module_request_startup_handlers = (zend_module_entry**)malloc(
 	    sizeof(zend_module_entry*) *
 		(startup_count + 1 +
@@ -1837,9 +1908,7 @@ ZEND_API void zend_collect_module_handlers(TSRMLS_D) /* {{{ */
 	module_post_deactivate_handlers[post_deactivate_count] = NULL;
 	startup_count = 0;
 	
-	for (zend_hash_internal_pointer_reset_ex(&module_registry, &pos);
-	     zend_hash_get_current_data_ex(&module_registry, (void *) &module, &pos) == SUCCESS;
-	     zend_hash_move_forward_ex(&module_registry, &pos)) {
+	ZEND_HASH_FOREACH_PTR(&module_registry, module) {
 		if (module->request_startup_func) {
 			module_request_startup_handlers[startup_count++] = module;
 		}
@@ -1849,17 +1918,15 @@ ZEND_API void zend_collect_module_handlers(TSRMLS_D) /* {{{ */
 		if (module->post_deactivate_func) {
 			module_post_deactivate_handlers[--post_deactivate_count] = module;
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	/* Collect internal classes with static members */
-	for (zend_hash_internal_pointer_reset_ex(CG(class_table), &pos);
-	     zend_hash_get_current_data_ex(CG(class_table), (void *) &pce, &pos) == SUCCESS;
-	     zend_hash_move_forward_ex(CG(class_table), &pos)) {
-		if ((*pce)->type == ZEND_INTERNAL_CLASS &&
-		    (*pce)->default_static_members_count > 0) {
+	ZEND_HASH_FOREACH_PTR(CG(class_table), ce) {
+		if (ce->type == ZEND_INTERNAL_CLASS &&
+		    ce->default_static_members_count > 0) {
 		    class_count++;
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	class_cleanup_handlers = (zend_class_entry**)malloc(
 		sizeof(zend_class_entry*) *
@@ -1867,14 +1934,12 @@ ZEND_API void zend_collect_module_handlers(TSRMLS_D) /* {{{ */
 	class_cleanup_handlers[class_count] = NULL;
 
 	if (class_count) {
-		for (zend_hash_internal_pointer_reset_ex(CG(class_table), &pos);
-		     zend_hash_get_current_data_ex(CG(class_table), (void *) &pce, &pos) == SUCCESS;
-	    	 zend_hash_move_forward_ex(CG(class_table), &pos)) {
-			if ((*pce)->type == ZEND_INTERNAL_CLASS &&
-			    (*pce)->default_static_members_count > 0) {
-			    class_cleanup_handlers[--class_count] = *pce;
+		ZEND_HASH_FOREACH_PTR(CG(class_table), ce) {
+			if (ce->type == ZEND_INTERNAL_CLASS &&
+			    ce->default_static_members_count > 0) {
+			    class_cleanup_handlers[--class_count] = ce;
 			}
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 }
 /* }}} */
@@ -1882,7 +1947,7 @@ ZEND_API void zend_collect_module_handlers(TSRMLS_D) /* {{{ */
 ZEND_API int zend_startup_modules(TSRMLS_D) /* {{{ */
 {
 	zend_hash_sort(&module_registry, zend_sort_modules, NULL, 0 TSRMLS_CC);
-	zend_hash_apply(&module_registry, (apply_func_t)zend_startup_module_ex TSRMLS_CC);
+	zend_hash_apply(&module_registry, zend_startup_module_zval TSRMLS_CC);
 	return SUCCESS;
 }
 /* }}} */
@@ -1898,7 +1963,7 @@ ZEND_API void zend_destroy_modules(void) /* {{{ */
 ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TSRMLS_DC) /* {{{ */
 {
 	int name_len;
-	char *lcname;
+	zend_string *lcname;
 	zend_module_entry *module_ptr;
 
 	if (!module) {
@@ -1916,29 +1981,31 @@ ZEND_API zend_module_entry* zend_register_module_ex(zend_module_entry *module TS
 		while (dep->name) {
 			if (dep->type == MODULE_DEP_CONFLICTS) {
 				name_len = strlen(dep->name);
-				lcname = zend_str_tolower_dup(dep->name, name_len);
+				lcname = STR_ALLOC(name_len, 0);
+				zend_str_tolower_copy(lcname->val, dep->name, name_len);
 
-				if (zend_hash_exists(&module_registry, lcname, name_len+1)) {
-					efree(lcname);
+				if (zend_hash_exists(&module_registry, lcname)) {
+					STR_FREE(lcname);
 					/* TODO: Check version relationship */
 					zend_error(E_CORE_WARNING, "Cannot load module '%s' because conflicting module '%s' is already loaded", module->name, dep->name);
 					return NULL;
 				}
-				efree(lcname);
+				STR_FREE(lcname);
 			}
 			++dep;
 		}
 	}
 
 	name_len = strlen(module->name);
-	lcname = zend_str_tolower_dup(module->name, name_len);
+	lcname = STR_ALLOC(name_len, 1);
+	zend_str_tolower_copy(lcname->val, module->name, name_len);
 
-	if (zend_hash_add(&module_registry, lcname, name_len+1, (void *)module, sizeof(zend_module_entry), (void**)&module_ptr)==FAILURE) {
+	if ((module_ptr = zend_hash_add_mem(&module_registry, lcname, module, sizeof(zend_module_entry))) == NULL) {
 		zend_error(E_CORE_WARNING, "Module '%s' already loaded", module->name);
-		efree(lcname);
+		STR_RELEASE(lcname);
 		return NULL;
 	}
-	efree(lcname);
+	STR_RELEASE(lcname);
 	module = module_ptr;
 	EG(current_module) = module;
 
@@ -1968,59 +2035,59 @@ ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce,
 
 	/* we don't care if the function name is longer, in fact lowercasing only
 	 * the beginning of the name speeds up the check process */
-	name_len = strlen(fptr->common.function_name);
-	zend_str_tolower_copy(lcname, fptr->common.function_name, MIN(name_len, sizeof(lcname)-1));
+	name_len = fptr->common.function_name->len;
+	zend_str_tolower_copy(lcname, fptr->common.function_name->val, MIN(name_len, sizeof(lcname)-1));
 	lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
 
 	if (name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Destructor %s::%s() cannot take arguments", ce->name, ZEND_DESTRUCTOR_FUNC_NAME);
+		zend_error(error_type, "Destructor %s::%s() cannot take arguments", ce->name->val, ZEND_DESTRUCTOR_FUNC_NAME);
 	} else if (name_len == sizeof(ZEND_CLONE_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME) - 1) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Method %s::%s() cannot accept any arguments", ce->name, ZEND_CLONE_FUNC_NAME);
+		zend_error(error_type, "Method %s::%s() cannot accept any arguments", ce->name->val, ZEND_CLONE_FUNC_NAME);
 	} else if (name_len == sizeof(ZEND_GET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME) - 1)) {
 		if (fptr->common.num_args != 1) {
-			zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_GET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name->val, ZEND_GET_FUNC_NAME);
 		} else if (ARG_SHOULD_BE_SENT_BY_REF(fptr, 1)) {
-			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name, ZEND_GET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name->val, ZEND_GET_FUNC_NAME);
 		}
 	} else if (name_len == sizeof(ZEND_SET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME) - 1)) {
 		if (fptr->common.num_args != 2) {
-			zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_SET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name->val, ZEND_SET_FUNC_NAME);
 		} else if (ARG_SHOULD_BE_SENT_BY_REF(fptr, 1) || ARG_SHOULD_BE_SENT_BY_REF(fptr, 2)) {
-			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name, ZEND_SET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name->val, ZEND_SET_FUNC_NAME);
 		}
 	} else if (name_len == sizeof(ZEND_UNSET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME) - 1)) {
 		if (fptr->common.num_args != 1) {
-			zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_UNSET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name->val, ZEND_UNSET_FUNC_NAME);
 		} else if (ARG_SHOULD_BE_SENT_BY_REF(fptr, 1)) {
-			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name, ZEND_UNSET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name->val, ZEND_UNSET_FUNC_NAME);
 		}
 	} else if (name_len == sizeof(ZEND_ISSET_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME) - 1)) {
 		if (fptr->common.num_args != 1) {
-			zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name, ZEND_ISSET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() must take exactly 1 argument", ce->name->val, ZEND_ISSET_FUNC_NAME);
 		} else if (ARG_SHOULD_BE_SENT_BY_REF(fptr, 1)) {
-			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name, ZEND_ISSET_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name->val, ZEND_ISSET_FUNC_NAME);
 		}
 	} else if (name_len == sizeof(ZEND_CALL_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME) - 1)) {
 		if (fptr->common.num_args != 2) {
-			zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_CALL_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name->val, ZEND_CALL_FUNC_NAME);
 		} else if (ARG_SHOULD_BE_SENT_BY_REF(fptr, 1) || ARG_SHOULD_BE_SENT_BY_REF(fptr, 2)) {
-			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name, ZEND_CALL_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name->val, ZEND_CALL_FUNC_NAME);
 		}
 	} else if (name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME) - 1 &&
 		!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1)
 	) {
 		if (fptr->common.num_args != 2) {
-			zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name, ZEND_CALLSTATIC_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() must take exactly 2 arguments", ce->name->val, ZEND_CALLSTATIC_FUNC_NAME);
 		} else if (ARG_SHOULD_BE_SENT_BY_REF(fptr, 1) || ARG_SHOULD_BE_SENT_BY_REF(fptr, 2)) {
-			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name, ZEND_CALLSTATIC_FUNC_NAME);
+			zend_error(error_type, "Method %s::%s() cannot take arguments by reference", ce->name->val, ZEND_CALLSTATIC_FUNC_NAME);
 		}
  	} else if (name_len == sizeof(ZEND_TOSTRING_FUNC_NAME) - 1 &&
  		!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && fptr->common.num_args != 0
 	) {
-		zend_error(error_type, "Method %s::%s() cannot take arguments", ce->name, ZEND_TOSTRING_FUNC_NAME);
+		zend_error(error_type, "Method %s::%s() cannot take arguments", ce->name->val, ZEND_TOSTRING_FUNC_NAME);
 	} else if (name_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME) - 1 &&
 		!memcmp(lcname, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && fptr->common.num_args != 0) {
-		zend_error(error_type, "Method %s::%s() cannot take arguments", ce->name, ZEND_DEBUGINFO_FUNC_NAME);
+		zend_error(error_type, "Method %s::%s() cannot take arguments", ce->name->val, ZEND_DEBUGINFO_FUNC_NAME);
 	}
 }
 /* }}} */
@@ -2035,11 +2102,10 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 	HashTable *target_function_table = function_table;
 	int error_type;
 	zend_function *ctor = NULL, *dtor = NULL, *clone = NULL, *__get = NULL, *__set = NULL, *__unset = NULL, *__isset = NULL, *__call = NULL, *__callstatic = NULL, *__tostring = NULL, *__debugInfo = NULL;
-	const char *lowercase_name;
+	zend_string *lowercase_name;
 	int fname_len;
 	const char *lc_class_name = NULL;
 	int class_name_len = 0;
-	zend_ulong hash;
 
 	if (type==MODULE_PERSISTENT) {
 		error_type = E_CORE_WARNING;
@@ -2054,25 +2120,26 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 	internal_function->module = EG(current_module);
 
 	if (scope) {
-		class_name_len = strlen(scope->name);
-		if ((lc_class_name = zend_memrchr(scope->name, '\\', class_name_len))) {
+		class_name_len = scope->name->len;
+		if ((lc_class_name = zend_memrchr(scope->name->val, '\\', class_name_len))) {
 			++lc_class_name;
-			class_name_len -= (lc_class_name - scope->name);
+			class_name_len -= (lc_class_name - scope->name->val);
 			lc_class_name = zend_str_tolower_dup(lc_class_name, class_name_len);
 		} else {
-			lc_class_name = zend_str_tolower_dup(scope->name, class_name_len);
+			lc_class_name = zend_str_tolower_dup(scope->name->val, class_name_len);
 		}
 	}
 
 	while (ptr->fname) {
+		fname_len = strlen(ptr->fname);
 		internal_function->handler = ptr->handler;
-		internal_function->function_name = (char*)ptr->fname;
+		internal_function->function_name = zend_new_interned_string(STR_INIT(ptr->fname, fname_len, 1) TSRMLS_CC);
 		internal_function->scope = scope;
 		internal_function->prototype = NULL;
 		if (ptr->flags) {
 			if (!(ptr->flags & ZEND_ACC_PPP_MASK)) {
 				if (ptr->flags != ZEND_ACC_DEPRECATED || scope) {
-					zend_error(error_type, "Invalid access level for %s%s%s() - access must be exactly one of public, protected or private", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+					zend_error(error_type, "Invalid access level for %s%s%s() - access must be exactly one of public, protected or private", scope ? scope->name->val : "", scope ? "::" : "", ptr->fname);
 				}
 				internal_function->fn_flags = ZEND_ACC_PUBLIC | ptr->flags;
 			} else {
@@ -2115,29 +2182,32 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 				}
 			}
 			if (ptr->flags & ZEND_ACC_STATIC && (!scope || !(scope->ce_flags & ZEND_ACC_INTERFACE))) {
-				zend_error(error_type, "Static function %s%s%s() cannot be abstract", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+				zend_error(error_type, "Static function %s%s%s() cannot be abstract", scope ? scope->name->val : "", scope ? "::" : "", ptr->fname);
 			}
 		} else {
 			if (scope && (scope->ce_flags & ZEND_ACC_INTERFACE)) {
 				efree((char*)lc_class_name);
-				zend_error(error_type, "Interface %s cannot contain non abstract method %s()", scope->name, ptr->fname);
+				zend_error(error_type, "Interface %s cannot contain non abstract method %s()", scope->name->val, ptr->fname);
 				return FAILURE;
 			}
 			if (!internal_function->handler) {
 				if (scope) {
 					efree((char*)lc_class_name);
 				}
-				zend_error(error_type, "Method %s%s%s() cannot be a NULL function", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+				zend_error(error_type, "Method %s%s%s() cannot be a NULL function", scope ? scope->name->val : "", scope ? "::" : "", ptr->fname);
 				zend_unregister_functions(functions, count, target_function_table TSRMLS_CC);
 				return FAILURE;
 			}
 		}
-		fname_len = strlen(ptr->fname);
-		lowercase_name = zend_new_interned_string(zend_str_tolower_dup(ptr->fname, fname_len), fname_len + 1, 1 TSRMLS_CC);
-		hash = str_hash(lowercase_name, fname_len);
-		if (zend_hash_quick_add(target_function_table, lowercase_name, fname_len+1, hash, &function, sizeof(zend_function), (void**)&reg_function) == FAILURE) {
+		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);
+		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;
-			str_efree(lowercase_name);
+			free(reg_function);
+			STR_RELEASE(lowercase_name);
 			break;
 		}
 
@@ -2158,32 +2228,32 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 			 * If it's an old-style constructor, store it only if we don't have
 			 * a constructor already.
 			 */
-			if ((fname_len == class_name_len) && !ctor && !memcmp(lowercase_name, lc_class_name, class_name_len+1)) {
+			if ((fname_len == class_name_len) && !ctor && !memcmp(lowercase_name->val, lc_class_name, class_name_len+1)) {
 				ctor = reg_function;
-			} else if ((fname_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME) - 1)) {
 				ctor = reg_function;
-			} else if ((fname_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME) - 1)) {
 				dtor = reg_function;
 				if (internal_function->num_args) {
-					zend_error(error_type, "Destructor %s::%s() cannot take arguments", scope->name, ptr->fname);
+					zend_error(error_type, "Destructor %s::%s() cannot take arguments", scope->name->val, ptr->fname);
 				}
-			} else if ((fname_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME) - 1)) {
 				clone = reg_function;
-			} else if ((fname_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME) - 1)) {
 				__call = reg_function;
-			} else if ((fname_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME) - 1)) {
 				__callstatic = reg_function;
-			} else if ((fname_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME) - 1)) {
 				__tostring = reg_function;
-			} else if ((fname_len == sizeof(ZEND_GET_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_GET_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME) - 1)) {
 				__get = reg_function;
-			} else if ((fname_len == sizeof(ZEND_SET_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_SET_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME) - 1)) {
 				__set = reg_function;
-			} else if ((fname_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME) - 1)) {
 				__unset = reg_function;
-			} else if ((fname_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME) - 1)) {
 				__isset = reg_function;
-			} else if ((fname_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && !memcmp(lowercase_name, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME) - 1)) {
+			} else if ((fname_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && !memcmp(lowercase_name->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME) - 1)) {
 				__debugInfo = reg_function;
 			} else {
 				reg_function = NULL;
@@ -2194,7 +2264,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 		}
 		ptr++;
 		count++;
-		str_efree(lowercase_name);
+		STR_RELEASE(lowercase_name);
 	}
 	if (unload) { /* before unloading, display all remaining bad function in the module */
 		if (scope) {
@@ -2202,11 +2272,12 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 		}
 		while (ptr->fname) {
 			fname_len = strlen(ptr->fname);
-			lowercase_name = zend_str_tolower_dup(ptr->fname, fname_len);
-			if (zend_hash_exists(target_function_table, lowercase_name, fname_len+1)) {
-				zend_error(error_type, "Function registration failed - duplicate name - %s%s%s", scope ? scope->name : "", scope ? "::" : "", ptr->fname);
+			lowercase_name = STR_ALLOC(fname_len, 0);
+			zend_str_tolower_copy(lowercase_name->val, ptr->fname, fname_len);
+			if (zend_hash_exists(target_function_table, lowercase_name)) {
+				zend_error(error_type, "Function registration failed - duplicate name - %s%s%s", scope ? scope->name->val : "", scope ? "::" : "", ptr->fname);
 			}
-			efree((char*)lowercase_name);
+			STR_FREE(lowercase_name);
 			ptr++;
 		}
 		zend_unregister_functions(functions, count, target_function_table TSRMLS_CC);
@@ -2227,69 +2298,69 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
 		if (ctor) {
 			ctor->common.fn_flags |= ZEND_ACC_CTOR;
 			if (ctor->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Constructor %s::%s() cannot be static", scope->name, ctor->common.function_name);
+				zend_error(error_type, "Constructor %s::%s() cannot be static", scope->name->val, ctor->common.function_name->val);
 			}
 			ctor->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (dtor) {
 			dtor->common.fn_flags |= ZEND_ACC_DTOR;
 			if (dtor->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Destructor %s::%s() cannot be static", scope->name, dtor->common.function_name);
+				zend_error(error_type, "Destructor %s::%s() cannot be static", scope->name->val, dtor->common.function_name->val);
 			}
 			dtor->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (clone) {
 			clone->common.fn_flags |= ZEND_ACC_CLONE;
 			if (clone->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Constructor %s::%s() cannot be static", scope->name, clone->common.function_name);
+				zend_error(error_type, "Constructor %s::%s() cannot be static", scope->name->val, clone->common.function_name->val);
 			}
 			clone->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__call) {
 			if (__call->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __call->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __call->common.function_name->val);
 			}
 			__call->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__callstatic) {
 			if (!(__callstatic->common.fn_flags & ZEND_ACC_STATIC)) {
-				zend_error(error_type, "Method %s::%s() must be static", scope->name, __callstatic->common.function_name);
+				zend_error(error_type, "Method %s::%s() must be static", scope->name->val, __callstatic->common.function_name->val);
 			}
 			__callstatic->common.fn_flags |= ZEND_ACC_STATIC;
 		}
 		if (__tostring) {
 			if (__tostring->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __tostring->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __tostring->common.function_name->val);
 			}
 			__tostring->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__get) {
 			if (__get->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __get->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __get->common.function_name->val);
 			}
 			__get->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__set) {
 			if (__set->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __set->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __set->common.function_name->val);
 			}
 			__set->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__unset) {
 			if (__unset->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __unset->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __unset->common.function_name->val);
 			}
 			__unset->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__isset) {
 			if (__isset->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __isset->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __isset->common.function_name->val);
 			}
 			__isset->common.fn_flags &= ~ZEND_ACC_ALLOW_STATIC;
 		}
 		if (__debugInfo) {
 			if (__debugInfo->common.fn_flags & ZEND_ACC_STATIC) {
-				zend_error(error_type, "Method %s::%s() cannot be static", scope->name, __debugInfo->common.function_name);
+				zend_error(error_type, "Method %s::%s() cannot be static", scope->name->val, __debugInfo->common.function_name->val);
 			}
 		}
 		efree((char*)lc_class_name);
@@ -2306,6 +2377,8 @@ ZEND_API void zend_unregister_functions(const zend_function_entry *functions, in
 	const zend_function_entry *ptr = functions;
 	int i=0;
 	HashTable *target_function_table = function_table;
+	zend_string *lowercase_name;
+	int fname_len;
 
 	if (!target_function_table) {
 		target_function_table = CG(function_table);
@@ -2314,10 +2387,11 @@ ZEND_API void zend_unregister_functions(const zend_function_entry *functions, in
 		if (count!=-1 && i>=count) {
 			break;
 		}
-#if 0
-		zend_printf("Unregistering %s()\n", ptr->fname);
-#endif
-		zend_hash_del(target_function_table, ptr->fname, strlen(ptr->fname)+1);
+		fname_len = strlen(ptr->fname);
+		lowercase_name = STR_ALLOC(fname_len, 0);
+		zend_str_tolower_copy(lowercase_name->val, ptr->fname, fname_len);
+		zend_hash_del(target_function_table, lowercase_name);
+		STR_FREE(lowercase_name);
 		ptr++;
 		i++;
 	}
@@ -2337,7 +2411,8 @@ ZEND_API int zend_get_module_started(const char *module_name) /* {{{ */
 {
 	zend_module_entry *module;
 
-	return (zend_hash_find(&module_registry, module_name, strlen(module_name)+1, (void**)&module) == SUCCESS && module->module_started) ? SUCCESS : FAILURE;
+	module = zend_hash_str_find_ptr(&module_registry, module_name, strlen(module_name));
+	return (module && module->module_started) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
@@ -2419,8 +2494,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);
@@ -2437,7 +2514,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;
 
@@ -2506,8 +2583,7 @@ int zend_next_free_module(void) /* {{{ */
 static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class_entry, zend_uint ce_flags TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *class_entry = malloc(sizeof(zend_class_entry));
-	char *lowercase_name = emalloc(orig_class_entry->name_length + 1);
-	zend_ulong hash;
+	zend_string *lowercase_name = STR_ALLOC(orig_class_entry->name->len, 1);
 	*class_entry = *orig_class_entry;
 
 	class_entry->type = ZEND_INTERNAL_CLASS;
@@ -2519,11 +2595,10 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class
 		zend_register_functions(class_entry, class_entry->info.internal.builtin_functions, &class_entry->function_table, MODULE_PERSISTENT TSRMLS_CC);
 	}
 
-	zend_str_tolower_copy(lowercase_name, orig_class_entry->name, class_entry->name_length);
-	lowercase_name = (char*)zend_new_interned_string(lowercase_name, class_entry->name_length + 1, 1 TSRMLS_CC);
-	hash = str_hash(lowercase_name, class_entry->name_length);
-	zend_hash_quick_update(CG(class_table), lowercase_name, class_entry->name_length+1, hash, &class_entry, sizeof(zend_class_entry *), NULL);
-	str_efree(lowercase_name);
+	zend_str_tolower_copy(lowercase_name->val, orig_class_entry->name->val, class_entry->name->len);
+	lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
+	zend_hash_update_ptr(CG(class_table), lowercase_name, class_entry);
+	STR_RELEASE(lowercase_name);
 	return class_entry;
 }
 /* }}} */
@@ -2533,19 +2608,10 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class
  * If both parent_ce and parent_name are NULL it does a regular class registration
  * If parent_name is specified but not found NULL is returned
  */
-ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *register_class;
 
-	if (!parent_ce && parent_name) {
-		zend_class_entry **pce;
-		if (zend_hash_find(CG(class_table), parent_name, strlen(parent_name)+1, (void **) &pce)==FAILURE) {
-			return NULL;
-		} else {
-			parent_ce = *pce;
-		}
-	}
-
 	register_class = zend_register_internal_class(class_entry TSRMLS_CC);
 
 	if (parent_ce) {
@@ -2586,20 +2652,22 @@ ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *or
 
 ZEND_API int zend_register_class_alias_ex(const char *name, int name_len, zend_class_entry *ce TSRMLS_DC) /* {{{ */
 {
-	char *lcname = zend_str_tolower_dup(name, name_len);
-	int ret;
+	zend_string *lcname;
 
-	if (lcname[0] == '\\') {
-		ret = zend_hash_add(CG(class_table), lcname+1, name_len, &ce, sizeof(zend_class_entry *), NULL);
+	if (name[0] == '\\') {
+		lcname = STR_ALLOC(name_len-1, 1);
+		zend_str_tolower_copy(lcname->val, name+1, name_len-1);
 	} else {
-		ret = zend_hash_add(CG(class_table), lcname, name_len+1, &ce, sizeof(zend_class_entry *), NULL);
+		lcname = STR_ALLOC(name_len, 1);
+		zend_str_tolower_copy(lcname->val, name, name_len);
 	}
-
-	efree(lcname);
-	if (ret == SUCCESS) {
+	ce = zend_hash_add_ptr(CG(class_table), lcname, ce);
+	STR_RELEASE(lcname);
+	if (ce) {
 		ce->refcount++;
+		return SUCCESS;
 	}
-	return ret;
+	return FAILURE;
 }
 /* }}} */
 
@@ -2610,13 +2678,17 @@ ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_lengt
 
 	if (num_symbol_tables <= 0) return FAILURE;
 
-	Z_SET_ISREF_TO_P(symbol, is_ref);
+	if (is_ref && !Z_ISREF_P(symbol)) {
+		ZVAL_NEW_REF(symbol, symbol);
+	}
 
 	va_start(symbol_table_list, num_symbol_tables);
 	while (num_symbol_tables-- > 0) {
 		symbol_table = va_arg(symbol_table_list, HashTable *);
-		zend_hash_update(symbol_table, name, name_length + 1, &symbol, sizeof(zval *), NULL);
-		zval_add_ref(&symbol);
+		zend_hash_str_update(symbol_table, name, name_length, symbol);
+		if (Z_REFCOUNTED_P(symbol)) {
+			Z_ADDREF_P(symbol);
+		}
 	}
 	va_end(symbol_table_list);
 	return SUCCESS;
@@ -2640,7 +2712,10 @@ static zend_function_entry disabled_function[] = {
 
 ZEND_API int zend_disable_function(char *function_name, uint function_name_length TSRMLS_DC) /* {{{ */
 {
-	if (zend_hash_del(CG(function_table), function_name, function_name_length+1)==FAILURE) {
+	int ret;
+
+	ret = zend_hash_str_del(CG(function_table), function_name, function_name_length);
+	if (ret == FAILURE) {
 		return FAILURE;
 	}
 	disabled_function[0].fname = function_name;
@@ -2651,13 +2726,13 @@ ZEND_API int zend_disable_function(char *function_name, uint function_name_lengt
 #ifdef ZEND_WIN32
 #pragma optimize("", off)
 #endif
-static zend_object_value display_disabled_class(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *display_disabled_class(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	zend_object_value retval;
 	zend_object *intern;
-	retval = zend_objects_new(&intern, class_type TSRMLS_CC);
-	zend_error(E_WARNING, "%s() has been disabled for security reasons", class_type->name);
-	return retval;
+
+	intern = zend_objects_new(class_type TSRMLS_CC);
+	zend_error(E_WARNING, "%s() has been disabled for security reasons", class_type->name->val);
+	return intern;
 }
 #ifdef ZEND_WIN32
 #pragma optimize("", on)
@@ -2670,40 +2745,47 @@ static const zend_function_entry disabled_class_new[] = {
 
 ZEND_API int zend_disable_class(char *class_name, uint class_name_length TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry **disabled_class;
+	zend_class_entry *disabled_class;
+	zend_string *key;
 
-	zend_str_tolower(class_name, class_name_length);
-	if (zend_hash_find(CG(class_table), class_name, class_name_length+1, (void **)&disabled_class)==FAILURE) {
+	key = STR_ALLOC(class_name_length, 0);
+	zend_str_tolower_copy(key->val, class_name, class_name_length);
+	disabled_class = zend_hash_find_ptr(CG(class_table), key);
+	if (!disabled_class) {
 		return FAILURE;
 	}
-	INIT_CLASS_ENTRY_INIT_METHODS((**disabled_class), disabled_class_new, NULL, NULL, NULL, NULL, NULL);
-	(*disabled_class)->create_object = display_disabled_class;
-	zend_hash_clean(&((*disabled_class)->function_table));
+	INIT_CLASS_ENTRY_INIT_METHODS((*disabled_class), disabled_class_new, NULL, NULL, NULL, NULL, NULL);
+	disabled_class->create_object = display_disabled_class;
+	zend_hash_clean(&disabled_class->function_table);
 	return SUCCESS;
 }
 /* }}} */
 
-static int zend_is_callable_check_class(const char *name, int name_len, zend_fcall_info_cache *fcc, int *strict_class, char **error TSRMLS_DC) /* {{{ */
+static int zend_is_callable_check_class(zend_string *name, zend_fcall_info_cache *fcc, int *strict_class, char **error TSRMLS_DC) /* {{{ */
 {
 	int ret = 0;
-	zend_class_entry **pce;
-	char *lcname = zend_str_tolower_dup(name, name_len);
+	zend_class_entry *ce;
+	int name_len = name->len;
+	zend_string *lcname;
+	
+	lcname = STR_ALLOC(name_len, 0);	
+	zend_str_tolower_copy(lcname->val, name->val, name_len);
 
 	*strict_class = 0;
 	if (name_len == sizeof("self") - 1 &&
-	    !memcmp(lcname, "self", sizeof("self") - 1)) {
+	    !memcmp(lcname->val, "self", sizeof("self") - 1)) {
 		if (!EG(scope)) {
 			if (error) *error = estrdup("cannot access self:: when no class scope is active");
 		} else {
 			fcc->called_scope = EG(called_scope);
 			fcc->calling_scope = EG(scope);
-			if (!fcc->object_ptr) {
-				fcc->object_ptr = EG(This);
+			if (!fcc->object && Z_OBJ(EG(This))) {
+				fcc->object = Z_OBJ(EG(This));
 			}
 			ret = 1;
 		}
 	} else if (name_len == sizeof("parent") - 1 && 
-		       !memcmp(lcname, "parent", sizeof("parent") - 1)) {
+		       !memcmp(lcname->val, "parent", sizeof("parent") - 1)) {
 		if (!EG(scope)) {
 			if (error) *error = estrdup("cannot access parent:: when no class scope is active");
 		} else if (!EG(scope)->parent) {
@@ -2711,43 +2793,43 @@ static int zend_is_callable_check_class(const char *name, int name_len, zend_fca
 		} else {
 			fcc->called_scope = EG(called_scope);
 			fcc->calling_scope = EG(scope)->parent;
-			if (!fcc->object_ptr) {
-				fcc->object_ptr = EG(This);
+			if (!fcc->object && Z_OBJ(EG(This))) {
+				fcc->object = Z_OBJ(EG(This));
 			}
 			*strict_class = 1;
 			ret = 1;
 		}
 	} else if (name_len == sizeof("static") - 1 &&
-	           !memcmp(lcname, "static", sizeof("static") - 1)) {
+	           !memcmp(lcname->val, "static", sizeof("static") - 1)) {
 		if (!EG(called_scope)) {
 			if (error) *error = estrdup("cannot access static:: when no class scope is active");
 		} else {
 			fcc->called_scope = EG(called_scope);
 			fcc->calling_scope = EG(called_scope);
-			if (!fcc->object_ptr) {
-				fcc->object_ptr = EG(This);
+			if (!fcc->object && Z_OBJ(EG(This))) {
+				fcc->object = Z_OBJ(EG(This));
 			}
 			*strict_class = 1;
 			ret = 1;
 		}
-	} else if (zend_lookup_class_ex(name, name_len, NULL, 1, &pce TSRMLS_CC) == SUCCESS) {
+	} else if ((ce = zend_lookup_class_ex(name, NULL, 1 TSRMLS_CC)) != NULL) {
 		zend_class_entry *scope = EG(active_op_array) ? EG(active_op_array)->scope : NULL;
 
-		fcc->calling_scope = *pce;
-		if (scope && !fcc->object_ptr && EG(This) &&
-		    instanceof_function(Z_OBJCE_P(EG(This)), scope TSRMLS_CC) &&
+		fcc->calling_scope = ce;
+		if (scope && !fcc->object && Z_OBJ(EG(This)) &&
+		    instanceof_function(Z_OBJCE(EG(This)), scope TSRMLS_CC) &&
 		    instanceof_function(scope, fcc->calling_scope TSRMLS_CC)) {
-			fcc->object_ptr = EG(This);
-			fcc->called_scope = Z_OBJCE_P(fcc->object_ptr);
+			fcc->object = Z_OBJ(EG(This));
+			fcc->called_scope = Z_OBJCE(EG(This));
 		} else {
-			fcc->called_scope = fcc->object_ptr ? Z_OBJCE_P(fcc->object_ptr) : fcc->calling_scope;
+			fcc->called_scope = fcc->object ? zend_get_class_entry(fcc->object TSRMLS_CC) : fcc->calling_scope;
 		}
 		*strict_class = 1;
 		ret = 1;
 	} else {
-		if (error) zend_spprintf(error, 0, "class '%.*s' not found", name_len, name);
+		if (error) zend_spprintf(error, 0, "class '%.*s' not found", name_len, name->val);
 	}
-	efree(lcname);
+	STR_FREE(lcname);
 	return ret;
 }
 /* }}} */
@@ -2756,12 +2838,14 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
 {
 	zend_class_entry *ce_org = fcc->calling_scope;
 	int retval = 0;
-	char *mname, *lmname;
+	zend_string *mname, *cname;
+	zend_string *lmname;
 	const char *colon;
 	int clen, mlen;
 	zend_class_entry *last_scope;
 	HashTable *ftable;
 	int call_via_handler = 0;
+	ALLOCA_FLAG(use_heap)
 
 	if (error) {
 		*error = NULL;
@@ -2771,21 +2855,27 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
 	fcc->function_handler = NULL;
 
 	if (!ce_org) {
+		char *lmname;
+		int lmname_len;
+
 		/* Skip leading \ */
 		if (Z_STRVAL_P(callable)[0] == '\\') {
-			mlen = Z_STRLEN_P(callable) - 1;
-			lmname = zend_str_tolower_dup(Z_STRVAL_P(callable) + 1, mlen);
+			lmname = do_alloca(Z_STRLEN_P(callable) - 1, use_heap);
+			lmname_len = Z_STRLEN_P(callable) - 1;
+			zend_str_tolower_copy(lmname, Z_STRVAL_P(callable) + 1, lmname_len);
 		} else {
-			mlen = Z_STRLEN_P(callable);
-			lmname = zend_str_tolower_dup(Z_STRVAL_P(callable), mlen);
+			lmname = do_alloca(Z_STRLEN_P(callable), use_heap);
+			lmname_len = Z_STRLEN_P(callable);
+			zend_str_tolower_copy(lmname, Z_STRVAL_P(callable), lmname_len);
 		}
 		/* Check if function with given name exists.
 		 * This may be a compound name that includes namespace name */
-		if (zend_hash_find(EG(function_table), lmname, mlen+1, (void**)&fcc->function_handler) == SUCCESS) {
-			efree(lmname);
+		fcc->function_handler = zend_hash_str_find_ptr(EG(function_table), lmname, lmname_len);
+		if (fcc->function_handler != NULL) {
+			free_alloca(lmname, use_heap);
 			return 1;
 		}
-		efree(lmname);
+		free_alloca(lmname, use_heap);
 	}
 
 	/* Split name into class/namespace and method/function names */
@@ -2809,22 +2899,26 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
 			EG(scope) = ce_org;
 		}
 
-		if (!zend_is_callable_check_class(Z_STRVAL_P(callable), clen, fcc, &strict_class, error TSRMLS_CC)) {
+		cname = STR_INIT(Z_STRVAL_P(callable), clen, 0);
+		if (!zend_is_callable_check_class(cname, fcc, &strict_class, error TSRMLS_CC)) {
+			STR_RELEASE(cname);
 			EG(scope) = last_scope;
 			return 0;
 		}
+		STR_RELEASE(cname);
 		EG(scope) = last_scope;
 
 		ftable = &fcc->calling_scope->function_table;
 		if (ce_org && !instanceof_function(ce_org, fcc->calling_scope TSRMLS_CC)) {
-			if (error) zend_spprintf(error, 0, "class '%s' is not a subclass of '%s'", ce_org->name, fcc->calling_scope->name);
+			if (error) zend_spprintf(error, 0, "class '%s' is not a subclass of '%s'", ce_org->name->val, fcc->calling_scope->name->val);
 			return 0;
 		}
-		mname = Z_STRVAL_P(callable) + clen + 2;
+		mname = STR_INIT(Z_STRVAL_P(callable) + clen + 2, mlen, 0);
 	} else if (ce_org) {
 		/* Try to fetch find static method of given class. */
 		mlen = Z_STRLEN_P(callable);
-		mname = Z_STRVAL_P(callable);
+		mname = Z_STR_P(callable);
+		STR_ADDREF(mname);
 		ftable = &ce_org->function_table;
 		fcc->calling_scope = ce_org;
 	} else {
@@ -2835,23 +2929,24 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
 		return 0;
 	}
 
-	lmname = zend_str_tolower_dup(mname, mlen);
+	lmname = STR_ALLOC(mlen, 0);
+	zend_str_tolower_copy(lmname->val, mname->val, mlen);
 	if (strict_class &&
 	    fcc->calling_scope &&
 	    mlen == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1 &&
-	    !memcmp(lmname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME) - 1)) {
+	    !memcmp(lmname->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME) - 1)) {
 		fcc->function_handler = fcc->calling_scope->constructor;
 		if (fcc->function_handler) {
 			retval = 1;
 		}
-	} else if (zend_hash_find(ftable, lmname, mlen+1, (void**)&fcc->function_handler) == SUCCESS) {
+	} else if ((fcc->function_handler = zend_hash_find_ptr(ftable, lmname)) != NULL) {
 		retval = 1;
 		if ((fcc->function_handler->op_array.fn_flags & ZEND_ACC_CHANGED) &&
 		    !strict_class && EG(scope) &&
 		    instanceof_function(fcc->function_handler->common.scope, EG(scope) TSRMLS_CC)) {
 			zend_function *priv_fbc;
 
-			if (zend_hash_find(&EG(scope)->function_table, lmname, mlen+1, (void **) &priv_fbc)==SUCCESS
+			if ((priv_fbc = zend_hash_find_ptr(&EG(scope)->function_table, lmname)) != NULL
 				&& priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE
 				&& priv_fbc->common.scope == EG(scope)) {
 				fcc->function_handler = priv_fbc;
@@ -2859,10 +2954,10 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
 		}
 		if ((check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0 &&
 		    (fcc->calling_scope &&
-		     ((fcc->object_ptr && fcc->calling_scope->__call) ||
-		      (!fcc->object_ptr && fcc->calling_scope->__callstatic)))) {
+		     ((fcc->object && fcc->calling_scope->__call) ||
+		      (!fcc->object && fcc->calling_scope->__callstatic)))) {
 			if (fcc->function_handler->op_array.fn_flags & ZEND_ACC_PRIVATE) {
-				if (!zend_check_private(fcc->function_handler, fcc->object_ptr ? Z_OBJCE_P(fcc->object_ptr) : EG(scope), lmname, mlen TSRMLS_CC)) {
+				if (!zend_check_private(fcc->function_handler, fcc->object ? zend_get_class_entry(fcc->object TSRMLS_CC) : EG(scope), lmname TSRMLS_CC)) {
 					retval = 0;
 					fcc->function_handler = NULL;
 					goto get_function_via_handler;
@@ -2877,7 +2972,7 @@ static int zend_is_callable_check_func(int check_flags, zval *callable, zend_fca
 		}
 	} else {
 get_function_via_handler:
-		if (fcc->object_ptr && fcc->calling_scope == ce_org) {
+		if (fcc->object && fcc->calling_scope == ce_org) {
 			if (strict_class && ce_org->__call) {
 				fcc->function_handler = emalloc(sizeof(zend_internal_function));
 				fcc->function_handler->internal_function.type = ZEND_INTERNAL_FUNCTION;
@@ -2887,18 +2982,19 @@ get_function_via_handler:
 				fcc->function_handler->internal_function.num_args = 0;
 				fcc->function_handler->internal_function.scope = ce_org;
 				fcc->function_handler->internal_function.fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
-				fcc->function_handler->internal_function.function_name = estrndup(mname, mlen);
+				fcc->function_handler->internal_function.function_name = mname;
+				STR_ADDREF(mname);
 				call_via_handler = 1;
 				retval = 1;
-			} else if (Z_OBJ_HT_P(fcc->object_ptr)->get_method) {
-				fcc->function_handler = Z_OBJ_HT_P(fcc->object_ptr)->get_method(&fcc->object_ptr, mname, mlen, NULL TSRMLS_CC);
+			} else if (fcc->object->handlers->get_method) {
+				fcc->function_handler = fcc->object->handlers->get_method(&fcc->object, mname, NULL TSRMLS_CC);
 				if (fcc->function_handler) {
 					if (strict_class &&
 					    (!fcc->function_handler->common.scope ||
 					     !instanceof_function(ce_org, fcc->function_handler->common.scope TSRMLS_CC))) {
 						if ((fcc->function_handler->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0) {
 							if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION) {
-								efree((char*)fcc->function_handler->common.function_name);
+								STR_RELEASE(fcc->function_handler->common.function_name);
 							}
 							efree(fcc->function_handler);
 						}
@@ -2910,17 +3006,17 @@ get_function_via_handler:
 			}
 		} else if (fcc->calling_scope) {
 			if (fcc->calling_scope->get_static_method) {
-				fcc->function_handler = fcc->calling_scope->get_static_method(fcc->calling_scope, mname, mlen TSRMLS_CC);
+				fcc->function_handler = fcc->calling_scope->get_static_method(fcc->calling_scope, mname TSRMLS_CC);
 			} else {
-				fcc->function_handler = zend_std_get_static_method(fcc->calling_scope, mname, mlen, NULL TSRMLS_CC);
+				fcc->function_handler = zend_std_get_static_method(fcc->calling_scope, mname, NULL TSRMLS_CC);
 			}
 			if (fcc->function_handler) {
 				retval = 1;
 				call_via_handler = (fcc->function_handler->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0;
-				if (call_via_handler && !fcc->object_ptr && EG(This) &&
-				    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-				    instanceof_function(Z_OBJCE_P(EG(This)), fcc->calling_scope TSRMLS_CC)) {
-					fcc->object_ptr = EG(This);
+				if (call_via_handler && !fcc->object && Z_OBJ(EG(This)) &&
+				    Z_OBJ_HT(EG(This))->get_class_entry &&
+				    instanceof_function(Z_OBJCE(EG(This)), fcc->calling_scope TSRMLS_CC)) {
+					fcc->object = Z_OBJ(EG(This));
 				}
 			}
 		}
@@ -2928,14 +3024,14 @@ get_function_via_handler:
 
 	if (retval) {
 		if (fcc->calling_scope && !call_via_handler) {
-			if (!fcc->object_ptr && (fcc->function_handler->common.fn_flags & ZEND_ACC_ABSTRACT)) {
+			if (!fcc->object && (fcc->function_handler->common.fn_flags & ZEND_ACC_ABSTRACT)) {
 				if (error) {
-					zend_spprintf(error, 0, "cannot call abstract method %s::%s()", fcc->calling_scope->name, fcc->function_handler->common.function_name);
+					zend_spprintf(error, 0, "cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
 					retval = 0;
 				} else {
-					zend_error(E_ERROR, "Cannot call abstract method %s::%s()", fcc->calling_scope->name, fcc->function_handler->common.function_name);
+					zend_error(E_ERROR, "Cannot call abstract method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
 				}
-			} else if (!fcc->object_ptr && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) {
+			} else if (!fcc->object && !(fcc->function_handler->common.fn_flags & ZEND_ACC_STATIC)) {
 				int severity;
 				char *verb;
 				if (fcc->function_handler->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
@@ -2949,35 +3045,35 @@ get_function_via_handler:
 				if ((check_flags & IS_CALLABLE_CHECK_IS_STATIC) != 0) {
 					retval = 0;
 				}
-				if (EG(This) && instanceof_function(Z_OBJCE_P(EG(This)), fcc->calling_scope TSRMLS_CC)) {
-					fcc->object_ptr = EG(This);
+				if (Z_OBJ(EG(This)) && instanceof_function(Z_OBJCE(EG(This)), fcc->calling_scope TSRMLS_CC)) {
+					fcc->object = Z_OBJ(EG(This));
 					if (error) {
-						zend_spprintf(error, 0, "non-static method %s::%s() %s be called statically, assuming $this from compatible context %s", fcc->calling_scope->name, fcc->function_handler->common.function_name, verb, Z_OBJCE_P(EG(This))->name);
+						zend_spprintf(error, 0, "non-static method %s::%s() %s be called statically, assuming $this from compatible context %s", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val, verb, Z_OBJCE(EG(This))->name->val);
 						if (severity == E_ERROR) {
 							retval = 0;
 						}
 					} else if (retval) {
-						zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from compatible context %s", fcc->calling_scope->name, fcc->function_handler->common.function_name, verb, Z_OBJCE_P(EG(This))->name);
+						zend_error(severity, "Non-static method %s::%s() %s be called statically, assuming $this from compatible context %s", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val, verb, Z_OBJCE(EG(This))->name->val);
 					}
 				} else {
 					if (error) {
-						zend_spprintf(error, 0, "non-static method %s::%s() %s be called statically", fcc->calling_scope->name, fcc->function_handler->common.function_name, verb);
+						zend_spprintf(error, 0, "non-static method %s::%s() %s be called statically", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val, verb);
 						if (severity == E_ERROR) {
 							retval = 0;
 						}
 					} else if (retval) {
-						zend_error(severity, "Non-static method %s::%s() %s be called statically", fcc->calling_scope->name, fcc->function_handler->common.function_name, verb);
+						zend_error(severity, "Non-static method %s::%s() %s be called statically", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val, verb);
 					}
 				}
 			}
 			if (retval && (check_flags & IS_CALLABLE_CHECK_NO_ACCESS) == 0) {
 				if (fcc->function_handler->op_array.fn_flags & ZEND_ACC_PRIVATE) {
-					if (!zend_check_private(fcc->function_handler, fcc->object_ptr ? Z_OBJCE_P(fcc->object_ptr) : EG(scope), lmname, mlen TSRMLS_CC)) {
+					if (!zend_check_private(fcc->function_handler, fcc->object ? zend_get_class_entry(fcc->object TSRMLS_CC) : EG(scope), lmname TSRMLS_CC)) {
 						if (error) {
 							if (*error) {
 								efree(*error);
 							}
-							zend_spprintf(error, 0, "cannot access private method %s::%s()", fcc->calling_scope->name, fcc->function_handler->common.function_name);
+							zend_spprintf(error, 0, "cannot access private method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
 						}
 						retval = 0;
 					}
@@ -2987,7 +3083,7 @@ get_function_via_handler:
 							if (*error) {
 								efree(*error);
 							}
-							zend_spprintf(error, 0, "cannot access protected method %s::%s()", fcc->calling_scope->name, fcc->function_handler->common.function_name);
+							zend_spprintf(error, 0, "cannot access protected method %s::%s()", fcc->calling_scope->name->val, fcc->function_handler->common.function_name->val);
 						}
 						retval = 0;
 					}
@@ -2996,15 +3092,16 @@ get_function_via_handler:
 		}
 	} else if (error && !(check_flags & IS_CALLABLE_CHECK_SILENT)) {
 		if (fcc->calling_scope) {
-			if (error) zend_spprintf(error, 0, "class '%s' does not have a method '%s'", fcc->calling_scope->name, mname);
+			if (error) zend_spprintf(error, 0, "class '%s' does not have a method '%s'", fcc->calling_scope->name->val, mname->val);
 		} else {
-			if (error) zend_spprintf(error, 0, "function '%s' does not exist", mname);
+			if (error) zend_spprintf(error, 0, "function '%s' does not exist", mname->val);
 		}
 	}
-	efree(lmname);
+	STR_FREE(lmname);
+	STR_RELEASE(mname);
 
-	if (fcc->object_ptr) {
-		fcc->called_scope = Z_OBJCE_P(fcc->object_ptr);
+	if (fcc->object) {
+		fcc->called_scope = zend_get_class_entry(fcc->object TSRMLS_CC);
 	}
 	if (retval) {
 		fcc->initialized = 1;
@@ -3013,18 +3110,14 @@ get_function_via_handler:
 }
 /* }}} */
 
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, char **callable_name, int *callable_name_len, zend_fcall_info_cache *fcc, char **error TSRMLS_DC) /* {{{ */
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error TSRMLS_DC) /* {{{ */
 {
 	zend_bool ret;
-	int callable_name_len_local;
 	zend_fcall_info_cache fcc_local;
 
 	if (callable_name) {
 		*callable_name = NULL;
 	}
-	if (callable_name_len == NULL) {
-		callable_name_len = &callable_name_len_local;
-	}
 	if (fcc == NULL) {
 		fcc = &fcc_local;
 	}
@@ -3037,36 +3130,32 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint ch
 	fcc->called_scope = NULL;
 	fcc->function_handler = NULL;
 	fcc->calling_scope = NULL;
-	fcc->object_ptr = NULL;
+	fcc->object = NULL;
 
-	if (object_ptr && Z_TYPE_P(object_ptr) != IS_OBJECT) {
-		object_ptr = NULL;
-	}
-	if (object_ptr &&
-	    (!EG(objects_store).object_buckets || 
-	     !EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(object_ptr)].valid)) {
+	if (object &&
+	    (!EG(objects_store).object_buckets ||
+	     !IS_OBJ_VALID(EG(objects_store).object_buckets[object->handle]))) {
 		return 0;
 	}
 
 	switch (Z_TYPE_P(callable)) {
 		case IS_STRING:
-			if (object_ptr) {
-				fcc->object_ptr = object_ptr;
-				fcc->calling_scope = Z_OBJCE_P(object_ptr);
+			if (object) {
+				fcc->object = object;
+				fcc->calling_scope = zend_get_class_entry(object TSRMLS_CC);
 				if (callable_name) {
 					char *ptr;
 
-					*callable_name_len = fcc->calling_scope->name_length + Z_STRLEN_P(callable) + sizeof("::") - 1;
-					ptr = *callable_name = emalloc(*callable_name_len + 1);
-					memcpy(ptr, fcc->calling_scope->name, fcc->calling_scope->name_length);
-					ptr += fcc->calling_scope->name_length;
+					*callable_name = STR_ALLOC(fcc->calling_scope->name->len + Z_STRLEN_P(callable) + sizeof("::") - 1, 0);
+					ptr = (*callable_name)->val;
+					memcpy(ptr, fcc->calling_scope->name->val, fcc->calling_scope->name->len);
+					ptr += fcc->calling_scope->name->len;
 					memcpy(ptr, "::", sizeof("::") - 1);
 					ptr += sizeof("::") - 1;
 					memcpy(ptr, Z_STRVAL_P(callable), Z_STRLEN_P(callable) + 1);
 				}
 			} else if (callable_name) {
-				*callable_name = estrndup(Z_STRVAL_P(callable), Z_STRLEN_P(callable));
-				*callable_name_len = Z_STRLEN_P(callable);
+				*callable_name = STR_COPY(Z_STR_P(callable));
 			}
 			if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) {
 				fcc->called_scope = fcc->calling_scope;
@@ -3081,7 +3170,7 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint ch
 			     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
 			     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
 				if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION) {
-					efree((char*)fcc->function_handler->common.function_name);
+					STR_RELEASE(fcc->function_handler->common.function_name);
 				}
 				efree(fcc->function_handler);
 			}
@@ -3089,69 +3178,79 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint ch
 
 		case IS_ARRAY:
 			{
-				zval **method = NULL;
-				zval **obj = NULL;
+				zval *method = NULL;
+				zval *obj = NULL;
 				int strict_class = 0;
 
 				if (zend_hash_num_elements(Z_ARRVAL_P(callable)) == 2) {
-					zend_hash_index_find(Z_ARRVAL_P(callable), 0, (void **) &obj);
-					zend_hash_index_find(Z_ARRVAL_P(callable), 1, (void **) &method);
+					obj = zend_hash_index_find(Z_ARRVAL_P(callable), 0);
+					method = zend_hash_index_find(Z_ARRVAL_P(callable), 1);
 				}
-				if (obj && method &&
-					(Z_TYPE_PP(obj) == IS_OBJECT ||
-					Z_TYPE_PP(obj) == IS_STRING) &&
-					Z_TYPE_PP(method) == IS_STRING) {
 
-					if (Z_TYPE_PP(obj) == IS_STRING) {
+				do {
+					if (obj == NULL || method == NULL) {
+						break;
+					}
+
+					ZVAL_DEREF(method);
+					if (Z_TYPE_P(method) != IS_STRING) {
+						break;
+					}
+
+					ZVAL_DEREF(obj);
+					if (Z_TYPE_P(obj) == IS_STRING) {
 						if (callable_name) {
 							char *ptr;
 
-							*callable_name_len = Z_STRLEN_PP(obj) + Z_STRLEN_PP(method) + sizeof("::") - 1;
-							ptr = *callable_name = emalloc(*callable_name_len + 1);
-							memcpy(ptr, Z_STRVAL_PP(obj), Z_STRLEN_PP(obj));
-							ptr += Z_STRLEN_PP(obj);
+							
+							*callable_name = STR_ALLOC(Z_STRLEN_P(obj) + Z_STRLEN_P(method) + sizeof("::") - 1, 0);
+							ptr = (*callable_name)->val;
+							memcpy(ptr, Z_STRVAL_P(obj), Z_STRLEN_P(obj));
+							ptr += Z_STRLEN_P(obj);
 							memcpy(ptr, "::", sizeof("::") - 1);
 							ptr += sizeof("::") - 1;
-							memcpy(ptr, Z_STRVAL_PP(method), Z_STRLEN_PP(method) + 1);
+							memcpy(ptr, Z_STRVAL_P(method), Z_STRLEN_P(method) + 1);
 						}
 
 						if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) {
 							return 1;
 						}
 
-						if (!zend_is_callable_check_class(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), fcc, &strict_class, error TSRMLS_CC)) {
+						if (!zend_is_callable_check_class(Z_STR_P(obj), fcc, &strict_class, error TSRMLS_CC)) {
 							return 0;
 						}
 
-					} else {
-						if (!EG(objects_store).object_buckets || 
-						    !EG(objects_store).object_buckets[Z_OBJ_HANDLE_PP(obj)].valid) {
+					} else if (Z_TYPE_P(obj) == IS_OBJECT) {
+						if (!EG(objects_store).object_buckets ||
+						    !IS_OBJ_VALID(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(obj)])) {
 							return 0;
 						}
 
-						fcc->calling_scope = Z_OBJCE_PP(obj); /* TBFixed: what if it's overloaded? */
+						fcc->calling_scope = Z_OBJCE_P(obj); /* TBFixed: what if it's overloaded? */
 
-						fcc->object_ptr = *obj;
+						fcc->object = Z_OBJ_P(obj);
 
 						if (callable_name) {
 							char *ptr;
 
-							*callable_name_len = fcc->calling_scope->name_length + Z_STRLEN_PP(method) + sizeof("::") - 1;
-							ptr = *callable_name = emalloc(*callable_name_len + 1);
-							memcpy(ptr, fcc->calling_scope->name, fcc->calling_scope->name_length);
-							ptr += fcc->calling_scope->name_length;
+							*callable_name = STR_ALLOC(fcc->calling_scope->name->len + Z_STRLEN_P(method) + sizeof("::") - 1, 0);
+							ptr = (*callable_name)->val;
+							memcpy(ptr, fcc->calling_scope->name->val, fcc->calling_scope->name->len);
+							ptr += fcc->calling_scope->name->len;
 							memcpy(ptr, "::", sizeof("::") - 1);
 							ptr += sizeof("::") - 1;
-							memcpy(ptr, Z_STRVAL_PP(method), Z_STRLEN_PP(method) + 1);
+							memcpy(ptr, Z_STRVAL_P(method), Z_STRLEN_P(method) + 1);
 						}
 
 						if (check_flags & IS_CALLABLE_CHECK_SYNTAX_ONLY) {
 							fcc->called_scope = fcc->calling_scope;
 							return 1;
 						}
+					} else {
+						break;
 					}
 
-					ret = zend_is_callable_check_func(check_flags, *method, fcc, strict_class, error TSRMLS_CC);
+					ret = zend_is_callable_check_func(check_flags, method, fcc, strict_class, error TSRMLS_CC);
 					if (fcc == &fcc_local &&
 					    fcc->function_handler &&
 						((fcc->function_handler->type == ZEND_INTERNAL_FUNCTION &&
@@ -3159,40 +3258,39 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint ch
 					     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
 					     fcc->function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
 						if (fcc->function_handler->type != ZEND_OVERLOADED_FUNCTION) {
-							efree((char*)fcc->function_handler->common.function_name);
+							STR_RELEASE(fcc->function_handler->common.function_name);
 						}
 						efree(fcc->function_handler);
 					}
 					return ret;
 
-				} else {
-					if (zend_hash_num_elements(Z_ARRVAL_P(callable)) == 2) {
-						if (!obj || (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT)) {
-							if (error) zend_spprintf(error, 0, "first array member is not a valid class name or object");
-						} else {
-							if (error) zend_spprintf(error, 0, "second array member is not a valid method");
-						}
+				} while (0);
+				if (zend_hash_num_elements(Z_ARRVAL_P(callable)) == 2) {
+					if (!obj || (!Z_ISREF_P(obj)?
+								(Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) :
+								(Z_TYPE_P(Z_REFVAL_P(obj)) != IS_STRING && Z_TYPE_P(Z_REFVAL_P(obj)) != IS_OBJECT))) {
+						if (error) zend_spprintf(error, 0, "first array member is not a valid class name or object");
 					} else {
-						if (error) zend_spprintf(error, 0, "array must have exactly two members");
-					}
-					if (callable_name) {
-						*callable_name = estrndup("Array", sizeof("Array")-1);
-						*callable_name_len = sizeof("Array") - 1;
+						if (error) zend_spprintf(error, 0, "second array member is not a valid method");
 					}
+				} else {
+					if (error) zend_spprintf(error, 0, "array must have exactly two members");
+				}
+				if (callable_name) {
+					*callable_name = STR_INIT("Array", sizeof("Array")-1, 0);
 				}
 			}
 			return 0;
 
 		case IS_OBJECT:
-			if (Z_OBJ_HANDLER_P(callable, get_closure) && Z_OBJ_HANDLER_P(callable, get_closure)(callable, &fcc->calling_scope, &fcc->function_handler, &fcc->object_ptr TSRMLS_CC) == SUCCESS) {
+			if (Z_OBJ_HANDLER_P(callable, get_closure) && Z_OBJ_HANDLER_P(callable, get_closure)(callable, &fcc->calling_scope, &fcc->function_handler, &fcc->object TSRMLS_CC) == SUCCESS) {
 				fcc->called_scope = fcc->calling_scope;
 				if (callable_name) {
 					zend_class_entry *ce = Z_OBJCE_P(callable); /* TBFixed: what if it's overloaded? */
 
-					*callable_name_len = ce->name_length + sizeof("::__invoke") - 1;
-					*callable_name = emalloc(*callable_name_len + 1);
-					memcpy(*callable_name, ce->name, ce->name_length);
-					memcpy((*callable_name) + ce->name_length, "::__invoke", sizeof("::__invoke"));
+					*callable_name = STR_ALLOC(ce->name->len + sizeof("::__invoke") - 1, 0);
+					memcpy((*callable_name)->val, ce->name->val, ce->name->len);
+					memcpy((*callable_name)->val + ce->name->len, "::__invoke", sizeof("::__invoke"));
 				}									
 				return 1;
 			}
@@ -3200,13 +3298,7 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint ch
 
 		default:
 			if (callable_name) {
-				zval expr_copy;
-				int use_copy;
-
-				zend_make_printable_zval(callable, &expr_copy, &use_copy);
-				*callable_name = estrndup(Z_STRVAL(expr_copy), Z_STRLEN(expr_copy));
-				*callable_name_len = Z_STRLEN(expr_copy);
-				zval_dtor(&expr_copy);
+				*callable_name = zval_get_string(callable);
 			}
 			if (error) zend_spprintf(error, 0, "no array or string given");
 			return 0;
@@ -3214,22 +3306,22 @@ ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint ch
 }
 /* }}} */
 
-ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name TSRMLS_DC) /* {{{ */
+ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, zend_string **callable_name TSRMLS_DC) /* {{{ */
 {
-	return zend_is_callable_ex(callable, NULL, check_flags, callable_name, NULL, NULL, NULL TSRMLS_CC);
+	return zend_is_callable_ex(callable, NULL, check_flags, callable_name, NULL, NULL TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC) /* {{{ */
+ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_name TSRMLS_DC) /* {{{ */
 {
 	zend_fcall_info_cache fcc;
 
-	if (zend_is_callable_ex(callable, NULL, IS_CALLABLE_STRICT, callable_name, NULL, &fcc, NULL TSRMLS_CC)) {
+	if (zend_is_callable_ex(callable, NULL, IS_CALLABLE_STRICT, callable_name, &fcc, NULL TSRMLS_CC)) {
 		if (Z_TYPE_P(callable) == IS_STRING && fcc.calling_scope) {
 			zval_dtor(callable);
 			array_init(callable);
-			add_next_index_string(callable, fcc.calling_scope->name, 1);
-			add_next_index_string(callable, fcc.function_handler->common.function_name, 1);
+			add_next_index_str(callable, STR_COPY(fcc.calling_scope->name));
+			add_next_index_str(callable, STR_COPY(fcc.function_handler->common.function_name));
 		}
 		if (fcc.function_handler &&
 			((fcc.function_handler->type == ZEND_INTERNAL_FUNCTION &&
@@ -3237,7 +3329,7 @@ ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRML
 		     fcc.function_handler->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY ||
 		     fcc.function_handler->type == ZEND_OVERLOADED_FUNCTION)) {
 			if (fcc.function_handler->type != ZEND_OVERLOADED_FUNCTION) {
-				efree((char*)fcc.function_handler->common.function_name);
+				STR_RELEASE(fcc.function_handler->common.function_name);
 			}
 			efree(fcc.function_handler);
 		}
@@ -3247,17 +3339,17 @@ ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRML
 }
 /* }}} */
 
-ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_info *fci, zend_fcall_info_cache *fcc, char **callable_name, char **error TSRMLS_DC) /* {{{ */
+ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_string **callable_name, char **error TSRMLS_DC) /* {{{ */
 {
-	if (!zend_is_callable_ex(callable, NULL, check_flags, callable_name, NULL, fcc, error TSRMLS_CC)) {
+	if (!zend_is_callable_ex(callable, NULL, check_flags, callable_name, fcc, error TSRMLS_CC)) {
 		return FAILURE;
 	}
 
 	fci->size = sizeof(*fci);
 	fci->function_table = fcc->calling_scope ? &fcc->calling_scope->function_table : EG(function_table);
-	fci->object_ptr = fcc->object_ptr;
-	fci->function_name = callable;
-	fci->retval_ptr_ptr = NULL;
+	fci->object = fcc->object;
+	ZVAL_COPY_VALUE(&fci->function_name, callable);
+	fci->retval = NULL;
 	fci->param_count = 0;
 	fci->params = NULL;
 	fci->no_separation = 1;
@@ -3270,6 +3362,11 @@ ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_i
 ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem) /* {{{ */
 {
 	if (fci->params) {
+		int i;
+
+		for (i = 0; i < fci->param_count; i++) {
+			zval_ptr_dtor(&fci->params[i]);
+		}
 		if (free_mem) {
 			efree(fci->params);
 			fci->params = NULL;
@@ -3279,7 +3376,7 @@ ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem) /*
 }
 /* }}} */
 
-ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval ****params) /* {{{ */
+ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval **params) /* {{{ */
 {
 	*param_count = fci->param_count;
 	*params = fci->params;
@@ -3288,7 +3385,7 @@ ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count,
 }
 /* }}} */
 
-ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval ***params) /* {{{ */
+ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval *params) /* {{{ */
 {
 	zend_fcall_info_args_clear(fci, 1);
 	fci->param_count = param_count;
@@ -3298,8 +3395,7 @@ ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count
 
 ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args TSRMLS_DC) /* {{{ */
 {
-	HashPosition pos;
-	zval **arg, ***params;
+	zval *arg, *params;
 
 	zend_fcall_info_args_clear(fci, !args);
 
@@ -3312,19 +3408,18 @@ ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args TSRMLS_DC) /*
 	}
 
 	fci->param_count = zend_hash_num_elements(Z_ARRVAL_P(args));
-	fci->params = params = (zval ***) erealloc(fci->params, fci->param_count * sizeof(zval **));
+	fci->params = params = (zval *) erealloc(fci->params, fci->param_count * sizeof(zval));
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(args), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(args), (void *) &arg, &pos) == SUCCESS) {
-		*params++ = arg;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(args), &pos);
-	}
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(args), arg) {
+		ZVAL_COPY(params, arg);
+		params++;
+	} ZEND_HASH_FOREACH_END();
 
 	return SUCCESS;
 }
 /* }}} */
 
-ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval ***argv) /* {{{ */
+ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval *argv) /* {{{ */
 {
 	int i;
 
@@ -3336,10 +3431,10 @@ ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval
 
 	if (argc) {
 		fci->param_count = argc;
-		fci->params = (zval ***) erealloc(fci->params, fci->param_count * sizeof(zval **));
+		fci->params = (zval *) erealloc(fci->params, fci->param_count * sizeof(zval));
 
 		for (i = 0; i < argc; ++i) {
-			fci->params[i] = argv[i];
+			ZVAL_COPY_VALUE(&fci->params[i], &argv[i]);
 		}
 	}
 
@@ -3350,7 +3445,7 @@ ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval
 ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci TSRMLS_DC, int argc, va_list *argv) /* {{{ */
 {
 	int i;
-	zval **arg;
+	zval *arg;
 
 	if (argc < 0) {
 		return FAILURE;
@@ -3360,11 +3455,11 @@ ZEND_API int zend_fcall_info_argv(zend_fcall_info *fci TSRMLS_DC, int argc, va_l
 
 	if (argc) {
 		fci->param_count = argc;
-		fci->params = (zval ***) erealloc(fci->params, fci->param_count * sizeof(zval **));
+		fci->params = (zval *) erealloc(fci->params, fci->param_count * sizeof(zval));
 
 		for (i = 0; i < argc; ++i) {
-			arg = va_arg(*argv, zval **);
-			fci->params[i] = arg;
+			arg = va_arg(*argv, zval *);
+			ZVAL_COPY_VALUE(&fci->params[i], arg);
 		}
 	}
 
@@ -3385,19 +3480,19 @@ ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci TSRMLS_DC, int argc, ...)
 }
 /* }}} */
 
-ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval **retval_ptr_ptr, zval *args TSRMLS_DC) /* {{{ */
+ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval *retval_ptr, zval *args TSRMLS_DC) /* {{{ */
 {
-	zval *retval, ***org_params = NULL;
+	zval retval, *org_params = NULL;
 	int result, org_count = 0;
 
-	fci->retval_ptr_ptr = retval_ptr_ptr ? retval_ptr_ptr : &retval;
+	fci->retval = retval_ptr ? retval_ptr : &retval;
 	if (args) {
 		zend_fcall_info_args_save(fci, &org_count, &org_params);
 		zend_fcall_info_args(fci, args TSRMLS_CC);
 	}
 	result = zend_call_function(fci, fcc TSRMLS_CC);
 
-	if (!retval_ptr_ptr && retval) {
+	if (!retval_ptr && Z_TYPE(retval) != IS_UNDEF) {
 		zval_ptr_dtor(&retval);
 	}
 	if (args) {
@@ -3409,58 +3504,55 @@ ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *f
 
 ZEND_API const char *zend_get_module_version(const char *module_name) /* {{{ */
 {
-	char *lname;
+	zend_string *lname;
 	int name_len = strlen(module_name);
 	zend_module_entry *module;
 
-	lname = zend_str_tolower_dup(module_name, name_len);
-	if (zend_hash_find(&module_registry, lname, name_len + 1, (void**)&module) == FAILURE) {
-		efree(lname);
-		return NULL;
-	}
-	efree(lname);
-	return module->version;
+	lname = STR_ALLOC(name_len, 0);
+	zend_str_tolower_copy(lname->val, module_name, name_len);
+	module = zend_hash_find_ptr(&module_registry, lname);
+	STR_FREE(lname);
+	return module ? module->version : NULL;
 }
 /* }}} */
 
-ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type, const char *doc_comment, int doc_comment_len TSRMLS_DC) /* {{{ */
+ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment TSRMLS_DC) /* {{{ */
 {
 	zend_property_info property_info, *property_info_ptr;
-	const char *interned_name;
-	ulong h = zend_get_hash_value(name, name_length+1);
 
 	if (!(access_type & ZEND_ACC_PPP_MASK)) {
 		access_type |= ZEND_ACC_PUBLIC;
 	}
 	if (access_type & ZEND_ACC_STATIC) {
-		if (zend_hash_quick_find(&ce->properties_info, name, name_length + 1, h, (void**)&property_info_ptr) == SUCCESS &&
+		if ((property_info_ptr = zend_hash_find_ptr(&ce->properties_info, name)) != NULL &&
 		    (property_info_ptr->flags & ZEND_ACC_STATIC) != 0) {
 			property_info.offset = property_info_ptr->offset;
 			zval_ptr_dtor(&ce->default_static_members_table[property_info.offset]);
-			zend_hash_quick_del(&ce->properties_info, name, name_length + 1, h);
+			zend_hash_del(&ce->properties_info, name);
 		} else {
 			property_info.offset = ce->default_static_members_count++;
-			ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval*) * ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);
+			ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval) * ce->default_static_members_count, ce->type == ZEND_INTERNAL_CLASS);
 		}
-		ce->default_static_members_table[property_info.offset] = property;
+		ZVAL_COPY_VALUE(&ce->default_static_members_table[property_info.offset], property);
 		if (ce->type == ZEND_USER_CLASS) {
 			ce->static_members_table = ce->default_static_members_table;
 		}
 	} else {
-		if (zend_hash_quick_find(&ce->properties_info, name, name_length + 1, h, (void**)&property_info_ptr) == SUCCESS &&
+		if ((property_info_ptr = zend_hash_find_ptr(&ce->properties_info, name)) != NULL &&
 		    (property_info_ptr->flags & ZEND_ACC_STATIC) == 0) {
 			property_info.offset = property_info_ptr->offset;
 			zval_ptr_dtor(&ce->default_properties_table[property_info.offset]);
-			zend_hash_quick_del(&ce->properties_info, name, name_length + 1, h);
+			zend_hash_del(&ce->properties_info, name);
 		} else {
 			property_info.offset = ce->default_properties_count++;
-			ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval*) * ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
+			ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval) * ce->default_properties_count, ce->type == ZEND_INTERNAL_CLASS);
 		}
-		ce->default_properties_table[property_info.offset] = property;
+		ZVAL_COPY_VALUE(&ce->default_properties_table[property_info.offset], property);
 	}
 	if (ce->type & ZEND_INTERNAL_CLASS) {
 		switch(Z_TYPE_P(property)) {
 			case IS_ARRAY:
+			case IS_CONSTANT_ARRAY:
 			case IS_OBJECT:
 			case IS_RESOURCE:
 				zend_error(E_CORE_ERROR, "Internal zval's can't be arrays, objects or resources");
@@ -3471,52 +3563,27 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, in
 	}
 	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, ce->name_length, name, name_length, ce->type & ZEND_INTERNAL_CLASS);
-				property_info.name = priv_name;
-				property_info.name_length = priv_name_length;
+				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, name_length, ce->type & ZEND_INTERNAL_CLASS);
-				property_info.name = prot_name;
-				property_info.name_length = prot_name_length;
+				property_info.name = zend_mangle_property_name("*", 1, name->val, name->len, ce->type & ZEND_INTERNAL_CLASS);
 			}
 			break;
 		case ZEND_ACC_PUBLIC:
-			if (IS_INTERNED(name)) {
-				property_info.name = (char*)name;
-			} else {
-				property_info.name = ce->type & ZEND_INTERNAL_CLASS ? zend_strndup(name, name_length) : estrndup(name, name_length);
-			}
-			property_info.name_length = name_length;
+			property_info.name = STR_COPY(name);
 			break;
 	}
 
-	interned_name = zend_new_interned_string(property_info.name, property_info.name_length+1, 0 TSRMLS_CC);
-	if (interned_name != property_info.name) {
-		if (ce->type == ZEND_USER_CLASS) {
-			efree((char*)property_info.name);
-		} else {
-			free((char*)property_info.name);
-		}
-		property_info.name = interned_name;
-	}
+	property_info.name = zend_new_interned_string(property_info.name TSRMLS_CC);
 
 	property_info.flags = access_type;
-	property_info.h = (access_type & ZEND_ACC_PUBLIC) ? h : zend_get_hash_value(property_info.name, property_info.name_length+1);
 
 	property_info.doc_comment = doc_comment;
-	property_info.doc_comment_len = doc_comment_len;
 
 	property_info.ce = ce;
 
-	zend_hash_quick_update(&ce->properties_info, name, name_length+1, h, &property_info, sizeof(zend_property_info), NULL);
+	zend_hash_update_mem(&ce->properties_info, name, &property_info, sizeof(zend_property_info));
 
 	return SUCCESS;
 }
@@ -3524,181 +3591,116 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, in
 
 ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type TSRMLS_DC) /* {{{ */
 {
-	return zend_declare_property_ex(ce, name, name_length, property, access_type, NULL, 0 TSRMLS_CC);
+	zend_string *key = STR_INIT(name, name_length, ce->type & ZEND_INTERNAL_CLASS);
+	int ret = zend_declare_property_ex(ce, key, property, access_type, NULL TSRMLS_CC);
+	STR_RELEASE(key);
+	return ret;
 }
 /* }}} */
 
 ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, int name_length, int access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(property);
-	} else {
-		ALLOC_ZVAL(property);
-	}
-	INIT_ZVAL(*property);
-	return zend_declare_property(ce, name, name_length, property, access_type TSRMLS_CC);
+	ZVAL_NULL(&property);
+	return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(property);
-	} else {
-		ALLOC_ZVAL(property);
-	}
-	INIT_PZVAL(property);
-	ZVAL_BOOL(property, value);
-	return zend_declare_property(ce, name, name_length, property, access_type TSRMLS_CC);
+	ZVAL_BOOL(&property, value);
+	return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(property);
-	} else {
-		ALLOC_ZVAL(property);
-	}
-	INIT_PZVAL(property);
-	ZVAL_LONG(property, value);
-	return zend_declare_property(ce, name, name_length, property, access_type TSRMLS_CC);
+	ZVAL_LONG(&property, value);
+	return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_property_double(zend_class_entry *ce, const char *name, int name_length, double value, int access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(property);
-	} else {
-		ALLOC_ZVAL(property);
-	}
-	INIT_PZVAL(property);
-	ZVAL_DOUBLE(property, value);
-	return zend_declare_property(ce, name, name_length, property, access_type TSRMLS_CC);
+	ZVAL_DOUBLE(&property, value);
+	return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_property_string(zend_class_entry *ce, const char *name, int name_length, const char *value, int access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
-	int len = strlen(value);
+	zval property;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(property);
-		ZVAL_STRINGL(property, zend_strndup(value, len), len, 0);
-	} else {
-		ALLOC_ZVAL(property);
-		ZVAL_STRINGL(property, value, len, 1);
-	}
-	INIT_PZVAL(property);
-	return zend_declare_property(ce, name, name_length, property, access_type TSRMLS_CC);
+	ZVAL_NEW_STR(&property, STR_INIT(value, strlen(value), ce->type & ZEND_INTERNAL_CLASS));
+	return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_property_stringl(zend_class_entry *ce, const char *name, int name_length, const char *value, int value_len, int access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(property);
-		ZVAL_STRINGL(property, zend_strndup(value, value_len), value_len, 0);
-	} else {
-		ALLOC_ZVAL(property);
-		ZVAL_STRINGL(property, value, value_len, 1);
-	}
-	INIT_PZVAL(property);
-	return zend_declare_property(ce, name, name_length, property, access_type TSRMLS_CC);
+	ZVAL_NEW_STR(&property, STR_INIT(value, value_len, ce->type & ZEND_INTERNAL_CLASS));
+	return zend_declare_property(ce, name, name_length, &property, access_type TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_class_constant(zend_class_entry *ce, const char *name, size_t name_length, zval *value TSRMLS_DC) /* {{{ */
 {
-	return zend_hash_update(&ce->constants_table, name, name_length+1, &value, sizeof(zval *), NULL);
+	return zend_hash_str_update(&ce->constants_table, name, name_length, value) ?
+		SUCCESS : FAILURE;
 }
 /* }}} */
 
 ZEND_API int zend_declare_class_constant_null(zend_class_entry *ce, const char *name, size_t name_length TSRMLS_DC) /* {{{ */
 {
-	zval *constant;
+	zval constant;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(constant);
-	} else {
-		ALLOC_ZVAL(constant);
-	}
-	ZVAL_NULL(constant);
-	INIT_PZVAL(constant);
-	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
+	ZVAL_NULL(&constant);
+	return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_class_constant_long(zend_class_entry *ce, const char *name, size_t name_length, long value TSRMLS_DC) /* {{{ */
 {
-	zval *constant;
+	zval constant;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(constant);
-	} else {
-		ALLOC_ZVAL(constant);
-	}
-	ZVAL_LONG(constant, value);
-	INIT_PZVAL(constant);
-	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
+	ZVAL_LONG(&constant, value);
+	return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_class_constant_bool(zend_class_entry *ce, const char *name, size_t name_length, zend_bool value TSRMLS_DC) /* {{{ */
 {
-	zval *constant;
+	zval constant;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(constant);
-	} else {
-		ALLOC_ZVAL(constant);
-	}
-	ZVAL_BOOL(constant, value);
-	INIT_PZVAL(constant);
-	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
+	ZVAL_BOOL(&constant, value);
+	return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_class_constant_double(zend_class_entry *ce, const char *name, size_t name_length, double value TSRMLS_DC) /* {{{ */
 {
-	zval *constant;
+	zval constant;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(constant);
-	} else {
-		ALLOC_ZVAL(constant);
-	}
-	ZVAL_DOUBLE(constant, value);
-	INIT_PZVAL(constant);
-	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
+	ZVAL_DOUBLE(&constant, value);
+	return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_declare_class_constant_stringl(zend_class_entry *ce, const char *name, size_t name_length, const char *value, size_t value_length TSRMLS_DC) /* {{{ */
 {
-	zval *constant;
+	zval constant;
 
-	if (ce->type & ZEND_INTERNAL_CLASS) {
-		ALLOC_PERMANENT_ZVAL(constant);
-		ZVAL_STRINGL(constant, zend_strndup(value, value_length), value_length, 0);
-	} else {
-		ALLOC_ZVAL(constant);
-		ZVAL_STRINGL(constant, value, value_length, 1);
-	}
-	INIT_PZVAL(constant);
-	return zend_declare_class_constant(ce, name, name_length, constant TSRMLS_CC);
+	ZVAL_NEW_STR(&constant, STR_INIT(value, value_length, ce->type & ZEND_INTERNAL_CLASS));
+	return zend_declare_class_constant(ce, name, name_length, &constant TSRMLS_CC);
 }
 /* }}} */
 
@@ -3710,22 +3712,17 @@ ZEND_API int zend_declare_class_constant_string(zend_class_entry *ce, const char
 
 ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zval *value TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 	zend_class_entry *old_scope = EG(scope);
 
 	EG(scope) = scope;
 
 	if (!Z_OBJ_HT_P(object)->write_property) {
-		const char *class_name;
-		zend_uint class_name_len;
-
-		zend_get_object_classname(object, &class_name, &class_name_len TSRMLS_CC);
-
-		zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, class_name);
+		zend_string *class_name = zend_get_object_classname(Z_OBJ_P(object) TSRMLS_CC);
+		zend_error(E_CORE_ERROR, "Property %s of class %s cannot be updated", name, class_name->val);
 	}
-	MAKE_STD_ZVAL(property);
-	ZVAL_STRINGL(property, name, name_length, 1);
-	Z_OBJ_HT_P(object)->write_property(object, property, value, 0 TSRMLS_CC);
+	ZVAL_STRINGL(&property, name, name_length);
+	Z_OBJ_HT_P(object)->write_property(object, &property, value, -1 TSRMLS_CC);
 	zval_ptr_dtor(&property);
 
 	EG(scope) = old_scope;
@@ -3734,105 +3731,98 @@ ZEND_API void zend_update_property(zend_class_entry *scope, zval *object, const
 
 ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, const char *name, int name_length TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_NULL(tmp);
-	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
+	ZVAL_NULL(&tmp);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_BOOL(tmp, value);
-	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
+	ZVAL_BOOL(&tmp, value);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_LONG(tmp, value);
-	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
+	ZVAL_LONG(&tmp, value);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, int name_length, double value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
+
+	ZVAL_DOUBLE(&tmp, value);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
+}
+/* }}} */
+
+ZEND_API void zend_update_property_str(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_string *value TSRMLS_DC) /* {{{ */
+{
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_DOUBLE(tmp, value);
-	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
+	ZVAL_STR(&tmp, value);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_STRING(tmp, value, 1);
-	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
+	ZVAL_STRING(&tmp, value);
+	Z_SET_REFCOUNT(tmp, 0);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value, int value_len TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_STRINGL(tmp, value, value_len, 1);
-	zend_update_property(scope, object, name, name_length, tmp TSRMLS_CC);
+	ZVAL_STRINGL(&tmp, value, value_len);
+	Z_SET_REFCOUNT(tmp, 0);
+	zend_update_property(scope, object, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *name, int name_length, zval *value TSRMLS_DC) /* {{{ */
 {
-	zval **property;
+	zval *property;
 	zend_class_entry *old_scope = EG(scope);
+	zend_string *key = STR_INIT(name, name_length, 0);
 
 	EG(scope) = scope;
-	property = zend_std_get_static_property(scope, name, name_length, 0, NULL TSRMLS_CC);
+	property = zend_std_get_static_property(scope, key, 0, -1 TSRMLS_CC);
 	EG(scope) = old_scope;
+	STR_FREE(key);
 	if (!property) {
 		return FAILURE;
 	} else {
-		if (*property != value) {
-			if (PZVAL_IS_REF(*property)) {
-				zval_dtor(*property);
-				Z_TYPE_PP(property) = Z_TYPE_P(value);
-				(*property)->value = value->value;
+		if (property != value) {
+			if (Z_ISREF_P(property)) {
+				zval_dtor(property);
+				ZVAL_COPY_VALUE(property, value);
 				if (Z_REFCOUNT_P(value) > 0) {
-					zval_copy_ctor(*property);
-				} else {
-					efree(value);
+					zval_opt_copy_ctor(property);
 				}
 			} else {
-				zval *garbage = *property;
+				zval garbage;
 
+				ZVAL_COPY_VALUE(&garbage, property);
 				Z_ADDREF_P(value);
-				if (PZVAL_IS_REF(value)) {
-					SEPARATE_ZVAL(&value);
+				if (Z_ISREF_P(value)) {
+					SEPARATE_ZVAL(value);
 				}
-				*property = value;
+				ZVAL_COPY_VALUE(property, value);
 				zval_ptr_dtor(&garbage);
 			}
 		}
@@ -3843,94 +3833,75 @@ ZEND_API int zend_update_static_property(zend_class_entry *scope, const char *na
 
 ZEND_API int zend_update_static_property_null(zend_class_entry *scope, const char *name, int name_length TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
-
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_NULL(tmp);
-	return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
+	zval tmp;
+	
+	ZVAL_NULL(&tmp);
+	return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_update_static_property_bool(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_BOOL(tmp, value);
-	return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
+	ZVAL_BOOL(&tmp, value);
+	return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_update_static_property_long(zend_class_entry *scope, const char *name, int name_length, long value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_LONG(tmp, value);
-	return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
+	ZVAL_LONG(&tmp, value);
+	return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_update_static_property_double(zend_class_entry *scope, const char *name, int name_length, double value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_DOUBLE(tmp, value);
-	return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
+	ZVAL_DOUBLE(&tmp, value);
+	return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_update_static_property_string(zend_class_entry *scope, const char *name, int name_length, const char *value TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_STRING(tmp, value, 1);
-	return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
+	ZVAL_STRING(&tmp, value);
+	Z_SET_REFCOUNT(tmp, 0);
+	return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API int zend_update_static_property_stringl(zend_class_entry *scope, const char *name, int name_length, const char *value, int value_len TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 
-	ALLOC_ZVAL(tmp);
-	Z_UNSET_ISREF_P(tmp);
-	Z_SET_REFCOUNT_P(tmp, 0);
-	ZVAL_STRINGL(tmp, value, value_len, 1);
-	return zend_update_static_property(scope, name, name_length, tmp TSRMLS_CC);
+	ZVAL_STRINGL(&tmp, value, value_len);
+	Z_SET_REFCOUNT(tmp, 0);
+	return zend_update_static_property(scope, name, name_length, &tmp TSRMLS_CC);
 }
 /* }}} */
 
 ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_bool silent TSRMLS_DC) /* {{{ */
 {
-	zval *property, *value;
+	zval property, *value;
 	zend_class_entry *old_scope = EG(scope);
+	zval rv;
 
 	EG(scope) = scope;
 
 	if (!Z_OBJ_HT_P(object)->read_property) {
-		const char *class_name;
-		zend_uint class_name_len;
-
-		zend_get_object_classname(object, &class_name, &class_name_len TSRMLS_CC);
-		zend_error(E_CORE_ERROR, "Property %s of class %s cannot be read", name, class_name);
+		zend_string *class_name = zend_get_object_classname(Z_OBJ_P(object) TSRMLS_CC);
+		zend_error(E_CORE_ERROR, "Property %s of class %s cannot be read", name, class_name->val);
 	}
 
-	MAKE_STD_ZVAL(property);
-	ZVAL_STRINGL(property, name, name_length, 1);
-	value = Z_OBJ_HT_P(object)->read_property(object, property, silent?BP_VAR_IS:BP_VAR_R, 0 TSRMLS_CC);
+	ZVAL_STRINGL(&property, name, name_length);
+	value = Z_OBJ_HT_P(object)->read_property(object, &property, silent?BP_VAR_IS:BP_VAR_R, -1, &rv TSRMLS_CC);
 	zval_ptr_dtor(&property);
 
 	EG(scope) = old_scope;
@@ -3940,14 +3911,16 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const c
 
 ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, int name_length, zend_bool silent TSRMLS_DC) /* {{{ */
 {
-	zval **property;
+	zval *property;
 	zend_class_entry *old_scope = EG(scope);
+	zend_string *key = STR_INIT(name, name_length, 0);
 
 	EG(scope) = scope;
-	property = zend_std_get_static_property(scope, name, name_length, silent, NULL TSRMLS_CC);
+	property = zend_std_get_static_property(scope, key, silent, -1 TSRMLS_CC);
 	EG(scope) = old_scope;
+	STR_FREE(key);
 
-	return property?*property:NULL;
+	return property;
 }
 /* }}} */
 
@@ -3955,10 +3928,7 @@ ZEND_API void zend_save_error_handling(zend_error_handling *current TSRMLS_DC) /
 {
 	current->handling = EG(error_handling);
 	current->exception = EG(exception_class);
-	current->user_handler = EG(user_error_handler);
-	if (current->user_handler) {
-		Z_ADDREF_P(current->user_handler);
-	}
+	ZVAL_COPY(&current->user_handler, &EG(user_error_handler));
 }
 /* }}} */
 
@@ -3966,9 +3936,9 @@ ZEND_API void zend_replace_error_handling(zend_error_handling_t error_handling,
 {
 	if (current) {
 		zend_save_error_handling(current TSRMLS_CC);
-		if (error_handling != EH_NORMAL && EG(user_error_handler)) {
+		if (error_handling != EH_NORMAL && Z_TYPE(EG(user_error_handler)) != IS_UNDEF) {
 			zval_ptr_dtor(&EG(user_error_handler));
-			EG(user_error_handler) = NULL;
+			ZVAL_UNDEF(&EG(user_error_handler));
 		}
 	}
 	EG(error_handling) = error_handling;
@@ -3976,31 +3946,55 @@ ZEND_API void zend_replace_error_handling(zend_error_handling_t error_handling,
 }
 /* }}} */
 
+static int same_zval(zval *zv1, zval *zv2)  /* {{{ */
+{
+	if (Z_TYPE_P(zv1) != Z_TYPE_P(zv2)) {
+		return 0;
+	}
+	switch (Z_TYPE_P(zv1)) {
+		case IS_UNDEF:
+		case IS_NULL:
+			return 1;
+		case IS_BOOL:
+		case IS_LONG:
+			return Z_LVAL_P(zv1) == Z_LVAL_P(zv2);
+		case IS_DOUBLE:
+			return Z_LVAL_P(zv1) == Z_LVAL_P(zv2);
+		case IS_STRING:
+		case IS_ARRAY:
+		case IS_OBJECT:
+		case IS_RESOURCE:
+			return Z_COUNTED_P(zv1) == Z_COUNTED_P(zv2);
+		default:
+			return 0;
+	}
+}
+/* }}} */
+
 ZEND_API void zend_restore_error_handling(zend_error_handling *saved TSRMLS_DC) /* {{{ */
 {
 	EG(error_handling) = saved->handling;
 	EG(exception_class) = saved->handling == EH_THROW ? saved->exception : NULL;
-	if (saved->user_handler	&& saved->user_handler != EG(user_error_handler)) {
-		if (EG(user_error_handler)) {
-			zval_ptr_dtor(&EG(user_error_handler));
-		}
-		EG(user_error_handler) = saved->user_handler;
-	} else if (saved->user_handler) {
+	if (Z_TYPE(saved->user_handler) != IS_UNDEF
+		&& !same_zval(&saved->user_handler, &EG(user_error_handler))) {
+		zval_ptr_dtor(&EG(user_error_handler));
+		ZVAL_COPY_VALUE(&EG(user_error_handler), &saved->user_handler);
+	} else if (Z_TYPE(saved->user_handler)) {
 		zval_ptr_dtor(&saved->user_handler);
 	}
-	saved->user_handler = NULL;
+	ZVAL_UNDEF(&saved->user_handler);
 }
 /* }}} */
 
-ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name, zend_uint len) /* {{{ */
+ZEND_API zend_string* zend_find_alias_name(zend_class_entry *ce, zend_string *name) /* {{{ */
 {
 	zend_trait_alias *alias, **alias_ptr;
 
 	if ((alias_ptr = ce->trait_aliases)) {
 		alias = *alias_ptr;
 		while (alias) {
-			if (alias->alias_len == len &&
-				!strncasecmp(name, alias->alias, alias->alias_len)) {
+			if (alias->alias->len == name->len &&
+				!strncasecmp(name->val, alias->alias->val, alias->alias->len)) {
 				return alias->alias;
 			}
 			alias_ptr++;
@@ -4012,11 +4006,11 @@ ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name
 }
 /* }}} */
 
-ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_function *f) /* {{{ */
+ZEND_API zend_string *zend_resolve_method_name(zend_class_entry *ce, zend_function *f) /* {{{ */
 {
 	zend_function *func;
-	HashPosition iterator;
 	HashTable *function_table;
+	zend_string *name;
 
 	if (f->common.type != ZEND_USER_FUNCTION ||
 	    *(f->op_array.refcount) < 2 ||
@@ -4026,25 +4020,18 @@ ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_functio
 	}
 
 	function_table = &ce->function_table;
-	zend_hash_internal_pointer_reset_ex(function_table, &iterator);
-	while (zend_hash_get_current_data_ex(function_table, (void **)&func, &iterator) == SUCCESS) {
+	ZEND_HASH_FOREACH_STR_KEY_PTR(function_table, name, func) {
 		if (func == f) {
-			char *name;
-			uint len;
-			ulong idx;
-
-			if (zend_hash_get_current_key_ex(function_table, &name, &len, &idx, 0, &iterator) != HASH_KEY_IS_STRING) {
+			if (!name) {
 				return f->common.function_name;
 			}
-			--len;
-			if (len == strlen(f->common.function_name) &&
-			    !strncasecmp(name, f->common.function_name, len)) {
+			if (name->len == f->common.function_name->len &&
+			    !strncasecmp(name->val, f->common.function_name->val, f->common.function_name->len)) {
 				return f->common.function_name;
 			}
-			return zend_find_alias_name(f->common.scope, name, len);
+			return zend_find_alias_name(f->common.scope, name);
 		}
-		zend_hash_move_forward_ex(function_table, &iterator);
-	}
+	} ZEND_HASH_FOREACH_END();
 	return f->common.function_name;
 }
 /* }}} */
diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index 62a4a8307c..ae26375f70 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -43,12 +43,12 @@ typedef struct _zend_function_entry {
 typedef struct _zend_fcall_info {
 	size_t size;
 	HashTable *function_table;
-	zval *function_name;
-	HashTable *symbol_table;
-	zval **retval_ptr_ptr;
+	zval function_name;
+	zend_array *symbol_table;
+	zval *retval;
 	zend_uint param_count;
-	zval ***params;
-	zval *object_ptr;
+	zval *params;
+	zend_object *object;
 	zend_bool no_separation;
 } zend_fcall_info;
 
@@ -57,7 +57,7 @@ typedef struct _zend_fcall_info_cache {
 	zend_function *function_handler;
 	zend_class_entry *calling_scope;
 	zend_class_entry *called_scope;
-	zval *object_ptr;
+	zend_object *object;
 } zend_fcall_info_cache;
 
 #define ZEND_NS_NAME(ns, name)			ns "\\" name
@@ -170,13 +170,9 @@ typedef struct _zend_fcall_info_cache {
 
 #define INIT_OVERLOADED_CLASS_ENTRY_EX(class_container, class_name, class_name_len, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
 	{															\
-		const char *cl_name = class_name;								\
-		int _len = class_name_len;								\
-		class_container.name = zend_new_interned_string(cl_name, _len+1, 0 TSRMLS_CC);	\
-		if (class_container.name == cl_name) {					\
-			class_container.name = zend_strndup(cl_name, _len);	\
-		}														\
-		class_container.name_length = _len;						\
+		zend_string *cl_name;									\
+		cl_name = STR_INIT(class_name, class_name_len, 1);		\
+		class_container.name = zend_new_interned_string(cl_name TSRMLS_CC);	\
 		INIT_CLASS_ENTRY_INIT_METHODS(class_container, functions, handle_fcall, handle_propget, handle_propset, handle_propunset, handle_propisset) \
 	}
 
@@ -237,9 +233,9 @@ int zend_next_free_module(void);
 
 BEGIN_EXTERN_C()
 ZEND_API int zend_get_parameters(int ht, int param_count, ...);
-ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval **argument_array TSRMLS_DC);
+ZEND_API int _zend_get_parameters_array(int ht, int param_count, zval *argument_array TSRMLS_DC);
 ZEND_API ZEND_ATTRIBUTE_DEPRECATED int zend_get_parameters_ex(int param_count, ...);
-ZEND_API int _zend_get_parameters_array_ex(int param_count, zval ***argument_array TSRMLS_DC);
+ZEND_API int _zend_get_parameters_array_ex(int param_count, zval *argument_array TSRMLS_DC);
 
 /* internal function to efficiently copy parameters when executing __call() */
 ZEND_API int zend_copy_parameters_array(int param_count, zval *argument_array TSRMLS_DC);
@@ -261,7 +257,7 @@ ZEND_API char *zend_zval_type_name(const zval *arg);
 ZEND_API int zend_parse_method_parameters(int num_args TSRMLS_DC, zval *this_ptr, const char *type_spec, ...);
 ZEND_API int zend_parse_method_parameters_ex(int flags, int num_args TSRMLS_DC, zval *this_ptr, const char *type_spec, ...);
 
-ZEND_API int zend_parse_parameter(int flags, int arg_num TSRMLS_DC, zval **arg, const char *spec, ...);
+ZEND_API int zend_parse_parameter(int flags, int arg_num TSRMLS_DC, zval *arg, const char *spec, ...);
 
 /* End of parameter parsing API -- andrei */
 
@@ -277,7 +273,7 @@ ZEND_API void zend_destroy_modules(void);
 ZEND_API void zend_check_magic_method_implementation(const zend_class_entry *ce, const zend_function *fptr, int error_type TSRMLS_DC);
 
 ZEND_API zend_class_entry *zend_register_internal_class(zend_class_entry *class_entry TSRMLS_DC);
-ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce, char *parent_name TSRMLS_DC);
+ZEND_API zend_class_entry *zend_register_internal_class_ex(zend_class_entry *class_entry, zend_class_entry *parent_ce TSRMLS_DC);
 ZEND_API zend_class_entry *zend_register_internal_interface(zend_class_entry *orig_class_entry TSRMLS_DC);
 ZEND_API void zend_class_implements(zend_class_entry *class_entry TSRMLS_DC, int num_interfaces, ...);
 
@@ -300,13 +296,13 @@ ZEND_API void zend_wrong_param_count(TSRMLS_D);
 
 #define IS_CALLABLE_STRICT  (IS_CALLABLE_CHECK_IS_STATIC)
 
-ZEND_API zend_bool zend_is_callable_ex(zval *callable, zval *object_ptr, uint check_flags, char **callable_name, int *callable_name_len, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
-ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, char **callable_name TSRMLS_DC);
-ZEND_API zend_bool zend_make_callable(zval *callable, char **callable_name TSRMLS_DC);
+ZEND_API zend_bool zend_is_callable_ex(zval *callable, zend_object *object, uint check_flags, zend_string **callable_name, zend_fcall_info_cache *fcc, char **error TSRMLS_DC);
+ZEND_API zend_bool zend_is_callable(zval *callable, uint check_flags, zend_string **callable_name TSRMLS_DC);
+ZEND_API zend_bool zend_make_callable(zval *callable, zend_string **callable_name TSRMLS_DC);
 ZEND_API const char *zend_get_module_version(const char *module_name);
 ZEND_API int zend_get_module_started(const char *module_name);
+ZEND_API int zend_declare_property_ex(zend_class_entry *ce, zend_string *name, zval *property, int access_type, zend_string *doc_comment TSRMLS_DC);
 ZEND_API int zend_declare_property(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type TSRMLS_DC);
-ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, int name_length, zval *property, int access_type, const char *doc_comment, int doc_comment_len TSRMLS_DC);
 ZEND_API int zend_declare_property_null(zend_class_entry *ce, const char *name, int name_length, int access_type TSRMLS_DC);
 ZEND_API int zend_declare_property_bool(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
 ZEND_API int zend_declare_property_long(zend_class_entry *ce, const char *name, int name_length, long value, int access_type TSRMLS_DC);
@@ -328,6 +324,7 @@ ZEND_API void zend_update_property_null(zend_class_entry *scope, zval *object, c
 ZEND_API void zend_update_property_bool(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
 ZEND_API void zend_update_property_long(zend_class_entry *scope, zval *object, const char *name, int name_length, long value TSRMLS_DC);
 ZEND_API void zend_update_property_double(zend_class_entry *scope, zval *object, const char *name, int name_length, double value TSRMLS_DC);
+ZEND_API void zend_update_property_str(zend_class_entry *scope, zval *object, const char *name, int name_length, zend_string *value TSRMLS_DC);
 ZEND_API void zend_update_property_string(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value TSRMLS_DC);
 ZEND_API void zend_update_property_stringl(zend_class_entry *scope, zval *object, const char *name, int name_length, const char *value, int value_length TSRMLS_DC);
 
@@ -343,16 +340,16 @@ ZEND_API zval *zend_read_property(zend_class_entry *scope, zval *object, const c
 
 ZEND_API zval *zend_read_static_property(zend_class_entry *scope, const char *name, int name_length, zend_bool silent TSRMLS_DC);
 
-ZEND_API zend_class_entry *zend_get_class_entry(const zval *zobject TSRMLS_DC);
-ZEND_API int zend_get_object_classname(const zval *object, const char **class_name, zend_uint *class_name_len TSRMLS_DC);
+ZEND_API zend_class_entry *zend_get_class_entry(const zend_object *object TSRMLS_DC);
+ZEND_API zend_string *zend_get_object_classname(const zend_object *object TSRMLS_DC);
 ZEND_API char *zend_get_type_by_const(int type);
 
-#define getThis() (this_ptr)
+#define getThis() (Z_OBJ(EG(This)) ? &EG(This) : NULL)
 
 #define WRONG_PARAM_COUNT					ZEND_WRONG_PARAM_COUNT()
 #define WRONG_PARAM_COUNT_WITH_RETVAL(ret)	ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)
-#define ARG_COUNT(dummy)	(ht)
-#define ZEND_NUM_ARGS()		(ht)
+#define ARG_COUNT(dummy)	(param_count)
+#define ZEND_NUM_ARGS()		(param_count)
 #define ZEND_WRONG_PARAM_COUNT()					{ zend_wrong_param_count(TSRMLS_C); return; }
 #define ZEND_WRONG_PARAM_COUNT_WITH_RETVAL(ret)		{ zend_wrong_param_count(TSRMLS_C); return ret; }
 
@@ -370,6 +367,8 @@ ZEND_API int _object_init(zval *arg ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API int _object_init_ex(zval *arg, zend_class_entry *ce ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API int _object_and_properties_init(zval *arg, zend_class_entry *ce, HashTable *properties ZEND_FILE_LINE_DC TSRMLS_DC);
 ZEND_API void object_properties_init(zend_object *object, zend_class_entry *class_type);
+ZEND_API void object_properties_init_ex(zend_object *object, HashTable *properties TSRMLS_DC);
+ZEND_API void object_properties_load(zend_object *object, HashTable *properties TSRMLS_DC);
 
 ZEND_API void zend_merge_properties(zval *obj, HashTable *properties, int destroy_ht TSRMLS_DC);
 
@@ -379,23 +378,25 @@ ZEND_API int add_assoc_function(zval *arg, const char *key, void (*function_ptr)
 ZEND_API int add_assoc_long_ex(zval *arg, const char *key, uint key_len, long n);
 ZEND_API int add_assoc_null_ex(zval *arg, const char *key, uint key_len);
 ZEND_API int add_assoc_bool_ex(zval *arg, const char *key, uint key_len, int b);
-ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, int r);
+ZEND_API int add_assoc_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r);
 ZEND_API int add_assoc_double_ex(zval *arg, const char *key, uint key_len, double d);
-ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str, int duplicate);
-ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length, int duplicate);
+ZEND_API int add_assoc_str_ex(zval *arg, const char *key, uint key_len, zend_string *str);
+ZEND_API int add_assoc_string_ex(zval *arg, const char *key, uint key_len, char *str);
+ZEND_API int add_assoc_stringl_ex(zval *arg, const char *key, uint key_len, char *str, uint length);
 ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *value);
 
-#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key)+1, __n)
-#define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
-#define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key)+1, __b)
-#define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key)+1, __r)
-#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key)+1, __d)
-#define add_assoc_string(__arg, __key, __str, __duplicate) add_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate)
-#define add_assoc_stringl(__arg, __key, __str, __length, __duplicate) add_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate)
-#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key)+1, __value)
+#define add_assoc_long(__arg, __key, __n) add_assoc_long_ex(__arg, __key, strlen(__key), __n)
+#define add_assoc_null(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key))
+#define add_assoc_bool(__arg, __key, __b) add_assoc_bool_ex(__arg, __key, strlen(__key), __b)
+#define add_assoc_resource(__arg, __key, __r) add_assoc_resource_ex(__arg, __key, strlen(__key), __r)
+#define add_assoc_double(__arg, __key, __d) add_assoc_double_ex(__arg, __key, strlen(__key), __d)
+#define add_assoc_str(__arg, __key, __str) add_assoc_str_ex(__arg, __key, strlen(__key), __str)
+#define add_assoc_string(__arg, __key, __str) add_assoc_string_ex(__arg, __key, strlen(__key), __str)
+#define add_assoc_stringl(__arg, __key, __str, __length) add_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
+#define add_assoc_zval(__arg, __key, __value) add_assoc_zval_ex(__arg, __key, strlen(__key), __value)
 
 /* unset() functions are only suported for legacy modules and null() functions should be used */
-#define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key) + 1)
+#define add_assoc_unset(__arg, __key) add_assoc_null_ex(__arg, __key, strlen(__key))
 #define add_index_unset(__arg, __key) add_index_null(__arg, __key)
 #define add_next_index_unset(__arg) add_next_index_null(__arg)
 #define add_property_unset(__arg, __key) add_property_null(__arg, __key)
@@ -403,55 +404,58 @@ ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, uint key_len, zval *v
 ZEND_API int add_index_long(zval *arg, ulong idx, long n);
 ZEND_API int add_index_null(zval *arg, ulong idx);
 ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
-ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
+ZEND_API int add_index_resource(zval *arg, ulong idx, zend_resource *r);
 ZEND_API int add_index_double(zval *arg, ulong idx, double d);
-ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
-ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length, int duplicate);
+ZEND_API int add_index_str(zval *arg, ulong idx, zend_string *str);
+ZEND_API int add_index_string(zval *arg, ulong idx, const char *str);
+ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, uint length);
 ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
 
 ZEND_API int add_next_index_long(zval *arg, long n);
 ZEND_API int add_next_index_null(zval *arg);
 ZEND_API int add_next_index_bool(zval *arg, int b);
-ZEND_API int add_next_index_resource(zval *arg, int r);
+ZEND_API int add_next_index_resource(zval *arg, zend_resource *r);
 ZEND_API int add_next_index_double(zval *arg, double d);
-ZEND_API int add_next_index_string(zval *arg, const char *str, int duplicate);
-ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length, int duplicate);
+ZEND_API int add_next_index_str(zval *arg, zend_string *str);
+ZEND_API int add_next_index_string(zval *arg, const char *str);
+ZEND_API int add_next_index_stringl(zval *arg, const char *str, uint length);
 ZEND_API int add_next_index_zval(zval *arg, zval *value);
 
-ZEND_API int add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str, void **dest, int duplicate);
-ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length, void **dest, int duplicate);
+ZEND_API zval *add_get_assoc_string_ex(zval *arg, const char *key, uint key_len, const char *str);
+ZEND_API zval *add_get_assoc_stringl_ex(zval *arg, const char *key, uint key_len, const char *str, uint length);
 
-#define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
-#define add_get_assoc_stringl(__arg, __key, __str, __length, __dest, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __dest, __duplicate)
+#define add_get_assoc_string(__arg, __key, __str) add_get_assoc_string_ex(__arg, __key, strlen(__key), __str)
+#define add_get_assoc_stringl(__arg, __key, __str, __length) add_get_assoc_stringl_ex(__arg, __key, strlen(__key), __str, __length)
 
-ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
-ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
-ZEND_API int add_get_index_string(zval *arg, ulong idx, const char *str, void **dest, int duplicate);
-ZEND_API int add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length, void **dest, int duplicate);
+ZEND_API zval *add_get_index_long(zval *arg, ulong idx, long l);
+ZEND_API zval *add_get_index_double(zval *arg, ulong idx, double d);
+ZEND_API zval *add_get_index_str(zval *arg, ulong index, zend_string *str);
+ZEND_API zval *add_get_index_string(zval *arg, ulong idx, const char *str);
+ZEND_API zval *add_get_index_stringl(zval *arg, ulong idx, const char *str, uint length);
 
-ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
+ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC);
 
 ZEND_API int add_property_long_ex(zval *arg, const char *key, uint key_len, long l TSRMLS_DC);
 ZEND_API int add_property_null_ex(zval *arg, const char *key, uint key_len TSRMLS_DC);
 ZEND_API int add_property_bool_ex(zval *arg, const char *key, uint key_len, int b TSRMLS_DC);
-ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, long r TSRMLS_DC);
+ZEND_API int add_property_resource_ex(zval *arg, const char *key, uint key_len, zend_resource *r TSRMLS_DC);
 ZEND_API int add_property_double_ex(zval *arg, const char *key, uint key_len, double d TSRMLS_DC);
-ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str, int duplicate TSRMLS_DC);
-ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  const char *str, uint length, int duplicate TSRMLS_DC);
+ZEND_API int add_property_string_ex(zval *arg, const char *key, uint key_len, const char *str TSRMLS_DC);
+ZEND_API int add_property_stringl_ex(zval *arg, const char *key, uint key_len,  const char *str, uint length TSRMLS_DC);
 ZEND_API int add_property_zval_ex(zval *arg, const char *key, uint key_len, zval *value TSRMLS_DC);
 
-#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key)+1, __n TSRMLS_CC)
-#define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) + 1 TSRMLS_CC)
-#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key)+1, __b TSRMLS_CC)
-#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key)+1, __r TSRMLS_CC)
-#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key)+1, __d TSRMLS_CC)
-#define add_property_string(__arg, __key, __str, __duplicate) add_property_string_ex(__arg, __key, strlen(__key)+1, __str, __duplicate TSRMLS_CC)
-#define add_property_stringl(__arg, __key, __str, __length, __duplicate) add_property_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __duplicate TSRMLS_CC)
-#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key)+1, __value TSRMLS_CC)       
+#define add_property_long(__arg, __key, __n) add_property_long_ex(__arg, __key, strlen(__key), __n TSRMLS_CC)
+#define add_property_null(__arg, __key) add_property_null_ex(__arg, __key, strlen(__key) TSRMLS_CC)
+#define add_property_bool(__arg, __key, __b) add_property_bool_ex(__arg, __key, strlen(__key), __b TSRMLS_CC)
+#define add_property_resource(__arg, __key, __r) add_property_resource_ex(__arg, __key, strlen(__key), __r TSRMLS_CC)
+#define add_property_double(__arg, __key, __d) add_property_double_ex(__arg, __key, strlen(__key), __d TSRMLS_CC)
+#define add_property_string(__arg, __key, __str) add_property_string_ex(__arg, __key, strlen(__key), __str TSRMLS_CC)
+#define add_property_stringl(__arg, __key, __str, __length) add_property_stringl_ex(__arg, __key, strlen(__key), __str, __length TSRMLS_CC)
+#define add_property_zval(__arg, __key, __value) add_property_zval_ex(__arg, __key, strlen(__key), __value TSRMLS_CC)       
 
 
-ZEND_API int call_user_function(HashTable *function_table, zval **object_pp, 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_pp, zval *function_name, zval **retval_ptr_ptr, zend_uint param_count, zval **params[], int no_separation, HashTable *symbol_table TSRMLS_DC);
+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, 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;
@@ -466,7 +470,7 @@ ZEND_API extern const zend_fcall_info_cache empty_fcall_info_cache;
  * The callable_name argument may be NULL.
  * Set check_flags to IS_CALLABLE_STRICT for every new usage!
  */
-ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_info *fci, zend_fcall_info_cache *fcc, char **callable_name, char **error TSRMLS_DC);
+ZEND_API int zend_fcall_info_init(zval *callable, uint check_flags, zend_fcall_info *fci, zend_fcall_info_cache *fcc, zend_string **callable_name, char **error TSRMLS_DC);
 
 /** Clear arguments connected with zend_fcall_info *fci
  * If free_mem is not zero then the params array gets free'd as well
@@ -476,11 +480,11 @@ ZEND_API void zend_fcall_info_args_clear(zend_fcall_info *fci, int free_mem);
 /** Save current arguments from zend_fcall_info *fci
  * params array will be set to NULL
  */
-ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval ****params);
+ZEND_API void zend_fcall_info_args_save(zend_fcall_info *fci, int *param_count, zval **params);
 
 /** Free arguments connected with zend_fcall_info *fci andset back saved ones.
  */
-ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval ***params);
+ZEND_API void zend_fcall_info_args_restore(zend_fcall_info *fci, int param_count, zval *params);
 
 /** Set or clear the arguments in the zend_call_info struct taking care of
  * refcount. If args is NULL and arguments are set then those are cleared.
@@ -491,7 +495,7 @@ ZEND_API int zend_fcall_info_args(zend_fcall_info *fci, zval *args TSRMLS_DC);
  * If argc is 0 the arguments which are set will be cleared, else pass
  * a variable amount of zval** arguments.
  */
-ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval ***argv);
+ZEND_API int zend_fcall_info_argp(zend_fcall_info *fci TSRMLS_DC, int argc, zval *argv);
 
 /** Set arguments in the zend_fcall_info struct taking care of refcount.
  * If argc is 0 the arguments which are set will be cleared, else pass
@@ -508,24 +512,22 @@ ZEND_API int zend_fcall_info_argn(zend_fcall_info *fci TSRMLS_DC, int argc, ...)
 /** Call a function using information created by zend_fcall_info_init()/args().
  * If args is given then those replace the argument info in fci is temporarily.
  */
-ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval **retval, zval *args TSRMLS_DC);
+ZEND_API int zend_fcall_info_call(zend_fcall_info *fci, zend_fcall_info_cache *fcc, zval *retval, zval *args TSRMLS_DC);
 
 ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC);
 
 ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, int name_length, zend_bool is_ref, int num_symbol_tables, ...);
 
-ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, int name_len, ulong hash_value TSRMLS_DC);
-
-ZEND_API int zend_delete_global_variable(const char *name, int name_len TSRMLS_DC);
-
-ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulong hash_value TSRMLS_DC);
-
-ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);
+ZEND_API int zend_delete_global_variable(zend_string *name TSRMLS_DC);
 
 ZEND_API void zend_rebuild_symbol_table(TSRMLS_D);
+ZEND_API void zend_attach_symbol_table(zend_execute_data *execute_data);
+ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data);
+ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force TSRMLS_DC);
+ZEND_API int zend_set_local_var_str(const char *name, int len, zval *value, int force TSRMLS_DC);
 
-ZEND_API const char* zend_find_alias_name(zend_class_entry *ce, const char *name, zend_uint len);
-ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
+ZEND_API zend_string *zend_find_alias_name(zend_class_entry *ce, zend_string *name);
+ZEND_API zend_string *zend_resolve_method_name(zend_class_entry *ce, zend_function *f);
 
 #define add_method(arg, key, method)	add_assoc_function((arg), (key), (method))
 
@@ -534,10 +536,10 @@ ZEND_API ZEND_FUNCTION(display_disabled_class);
 END_EXTERN_C()
 
 #if ZEND_DEBUG
-#define CHECK_ZVAL_STRING(z) \
-	if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", Z_STRVAL_P(z)); }
-#define CHECK_ZVAL_STRING_REL(z) \
-	if (Z_STRVAL_P(z)[ Z_STRLEN_P(z) ] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", Z_STRVAL_P(z) ZEND_FILE_LINE_RELAY_CC); }
+#define CHECK_ZVAL_STRING(str) \
+	if ((str)->val[(str)->len] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s)", (str)->val); }
+#define CHECK_ZVAL_STRING_REL(str) \
+	if ((str)->val[(str)->len] != '\0') { zend_error(E_WARNING, "String is not zero-terminated (%s) (source: %s:%d)", (str)->val ZEND_FILE_LINE_RELAY_CC); }
 #else
 #define CHECK_ZVAL_STRING(z)
 #define CHECK_ZVAL_STRING_REL(z)
@@ -546,95 +548,81 @@ END_EXTERN_C()
 #define CHECK_ZVAL_NULL_PATH(p) (Z_STRLEN_P(p) != strlen(Z_STRVAL_P(p)))
 #define CHECK_NULL_PATH(p, l) (strlen(p) != l)
 
-#define ZVAL_RESOURCE(z, l) do {	\
-		zval *__z = (z);			\
-		Z_LVAL_P(__z) = l;			\
-		Z_TYPE_P(__z) = IS_RESOURCE;\
+#define ZVAL_STRINGL(z, s, l) do {				\
+		ZVAL_NEW_STR(z, STR_INIT(s, l, 0));		\
 	} while (0)
 
-#define ZVAL_BOOL(z, b) do {		\
-		zval *__z = (z);			\
-		Z_LVAL_P(__z) = ((b) != 0);	\
-		Z_TYPE_P(__z) = IS_BOOL;	\
+#define ZVAL_STRING(z, s) do {					\
+		const char *_s = (s);					\
+		ZVAL_STRINGL(z, _s, strlen(_s));		\
 	} while (0)
 
-#define ZVAL_NULL(z) {				\
-		Z_TYPE_P(z) = IS_NULL;		\
-	}
-
-#define ZVAL_LONG(z, l) {			\
-		zval *__z = (z);			\
-		Z_LVAL_P(__z) = l;			\
-		Z_TYPE_P(__z) = IS_LONG;	\
-	}
-
-#define ZVAL_DOUBLE(z, d) {			\
-		zval *__z = (z);			\
-		Z_DVAL_P(__z) = d;			\
-		Z_TYPE_P(__z) = IS_DOUBLE;	\
-	}
+#define ZVAL_EMPTY_STRING(z) do {				\
+		ZVAL_INT_STR(z, STR_EMPTY_ALLOC());		\
+	} while (0)
 
-#define ZVAL_STRING(z, s, duplicate) do {	\
-		const char *__s=(s);				\
-		zval *__z = (z);					\
-		Z_STRLEN_P(__z) = strlen(__s);		\
-		Z_STRVAL_P(__z) = (duplicate?estrndup(__s, Z_STRLEN_P(__z)):(char*)__s);\
-		Z_TYPE_P(__z) = IS_STRING;			\
+#define ZVAL_PSTRINGL(z, s, l) do {				\
+		ZVAL_NEW_STR(z, STR_INIT(s, l, 1));		\
 	} while (0)
 
-#define ZVAL_STRINGL(z, s, l, duplicate) do {	\
-		const char *__s=(s); int __l=l;			\
-		zval *__z = (z);						\
-		Z_STRLEN_P(__z) = __l;					\
-		Z_STRVAL_P(__z) = (duplicate?estrndup(__s, __l):(char*)__s);\
-		Z_TYPE_P(__z) = IS_STRING;				\
+#define ZVAL_PSTRING(z, s) do {					\
+		const char *_s = (s);					\
+		ZVAL_PSTRINGL(z, _s, strlen(_s));		\
 	} while (0)
 
-#define ZVAL_EMPTY_STRING(z) do {	\
-		zval *__z = (z);			\
-		Z_STRLEN_P(__z) = 0;		\
-		Z_STRVAL_P(__z) = STR_EMPTY_ALLOC();\
-		Z_TYPE_P(__z) = IS_STRING;	\
+#define ZVAL_EMPTY_PSTRING(z) do {				\
+		ZVAL_PSTRINGL(z, "", 0);				\
 	} while (0)
 
 #define ZVAL_ZVAL(z, zv, copy, dtor) do {		\
 		zval *__z = (z);						\
 		zval *__zv = (zv);						\
-		ZVAL_COPY_VALUE(__z, __zv);				\
+		if (EXPECTED(!Z_ISREF_P(__zv))) {		\
+			ZVAL_COPY_VALUE(__z, __zv);			\
+		} else {                                \
+			ZVAL_COPY_VALUE(__z,                \
+				Z_REFVAL_P(__zv));				\
+		}										\
 		if (copy) {								\
-			zval_copy_ctor(__z);				\
+			zval_opt_copy_ctor(__z);			\
 	    }										\
 		if (dtor) {								\
 			if (!copy) {						\
 				ZVAL_NULL(__zv);				\
 			}									\
-			zval_ptr_dtor(&__zv);				\
+			zval_ptr_dtor(__zv);				\
 	    }										\
 	} while (0)
 
 #define ZVAL_FALSE(z)  					ZVAL_BOOL(z, 0)
 #define ZVAL_TRUE(z)  					ZVAL_BOOL(z, 1)
 
-#define RETVAL_RESOURCE(l)				ZVAL_RESOURCE(return_value, l)
 #define RETVAL_BOOL(b)					ZVAL_BOOL(return_value, b)
 #define RETVAL_NULL() 					ZVAL_NULL(return_value)
 #define RETVAL_LONG(l) 					ZVAL_LONG(return_value, l)
 #define RETVAL_DOUBLE(d) 				ZVAL_DOUBLE(return_value, d)
-#define RETVAL_STRING(s, duplicate) 		ZVAL_STRING(return_value, s, duplicate)
-#define RETVAL_STRINGL(s, l, duplicate) 	ZVAL_STRINGL(return_value, s, l, duplicate)
+#define RETVAL_STR(s)			 		ZVAL_STR(return_value, s)
+#define RETVAL_INT_STR(s)		 		ZVAL_INT_STR(return_value, s)
+#define RETVAL_NEW_STR(s)		 		ZVAL_NEW_STR(return_value, s)
+#define RETVAL_STRING(s)		 		ZVAL_STRING(return_value, s)
+#define RETVAL_STRINGL(s, l)		 	ZVAL_STRINGL(return_value, s, l)
 #define RETVAL_EMPTY_STRING() 			ZVAL_EMPTY_STRING(return_value)
+#define RETVAL_RES(r)			 		ZVAL_RES(return_value, r)
 #define RETVAL_ZVAL(zv, copy, dtor)		ZVAL_ZVAL(return_value, zv, copy, dtor)
 #define RETVAL_FALSE  					ZVAL_BOOL(return_value, 0)
 #define RETVAL_TRUE   					ZVAL_BOOL(return_value, 1)
 
-#define RETURN_RESOURCE(l) 				{ RETVAL_RESOURCE(l); return; }
 #define RETURN_BOOL(b) 					{ RETVAL_BOOL(b); return; }
 #define RETURN_NULL() 					{ RETVAL_NULL(); return;}
 #define RETURN_LONG(l) 					{ RETVAL_LONG(l); return; }
 #define RETURN_DOUBLE(d) 				{ RETVAL_DOUBLE(d); return; }
-#define RETURN_STRING(s, duplicate) 	{ RETVAL_STRING(s, duplicate); return; }
-#define RETURN_STRINGL(s, l, duplicate) { RETVAL_STRINGL(s, l, duplicate); return; }
+#define RETURN_STR(s) 					{ RETVAL_STR(s); return; }
+#define RETURN_INT_STR(s)				{ RETVAL_INT_STR(s); return; }
+#define RETURN_NEW_STR(s)				{ RETVAL_NEW_STR(s); return; }
+#define RETURN_STRING(s) 				{ RETVAL_STRING(s); return; }
+#define RETURN_STRINGL(s, l) 			{ RETVAL_STRINGL(s, l); return; }
 #define RETURN_EMPTY_STRING() 			{ RETVAL_EMPTY_STRING(); return; }
+#define RETURN_RES(r) 					{ RETVAL_RES(r); return; }
 #define RETURN_ZVAL(zv, copy, dtor)		{ RETVAL_ZVAL(zv, copy, dtor); return; }
 #define RETURN_FALSE  					{ RETVAL_FALSE; return; }
 #define RETURN_TRUE   					{ RETVAL_TRUE; return; }
@@ -644,97 +632,16 @@ END_EXTERN_C()
 	if (Z_ISREF_P(_z)) {              \
 		RETVAL_ZVAL(_z, 1, 0);        \
 	} else {                          \
-		zval_ptr_dtor(&return_value); \
-		Z_ADDREF_P(_z);               \
-		*return_value_ptr = _z;       \
+		zval_ptr_dtor(return_value);  \
+		ZVAL_COPY(return_value, _z);  \
 	}                                 \
 } while (0)
-#define RETURN_ZVAL_FAST(z) { RETVAL_ZVAL_FAST(z); return; }
-
-#define SET_VAR_STRING(n, v) {																				\
-								{																			\
-									zval *var;																\
-									ALLOC_ZVAL(var);														\
-									ZVAL_STRING(var, v, 0);													\
-									ZEND_SET_GLOBAL_VAR(n, var);											\
-								}																			\
-							}
-
-#define SET_VAR_STRINGL(n, v, l) {														\
-									{													\
-										zval *var;										\
-										ALLOC_ZVAL(var);								\
-										ZVAL_STRINGL(var, v, l, 0);						\
-										ZEND_SET_GLOBAL_VAR(n, var);					\
-									}													\
-								}
-
-#define SET_VAR_LONG(n, v)	{															\
-								{														\
-									zval *var;											\
-									ALLOC_ZVAL(var);									\
-									ZVAL_LONG(var, v);									\
-									ZEND_SET_GLOBAL_VAR(n, var);						\
-								}														\
-							}
-
-#define SET_VAR_DOUBLE(n, v) {															\
-								{														\
-									zval *var;											\
-									ALLOC_ZVAL(var);									\
-									ZVAL_DOUBLE(var, v);								\
-									ZEND_SET_GLOBAL_VAR(n, var);						\
-								}														\
-							}
-
-
-#define ZEND_SET_SYMBOL(symtable, name, var)										\
-	{																				\
-		char *_name = (name);														\
-																					\
-		ZEND_SET_SYMBOL_WITH_LENGTH(symtable, _name, strlen(_name)+1, var, 1, 0);	\
-	}
-
-#define ZEND_SET_SYMBOL_WITH_LENGTH(symtable, name, name_length, var, _refcount, _is_ref)				\
-	{																									\
-		zval **orig_var;																				\
-																										\
-		if (zend_hash_find(symtable, (name), (name_length), (void **) &orig_var)==SUCCESS				\
-			&& PZVAL_IS_REF(*orig_var)) {																\
-			Z_SET_REFCOUNT_P(var, Z_REFCOUNT_PP(orig_var));												\
-			Z_SET_ISREF_P(var);																			\
-																										\
-			if (_refcount) {																			\
-				Z_SET_REFCOUNT_P(var, Z_REFCOUNT_P(var) + _refcount - 1);								\
-			}																							\
-			zval_dtor(*orig_var);																		\
-			**orig_var = *(var);																		\
-			FREE_ZVAL(var);																				\
-		} else {																						\
-			Z_SET_ISREF_TO_P(var, _is_ref);																\
-			if (_refcount) {																			\
-				Z_SET_REFCOUNT_P(var, _refcount);														\
-			}																							\
-			zend_hash_update(symtable, (name), (name_length), &(var), sizeof(zval *), NULL);			\
-		}																								\
-	}
 
-
-#define ZEND_SET_GLOBAL_VAR(name, var)				\
-	ZEND_SET_SYMBOL(&EG(symbol_table), name, var)
-
-#define ZEND_SET_GLOBAL_VAR_WITH_LENGTH(name, name_length, var, _refcount, _is_ref)	\
-	ZEND_SET_SYMBOL_WITH_LENGTH(&EG(symbol_table), name, name_length, var, _refcount, _is_ref)
-
-#define ZEND_DEFINE_PROPERTY(class_ptr, name, value, mask)							\
-{																					\
-	char *_name = (name);															\
-	int namelen = strlen(_name);													\
-	zend_declare_property(class_ptr, _name, namelen, value, mask TSRMLS_CC);		\
-}
+#define RETURN_ZVAL_FAST(z) { RETVAL_ZVAL_FAST(z); return; }
 
 #define HASH_OF(p) (Z_TYPE_P(p)==IS_ARRAY ? Z_ARRVAL_P(p) : ((Z_TYPE_P(p)==IS_OBJECT ? Z_OBJ_HT_P(p)->get_properties((p) TSRMLS_CC) : NULL)))
-#define ZVAL_IS_NULL(z) (Z_TYPE_P(z)==IS_NULL)
+#define ZVAL_IS_NULL(z) (Z_TYPE_P(z) == IS_NULL)
+#define ZVAL_IS_UNDEF(z) (Z_TYPE_P(z) == IS_UNDEF)
 
 /* For compatibility */
 #define ZEND_MINIT			ZEND_MODULE_STARTUP_N
diff --git a/Zend/zend_alloc.c b/Zend/zend_alloc.c
index f621487819..3e94ae0bd6 100644
--- a/Zend/zend_alloc.c
+++ b/Zend/zend_alloc.c
@@ -1758,10 +1758,11 @@ static void zend_mm_safe_error(zend_mm_heap *heap,
 		uint error_lineno;
 		TSRMLS_FETCH();
 		if (zend_is_compiling(TSRMLS_C)) {
-			error_filename = zend_get_compiled_filename(TSRMLS_C);
+			zend_string *str = zend_get_compiled_filename(TSRMLS_C);
+			error_filename = str ? str->val : NULL;
 			error_lineno = zend_get_compiled_lineno(TSRMLS_C);
 		} else if (EG(in_execution)) {
-			error_filename = EG(active_op_array)?EG(active_op_array)->filename:NULL;
+			error_filename = EG(active_op_array)?EG(active_op_array)->filename->val:NULL;
 			error_lineno = EG(opline_ptr)?(*EG(opline_ptr))->lineno:0;
 		} else {
 			error_filename = NULL;
diff --git a/Zend/zend_alloc.h b/Zend/zend_alloc.h
index 1541dffcec..609db22dac 100644
--- a/Zend/zend_alloc.h
+++ b/Zend/zend_alloc.h
@@ -136,9 +136,6 @@ inline static void * __zend_realloc(void *p, size_t len)
 #define perealloc_recoverable_rel(ptr, size, persistent) ((persistent)?__zend_realloc((ptr), (size)):erealloc_recoverable_rel((ptr), (size)))
 #define pestrdup_rel(s, persistent) ((persistent)?strdup(s):estrdup_rel(s))
 
-#define safe_estrdup(ptr)  ((ptr)?(estrdup(ptr)):STR_EMPTY_ALLOC())
-#define safe_estrndup(ptr, len) ((ptr)?(estrndup((ptr), (len))):STR_EMPTY_ALLOC())
-
 ZEND_API int zend_set_memory_limit(size_t memory_limit TSRMLS_DC);
 
 ZEND_API void start_memory_manager(TSRMLS_D);
@@ -161,19 +158,6 @@ ZEND_API size_t zend_memory_peak_usage(int real_usage TSRMLS_DC);
 
 END_EXTERN_C()
 
-/* fast cache for zval's */
-#define ALLOC_ZVAL(z)	\
-	(z) = (zval *) emalloc(sizeof(zval))
-
-#define FREE_ZVAL(z)	\
-	efree_rel(z)
-
-#define ALLOC_ZVAL_REL(z)	\
-	(z) = (zval *) emalloc_rel(sizeof(zval))
-
-#define FREE_ZVAL_REL(z)	\
-	efree_rel(z)
-
 /* fast cache for HashTables */
 #define ALLOC_HASHTABLE(ht)	\
 	(ht) = (HashTable *) emalloc(sizeof(HashTable))
diff --git a/Zend/zend_ast.c b/Zend/zend_ast.c
index e486aa326c..07d38dc6bf 100644
--- a/Zend/zend_ast.c
+++ b/Zend/zend_ast.c
@@ -28,8 +28,7 @@ ZEND_API zend_ast *zend_ast_create_constant(zval *zv)
 	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zval));
 	ast->kind = ZEND_CONST;
 	ast->children = 0;
-	ast->u.val = (zval*)(ast + 1);
-	INIT_PZVAL_COPY(ast->u.val, zv);
+	ZVAL_COPY_VALUE(&ast->u.val, zv);
 	return ast;
 }
 
@@ -63,33 +62,12 @@ ZEND_API zend_ast* zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *o
 	return ast;
 }
 
-ZEND_API zend_ast* zend_ast_create_dynamic(uint kind)
-{
-	zend_ast *ast = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * 3); /* use 4 children as deafult */
-	ast->kind = kind;
-	ast->children = 0;
-	return ast;
-}
-
-ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op)
-{
-	if ((*ast)->children >= 4 && (*ast)->children == ((*ast)->children & -(*ast)->children)) {
-		*ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children * 2 + 1));
-	}
-	(&(*ast)->u.child)[(*ast)->children++] = op;
-}
-
-ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast)
-{
-	*ast = erealloc(*ast, sizeof(zend_ast) + sizeof(zend_ast*) * ((*ast)->children - 1));
-}
-
 ZEND_API int zend_ast_is_ct_constant(zend_ast *ast)
 {
 	int i;
 
 	if (ast->kind == ZEND_CONST) {
-		return !IS_CONSTANT_TYPE(Z_TYPE_P(ast->u.val));
+		return !Z_CONSTANT(ast->u.val);
 	} else {
 		for (i = 0; i < ast->children; i++) {
 			if ((&ast->u.child)[i]) {
@@ -251,10 +229,9 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			zval_dtor(&op2);
 			break;
 		case ZEND_CONST:
-			*result = *ast->u.val;
-			zval_copy_ctor(result);
-			if (IS_CONSTANT_TYPE(Z_TYPE_P(result))) {
-				zval_update_constant_ex(&result, 1, scope TSRMLS_CC);
+			ZVAL_DUP(result, &ast->u.val);
+			if (Z_OPT_CONSTANT_P(result)) {
+				zval_update_constant_ex(result, 1, scope TSRMLS_CC);
 			}
 			break;
 		case ZEND_BOOL_AND:
@@ -305,35 +282,6 @@ ZEND_API void zend_ast_evaluate(zval *result, zend_ast *ast, zend_class_entry *s
 			sub_function(result, &op1, &op2 TSRMLS_CC);
 			zval_dtor(&op2);
 			break;
-		case ZEND_INIT_ARRAY:
-			INIT_PZVAL(result);
-			array_init(result);
-			{
-				int i;
-				zend_bool has_key;
-				for (i = 0; i < ast->children; i+=2) {
-					zval *expr;
-					MAKE_STD_ZVAL(expr);
-					if ((has_key = !!(&ast->u.child)[i])) {
-						zend_ast_evaluate(&op1, (&ast->u.child)[i], scope TSRMLS_CC);
-					}
-					zend_ast_evaluate(expr, (&ast->u.child)[i+1], scope TSRMLS_CC);
-					zend_do_add_static_array_element(result, has_key?&op1:NULL, expr);
-				}
-			}
-			break;
-		case ZEND_FETCH_DIM_R:
-			zend_ast_evaluate(&op1, (&ast->u.child)[0], scope TSRMLS_CC);
-			zend_ast_evaluate(&op2, (&ast->u.child)[1], scope TSRMLS_CC);
-			{
-				zval *tmp;
-				zend_fetch_dimension_by_zval(&tmp, &op1, &op2 TSRMLS_CC);
-				*result = *tmp;
-				efree(tmp);
-			}
-			zval_dtor(&op1);
-			zval_dtor(&op2);
-			break;
 		default:
 			zend_error(E_ERROR, "Unsupported constant expression");
 	}
@@ -344,8 +292,8 @@ ZEND_API zend_ast *zend_ast_copy(zend_ast *ast)
 	if (ast == NULL) {
 		return NULL;
 	} else if (ast->kind == ZEND_CONST) {
-		zend_ast *copy = zend_ast_create_constant(ast->u.val);
-		zval_copy_ctor(copy->u.val);
+		zend_ast *copy = zend_ast_create_constant(&ast->u.val);
+		zval_copy_ctor(&copy->u.val);
 		return copy;
 	} else if (ast->children) {
 		zend_ast *new = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
@@ -357,7 +305,7 @@ ZEND_API zend_ast *zend_ast_copy(zend_ast *ast)
 		}
 		return new;
 	}
-	return zend_ast_create_dynamic(ast->kind);
+	return NULL;
 }
 
 ZEND_API void zend_ast_destroy(zend_ast *ast)
@@ -365,7 +313,7 @@ ZEND_API void zend_ast_destroy(zend_ast *ast)
 	int i;
 
 	if (ast->kind == ZEND_CONST) {
-		zval_dtor(ast->u.val);
+		zval_dtor(&ast->u.val);
 	} else {
 		for (i = 0; i < ast->children; i++) {
 			if ((&ast->u.child)[i]) {
diff --git a/Zend/zend_ast.h b/Zend/zend_ast.h
index f8df15c95b..cac3a54dd4 100644
--- a/Zend/zend_ast.h
+++ b/Zend/zend_ast.h
@@ -22,8 +22,6 @@
 #ifndef ZEND_AST_H
 #define ZEND_AST_H
 
-typedef struct _zend_ast zend_ast;
-
 #include "zend.h"
 
 typedef enum _zend_ast_kind {
@@ -40,7 +38,7 @@ struct _zend_ast {
 	unsigned short kind;
 	unsigned short children;
 	union {
-		zval     *val;
+		zval      val;
 		zend_ast *child;
 	} u;
 };
@@ -50,9 +48,6 @@ ZEND_API zend_ast *zend_ast_create_constant(zval *zv);
 ZEND_API zend_ast *zend_ast_create_unary(uint kind, zend_ast *op0);
 ZEND_API zend_ast *zend_ast_create_binary(uint kind, zend_ast *op0, zend_ast *op1);
 ZEND_API zend_ast *zend_ast_create_ternary(uint kind, zend_ast *op0, zend_ast *op1, zend_ast *op2);
-ZEND_API zend_ast* zend_ast_create_dynamic(uint kind);
-ZEND_API void zend_ast_dynamic_add(zend_ast **ast, zend_ast *op);
-ZEND_API void zend_ast_dynamic_shrink(zend_ast **ast);
 
 ZEND_API int zend_ast_is_ct_constant(zend_ast *ast);
 
diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 6bfb888988..32bd68e58e 100644
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -349,7 +349,7 @@ int zend_startup_builtin_functions(TSRMLS_D) /* {{{ */
    Get the version of the Zend Engine */
 ZEND_FUNCTION(zend_version)
 {
-	RETURN_STRINGL(ZEND_VERSION, sizeof(ZEND_VERSION)-1, 1);
+	RETURN_STRINGL(ZEND_VERSION, sizeof(ZEND_VERSION)-1);
 }
 /* }}} */
 
@@ -374,7 +374,9 @@ ZEND_FUNCTION(gc_enabled)
    Activates the circular reference collector */
 ZEND_FUNCTION(gc_enable)
 {
-	zend_alter_ini_entry("zend.enable_gc", sizeof("zend.enable_gc"), "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+	zend_string *key = STR_INIT("zend.enable_gc", sizeof("zend.enable_gc")-1, 0);
+	zend_alter_ini_entry(key, "1", sizeof("1")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+	STR_RELEASE(key);
 }
 /* }}} */
 
@@ -382,7 +384,9 @@ ZEND_FUNCTION(gc_enable)
    Deactivates the circular reference collector */
 ZEND_FUNCTION(gc_disable)
 {
-	zend_alter_ini_entry("zend.enable_gc", sizeof("zend.enable_gc"), "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+	zend_string *key = STR_INIT("zend.enable_gc", sizeof("zend.enable_gc")-1, 0);
+	zend_alter_ini_entry(key, "0", sizeof("0")-1, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+	STR_RELEASE(key);
 }
 /* }}} */
 
@@ -393,7 +397,7 @@ ZEND_FUNCTION(func_num_args)
 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
 
 	if (ex && ex->function_state.arguments) {
-		RETURN_LONG((long)(zend_uintptr_t)*(ex->function_state.arguments));
+		RETURN_LONG(Z_LVAL_P(ex->function_state.arguments));
 	} else {
 		zend_error(E_WARNING, "func_num_args():  Called from the global scope - no function context");
 		RETURN_LONG(-1);
@@ -406,7 +410,7 @@ ZEND_FUNCTION(func_num_args)
    Get the $arg_num'th argument that was passed to the function */
 ZEND_FUNCTION(func_get_arg)
 {
-	void **p;
+	zval *p;
 	int arg_count;
 	zval *arg;
 	long requested_offset;
@@ -427,14 +431,14 @@ ZEND_FUNCTION(func_get_arg)
 	}
 
 	p = ex->function_state.arguments;
-	arg_count = (int)(zend_uintptr_t) *p;		/* this is the amount of arguments passed to func_get_arg(); */
+	arg_count = Z_LVAL_P(p);		/* this is the amount of arguments passed to func_get_arg(); */
 
 	if (requested_offset >= arg_count) {
 		zend_error(E_WARNING, "func_get_arg():  Argument %ld not passed to function", requested_offset);
 		RETURN_FALSE;
 	}
 
-	arg = *(p-(arg_count-requested_offset));
+	arg = p-(arg_count-requested_offset);
 	RETURN_ZVAL_FAST(arg);
 }
 /* }}} */
@@ -444,7 +448,7 @@ ZEND_FUNCTION(func_get_arg)
    Get an array of the arguments that were passed to the function */
 ZEND_FUNCTION(func_get_args)
 {
-	void **p;
+	zval *p;
 	int arg_count;
 	int i;
 	zend_execute_data *ex = EG(current_execute_data)->prev_execute_data;
@@ -455,22 +459,21 @@ ZEND_FUNCTION(func_get_args)
 	}
 
 	p = ex->function_state.arguments;
-	arg_count = (int)(zend_uintptr_t) *p;		/* this is the amount of arguments passed to func_get_args(); */
+	arg_count = Z_LVAL_P(p);		/* this is the amount of arguments passed to func_get_args(); */
 
 	array_init_size(return_value, arg_count);
 	for (i=0; i<arg_count; i++) {
-		zval *element, *arg;
+		zval *element, *arg, tmp;
 
-		arg = *((zval **) (p-(arg_count-i)));
+		arg = p-(arg_count-i);
 		if (!Z_ISREF_P(arg)) {
 			element = arg;
-			Z_ADDREF_P(element);
+			if (Z_REFCOUNTED_P(element)) Z_ADDREF_P(element);
 		} else {
-			ALLOC_ZVAL(element);
-			INIT_PZVAL_COPY(element, arg);
-			zval_copy_ctor(element);
+			ZVAL_DUP(&tmp, Z_REFVAL_P(arg));
+			element = &tmp;
 	    }
-		zend_hash_next_index_insert(return_value->value.ht, &element, sizeof(zval *), NULL);
+		zend_hash_next_index_insert(Z_ARRVAL_P(return_value), element);
 	}
 }
 /* }}} */
@@ -572,53 +575,57 @@ ZEND_FUNCTION(strncasecmp)
    Return the currently pointed key..value pair in the passed array, and advance the pointer to the next element */
 ZEND_FUNCTION(each)
 {
-	zval *array, *entry, **entry_ptr, *tmp;
-	char *string_key;
-	uint string_key_len;
+	zval *array, *entry, tmp;
 	ulong num_key;
-	zval **inserted_pointer;
+	zval *inserted_pointer;
 	HashTable *target_hash;
+	zend_string *key;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
 		return;
 	}
 
+	ZVAL_DEREF(array);
 	target_hash = HASH_OF(array);
 	if (!target_hash) {
 		zend_error(E_WARNING,"Variable passed to each() is not an array or object");
 		return;
 	}
-	if (zend_hash_get_current_data(target_hash, (void **) &entry_ptr)==FAILURE) {
-		RETURN_FALSE;
+	while (1) {
+		entry = zend_hash_get_current_data(target_hash);
+		if (!entry) {
+			RETURN_FALSE;
+		} else if (Z_TYPE_P(entry) == IS_INDIRECT) {
+			entry = Z_INDIRECT_P(entry);
+			if (Z_TYPE_P(entry) == IS_UNDEF) {
+				zend_hash_move_forward(target_hash);
+				continue;
+			}
+		}
+		break;
 	}
 	array_init(return_value);
-	entry = *entry_ptr;
 
 	/* add value elements */
 	if (Z_ISREF_P(entry)) {
-		ALLOC_ZVAL(tmp);
-		*tmp = *entry;
-		zval_copy_ctor(tmp);
-		Z_UNSET_ISREF_P(tmp);
-		Z_SET_REFCOUNT_P(tmp, 0);
-		entry=tmp;
-	}
-	zend_hash_index_update(return_value->value.ht, 1, &entry, sizeof(zval *), NULL);
-	Z_ADDREF_P(entry);
-	zend_hash_update(return_value->value.ht, "value", sizeof("value"), &entry, sizeof(zval *), NULL);
-	Z_ADDREF_P(entry);
+		ZVAL_DUP(&tmp, Z_REFVAL_P(entry));
+		entry = &tmp;
+		if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
+	} else {
+		if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
+		if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
+	}
+	zend_hash_index_update(Z_ARRVAL_P(return_value), 1, entry);
+	zend_hash_str_update(Z_ARRVAL_P(return_value), "value", sizeof("value")-1, entry);
 
 	/* add the key elements */
-	switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_key_len, &num_key, 0, NULL)) {
-		case HASH_KEY_IS_STRING:
-			add_get_index_stringl(return_value, 0, string_key, string_key_len-1, (void **) &inserted_pointer, !IS_INTERNED(string_key));
-			break;
-		case HASH_KEY_IS_LONG:
-			add_get_index_long(return_value, 0, num_key, (void **) &inserted_pointer);
-			break;
+	if (zend_hash_get_current_key(target_hash, &key, &num_key, 0) == HASH_KEY_IS_STRING) {
+		inserted_pointer = add_get_index_str(return_value, 0, STR_COPY(key));
+	} else {
+		inserted_pointer = add_get_index_long(return_value, 0, num_key);
 	}
-	zend_hash_update(return_value->value.ht, "key", sizeof("key"), inserted_pointer, sizeof(zval *), NULL);
-	Z_ADDREF_PP(inserted_pointer);
+	zend_hash_str_update(Z_ARRVAL_P(return_value), "key", sizeof("key")-1, inserted_pointer);
+	if (Z_REFCOUNTED_P(inserted_pointer)) Z_ADDREF_P(inserted_pointer);
 	zend_hash_move_forward(target_hash);
 }
 /* }}} */
@@ -638,7 +645,9 @@ ZEND_FUNCTION(error_reporting)
 
 	old_error_reporting = EG(error_reporting);
 	if(ZEND_NUM_ARGS() != 0) {
-		zend_alter_ini_entry("error_reporting", sizeof("error_reporting"), err, err_len, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+		zend_string *key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0);
+		zend_alter_ini_entry(key, err, err_len, ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+		STR_RELEASE(key);
 	}
 
 	RETVAL_LONG(old_error_reporting);
@@ -650,15 +659,13 @@ ZEND_FUNCTION(error_reporting)
    Define a new constant */
 ZEND_FUNCTION(define)
 {
-	char *name;
-	int name_len;
-	zval *val;
-	zval *val_free = NULL;
+	zend_string *name;
+	zval *val, val_free;
 	zend_bool non_cs = 0;
 	int case_sensitive = CONST_CS;
 	zend_constant c;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|b", &name, &name_len, &val, &non_cs) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|b", &name, &val, &non_cs) == FAILURE) {
 		return;
 	}
 
@@ -667,11 +674,13 @@ ZEND_FUNCTION(define)
 	}
 
 	/* class constant, check if there is name and make sure class is valid & exists */
-	if (zend_memnstr(name, "::", sizeof("::") - 1, name + name_len)) {
+	if (zend_memnstr(name->val, "::", sizeof("::") - 1, name->val + name->len)) {
 		zend_error(E_WARNING, "Class constants cannot be defined or redefined");
 		RETURN_FALSE;
 	}
 
+	ZVAL_UNDEF(&val_free);
+
 repeat:
 	switch (Z_TYPE_P(val)) {
 		case IS_LONG:
@@ -682,14 +691,15 @@ repeat:
 		case IS_NULL:
 			break;
 		case IS_OBJECT:
-			if (!val_free) {
+			if (Z_TYPE(val_free) == IS_UNDEF) {
 				if (Z_OBJ_HT_P(val)->get) {
-					val_free = val = Z_OBJ_HT_P(val)->get(val TSRMLS_CC);
+					zval rv;
+					val = Z_OBJ_HT_P(val)->get(val, &rv TSRMLS_CC);
+					ZVAL_COPY_VALUE(&val_free, val);
 					goto repeat;
 				} else if (Z_OBJ_HT_P(val)->cast_object) {
-					ALLOC_INIT_ZVAL(val_free);
-					if (Z_OBJ_HT_P(val)->cast_object(val, val_free, IS_STRING TSRMLS_CC) == SUCCESS) {
-						val = val_free;
+					if (Z_OBJ_HT_P(val)->cast_object(val, &val_free, IS_STRING TSRMLS_CC) == SUCCESS) {
+						val = &val_free;
 						break;
 					}
 				}
@@ -697,23 +707,14 @@ repeat:
 			/* no break */
 		default:
 			zend_error(E_WARNING,"Constants may only evaluate to scalar values");
-			if (val_free) {
-				zval_ptr_dtor(&val_free);
-			}
+			zval_ptr_dtor(&val_free);
 			RETURN_FALSE;
 	}
 	
-	c.value = *val;
-	zval_copy_ctor(&c.value);
-	if (val_free) {
-		zval_ptr_dtor(&val_free);
-	}
+	ZVAL_DUP(&c.value, val);
+	zval_ptr_dtor(&val_free);
 	c.flags = case_sensitive; /* non persistent */
-	c.name = str_strndup(name, name_len);
-	if(c.name == NULL) {
-		RETURN_FALSE;
-	}
-	c.name_len = name_len+1;
+	c.name = STR_COPY(name);
 	c.module_number = PHP_USER_CONSTANT;
 	if (zend_register_constant(&c TSRMLS_CC) == SUCCESS) {
 		RETURN_TRUE;
@@ -728,16 +729,13 @@ repeat:
    Check whether a constant exists */
 ZEND_FUNCTION(defined)
 {
-	char *name;
-	int name_len;
-	zval c;
+	zend_string *name;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name) == FAILURE) {
 		return;
 	}
 	
-	if (zend_get_constant_ex(name, name_len, &c, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
-		zval_dtor(&c);
+	if (zend_get_constant_ex(name, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
 		RETURN_TRUE;
 	} else {
 		RETURN_FALSE;
@@ -751,9 +749,6 @@ ZEND_FUNCTION(defined)
 ZEND_FUNCTION(get_class)
 {
 	zval *obj = NULL;
-	const char *name = "";
-	zend_uint name_len = 0;
-	int dup;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|o!", &obj) == FAILURE) {
 		RETURN_FALSE;
@@ -761,16 +756,14 @@ ZEND_FUNCTION(get_class)
 
 	if (!obj) {
 		if (EG(scope)) {
-			RETURN_STRINGL(EG(scope)->name, EG(scope)->name_length, 1);
+			RETURN_STR(STR_COPY(EG(scope)->name));
 		} else {
 			zend_error(E_WARNING, "get_class() called without object from outside a class");
 			RETURN_FALSE;
 		}
 	}
 
-	dup = zend_get_object_classname(obj, &name, &name_len TSRMLS_CC);
-
-	RETURN_STRINGL(name, name_len, dup);
+	RETURN_STR(zend_get_object_classname(Z_OBJ_P(obj) TSRMLS_CC));
 }
 /* }}} */
 
@@ -784,7 +777,7 @@ ZEND_FUNCTION(get_called_class)
 	}
 
 	if (EG(called_scope)) {
-		RETURN_STRINGL(EG(called_scope)->name, EG(called_scope)->name_length, 1);
+		RETURN_STR(STR_COPY(EG(called_scope)->name));
 	} else if (!EG(scope))  {
 		zend_error(E_WARNING, "get_called_class() called from outside a class");
 	}
@@ -799,8 +792,7 @@ ZEND_FUNCTION(get_parent_class)
 {
 	zval *arg;
 	zend_class_entry *ce = NULL;
-	const char *name;
-	zend_uint name_length;
+	zend_string *name;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) {
 		return;
@@ -809,7 +801,7 @@ ZEND_FUNCTION(get_parent_class)
 	if (!ZEND_NUM_ARGS()) {
 		ce = EG(scope);
 		if (ce && ce->parent) {
-			RETURN_STRINGL(ce->parent->name, ce->parent->name_length, 1);
+			RETURN_STR(STR_COPY(ce->parent->name));
 		} else {
 			RETURN_FALSE;
 		}
@@ -817,21 +809,17 @@ ZEND_FUNCTION(get_parent_class)
 
 	if (Z_TYPE_P(arg) == IS_OBJECT) {
 		if (Z_OBJ_HT_P(arg)->get_class_name
-			&& Z_OBJ_HT_P(arg)->get_class_name(arg, &name, &name_length, 1 TSRMLS_CC) == SUCCESS) {
-			RETURN_STRINGL(name, name_length, 0);
+			&& (name = Z_OBJ_HT_P(arg)->get_class_name(Z_OBJ_P(arg), 1 TSRMLS_CC)) != NULL) {
+			RETURN_STR(name);
 		} else {
-			ce = zend_get_class_entry(arg TSRMLS_CC);
+			ce = zend_get_class_entry(Z_OBJ_P(arg) TSRMLS_CC);
 		}
 	} else if (Z_TYPE_P(arg) == IS_STRING) {
-		zend_class_entry **pce;
-		
-		if (zend_lookup_class(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &pce TSRMLS_CC) == SUCCESS) {
-			ce = *pce;
-		}
+	    ce = zend_lookup_class(Z_STR_P(arg) TSRMLS_CC);
 	}
 
 	if (ce && ce->parent) {
-		RETURN_STRINGL(ce->parent->name, ce->parent->name_length, 1);
+		RETURN_STR(STR_COPY(ce->parent->name));
 	} else {
 		RETURN_FALSE;
 	}
@@ -842,14 +830,13 @@ ZEND_FUNCTION(get_parent_class)
 static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
 {
 	zval *obj;
-	char *class_name;
-	int class_name_len;
+	zend_string *class_name;
 	zend_class_entry *instance_ce;
-	zend_class_entry **ce;
+	zend_class_entry *ce;
 	zend_bool allow_string = only_subclass;
 	zend_bool retval;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|b", &obj, &class_name, &class_name_len, &allow_string) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zS|b", &obj, &class_name, &allow_string) == FAILURE) {
 		return;
 	}
 	/*
@@ -860,24 +847,24 @@ static void is_a_impl(INTERNAL_FUNCTION_PARAMETERS, zend_bool only_subclass)
 	 */
 
 	if (allow_string && Z_TYPE_P(obj) == IS_STRING) {
-		zend_class_entry **the_ce;
-		if (zend_lookup_class(Z_STRVAL_P(obj), Z_STRLEN_P(obj), &the_ce TSRMLS_CC) == FAILURE) {
+		instance_ce = zend_lookup_class(Z_STR_P(obj) TSRMLS_CC);
+		if (!instance_ce) {
 			RETURN_FALSE;
 		}
-		instance_ce = *the_ce;
 	} else if (Z_TYPE_P(obj) == IS_OBJECT && HAS_CLASS_ENTRY(*obj)) {
 		instance_ce = Z_OBJCE_P(obj);
 	} else {
 		RETURN_FALSE;
 	}
 
-	if (zend_lookup_class_ex(class_name, class_name_len, NULL, 0, &ce TSRMLS_CC) == FAILURE) {
+	ce = zend_lookup_class_ex(class_name, NULL, 0 TSRMLS_CC);
+	if (!ce) {
 		retval = 0;
 	} else {
-		if (only_subclass && instance_ce == *ce) {
+		if (only_subclass && instance_ce == ce) {
 			retval = 0;
  		} else {
-			retval = instanceof_function(instance_ce, *ce TSRMLS_CC);
+			retval = instanceof_function(instance_ce, ce TSRMLS_CC);
 		}
 	}
 
@@ -906,17 +893,11 @@ ZEND_FUNCTION(is_a)
 /* {{{ add_class_vars */
 static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value TSRMLS_DC)
 {
-	HashPosition pos;
 	zend_property_info *prop_info;
-	zval *prop, *prop_copy;
-	char *key;
-	uint key_len;
-	ulong num_index;
-
-	zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
-	while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop_info, &pos) == SUCCESS) {
-		zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
-		zend_hash_move_forward_ex(&ce->properties_info, &pos);
+	zval *prop, prop_copy;
+	zend_string *key;
+
+	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->properties_info, key, prop_info) {
 		if (((prop_info->flags & ZEND_ACC_SHADOW) &&
 		     prop_info->ce != EG(scope)) ||
 		    ((prop_info->flags & ZEND_ACC_PROTECTED) &&
@@ -929,29 +910,26 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
 		prop = NULL;
 		if (prop_info->offset >= 0) {
 			if (statics && (prop_info->flags & ZEND_ACC_STATIC) != 0) {
-				prop = ce->default_static_members_table[prop_info->offset];
+				prop = &ce->default_static_members_table[prop_info->offset];
 			} else if (!statics && (prop_info->flags & ZEND_ACC_STATIC) == 0) {
-				prop = ce->default_properties_table[prop_info->offset];
+				prop = &ce->default_properties_table[prop_info->offset];
  			}
 		}
-		if (!prop) {
+		if (!prop || Z_TYPE_P(prop) == IS_UNDEF) {
 			continue;
 		}
 
 		/* copy: enforce read only access */
-		ALLOC_ZVAL(prop_copy);
-		*prop_copy = *prop;
-		zval_copy_ctor(prop_copy);
-		INIT_PZVAL(prop_copy);
+		ZVAL_DUP_DEREF(&prop_copy, prop);
 
 		/* this is necessary to make it able to work with default array
 		 * properties, returned to user */
-		if (IS_CONSTANT_TYPE(Z_TYPE_P(prop_copy))) {
+		if (Z_OPT_CONSTANT(prop_copy)) {
 			zval_update_constant(&prop_copy, 0 TSRMLS_CC);
 		}
 
-		zend_hash_update(Z_ARRVAL_P(return_value), key, key_len, &prop_copy, sizeof(zval*), NULL);
-	}
+		zend_hash_update(Z_ARRVAL_P(return_value), key, &prop_copy);
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -960,21 +938,21 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
    Returns an array of default properties of the class. */
 ZEND_FUNCTION(get_class_vars)
 {
-	char *class_name;
-	int class_name_len;
-	zend_class_entry **pce;
+	zend_string *class_name;
+	zend_class_entry *ce;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &class_name, &class_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &class_name) == FAILURE) {
 		return;
 	}
 
-	if (zend_lookup_class(class_name, class_name_len, &pce TSRMLS_CC) == FAILURE) {
+	ce = zend_lookup_class(class_name TSRMLS_CC);
+	if (!ce) {
 		RETURN_FALSE;
 	} else {
 		array_init(return_value);
-		zend_update_class_constants(*pce TSRMLS_CC);
-		add_class_vars(*pce, 0, return_value TSRMLS_CC);
-		add_class_vars(*pce, 1, return_value TSRMLS_CC);
+		zend_update_class_constants(ce TSRMLS_CC);
+		add_class_vars(ce, 0, return_value TSRMLS_CC);
+		add_class_vars(ce, 1, return_value TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -985,13 +963,11 @@ ZEND_FUNCTION(get_class_vars)
 ZEND_FUNCTION(get_object_vars)
 {
 	zval *obj;
-	zval **value;
+	zval *value;
 	HashTable *properties;
-	HashPosition pos;
-	char *key;
+	zend_string *key;
 	const char *prop_name, *class_name;
-	uint key_len, prop_len;
-	ulong num_index;
+	uint prop_len;
 	zend_object *zobj;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
@@ -1008,30 +984,24 @@ ZEND_FUNCTION(get_object_vars)
 		RETURN_FALSE;
 	}
 
-	zobj = zend_objects_get_address(obj TSRMLS_CC);
+	zobj = Z_OBJ_P(obj);
 
 	array_init(return_value);
 
-	zend_hash_internal_pointer_reset_ex(properties, &pos);
-
-	while (zend_hash_get_current_data_ex(properties, (void **) &value, &pos) == SUCCESS) {
-		if (zend_hash_get_current_key_ex(properties, &key, &key_len, &num_index, 0, &pos) == HASH_KEY_IS_STRING) {
-			if (zend_check_property_access(zobj, key, key_len-1 TSRMLS_CC) == SUCCESS) {
-				zend_unmangle_property_name_ex(key, key_len - 1, &class_name, &prop_name, (int*) &prop_len);
+	ZEND_HASH_FOREACH_STR_KEY_VAL_IND(properties, key, value) {
+		if (key) {
+			if (zend_check_property_access(zobj, key TSRMLS_CC) == SUCCESS) {
 				/* Not separating references */
-				Z_ADDREF_PP(value);
-				if (IS_INTERNED(key) && prop_name != key) {
-					/* we can't use substring of interned string as a new key */
-					char *tmp = estrndup(prop_name, prop_len);
-					add_assoc_zval_ex(return_value, tmp, prop_len + 1, *value);
-					efree(tmp);
+				if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
+				if (key->val[0] == 0) {
+					zend_unmangle_property_name_ex(key->val, key->len, &class_name, &prop_name, (int*) &prop_len);
+					zend_hash_str_update(Z_ARRVAL_P(return_value), prop_name, prop_len, value);
 				} else {
-					add_assoc_zval_ex(return_value, prop_name, prop_len + 1, *value);
+					zend_hash_update(Z_ARRVAL_P(return_value), key, value);
 				}
 			}
 		}
-		zend_hash_move_forward_ex(properties, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -1048,10 +1018,10 @@ static int same_name(const char *key, const char *name, zend_uint name_len)
 ZEND_FUNCTION(get_class_methods)
 {
 	zval *klass;
-	zval *method_name;
-	zend_class_entry *ce = NULL, **pce;
-	HashPosition pos;
+	zval method_name;
+	zend_class_entry *ce = NULL;
 	zend_function *mptr;
+	zend_string *key;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &klass) == FAILURE) {
 		return;
@@ -1064,9 +1034,7 @@ ZEND_FUNCTION(get_class_methods)
 		}
 		ce = Z_OBJCE_P(klass);
 	} else if (Z_TYPE_P(klass) == IS_STRING) {
-		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == SUCCESS) {
-			ce = *pce;
-		}
+	    ce = zend_lookup_class(Z_STR_P(klass) TSRMLS_CC);
 	}
 
 	if (!ce) {
@@ -1074,45 +1042,40 @@ ZEND_FUNCTION(get_class_methods)
 	}
 
 	array_init(return_value);
-	zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
 
-	while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_STR_KEY_PTR(&ce->function_table, key, mptr) {
+
 		if ((mptr->common.fn_flags & ZEND_ACC_PUBLIC) 
 		 || (EG(scope) &&
 		     (((mptr->common.fn_flags & ZEND_ACC_PROTECTED) &&
 		       zend_check_protected(mptr->common.scope, EG(scope)))
 		   || ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) &&
 		       EG(scope) == mptr->common.scope)))) {
-			char *key;
-			uint key_len;
-			ulong num_index;
-			uint len = strlen(mptr->common.function_name);
+			uint len = mptr->common.function_name->len;
 
 			/* Do not display old-style inherited constructors */
-			if (zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING) {
-				MAKE_STD_ZVAL(method_name);
-				ZVAL_STRINGL(method_name, mptr->common.function_name, len, 1);
-				zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
+			if (!key) {
+// TODO: we have to duplicate it, becaise it may be stored in opcache SHM ???
+				ZVAL_STR(&method_name, STR_DUP(mptr->common.function_name, 0));
+				zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &method_name);
 			} else if ((mptr->common.fn_flags & ZEND_ACC_CTOR) == 0 ||
 			    mptr->common.scope == ce ||
-			    zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0) {
+			    zend_binary_strcasecmp(key->val, key->len, mptr->common.function_name->val, len) == 0) {
 
 				if (mptr->type == ZEND_USER_FUNCTION &&
 				    *mptr->op_array.refcount > 1 &&
-			    	(len != key_len - 1 ||
-			    	 !same_name(key, mptr->common.function_name, len))) {
-					MAKE_STD_ZVAL(method_name);
-					ZVAL_STRINGL(method_name, zend_find_alias_name(mptr->common.scope, key, key_len - 1), key_len - 1, 1);
-					zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
+			    	(len != key->len ||
+			    	 !same_name(key->val, mptr->common.function_name->val, len))) {
+					ZVAL_STR(&method_name, STR_COPY(zend_find_alias_name(mptr->common.scope, key)));
+					zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &method_name);
 				} else {
-					MAKE_STD_ZVAL(method_name);
-					ZVAL_STRINGL(method_name, mptr->common.function_name, len, 1);
-					zend_hash_next_index_insert(return_value->value.ht, &method_name, sizeof(zval *), NULL);
+// TODO: we have to duplicate it, becaise it may be stored in opcache SHM ???
+					ZVAL_STR(&method_name, STR_DUP(mptr->common.function_name, 0));
+					zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &method_name);
 				}
 			}
 		}
-		zend_hash_move_forward_ex(&ce->function_table, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -1122,46 +1085,45 @@ ZEND_FUNCTION(get_class_methods)
 ZEND_FUNCTION(method_exists)
 {
 	zval *klass; 
-	char *method_name;
-	int method_len;
-	char *lcname;
-	zend_class_entry * ce, **pce;
+	zend_string *method_name;
+	zend_string *lcname;
+	zend_class_entry * ce;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &klass, &method_name, &method_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zS", &klass, &method_name) == FAILURE) {
 		return;
 	}
 	if (Z_TYPE_P(klass) == IS_OBJECT) {
 		ce = Z_OBJCE_P(klass);
 	} else if (Z_TYPE_P(klass) == IS_STRING) {
-		if (zend_lookup_class(Z_STRVAL_P(klass), Z_STRLEN_P(klass), &pce TSRMLS_CC) == FAILURE) {
+		if ((ce = zend_lookup_class(Z_STR_P(klass) TSRMLS_CC)) == NULL) {
 			RETURN_FALSE;
 		}
-		ce = *pce;
 	} else {
 		RETURN_FALSE;
 	}
 
-	lcname = zend_str_tolower_dup(method_name, method_len);
-	if (zend_hash_exists(&ce->function_table, lcname, method_len+1)) {
-		efree(lcname);
+	lcname = STR_ALLOC(method_name->len, 0);
+	zend_str_tolower_copy(lcname->val, method_name->val, method_name->len);
+	if (zend_hash_exists(&ce->function_table, lcname)) {
+		STR_FREE(lcname);
 		RETURN_TRUE;
 	} else {
 		union _zend_function *func = NULL;
 
 		if (Z_TYPE_P(klass) == IS_OBJECT 
 		&& Z_OBJ_HT_P(klass)->get_method != NULL
-		&& (func = Z_OBJ_HT_P(klass)->get_method(&klass, method_name, method_len, NULL TSRMLS_CC)) != NULL
+		&& (func = Z_OBJ_HT_P(klass)->get_method(&Z_OBJ_P(klass), method_name, NULL TSRMLS_CC)) != NULL
 		) {
 			if (func->type == ZEND_INTERNAL_FUNCTION 
 			&& (func->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0
 			) {
 				/* Returns true to the fake Closure's __invoke */
 				RETVAL_BOOL((func->common.scope == zend_ce_closure
-					&& (method_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
-					&& memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0) ? 1 : 0);
+					&& (method_name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
+					&& memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0) ? 1 : 0);
 					
-				efree(lcname);
-				efree((char*)((zend_internal_function*)func)->function_name);
+				STR_FREE(lcname);
+				STR_RELEASE(func->common.function_name);
 				efree(func);
 				return;
 			}
@@ -1179,26 +1141,24 @@ ZEND_FUNCTION(method_exists)
 ZEND_FUNCTION(property_exists)
 {
 	zval *object;
-	char *property;
-	int property_len;
-	zend_class_entry *ce, **pce;
+	zend_string *property;
+	zend_class_entry *ce;
 	zend_property_info *property_info;
 	zval property_z;
-	ulong h;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &object, &property, &property_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zS", &object, &property) == FAILURE) {
 		return;
 	}
 
-	if (property_len == 0) {
+	if (property == NULL) {
 		RETURN_FALSE;
 	}
 
 	if (Z_TYPE_P(object) == IS_STRING) {
-		if (zend_lookup_class(Z_STRVAL_P(object), Z_STRLEN_P(object), &pce TSRMLS_CC) == FAILURE) {
+		ce = zend_lookup_class(Z_STR_P(object) TSRMLS_CC);
+		if (!ce) {
 			RETURN_FALSE;
-		}
-		ce = *pce;
+		}			
 	} else if (Z_TYPE_P(object) == IS_OBJECT) {
 		ce = Z_OBJCE_P(object);
 	} else {
@@ -1206,17 +1166,16 @@ ZEND_FUNCTION(property_exists)
 		RETURN_NULL();
 	}
 
-	h = zend_get_hash_value(property, property_len+1);
-	if (zend_hash_quick_find(&ce->properties_info, property, property_len+1, h, (void **) &property_info) == SUCCESS
+	if ((property_info = zend_hash_find_ptr(&ce->properties_info, property)) != NULL
 		&& (property_info->flags & ZEND_ACC_SHADOW) == 0) {
 		RETURN_TRUE;
 	}
 
-	ZVAL_STRINGL(&property_z, property, property_len, 0);
+	ZVAL_STR(&property_z, property);
 
 	if (Z_TYPE_P(object) ==  IS_OBJECT &&
 		Z_OBJ_HANDLER_P(object, has_property) && 
-		Z_OBJ_HANDLER_P(object, has_property)(object, &property_z, 2, 0 TSRMLS_CC)) {
+		Z_OBJ_HANDLER_P(object, has_property)(object, &property_z, 2, -1 TSRMLS_CC)) {
 		RETURN_TRUE;
 	}
 	RETURN_FALSE;
@@ -1228,39 +1187,32 @@ ZEND_FUNCTION(property_exists)
    Checks if the class exists */
 ZEND_FUNCTION(class_exists)
 {
-	char *class_name, *lc_name;
-	zend_class_entry **ce;
-	int class_name_len;
-	int found;
+	zend_string *class_name;
+	zend_string *lc_name;
+	zend_class_entry *ce;
 	zend_bool autoload = 1;
-	ALLOCA_FLAG(use_heap)
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &class_name, &class_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &class_name, &autoload) == FAILURE) {
 		return;
 	}
 
 	if (!autoload) {
-		char *name;
-		int len;
-
-		lc_name = do_alloca(class_name_len + 1, use_heap);
-		zend_str_tolower_copy(lc_name, class_name, class_name_len);
-
-		/* Ignore leading "\" */
-		name = lc_name;
-		len = class_name_len;
-		if (lc_name[0] == '\\') {
-			name = &lc_name[1];
-			len--;
+		if (class_name->val[0] == '\\') {
+			/* Ignore leading "\" */
+			lc_name = STR_ALLOC(class_name->len - 1, 0);
+			zend_str_tolower_copy(lc_name->val, class_name->val + 1, class_name->len - 1);
+		} else {
+			lc_name = STR_ALLOC(class_name->len, 0);
+			zend_str_tolower_copy(lc_name->val, class_name->val, class_name->len);
 		}
-	
-		found = zend_hash_find(EG(class_table), name, len+1, (void **) &ce);
-		free_alloca(lc_name, use_heap);
-		RETURN_BOOL(found == SUCCESS && !(((*ce)->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT)) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
+		ce = zend_hash_find_ptr(EG(class_table), lc_name);
+		STR_FREE(lc_name);
+		RETURN_BOOL(ce && !((ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT)) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
 	}
 
- 	if (zend_lookup_class(class_name, class_name_len, &ce TSRMLS_CC) == SUCCESS) {
- 		RETURN_BOOL(((*ce)->ce_flags & (ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT - ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) == 0);
+	ce = zend_lookup_class(class_name TSRMLS_CC);
+ 	if (ce) {
+ 		RETURN_BOOL((ce->ce_flags & (ZEND_ACC_INTERFACE | (ZEND_ACC_TRAIT - ZEND_ACC_EXPLICIT_ABSTRACT_CLASS))) == 0);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1271,39 +1223,31 @@ ZEND_FUNCTION(class_exists)
    Checks if the class exists */
 ZEND_FUNCTION(interface_exists)
 {
-	char *iface_name, *lc_name;
-	zend_class_entry **ce;
-	int iface_name_len;
-	int found;
+	zend_string *iface_name, *lc_name;
+	zend_class_entry *ce;
 	zend_bool autoload = 1;
-	ALLOCA_FLAG(use_heap)
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &iface_name, &iface_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &iface_name, &autoload) == FAILURE) {
 		return;
 	}
 
 	if (!autoload) {
-		char *name;
-		int len;
-		
-		lc_name = do_alloca(iface_name_len + 1, use_heap);
-		zend_str_tolower_copy(lc_name, iface_name, iface_name_len);
-	
-		/* Ignore leading "\" */
-		name = lc_name;
-		len = iface_name_len;
-		if (lc_name[0] == '\\') {
-			name = &lc_name[1];
-			len--;
+		if (iface_name->val[0] == '\\') {
+			/* Ignore leading "\" */
+			lc_name = STR_ALLOC(iface_name->len - 1, 0);
+			zend_str_tolower_copy(lc_name->val, iface_name->val + 1, iface_name->len - 1);
+		} else {
+			lc_name = STR_ALLOC(iface_name->len, 0);
+			zend_str_tolower_copy(lc_name->val, iface_name->val, iface_name->len);
 		}
-
-		found = zend_hash_find(EG(class_table), name, len+1, (void **) &ce);
-		free_alloca(lc_name, use_heap);
-		RETURN_BOOL(found == SUCCESS && (*ce)->ce_flags & ZEND_ACC_INTERFACE);
+		ce = zend_hash_find_ptr(EG(class_table), lc_name);
+		STR_FREE(lc_name);
+		RETURN_BOOL(ce && ce->ce_flags & ZEND_ACC_INTERFACE);
 	}
 
- 	if (zend_lookup_class(iface_name, iface_name_len, &ce TSRMLS_CC) == SUCCESS) {
- 		RETURN_BOOL(((*ce)->ce_flags & ZEND_ACC_INTERFACE) > 0);
+	ce = zend_lookup_class(iface_name TSRMLS_CC);
+	if (ce) {
+ 		RETURN_BOOL((ce->ce_flags & ZEND_ACC_INTERFACE) > 0);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1314,39 +1258,31 @@ ZEND_FUNCTION(interface_exists)
  Checks if the trait exists */
 ZEND_FUNCTION(trait_exists)
 {
-	char *trait_name, *lc_name;
-	zend_class_entry **ce;
-	int trait_name_len;
-	int found;
+	zend_string *trait_name, *lc_name;
+	zend_class_entry *ce;
 	zend_bool autoload = 1;
-	ALLOCA_FLAG(use_heap)
   
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &trait_name, &trait_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|b", &trait_name, &autoload) == FAILURE) {
 		return;
 	}
   
 	if (!autoload) {
-		char *name;
-		int len;
-		
-		lc_name = do_alloca(trait_name_len + 1, use_heap);
-		zend_str_tolower_copy(lc_name, trait_name, trait_name_len);
-    
-		/* Ignore leading "\" */
-		name = lc_name;
-		len = trait_name_len;
-		if (lc_name[0] == '\\') {
-			name = &lc_name[1];
-			len--;
+		if (trait_name->val[0] == '\\') {
+			/* Ignore leading "\" */
+			lc_name = STR_ALLOC(trait_name->len - 1, 0);
+			zend_str_tolower_copy(lc_name->val, trait_name->val + 1, trait_name->len - 1);
+		} else {
+			lc_name = STR_ALLOC(trait_name->len, 0);
+			zend_str_tolower_copy(lc_name->val, trait_name->val, trait_name->len);
 		}
-    
-		found = zend_hash_find(EG(class_table), name, len+1, (void **) &ce);
-		free_alloca(lc_name, use_heap);
-		RETURN_BOOL(found == SUCCESS && (((*ce)->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
+		ce = zend_hash_find_ptr(EG(class_table), lc_name);
+		STR_FREE(lc_name);
+		RETURN_BOOL(ce && ((ce->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS));
 	}
   
- 	if (zend_lookup_class(trait_name, trait_name_len, &ce TSRMLS_CC) == SUCCESS) {
- 		RETURN_BOOL(((*ce)->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
+	ce = zend_lookup_class(trait_name TSRMLS_CC);
+	if (ce) {
+ 		RETURN_BOOL((ce->ce_flags & ZEND_ACC_TRAIT) > ZEND_ACC_EXPLICIT_ABSTRACT_CLASS);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1361,36 +1297,30 @@ ZEND_FUNCTION(function_exists)
 	char *name;
 	int name_len;
 	zend_function *func;
-	char *lcname;
-	zend_bool retval;
+	zend_string *lcname;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
 		return;
 	}
 
-	lcname = zend_str_tolower_dup(name, name_len);
-	
-	/* Ignore leading "\" */
-	name = lcname;
-	if (lcname[0] == '\\') {
-		name = &lcname[1];
-		name_len--;
+	if (name[0] == '\\') {
+		/* Ignore leading "\" */
+		lcname = STR_ALLOC(name_len - 1, 0);
+		zend_str_tolower_copy(lcname->val, name + 1, name_len - 1);
+	} else {
+		lcname = STR_ALLOC(name_len, 0);
+		zend_str_tolower_copy(lcname->val, name, name_len);
 	}
-
-	retval = (zend_hash_find(EG(function_table), name, name_len+1, (void **)&func) == SUCCESS);
 	
-	efree(lcname);
+	func = zend_hash_find_ptr(EG(function_table), lcname);	
+	STR_FREE(lcname);
 
 	/*
 	 * A bit of a hack, but not a bad one: we see if the handler of the function
 	 * is actually one that displays "function is disabled" message.
 	 */
-	if (retval && func->type == ZEND_INTERNAL_FUNCTION &&
-		func->internal_function.handler == zif_display_disabled_function) {
-		retval = 0;
-	}
-
-	RETURN_BOOL(retval);
+	RETURN_BOOL(func && (func->type != ZEND_INTERNAL_FUNCTION ||
+		func->internal_function.handler != zif_display_disabled_function));
 }
 /* }}} */
 
@@ -1398,21 +1328,21 @@ ZEND_FUNCTION(function_exists)
    Creates an alias for user defined class */
 ZEND_FUNCTION(class_alias)
 {
-	char *class_name, *alias_name;
-	zend_class_entry **ce;
-	int class_name_len, alias_name_len;
-	int found;
+	zend_string *class_name;
+	char *alias_name;
+	zend_class_entry *ce;
+	int alias_name_len;
 	zend_bool autoload = 1;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|b", &class_name, &class_name_len, &alias_name, &alias_name_len, &autoload) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|b", &class_name, &alias_name, &alias_name_len, &autoload) == FAILURE) {
 		return;
 	}
 
-	found = zend_lookup_class_ex(class_name, class_name_len, NULL, autoload, &ce TSRMLS_CC);
+	ce = zend_lookup_class_ex(class_name, NULL, autoload TSRMLS_CC);
 	
-	if (found == SUCCESS) {
-		if ((*ce)->type == ZEND_USER_CLASS) { 
-			if (zend_register_class_alias_ex(alias_name, alias_name_len, *ce TSRMLS_CC) == SUCCESS) {
+	if (ce) {
+		if (ce->type == ZEND_USER_CLASS) { 
+			if (zend_register_class_alias_ex(alias_name, alias_name_len, ce TSRMLS_CC) == SUCCESS) {
 				RETURN_TRUE;
 			} else {
 				zend_error(E_WARNING, "Cannot redeclare class %s", alias_name);
@@ -1423,7 +1353,7 @@ ZEND_FUNCTION(class_alias)
 			RETURN_FALSE;
 		}
 	} else {
-		zend_error(E_WARNING, "Class '%s' not found", class_name);
+		zend_error(E_WARNING, "Class '%s' not found", class_name->val);
 		RETURN_FALSE;
 	}
 }
@@ -1455,11 +1385,11 @@ ZEND_FUNCTION(leak_variable)
 	}
 
 	if (!leak_data) {
-		zval_add_ref(&zv);
+		Z_ADDREF_P(zv);
 	} else if (Z_TYPE_P(zv) == IS_RESOURCE) {
-		zend_list_addref(Z_RESVAL_P(zv));
+		Z_ADDREF_P(zv);
 	} else if (Z_TYPE_P(zv) == IS_OBJECT) {
-		Z_OBJ_HANDLER_P(zv, add_ref)(zv TSRMLS_CC);
+		Z_ADDREF_P(zv);
 	} else {
 		zend_error(E_WARNING, "Leaking non-zval data is only applicable to resources and objects");
 	}
@@ -1482,19 +1412,18 @@ ZEND_FUNCTION(crash)
    Returns an array with the file names that were include_once()'d */
 ZEND_FUNCTION(get_included_files)
 {
-	char *entry;
-	uint entry_len;
+	zend_string *entry;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	array_init(return_value);
-	zend_hash_internal_pointer_reset(&EG(included_files));
-	while (zend_hash_get_current_key_ex(&EG(included_files), &entry, &entry_len, NULL, 0, NULL) == HASH_KEY_IS_STRING) {
-		add_next_index_stringl(return_value, entry, entry_len-1, !IS_INTERNED(entry));
-		zend_hash_move_forward(&EG(included_files));
-	}
+	ZEND_HASH_FOREACH_STR_KEY(&EG(included_files), entry) {
+		if (entry) {
+			add_next_index_str(return_value, STR_COPY(entry));
+		}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -1534,7 +1463,7 @@ ZEND_FUNCTION(trigger_error)
 ZEND_FUNCTION(set_error_handler)
 {
 	zval *error_handler;
-	char *error_handler_name = NULL;
+	zend_string *error_handler_name = NULL;
 	long error_type = E_ALL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|l", &error_handler, &error_type) == FAILURE) {
@@ -1544,27 +1473,26 @@ ZEND_FUNCTION(set_error_handler)
 	if (Z_TYPE_P(error_handler) != IS_NULL) { /* NULL == unset */
 		if (!zend_is_callable(error_handler, 0, &error_handler_name TSRMLS_CC)) {
 			zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
-					   get_active_function_name(TSRMLS_C), error_handler_name?error_handler_name:"unknown");
-			efree(error_handler_name);
+					   get_active_function_name(TSRMLS_C), error_handler_name?error_handler_name->val:"unknown");
+			STR_RELEASE(error_handler_name);
 			return;
 		}
-		efree(error_handler_name);
+		STR_RELEASE(error_handler_name);
 	}
 
-	if (EG(user_error_handler)) {
-		RETVAL_ZVAL(EG(user_error_handler), 1, 0);
+	if (Z_TYPE(EG(user_error_handler)) != IS_UNDEF) {
+		RETVAL_ZVAL(&EG(user_error_handler), 1, 0);
 
 		zend_stack_push(&EG(user_error_handlers_error_reporting), &EG(user_error_handler_error_reporting), sizeof(EG(user_error_handler_error_reporting)));
-		zend_ptr_stack_push(&EG(user_error_handlers), EG(user_error_handler));
+		zend_stack_push(&EG(user_error_handlers), &EG(user_error_handler), sizeof(zval));
 	}
 
 	if (Z_TYPE_P(error_handler) == IS_NULL) { /* unset user-defined handler */
-		EG(user_error_handler) = NULL;
+		ZVAL_UNDEF(&EG(user_error_handler));
 		return;
 	}
 
-	ALLOC_ZVAL(EG(user_error_handler));
-	MAKE_COPY_ZVAL(&error_handler, EG(user_error_handler));
+	ZVAL_DUP(&EG(user_error_handler), error_handler);
 	EG(user_error_handler_error_reporting) = (int)error_type;
 }
 /* }}} */
@@ -1574,19 +1502,23 @@ ZEND_FUNCTION(set_error_handler)
    Restores the previously defined error handler function */
 ZEND_FUNCTION(restore_error_handler)
 {
-	if (EG(user_error_handler)) {
-		zval *zeh = EG(user_error_handler);
-
-		EG(user_error_handler) = NULL;
+	if (Z_TYPE(EG(user_error_handler)) != IS_UNDEF) {
+		zval zeh;
+		
+		ZVAL_COPY_VALUE(&zeh, &EG(user_error_handler));
+		ZVAL_UNDEF(&EG(user_error_handler));
 		zval_ptr_dtor(&zeh);
 	}
 
-	if (zend_ptr_stack_num_elements(&EG(user_error_handlers))==0) {
-		EG(user_error_handler) = NULL;
+	if (zend_stack_is_empty(&EG(user_error_handlers))) {
+		ZVAL_UNDEF(&EG(user_error_handler));
 	} else {
+		zval *tmp;
 		EG(user_error_handler_error_reporting) = zend_stack_int_top(&EG(user_error_handlers_error_reporting));
 		zend_stack_del_top(&EG(user_error_handlers_error_reporting));
-		EG(user_error_handler) = zend_ptr_stack_pop(&EG(user_error_handlers));
+		zend_stack_top(&EG(user_error_handlers), (void**)&tmp);
+		ZVAL_COPY_VALUE(&EG(user_error_handler), tmp);
+		zend_stack_del_top(&EG(user_error_handlers));
 	}
 	RETURN_TRUE;
 }
@@ -1598,7 +1530,7 @@ ZEND_FUNCTION(restore_error_handler)
 ZEND_FUNCTION(set_exception_handler)
 {
 	zval *exception_handler;
-	char *exception_handler_name = NULL;
+	zend_string *exception_handler_name = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &exception_handler) == FAILURE) {
 		return;
@@ -1607,26 +1539,25 @@ ZEND_FUNCTION(set_exception_handler)
 	if (Z_TYPE_P(exception_handler) != IS_NULL) { /* NULL == unset */
 		if (!zend_is_callable(exception_handler, 0, &exception_handler_name TSRMLS_CC)) {
 			zend_error(E_WARNING, "%s() expects the argument (%s) to be a valid callback",
-					   get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name:"unknown");
-			efree(exception_handler_name);
+					   get_active_function_name(TSRMLS_C), exception_handler_name?exception_handler_name->val:"unknown");
+			STR_RELEASE(exception_handler_name);
 			return;
 		}
-		efree(exception_handler_name);
+		STR_RELEASE(exception_handler_name);
 	}
 
-	if (EG(user_exception_handler)) {
-		RETVAL_ZVAL(EG(user_exception_handler), 1, 0);
+	if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) {
+		RETVAL_ZVAL(&EG(user_exception_handler), 1, 0);
 
-		zend_ptr_stack_push(&EG(user_exception_handlers), EG(user_exception_handler));
+		zend_stack_push(&EG(user_exception_handlers), &EG(user_exception_handler), sizeof(zval));
 	}
 
 	if (Z_TYPE_P(exception_handler) == IS_NULL) { /* unset user-defined handler */
-		EG(user_exception_handler) = NULL;
+		ZVAL_UNDEF(&EG(user_exception_handler));
 		return;
 	}
 
-	ALLOC_ZVAL(EG(user_exception_handler));
-	MAKE_COPY_ZVAL(&exception_handler, EG(user_exception_handler))
+	ZVAL_DUP(&EG(user_exception_handler), exception_handler);
 }
 /* }}} */
 
@@ -1635,13 +1566,17 @@ ZEND_FUNCTION(set_exception_handler)
    Restores the previously defined exception handler function */
 ZEND_FUNCTION(restore_exception_handler)
 {
-	if (EG(user_exception_handler)) {
+	if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) {
 		zval_ptr_dtor(&EG(user_exception_handler));
 	}
-	if (zend_ptr_stack_num_elements(&EG(user_exception_handlers))==0) {
-		EG(user_exception_handler) = NULL;
+	if (zend_stack_is_empty(&EG(user_exception_handlers))) {
+		ZVAL_UNDEF(&EG(user_exception_handler));
 	} else {
-		EG(user_exception_handler) = zend_ptr_stack_pop(&EG(user_exception_handlers));
+		zval *tmp;
+
+		zend_stack_top(&EG(user_exception_handlers), (void**)&tmp);
+		ZVAL_COPY_VALUE(&EG(user_exception_handler), tmp);
+		zend_stack_del_top(&EG(user_exception_handlers));
 	}
 	RETURN_TRUE;
 }
@@ -1655,14 +1590,14 @@ static int copy_class_or_interface_name(zend_class_entry **pce TSRMLS_DC, int nu
 	zend_uint comply_mask = (comply)? mask:0;
 	zend_class_entry *ce  = *pce;
 
-	if ((hash_key->nKeyLength==0 || hash_key->arKey[0]!=0)
+	if ((hash_key->key && hash_key->key->val[0] != 0)
 		&& (comply_mask == (ce->ce_flags & mask))) {
 		if (ce->refcount > 1 && 
-		    (ce->name_length != hash_key->nKeyLength - 1 || 
-		     !same_name(hash_key->arKey, ce->name, ce->name_length))) {
-			add_next_index_stringl(array, hash_key->arKey, hash_key->nKeyLength - 1, 1);
+		    (ce->name->len != hash_key->key->len - 1 || 
+		     !same_name(hash_key->key->val, ce->name->val, ce->name->len))) {
+			add_next_index_str(array, STR_COPY(hash_key->key));
 		} else {
-			add_next_index_stringl(array, ce->name, ce->name_length, 1);
+			add_next_index_str(array, STR_COPY(ce->name));
 		}
 	}
 	return ZEND_HASH_APPLY_KEEP;
@@ -1718,19 +1653,20 @@ ZEND_FUNCTION(get_declared_interfaces)
 /* }}} */
 
 
-static int copy_function_name(zend_function *func TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int copy_function_name(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
+	zend_function *func = Z_PTR_P(zv);
 	zval *internal_ar = va_arg(args, zval *),
 	     *user_ar     = va_arg(args, zval *);
 
-	if (hash_key->nKeyLength == 0 || hash_key->arKey[0] == 0) {
+	if (hash_key->key == NULL || hash_key->key->val[0] == 0) {
 		return 0;
 	}
 
 	if (func->type == ZEND_INTERNAL_FUNCTION) {
-		add_next_index_stringl(internal_ar, hash_key->arKey, hash_key->nKeyLength-1, 1);
+		add_next_index_str(internal_ar, STR_COPY(hash_key->key));
 	} else if (func->type == ZEND_USER_FUNCTION) {
-		add_next_index_stringl(user_ar, hash_key->arKey, hash_key->nKeyLength-1, 1);
+		add_next_index_str(user_ar, STR_COPY(hash_key->key));
 	}
 
 	return 0;
@@ -1741,23 +1677,21 @@ static int copy_function_name(zend_function *func TSRMLS_DC, int num_args, va_li
    Returns an array of all defined functions */
 ZEND_FUNCTION(get_defined_functions)
 {
-	zval *internal;
-	zval *user;
+	zval internal, user, *ret;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	MAKE_STD_ZVAL(internal);
-	MAKE_STD_ZVAL(user);
-
-	array_init(internal);
-	array_init(user);
+	array_init(&internal);
+	array_init(&user);
 	array_init(return_value);
 
-	zend_hash_apply_with_arguments(EG(function_table) TSRMLS_CC, (apply_func_args_t) copy_function_name, 2, internal, user);
+	zend_hash_apply_with_arguments(EG(function_table) TSRMLS_CC, (apply_func_args_t) copy_function_name, 2, &internal, &user);
+
+	ret = zend_hash_str_add(Z_ARRVAL_P(return_value), "internal", sizeof("internal")-1, &internal);
 
-	if (zend_hash_add(Z_ARRVAL_P(return_value), "internal", sizeof("internal"), (void **)&internal, sizeof(zval *), NULL) == FAILURE) {
+	if (!ret) {
 		zval_ptr_dtor(&internal);
 		zval_ptr_dtor(&user);
 		zval_dtor(return_value);
@@ -1765,7 +1699,8 @@ ZEND_FUNCTION(get_defined_functions)
 		RETURN_FALSE;
 	}
 
-	if (zend_hash_add(Z_ARRVAL_P(return_value), "user", sizeof("user"), (void **)&user, sizeof(zval *), NULL) == FAILURE) {
+	ret = zend_hash_str_add(Z_ARRVAL_P(return_value), "user", sizeof("user")-1, &user);
+	if (!ret) {		
 		zval_ptr_dtor(&user);
 		zval_dtor(return_value);
 		zend_error(E_WARNING, "Cannot add user functions to return value from get_defined_functions()");
@@ -1783,10 +1718,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),
-					(copy_ctor_func_t)zval_add_ref, NULL, sizeof(zval *));
+	zend_hash_copy(Z_ARRVAL_P(return_value), &EG(active_symbol_table)->ht, zval_add_ref);
 }
 /* }}} */
 
@@ -1796,8 +1730,9 @@ ZEND_FUNCTION(get_defined_vars)
    Creates an anonymous function, and returns its name (funny, eh?) */
 ZEND_FUNCTION(create_function)
 {
-	char *eval_code, *function_name, *function_args, *function_code;
-	int eval_code_length, function_name_length, function_args_len, function_code_len;
+    zend_string *function_name;
+	char *eval_code, *function_args, *function_code;
+	int eval_code_length, function_args_len, function_code_len;
 	int retval;
 	char *eval_name;
 
@@ -1832,25 +1767,27 @@ ZEND_FUNCTION(create_function)
 	efree(eval_name);
 
 	if (retval==SUCCESS) {
-		zend_function new_function, *func;
+		zend_op_array *new_function, *func;
 
-		if (zend_hash_find(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME), (void **) &func)==FAILURE) {
+		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 = emalloc(sizeof(zend_op_array));
+		memcpy(new_function, func, sizeof(zend_op_array));
+		function_add_ref((zend_function*)new_function);
 
-		function_name = (char *) emalloc(sizeof("0lambda_")+MAX_LENGTH_OF_LONG);
-		function_name[0] = '\0';
+		function_name = STR_ALLOC(sizeof("0lambda_")+MAX_LENGTH_OF_LONG, 0);
+		function_name->val[0] = '\0';
 
 		do {
-			function_name_length = 1 + snprintf(function_name + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count));
-		} while (zend_hash_add(EG(function_table), function_name, function_name_length+1, &new_function, sizeof(zend_function), NULL)==FAILURE);
-		zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
-		RETURN_STRINGL(function_name, function_name_length, 0);
+			function_name->len = snprintf(function_name->val + 1, sizeof("lambda_")+MAX_LENGTH_OF_LONG, "lambda_%d", ++EG(lambda_count)) + 1;
+		} 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 {
-		zend_hash_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME));
+		zend_hash_str_del(EG(function_table), LAMBDA_TEMP_FUNCNAME, sizeof(LAMBDA_TEMP_FUNCNAME)-1);
 		RETURN_FALSE;
 	}
 }
@@ -1862,7 +1799,7 @@ ZEND_FUNCTION(zend_test_func)
 {
 	zval *arg1, *arg2;
 
-	zend_get_parameters(ht, 2, &arg1, &arg2);
+	zend_get_parameters(ZEND_NUM_ARGS(), 2, &arg1, &arg2);
 }
 
 
@@ -1885,45 +1822,44 @@ ZEND_FUNCTION(get_resource_type)
 		return;
 	}
 
-	resource_type = zend_rsrc_list_get_rsrc_type(Z_LVAL_P(z_resource_type) TSRMLS_CC);
+	resource_type = zend_rsrc_list_get_rsrc_type(Z_RES_P(z_resource_type) TSRMLS_CC);
 	if (resource_type) {
-		RETURN_STRING(resource_type, 1);
+		RETURN_STRING(resource_type);
 	} else {
-		RETURN_STRING("Unknown", 1);
+		RETURN_STRING("Unknown");
 	}
 }
 /* }}} */
 
 
-static int add_extension_info(zend_module_entry *module, void *arg TSRMLS_DC)
+static int add_extension_info(zval *item, void *arg TSRMLS_DC)
 {
 	zval *name_array = (zval *)arg;
-	add_next_index_string(name_array, module->name, 1);
+	zend_module_entry *module = (zend_module_entry*)Z_PTR_P(item);
+	add_next_index_string(name_array, module->name);
 	return 0;
 }
 
 static int add_zendext_info(zend_extension *ext, void *arg TSRMLS_DC)
 {
 	zval *name_array = (zval *)arg;
-	add_next_index_string(name_array, ext->name, 1);
+	add_next_index_string(name_array, ext->name);
 	return 0;
 }
 
-static int add_constant_info(zend_constant *constant, void *arg TSRMLS_DC)
+static int add_constant_info(zval *item, void *arg TSRMLS_DC)
 {
 	zval *name_array = (zval *)arg;
-	zval *const_val;
+	zend_constant *constant = (zend_constant*)Z_PTR_P(item);
+	zval const_val;
 
 	if (!constant->name) {
 		/* skip special constants */
 		return 0;
 	}
 
-	MAKE_STD_ZVAL(const_val);
-	*const_val = constant->value;
-	zval_copy_ctor(const_val);
-	INIT_PZVAL(const_val);
-	add_assoc_zval_ex(name_array, constant->name, constant->name_len, const_val);
+	ZVAL_DUP(&const_val, &constant->value);
+	zend_hash_update(Z_ARRVAL_P(name_array), constant->name, &const_val);
 	return 0;
 }
 
@@ -1941,9 +1877,9 @@ ZEND_FUNCTION(get_loaded_extensions)
 	array_init(return_value);
 
 	if (zendext) {
-		zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t) add_zendext_info, return_value TSRMLS_CC);
+		zend_llist_apply_with_argument(&zend_extensions, (llist_apply_with_arg_func_t)add_zendext_info, return_value TSRMLS_CC);
 	} else {
-		zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t) add_extension_info, return_value TSRMLS_CC);
+		zend_hash_apply_with_argument(&module_registry, (apply_func_arg_t)add_extension_info, return_value TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -1962,121 +1898,104 @@ ZEND_FUNCTION(get_defined_constants)
 	array_init(return_value);
 
 	if (categorize) {
-		HashPosition pos;
 		zend_constant *val;
 		int module_number;
-		zval **modules;
+		zval *modules;
 		char **module_names;
 		zend_module_entry *module;
 		int i = 1;
 
-		modules = ecalloc(zend_hash_num_elements(&module_registry) + 2, sizeof(zval *));
+		modules = ecalloc(zend_hash_num_elements(&module_registry) + 2, sizeof(zval));
 		module_names = emalloc((zend_hash_num_elements(&module_registry) + 2) * sizeof(char *));
 
 		module_names[0] = "internal";
-		zend_hash_internal_pointer_reset_ex(&module_registry, &pos);
-		while (zend_hash_get_current_data_ex(&module_registry, (void *) &module, &pos) != FAILURE) {
+		ZEND_HASH_FOREACH_PTR(&module_registry, module) {
 			module_names[module->module_number] = (char *)module->name;
 			i++;
-			zend_hash_move_forward_ex(&module_registry, &pos);
-		}
+		} ZEND_HASH_FOREACH_END();
 		module_names[i] = "user";
 
-		zend_hash_internal_pointer_reset_ex(EG(zend_constants), &pos);
-		while (zend_hash_get_current_data_ex(EG(zend_constants), (void **) &val, &pos) != FAILURE) {
-			zval *const_val;
+		ZEND_HASH_FOREACH_PTR(EG(zend_constants), val) {
+			zval const_val;
 
 			if (!val->name) {
 				/* skip special constants */
-				goto next_constant;
+				continue;
 			}
 
 			if (val->module_number == PHP_USER_CONSTANT) {
 				module_number = i;
 			} else if (val->module_number > i || val->module_number < 0) {
 				/* should not happen */
-				goto next_constant;
+				continue;
 			} else {
 				module_number = val->module_number;
 			}
 
-			if (!modules[module_number]) {
-				MAKE_STD_ZVAL(modules[module_number]);
-				array_init(modules[module_number]);
-				add_assoc_zval(return_value, module_names[module_number], modules[module_number]);
+			if (Z_TYPE(modules[module_number]) == IS_UNDEF) {
+				array_init(&modules[module_number]);
+				add_assoc_zval(return_value, module_names[module_number], &modules[module_number]);
 			}
 
-			MAKE_STD_ZVAL(const_val);
-			*const_val = val->value;
-			zval_copy_ctor(const_val);
-			INIT_PZVAL(const_val);
+			ZVAL_DUP_DEREF(&const_val, &val->value);
+
+			zend_hash_update(Z_ARRVAL(modules[module_number]), val->name, &const_val);
+		} ZEND_HASH_FOREACH_END();
 
-			add_assoc_zval_ex(modules[module_number], val->name, val->name_len, const_val);
-next_constant:
-			zend_hash_move_forward_ex(EG(zend_constants), &pos);
-		}
 		efree(module_names);
 		efree(modules);
 	} else {
-		zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t) add_constant_info, return_value TSRMLS_CC);
+		zend_hash_apply_with_argument(EG(zend_constants), (apply_func_arg_t)add_constant_info, return_value TSRMLS_CC);
 	}
 }
 /* }}} */
 
 
-static zval *debug_backtrace_get_args(void **curpos TSRMLS_DC)
+static void debug_backtrace_get_args(zval *curpos, zval *arg_array TSRMLS_DC)
 {
-	void **p = curpos;
-	zval *arg_array, **arg;
-	int arg_count = (int)(zend_uintptr_t) *p;
+	zval *p = curpos;
+	zval *arg;
+	int arg_count = Z_LVAL_P(p);
 
-	MAKE_STD_ZVAL(arg_array);
 	array_init_size(arg_array, arg_count);
 	p -= arg_count;
 
 	while (--arg_count >= 0) {
-		arg = (zval **) p++;
-		if (*arg) {
-			if (Z_TYPE_PP(arg) != IS_OBJECT) {
-				SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
-			}
-			Z_ADDREF_PP(arg);
-			add_next_index_zval(arg_array, *arg);
+		arg = p++;
+		if (arg) {
+			if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
+			add_next_index_zval(arg_array, arg);
 		} else {
 			add_next_index_null(arg_array);
 		}
 	}
-
-	return arg_array;
 }
 
 void debug_print_backtrace_args(zval *arg_array TSRMLS_DC)
 {
-	zval **tmp;
-	HashPosition iterator;
+	zval *tmp;
 	int i = 0;
 
-	zend_hash_internal_pointer_reset_ex(arg_array->value.ht, &iterator);
-	while (zend_hash_get_current_data_ex(arg_array->value.ht, (void **) &tmp, &iterator) == SUCCESS) {
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arg_array), tmp) {
 		if (i++) {
 			ZEND_PUTS(", ");
 		}
-		zend_print_flat_zval_r(*tmp TSRMLS_CC);
-		zend_hash_move_forward_ex(arg_array->value.ht, &iterator);
-	}
+		zend_print_flat_zval_r(tmp TSRMLS_CC);
+	} ZEND_HASH_FOREACH_END();
 }
 
 /* {{{ proto void debug_print_backtrace([int options[, int limit]]) */
 ZEND_FUNCTION(debug_print_backtrace)
 {
 	zend_execute_data *ptr, *skip;
+	zend_object *object;
 	int lineno, frameno = 0;
 	const char *function_name;
 	const char *filename;
-	const char *class_name = NULL;
+	zend_string *class_name = NULL;
 	char *call_type;
 	const char *include_filename = NULL;
-	zval *arg_array = NULL;
+	zval arg_array;
 	int indent = 0;
 	long options = 0;
 	long limit = 0;
@@ -2085,17 +2004,18 @@ ZEND_FUNCTION(debug_print_backtrace)
 		return;
 	}
 
+	ZVAL_UNDEF(&arg_array);
 	ptr = EG(current_execute_data);
 
 	/* skip debug_backtrace() */
+	object = ptr->object;
 	ptr = ptr->prev_execute_data;
 
 	while (ptr && (limit == 0 || frameno < limit)) {
-		const char *free_class_name = NULL;
-
 		frameno++;
-		class_name = call_type = NULL;   
-		arg_array = NULL;
+		class_name = NULL;
+		call_type = NULL;   
+		ZVAL_UNDEF(&arg_array);
 
 		skip = ptr;
 		/* skip internal handler */
@@ -2109,34 +2029,37 @@ ZEND_FUNCTION(debug_print_backtrace)
 		}
 
 		if (skip->op_array) {
-			filename = skip->op_array->filename;
+			filename = skip->op_array->filename->val;
 			lineno = skip->opline->lineno;
 		} else {
 			filename = NULL;
 			lineno = 0;
 		}
 
+		/* $this may be passed into regular internal functions */
+		if (object &&
+		    ptr->function_state.function->type == ZEND_INTERNAL_FUNCTION &&
+		    !ptr->function_state.function->common.scope) {
+			object = NULL;
+		}
+
 		function_name = (ptr->function_state.function->common.scope &&
 			ptr->function_state.function->common.scope->trait_aliases) ?
 				zend_resolve_method_name(
-					ptr->object ?
-						Z_OBJCE_P(ptr->object) : 
+					object ?
+						zend_get_class_entry(object TSRMLS_CC) : 
 						ptr->function_state.function->common.scope,
-					ptr->function_state.function) :
-				ptr->function_state.function->common.function_name;
+					ptr->function_state.function)->val :
+				(ptr->function_state.function->common.function_name ?
+				 ptr->function_state.function->common.function_name->val :
+				 NULL);
 
 		if (function_name) {
-			if (ptr->object) {
+			if (object) {
 				if (ptr->function_state.function->common.scope) {
 					class_name = ptr->function_state.function->common.scope->name;
 				} else {
-					zend_uint class_name_len;
-					int dup;
-
-					dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
-					if(!dup) {
-						free_class_name = class_name;
-					}
+					class_name = zend_get_object_classname(object TSRMLS_CC);
 				}
 
 				call_type = "->";
@@ -2149,7 +2072,7 @@ ZEND_FUNCTION(debug_print_backtrace)
 			}
 			if ((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL))) {
 				if (ptr->function_state.arguments && (options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0) {
-					arg_array = debug_backtrace_get_args(ptr->function_state.arguments TSRMLS_CC);
+					debug_backtrace_get_args(ptr->function_state.arguments, &arg_array TSRMLS_CC);
 				}
 			}
 		} else {
@@ -2187,20 +2110,19 @@ ZEND_FUNCTION(debug_print_backtrace)
 			}
 
 			if (build_filename_arg && include_filename) {
-				MAKE_STD_ZVAL(arg_array);
-				array_init(arg_array);
-				add_next_index_string(arg_array, (char*)include_filename, 1);
+				array_init(&arg_array);
+				add_next_index_string(&arg_array, (char*)include_filename);
 			}
 			call_type = NULL;
 		}
 		zend_printf("#%-2d ", indent);
 		if (class_name) {
-			ZEND_PUTS(class_name);
+			ZEND_PUTS(class_name->val);
 			ZEND_PUTS(call_type);
 		}
 		zend_printf("%s(", function_name);
-		if (arg_array) {
-			debug_print_backtrace_args(arg_array TSRMLS_CC);
+		if (Z_TYPE(arg_array) != IS_UNDEF) {
+			debug_print_backtrace_args(&arg_array TSRMLS_CC);
 			zval_ptr_dtor(&arg_array);
 		}
 		if (filename) {
@@ -2215,7 +2137,7 @@ ZEND_FUNCTION(debug_print_backtrace)
 					break;
 				}				    
 				if (prev->op_array) {
-					zend_printf(") called at [%s:%d]\n", prev->op_array->filename, prev->opline->lineno);
+					zend_printf(") called at [%s:%d]\n", prev->op_array->filename->val, prev->opline->lineno);
 					break;
 				}
 				prev = prev->prev_execute_data;
@@ -2225,11 +2147,9 @@ ZEND_FUNCTION(debug_print_backtrace)
 			}
 		}
 		include_filename = filename;
+		object = skip->object;
 		ptr = skip->prev_execute_data;
 		++indent;
-		if (free_class_name) {
-			efree((char*)free_class_name);
-		}
 	}
 }
 
@@ -2238,22 +2158,25 @@ ZEND_FUNCTION(debug_print_backtrace)
 ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int options, int limit TSRMLS_DC)
 {
 	zend_execute_data *ptr, *skip;
+	zend_object *object = Z_OBJ(EG(This));
 	int lineno, frameno = 0;
 	const char *function_name;
 	const char *filename;
-	const char *class_name;
+	zend_string *class_name;
 	const char *include_filename = NULL;
-	zval *stack_frame;
+	zval stack_frame;
 
 	ptr = EG(current_execute_data);
 
 	/* skip "new Exception()" */
 	if (ptr && (skip_last == 0) && ptr->opline && (ptr->opline->opcode == ZEND_NEW)) {
+		object = ptr->object;
 		ptr = ptr->prev_execute_data;
 	}
 
 	/* skip debug_backtrace() */
 	if (skip_last-- && ptr) {
+		object = ptr->object;
 		ptr = ptr->prev_execute_data;
 	}
 
@@ -2261,8 +2184,7 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 
 	while (ptr && (limit == 0 || frameno < limit)) {
 		frameno++;
-		MAKE_STD_ZVAL(stack_frame);
-		array_init(stack_frame);
+		array_init(&stack_frame);
 
 		skip = ptr;
 		/* skip internal handler */
@@ -2276,10 +2198,10 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 		}
 
 		if (skip->op_array) {
-			filename = skip->op_array->filename;
+			filename = skip->op_array->filename->val;
 			lineno = skip->opline->lineno;
-			add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)filename, 1);
-			add_assoc_long_ex(stack_frame, "line", sizeof("line"), lineno);
+			add_assoc_string_ex(&stack_frame, "file", sizeof("file")-1, (char*)filename);
+			add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, lineno);
 
 			/* try to fetch args only if an FCALL was just made - elsewise we're in the middle of a function
 			 * and debug_baktrace() might have been called by the error_handler. in this case we don't 
@@ -2295,8 +2217,9 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 					break;
 				}				    
 				if (prev->op_array) {
-					add_assoc_string_ex(stack_frame, "file", sizeof("file"), (char*)prev->op_array->filename, 1);
-					add_assoc_long_ex(stack_frame, "line", sizeof("line"), prev->opline->lineno);
+// TODO: we have to duplicate it, becaise it may be stored in opcache SHM ???
+					add_assoc_str_ex(&stack_frame, "file", sizeof("file")-1, STR_DUP(prev->op_array->filename, 0));
+					add_assoc_long_ex(&stack_frame, "line", sizeof("line")-1, prev->opline->lineno);
 					break;
 				}
 				prev = prev->prev_execute_data;
@@ -2304,44 +2227,54 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 			filename = NULL;
 		}
 
+		/* $this may be passed into regular internal functions */
+		if (object &&
+		    ptr->function_state.function->type == ZEND_INTERNAL_FUNCTION &&
+		    !ptr->function_state.function->common.scope) {
+			object = NULL;
+		}
+
 		function_name = (ptr->function_state.function->common.scope &&
 			ptr->function_state.function->common.scope->trait_aliases) ?
 				zend_resolve_method_name(
-					ptr->object ?
-						Z_OBJCE_P(ptr->object) : 
+					object ?
+						zend_get_class_entry(object TSRMLS_CC) : 
 						ptr->function_state.function->common.scope,
-					ptr->function_state.function) :
-				ptr->function_state.function->common.function_name;
+					ptr->function_state.function)->val :
+				(ptr->function_state.function->common.function_name ?
+				 ptr->function_state.function->common.function_name->val : 
+				 NULL);
 
 		if (function_name) {
-			add_assoc_string_ex(stack_frame, "function", sizeof("function"), (char*)function_name, 1);
+			add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name);
 
-			if (ptr->object && Z_TYPE_P(ptr->object) == IS_OBJECT) {
+			if (object) {
 				if (ptr->function_state.function->common.scope) {
-					add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
+					add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(ptr->function_state.function->common.scope->name));
 				} else {
-					zend_uint class_name_len;
-					int dup;
-
-					dup = zend_get_object_classname(ptr->object, &class_name, &class_name_len TSRMLS_CC);
-					add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)class_name, dup);
+					class_name = zend_get_object_classname(object TSRMLS_CC);
+					add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(class_name));
 					
 				}
 				if ((options & DEBUG_BACKTRACE_PROVIDE_OBJECT) != 0) {
-					add_assoc_zval_ex(stack_frame, "object", sizeof("object"), ptr->object);
-					Z_ADDREF_P(ptr->object);
+					zval zv;
+					ZVAL_OBJ(&zv, object);
+					add_assoc_zval_ex(&stack_frame, "object", sizeof("object")-1, &zv);
+					Z_ADDREF(zv);
 				}
 
-				add_assoc_string_ex(stack_frame, "type", sizeof("type"), "->", 1);
+				add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "->");
 			} else if (ptr->function_state.function->common.scope) {
-				add_assoc_string_ex(stack_frame, "class", sizeof("class"), (char*)ptr->function_state.function->common.scope->name, 1);
-				add_assoc_string_ex(stack_frame, "type", sizeof("type"), "::", 1);
+				add_assoc_str_ex(&stack_frame, "class", sizeof("class")-1, STR_COPY(ptr->function_state.function->common.scope->name));
+				add_assoc_string_ex(&stack_frame, "type", sizeof("type")-1, "::");
 			}
 
 			if ((options & DEBUG_BACKTRACE_IGNORE_ARGS) == 0 && 
 				((! ptr->opline) || ((ptr->opline->opcode == ZEND_DO_FCALL_BY_NAME) || (ptr->opline->opcode == ZEND_DO_FCALL)))) {
 				if (ptr->function_state.arguments) {
-					add_assoc_zval_ex(stack_frame, "args", sizeof("args"), debug_backtrace_get_args(ptr->function_state.arguments TSRMLS_CC));
+					zval args;
+					debug_backtrace_get_args(ptr->function_state.arguments, &args TSRMLS_CC);
+					add_assoc_zval_ex(&stack_frame, "args", sizeof("args")-1, &args);
 				}
 			}
 		} else {
@@ -2379,26 +2312,26 @@ ZEND_API void zend_fetch_debug_backtrace(zval *return_value, int skip_last, int
 			}
 
 			if (build_filename_arg && include_filename) {
-				zval *arg_array;
+				zval arg_array;
 
-				MAKE_STD_ZVAL(arg_array);
-				array_init(arg_array);
+				array_init(&arg_array);
 
 				/* include_filename always points to the last filename of the last last called-function.
 				   if we have called include in the frame above - this is the file we have included.
 				 */
 
-				add_next_index_string(arg_array, (char*)include_filename, 1);
-				add_assoc_zval_ex(stack_frame, "args", sizeof("args"), arg_array);
+				add_next_index_string(&arg_array, (char*)include_filename);
+				add_assoc_zval_ex(&stack_frame, "args", sizeof("args")-1, &arg_array);
 			}
 
-			add_assoc_string_ex(stack_frame, "function", sizeof("function"), (char*)function_name, 1);
+			add_assoc_string_ex(&stack_frame, "function", sizeof("function")-1, (char*)function_name);
 		}
 
-		add_next_index_zval(return_value, stack_frame);
+		add_next_index_zval(return_value, &stack_frame);
 
 		include_filename = filename; 
 
+		object = skip->object;
 		ptr = skip->prev_execute_data;
 	}
 }
@@ -2426,19 +2359,20 @@ ZEND_FUNCTION(extension_loaded)
 {
 	char *extension_name;
 	int extension_name_len;
-	char *lcname;
+	zend_string *lcname;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
 		return;
 	}
 
-	lcname = zend_str_tolower_dup(extension_name, extension_name_len);
-	if (zend_hash_exists(&module_registry, lcname, extension_name_len+1)) {
+	lcname = STR_ALLOC(extension_name_len, 0);
+	zend_str_tolower_copy(lcname->val, extension_name, extension_name_len);
+	if (zend_hash_exists(&module_registry, lcname)) {
 		RETVAL_TRUE;
 	} else {
 		RETVAL_FALSE;
 	}
-	efree(lcname);
+	STR_FREE(lcname);
 }
 /* }}} */
 
@@ -2447,26 +2381,27 @@ ZEND_FUNCTION(extension_loaded)
    Returns an array with the names of functions belonging to the named extension */
 ZEND_FUNCTION(get_extension_funcs)
 {
-	char *extension_name, *lcname;
+	char *extension_name;
+	zend_string *lcname;
 	int extension_name_len, array;
 	zend_module_entry *module;
-	HashPosition iterator;
 	zend_function *zif;
+	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &extension_name, &extension_name_len) == FAILURE) {
 		return;
 	}
 	if (strncasecmp(extension_name, "zend", sizeof("zend"))) {
-		lcname = zend_str_tolower_dup(extension_name, extension_name_len);
+		lcname = STR_ALLOC(extension_name_len, 0);
+		zend_str_tolower_copy(lcname->val, extension_name, extension_name_len);
 	} else {
-		lcname = estrdup("core");
+		lcname = STR_INIT("core", sizeof("core")-1, 0);
 	}
-	if (zend_hash_find(&module_registry, lcname,
-		extension_name_len+1, (void**)&module) == FAILURE) {
-		efree(lcname);
+	module = zend_hash_find_ptr(&module_registry, lcname);
+	STR_FREE(lcname);
+	if (!module) {
 		RETURN_FALSE;
 	}
 
-	zend_hash_internal_pointer_reset_ex(CG(function_table), &iterator);
 	if (module->functions) {
 		/* avoid BC break, if functions list is empty, will return an empty array */
 		array_init(return_value);
@@ -2474,19 +2409,18 @@ ZEND_FUNCTION(get_extension_funcs)
 	} else {
 		array = 0;
 	}
-	while (zend_hash_get_current_data_ex(CG(function_table), (void **) &zif, &iterator) == SUCCESS) {
-		if (zif->common.type==ZEND_INTERNAL_FUNCTION
+
+	ZEND_HASH_FOREACH_PTR(CG(function_table), zif) {
+		if (zif->common.type == ZEND_INTERNAL_FUNCTION
 			&& zif->internal_function.module == module) {
 			if (!array) {
 				array_init(return_value);
 				array = 1;
 			}
-			add_next_index_string(return_value, zif->common.function_name, 1);
+// TODO: we have to duplicate it, becaise it may be stored in opcache SHM ???
+			add_next_index_str(return_value, STR_DUP(zif->common.function_name, 0));
 		}
-		zend_hash_move_forward_ex(CG(function_table), &iterator);
-	}
-
-	efree(lcname);
+	} ZEND_HASH_FOREACH_END();
 
 	if (!array) {
 		RETURN_FALSE;
diff --git a/Zend/zend_closures.c b/Zend/zend_closures.c
index d714b35b39..9d48dab9f2 100644
--- a/Zend/zend_closures.c
+++ b/Zend/zend_closures.c
@@ -37,7 +37,7 @@
 typedef struct _zend_closure {
 	zend_object    std;
 	zend_function  func;
-	zval          *this_ptr;
+	zval           this_ptr;
 	HashTable     *debug_info;
 } zend_closure;
 
@@ -48,24 +48,20 @@ static zend_object_handlers closure_handlers;
 ZEND_METHOD(Closure, __invoke) /* {{{ */
 {
 	zend_function *func = EG(current_execute_data)->function_state.function;
-	zval ***arguments;
-	zval *closure_result_ptr = NULL;
+	zval *arguments;
 
-	arguments = emalloc(sizeof(zval**) * ZEND_NUM_ARGS());
+	arguments = emalloc(sizeof(zval) * ZEND_NUM_ARGS());
 	if (zend_get_parameters_array_ex(ZEND_NUM_ARGS(), arguments) == FAILURE) {
 		efree(arguments);
 		zend_error(E_RECOVERABLE_ERROR, "Cannot get arguments for calling closure");
 		RETVAL_FALSE;
-	} else if (call_user_function_ex(CG(function_table), NULL, this_ptr, &closure_result_ptr, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
+	} else if (call_user_function_ex(CG(function_table), NULL, getThis(), return_value, ZEND_NUM_ARGS(), arguments, 1, NULL TSRMLS_CC) == FAILURE) {
 		RETVAL_FALSE;
-	} else if (closure_result_ptr) {
-		zval_ptr_dtor(&return_value);
-		*return_value_ptr = closure_result_ptr;
 	}
 	efree(arguments);
 
 	/* destruct the function also, then - we have allocated it in get_method */
-	efree((char*)func->internal_function.function_name);
+	STR_RELEASE(func->internal_function.function_name);
 	efree(func);
 }
 /* }}} */
@@ -76,13 +72,13 @@ ZEND_METHOD(Closure, bind)
 {
 	zval *newthis, *zclosure, *scope_arg = NULL;
 	zend_closure *closure;
-	zend_class_entry *ce, **ce_p;
+	zend_class_entry *ce;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oo!|z", &zclosure, zend_ce_closure, &newthis, &scope_arg) == FAILURE) {
 		RETURN_NULL();
 	}
 
-	closure = (zend_closure *)zend_object_store_get_object(zclosure TSRMLS_CC);
+	closure = (zend_closure *)Z_OBJ_P(zclosure);
 
 	if ((newthis != NULL) && (closure->func.common.fn_flags & ZEND_ACC_STATIC)) {
 		zend_error(E_WARNING, "Cannot bind an instance to a static closure");
@@ -94,34 +90,16 @@ ZEND_METHOD(Closure, bind)
 		} else if (Z_TYPE_P(scope_arg) == IS_NULL) {
 			ce = NULL;
 		} else {
-			char *class_name;
-			int class_name_len;
-			zval tmp_zval;
-			INIT_ZVAL(tmp_zval);
-
-			if (Z_TYPE_P(scope_arg) == IS_STRING) {
-				class_name = Z_STRVAL_P(scope_arg);
-				class_name_len = Z_STRLEN_P(scope_arg);
-			} else {
-				tmp_zval = *scope_arg;
-				zval_copy_ctor(&tmp_zval);
-				convert_to_string(&tmp_zval);
-				class_name = Z_STRVAL(tmp_zval);
-				class_name_len = Z_STRLEN(tmp_zval);
-			}
-
-			if ((class_name_len == sizeof("static") - 1) &&
-				(memcmp("static", class_name, sizeof("static") - 1) == 0)) {
+			zend_string *class_name = zval_get_string(scope_arg);
+			if ((class_name->len == sizeof("static") - 1) &&
+				(memcmp("static", class_name->val, sizeof("static") - 1) == 0)) {
 				ce = closure->func.common.scope;
-			}
-			else if (zend_lookup_class_ex(class_name, class_name_len, NULL, 1, &ce_p TSRMLS_CC) == FAILURE) {
-				zend_error(E_WARNING, "Class '%s' not found", class_name);
-				zval_dtor(&tmp_zval);
+			} else if ((ce = zend_lookup_class_ex(class_name, NULL, 1 TSRMLS_CC)) == NULL) {
+				zend_error(E_WARNING, "Class '%s' not found", class_name->val);
+				STR_RELEASE(class_name);
 				RETURN_NULL();
-			} else {
-				ce = *ce_p;
 			}
-			zval_dtor(&tmp_zval);
+			STR_RELEASE(class_name);
 		}
 	} else { /* scope argument not given; do not change the scope by default */
 		ce = closure->func.common.scope;
@@ -131,7 +109,7 @@ ZEND_METHOD(Closure, bind)
 }
 /* }}} */
 
-static zend_function *zend_closure_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+static zend_function *zend_closure_get_constructor(zend_object *object TSRMLS_DC) /* {{{ */
 {
 	zend_error(E_RECOVERABLE_ERROR, "Instantiation of 'Closure' is not allowed");
 	return NULL;
@@ -140,13 +118,13 @@ static zend_function *zend_closure_get_constructor(zval *object TSRMLS_DC) /* {{
 
 static int zend_closure_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 {
-	return (Z_OBJ_HANDLE_P(o1) != Z_OBJ_HANDLE_P(o2));
+	return (Z_OBJ_P(o1) != Z_OBJ_P(o2));
 }
 /* }}} */
 
-ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC) /* {{{ */
+ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
+	zend_closure *closure = (zend_closure *)object;
 	zend_function *invoke = (zend_function*)emalloc(sizeof(zend_function));
 
 	invoke->common = closure->func.common;
@@ -155,65 +133,63 @@ ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC) /* {
 	invoke->internal_function.handler = ZEND_MN(Closure___invoke);
 	invoke->internal_function.module = 0;
 	invoke->internal_function.scope = zend_ce_closure;
-	invoke->internal_function.function_name = estrndup(ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1);
+	invoke->internal_function.function_name = STR_INIT(ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1, 0);
 	return invoke;
 }
 /* }}} */
 
 ZEND_API const zend_function *zend_get_closure_method_def(zval *obj TSRMLS_DC) /* {{{ */
 {
-	zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
+	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
 	return &closure->func;
 }
 /* }}} */
 
 ZEND_API zval* zend_get_closure_this_ptr(zval *obj TSRMLS_DC) /* {{{ */
 {
-	zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
-	return closure->this_ptr;
+	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
+	return &closure->this_ptr;
 }
 /* }}} */
 
-static zend_function *zend_closure_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zend_function *zend_closure_get_method(zend_object **object, zend_string *method, const zval *key TSRMLS_DC) /* {{{ */
 {
-	char *lc_name;
-	ALLOCA_FLAG(use_heap)
+	zend_string *lc_name;
 
-	lc_name = do_alloca(method_len + 1, use_heap);
-	zend_str_tolower_copy(lc_name, method_name, method_len);
-	if ((method_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) &&
-		memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
+	lc_name = STR_ALLOC(method->len, 0);
+	zend_str_tolower_copy(lc_name->val, method->val, method->len);
+	if ((method->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) &&
+		memcmp(lc_name->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
 	) {
-		free_alloca(lc_name, use_heap);
-		return zend_get_closure_invoke_method(*object_ptr TSRMLS_CC);
+		STR_FREE(lc_name);
+		return zend_get_closure_invoke_method(*object TSRMLS_CC);
 	}
-	free_alloca(lc_name, use_heap);
-	return std_object_handlers.get_method(object_ptr, method_name, method_len, key TSRMLS_CC);
+	STR_FREE(lc_name);
+	return std_object_handlers.get_method(object, method, key TSRMLS_CC);
 }
 /* }}} */
 
-static zval *zend_closure_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *zend_closure_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
 	ZEND_CLOSURE_PROPERTY_ERROR();
-	Z_ADDREF(EG(uninitialized_zval));
 	return &EG(uninitialized_zval);
 }
 /* }}} */
 
-static void zend_closure_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void zend_closure_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	ZEND_CLOSURE_PROPERTY_ERROR();
 }
 /* }}} */
 
-static zval **zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *zend_closure_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	ZEND_CLOSURE_PROPERTY_ERROR();
 	return NULL;
 }
 /* }}} */
 
-static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int zend_closure_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	if (has_set_exists != 2) {
 		ZEND_CLOSURE_PROPERTY_ERROR();
@@ -222,13 +198,13 @@ static int zend_closure_has_property(zval *object, zval *member, int has_set_exi
 }
 /* }}} */
 
-static void zend_closure_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void zend_closure_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	ZEND_CLOSURE_PROPERTY_ERROR();
 }
 /* }}} */
 
-static void zend_closure_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void zend_closure_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
 	zend_closure *closure = (zend_closure *)object;
 
@@ -250,42 +226,37 @@ static void zend_closure_free_storage(void *object TSRMLS_DC) /* {{{ */
 		efree(closure->debug_info);
 	}
 
-	if (closure->this_ptr) {
+	if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
 		zval_ptr_dtor(&closure->this_ptr);
 	}
-
-	efree(closure);
 }
 /* }}} */
 
-static zend_object_value zend_closure_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *zend_closure_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
 	zend_closure *closure;
-	zend_object_value object;
 
 	closure = emalloc(sizeof(zend_closure));
 	memset(closure, 0, sizeof(zend_closure));
 
 	zend_object_std_init(&closure->std, class_type TSRMLS_CC);
+	closure->std.handlers = &closure_handlers;
 
-	object.handle = zend_objects_store_put(closure, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) zend_closure_free_storage, NULL TSRMLS_CC);
-	object.handlers = &closure_handlers;
-
-	return object;
+	return (zend_object*)closure;
 }
 /* }}} */
 
-static zend_object_value zend_closure_clone(zval *zobject TSRMLS_DC) /* {{{ */
+static zend_object *zend_closure_clone(zval *zobject TSRMLS_DC) /* {{{ */
 {
-	zend_closure *closure = (zend_closure *)zend_object_store_get_object(zobject TSRMLS_CC);
+	zend_closure *closure = (zend_closure *)Z_OBJ_P(zobject);
 	zval result;
 
-	zend_create_closure(&result, &closure->func, closure->func.common.scope, closure->this_ptr TSRMLS_CC);
-	return Z_OBJVAL(result);
+	zend_create_closure(&result, &closure->func, closure->func.common.scope, &closure->this_ptr TSRMLS_CC);
+	return Z_OBJ(result);
 }
 /* }}} */
 
-int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) /* {{{ */
+int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC) /* {{{ */
 {
 	zend_closure *closure;
 
@@ -293,17 +264,17 @@ int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function
 		return FAILURE;
 	}
 
-	closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
+	closure = (zend_closure *)Z_OBJ_P(obj);
 	*fptr_ptr = &closure->func;
 
-	if (closure->this_ptr) {
-		if (zobj_ptr) {
-			*zobj_ptr = closure->this_ptr;
+	if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
+		if (obj_ptr) {
+			*obj_ptr = Z_OBJ(closure->this_ptr);
 		}
-		*ce_ptr = Z_OBJCE_P(closure->this_ptr);
+		*ce_ptr = Z_OBJCE(closure->this_ptr);
 	} else {
-		if (zobj_ptr) {
-			*zobj_ptr = NULL;
+		if (obj_ptr) {
+			*obj_ptr = NULL;
 		}
 		*ce_ptr = closure->func.common.scope;
 	}
@@ -313,35 +284,33 @@ int zend_closure_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function
 
 static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
 {
-	zend_closure *closure = (zend_closure *)zend_object_store_get_object(object TSRMLS_CC);
-	zval *val;
+	zend_closure *closure = (zend_closure *)Z_OBJ_P(object);
+	zval val;
 	struct _zend_arg_info *arg_info = closure->func.common.arg_info;
 
 	*is_temp = 0;
 
 	if (closure->debug_info == NULL) {
 		ALLOC_HASHTABLE(closure->debug_info);
-		zend_hash_init(closure->debug_info, 1, NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_init(closure->debug_info, 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
-	if (closure->debug_info->nApplyCount == 0) {
+	if (closure->debug_info->u.v.nApplyCount == 0) {
 		if (closure->func.type == ZEND_USER_FUNCTION && closure->func.op_array.static_variables) {
 			HashTable *static_variables = closure->func.op_array.static_variables;
-			MAKE_STD_ZVAL(val);
-			array_init(val);
-			zend_hash_copy(Z_ARRVAL_P(val), static_variables, (copy_ctor_func_t)zval_add_ref, NULL, sizeof(zval*));
-			zend_hash_update(closure->debug_info, "static", sizeof("static"), (void *) &val, sizeof(zval *), NULL);
+			array_init(&val);
+			zend_hash_copy(Z_ARRVAL(val), static_variables, zval_add_ref);
+			zend_hash_str_update(closure->debug_info, "static", sizeof("static")-1, &val);
 		}
 
-		if (closure->this_ptr) {
-			Z_ADDREF_P(closure->this_ptr);
-			zend_symtable_update(closure->debug_info, "this", sizeof("this"), (void *) &closure->this_ptr, sizeof(zval *), NULL);
+		if (Z_TYPE(closure->this_ptr) != IS_UNDEF) {
+			Z_ADDREF(closure->this_ptr);
+			zend_hash_str_update(closure->debug_info, "this", sizeof("this")-1, &closure->this_ptr);
 		}
 
 		if (arg_info) {
 			zend_uint i, required = closure->func.common.required_num_args;
 
-			MAKE_STD_ZVAL(val);
-			array_init(val);
+			array_init(&val);
 
 			for (i = 0; i < closure->func.common.num_args; i++) {
 				char *name, *info;
@@ -356,12 +325,14 @@ static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_
 									i + 1);
 				}
 				info_len = zend_spprintf(&info, 0, "%s",
-								i >= required ? "<optional>" : "<required>");
-				add_assoc_stringl_ex(val, name, name_len + 1, info, info_len, 0);
+								i >= required ? "<optional>" : "<required>");				
+				// TODO: avoid reallocation ???
+				add_assoc_stringl_ex(&val, name, name_len, info, info_len);
+				efree(info);
 				efree(name);
 				arg_info++;
 			}
-			zend_hash_update(closure->debug_info, "parameter", sizeof("parameter"), (void *) &val, sizeof(zval *), NULL);
+			zend_hash_str_update(closure->debug_info, "parameter", sizeof("parameter")-1, &val);
 		}
 	}
 
@@ -369,12 +340,18 @@ static HashTable *zend_closure_get_debug_info(zval *object, int *is_temp TSRMLS_
 }
 /* }}} */
 
-static HashTable *zend_closure_get_gc(zval *obj, zval ***table, int *n TSRMLS_DC) /* {{{ */
+static HashTable *zend_closure_get_gc(zval *obj, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
-	zend_closure *closure = (zend_closure *)zend_object_store_get_object(obj TSRMLS_CC);
+	zend_closure *closure = (zend_closure *)Z_OBJ_P(obj);
+
+	if (closure->debug_info != NULL) {
+		zend_hash_destroy(closure->debug_info);
+		efree(closure->debug_info);
+		closure->debug_info = NULL;
+	}
 
-	*table = closure->this_ptr ? &closure->this_ptr : NULL;
-	*n = closure->this_ptr ? 1 : 0;
+	*table = Z_TYPE(closure->this_ptr) != IS_NULL ? &closure->this_ptr : NULL;
+	*n = Z_TYPE(closure->this_ptr) != IS_NULL ? 1 : 0;
 	return (closure->func.type == ZEND_USER_FUNCTION) ?
 		closure->func.op_array.static_variables : NULL;
 }
@@ -418,6 +395,8 @@ void zend_register_closure_ce(TSRMLS_D) /* {{{ */
 	zend_ce_closure->unserialize = zend_class_unserialize_deny;
 
 	memcpy(&closure_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	closure_handlers.free_obj = zend_closure_free_storage;
+	closure_handlers.clone_obj = NULL;
 	closure_handlers.get_constructor = zend_closure_get_constructor;
 	closure_handlers.get_method = zend_closure_get_method;
 	closure_handlers.write_property = zend_closure_write_property;
@@ -439,12 +418,12 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent
 
 	object_init_ex(res, zend_ce_closure);
 
-	closure = (zend_closure *)zend_object_store_get_object(res TSRMLS_CC);
+	closure = (zend_closure *)Z_OBJ_P(res);
 
 	closure->func = *func;
 	closure->func.common.prototype = NULL;
 
-	if ((scope == NULL) && (this_ptr != NULL)) {
+	if ((scope == NULL) && this_ptr && (Z_TYPE_P(this_ptr) != IS_UNDEF)) {
 		/* use dummy scope if we're binding an object without specifying a scope */
 		/* maybe it would be better to create one for this purpose */
 		scope = zend_ce_closure;
@@ -464,12 +443,12 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent
 		/* verify that we aren't binding internal function to a wrong scope */
 		if(func->common.scope != NULL) {
 			if(scope && !instanceof_function(scope, func->common.scope TSRMLS_CC)) {
-				zend_error(E_WARNING, "Cannot bind function %s::%s to scope class %s", func->common.scope->name, func->common.function_name, scope->name);
+				zend_error(E_WARNING, "Cannot bind function %s::%s to scope class %s", func->common.scope->name->val, func->common.function_name->val, scope->name->val);
 				scope = NULL;
 			}
 			if(scope && this_ptr && (func->common.fn_flags & ZEND_ACC_STATIC) == 0 &&
 					!instanceof_function(Z_OBJCE_P(this_ptr), closure->func.common.scope TSRMLS_CC)) {
-				zend_error(E_WARNING, "Cannot bind function %s::%s to object of class %s", func->common.scope->name, func->common.function_name, Z_OBJCE_P(this_ptr)->name);
+				zend_error(E_WARNING, "Cannot bind function %s::%s to object of class %s", func->common.scope->name->val, func->common.function_name->val, Z_OBJCE_P(this_ptr)->name->val);
 				scope = NULL;
 				this_ptr = NULL;
 			}
@@ -486,15 +465,14 @@ ZEND_API void zend_create_closure(zval *res, zend_function *func, zend_class_ent
 	closure->func.common.scope = scope;
 	if (scope) {
 		closure->func.common.fn_flags |= ZEND_ACC_PUBLIC;
-		if (this_ptr && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {
-			closure->this_ptr = this_ptr;
-			Z_ADDREF_P(this_ptr);
+		if (this_ptr && Z_TYPE_P(this_ptr) == IS_OBJECT && (closure->func.common.fn_flags & ZEND_ACC_STATIC) == 0) {
+			ZVAL_COPY(&closure->this_ptr, this_ptr);
 		} else {
 			closure->func.common.fn_flags |= ZEND_ACC_STATIC;
-			closure->this_ptr = NULL;
+			ZVAL_UNDEF(&closure->this_ptr);
 		}
 	} else {
-		closure->this_ptr = NULL;
+		ZVAL_UNDEF(&closure->this_ptr);
 	}
 }
 /* }}} */
diff --git a/Zend/zend_closures.h b/Zend/zend_closures.h
index fa66e9747d..4f8ae6dd91 100644
--- a/Zend/zend_closures.h
+++ b/Zend/zend_closures.h
@@ -29,7 +29,7 @@ void zend_register_closure_ce(TSRMLS_D);
 extern ZEND_API zend_class_entry *zend_ce_closure;
 
 ZEND_API void zend_create_closure(zval *res, zend_function *op_array, zend_class_entry *scope, zval *this_ptr TSRMLS_DC);
-ZEND_API zend_function *zend_get_closure_invoke_method(zval *obj TSRMLS_DC);
+ZEND_API zend_function *zend_get_closure_invoke_method(zend_object *obj TSRMLS_DC);
 ZEND_API const zend_function *zend_get_closure_method_def(zval *obj TSRMLS_DC);
 ZEND_API zval* zend_get_closure_this_ptr(zval *obj TSRMLS_DC);
 
diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index beb53402ba..8df612e18b 100644
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -31,7 +31,7 @@
 #include "zend_language_scanner.h"
 
 #define CONSTANT_EX(op_array, op) \
-	(op_array)->literals[op].constant
+	(op_array)->literals[op]
 
 #define CONSTANT(op) \
 	CONSTANT_EX(CG(active_op_array), op)
@@ -60,13 +60,8 @@
 		target = src; \
 	} while (0)
 
-#define CALCULATE_LITERAL_HASH(num) do { \
-		zval *c = &CONSTANT(num); \
-		Z_HASH_P(c) = str_hash(Z_STRVAL_P(c), Z_STRLEN_P(c)); \
-	} while (0)
-
 #define GET_CACHE_SLOT(literal) do { \
-		CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot++; \
+		Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot++; \
 		if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
 			CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
 			CG(active_op_array)->run_time_cache[CG(active_op_array)->last_cache_slot - 1] = NULL; \
@@ -76,7 +71,7 @@
 #define POLYMORPHIC_CACHE_SLOT_SIZE 2
 
 #define GET_POLYMORPHIC_CACHE_SLOT(literal) do { \
-		CG(active_op_array)->literals[literal].cache_slot = CG(active_op_array)->last_cache_slot; \
+		Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = CG(active_op_array)->last_cache_slot; \
 		CG(active_op_array)->last_cache_slot += POLYMORPHIC_CACHE_SLOT_SIZE; \
 		if ((CG(active_op_array)->fn_flags & ZEND_ACC_INTERACTIVE) && CG(active_op_array)->run_time_cache) { \
 			CG(active_op_array)->run_time_cache = erealloc(CG(active_op_array)->run_time_cache, CG(active_op_array)->last_cache_slot * sizeof(void*)); \
@@ -86,10 +81,10 @@
 	} while (0)
 
 #define FREE_POLYMORPHIC_CACHE_SLOT(literal) do { \
-		if (CG(active_op_array)->literals[literal].cache_slot != -1 && \
-		    CG(active_op_array)->literals[literal].cache_slot == \
+		if (Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) != -1 && \
+		    Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) == \
 		    CG(active_op_array)->last_cache_slot - POLYMORPHIC_CACHE_SLOT_SIZE) { \
-			CG(active_op_array)->literals[literal].cache_slot = -1; \
+			Z_CACHE_SLOT(CG(active_op_array)->literals[literal]) = -1; \
 			CG(active_op_array)->last_cache_slot -= POLYMORPHIC_CACHE_SLOT_SIZE; \
 		} \
 	} while (0)
@@ -111,31 +106,55 @@ static void zend_push_function_call_entry(zend_function *fbc TSRMLS_DC) /* {{{ *
 
 static void zend_duplicate_property_info(zend_property_info *property_info) /* {{{ */
 {
-	property_info->name = str_estrndup(property_info->name, property_info->name_length);
+	STR_ADDREF(property_info->name);
 	if (property_info->doc_comment) {
-		property_info->doc_comment = estrndup(property_info->doc_comment, property_info->doc_comment_len);
+		STR_ADDREF(property_info->doc_comment);
 	}
 }
 /* }}} */
 
+static void zend_duplicate_property_info_zval(zval *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);
+}
+/* }}} */
+
 static void zend_duplicate_property_info_internal(zend_property_info *property_info) /* {{{ */
 {
-	property_info->name = str_strndup(property_info->name, property_info->name_length);
+	STR_ADDREF(property_info->name);
+}
+/* }}} */
+
+static void zend_duplicate_property_info_internal_zval(zval *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);
 }
 /* }}} */
 
-static void zend_destroy_property_info(zend_property_info *property_info) /* {{{ */
+static void zend_destroy_property_info(zval *zv) /* {{{ */
 {
-	str_efree(property_info->name);
+	zend_property_info *property_info = Z_PTR_P(zv);
+
+	STR_RELEASE(property_info->name);
 	if (property_info->doc_comment) {
-		efree((char*)property_info->doc_comment);
+		STR_RELEASE(property_info->doc_comment);
 	}
+	efree(property_info);
 }
 /* }}} */
 
-static void zend_destroy_property_info_internal(zend_property_info *property_info) /* {{{ */
+static void zend_destroy_property_info_internal(zval *zv) /* {{{ */
 {
-	str_free((char*)property_info->name);
+	zend_property_info *property_info = Z_PTR_P(zv);
+
+	STR_RELEASE(property_info->name);
+	free(property_info);
 }
 /* }}} */
 
@@ -147,28 +166,23 @@ static void build_runtime_defined_function_key(zval *result, const char *name, i
 
 	char_pos_len = zend_sprintf(char_pos_buf, "%p", LANG_SCNG(yy_text));
 	if (CG(active_op_array)->filename) {
-		filename = CG(active_op_array)->filename;
+		filename = CG(active_op_array)->filename->val;
 	} else {
 		filename = "-";
 	}
 
 	/* NULL, name length, filename length, last accepting char position length */
-	Z_STRLEN_P(result) = 1+name_length+strlen(filename)+char_pos_len;
+	ZVAL_NEW_STR(result, STR_ALLOC(1+name_length+strlen(filename)+char_pos_len, 0));
 
  	/* must be binary safe */
- 	Z_STRVAL_P(result) = (char *) safe_emalloc(Z_STRLEN_P(result), 1, 1);
  	Z_STRVAL_P(result)[0] = '\0';
  	sprintf(Z_STRVAL_P(result)+1, "%s%s%s", name, filename, char_pos_buf);
-
-	result->type = IS_STRING;
-	Z_SET_REFCOUNT_P(result, 1);
 }
 /* }}} */
 
 static void init_compiler_declarables(TSRMLS_D) /* {{{ */
 {
-	Z_TYPE(CG(declarables).ticks) = IS_LONG;
-	Z_LVAL(CG(declarables).ticks) = 0;
+	ZVAL_LONG(&CG(declarables).ticks, 0);
 }
 /* }}} */
 
@@ -200,13 +214,13 @@ void zend_init_compiler_data_structures(TSRMLS_D) /* {{{ */
 	zend_stack_init(&CG(list_stack));
 	CG(in_compilation) = 0;
 	CG(start_lineno) = 0;
-	CG(current_namespace) = NULL;
+	ZVAL_UNDEF(&CG(current_namespace));
 	CG(in_namespace) = 0;
 	CG(has_bracketed_namespaces) = 0;
 	CG(current_import) = NULL;
 	CG(current_import_function) = NULL;
 	CG(current_import_const) = NULL;
-	zend_hash_init(&CG(const_filenames), 0, NULL, NULL, 0);
+	zend_hash_init(&CG(const_filenames), 8, NULL, NULL, 0);
 	init_compiler_declarables(TSRMLS_C);
 	zend_stack_init(&CG(context_stack));
 
@@ -228,7 +242,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), 8, 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;
 }
@@ -244,35 +258,34 @@ void shutdown_compiler(TSRMLS_D) /* {{{ */
 	zend_stack_destroy(&CG(declare_stack));
 	zend_stack_destroy(&CG(list_stack));
 	zend_hash_destroy(&CG(filenames_table));
-	zend_llist_destroy(&CG(open_files));
 	zend_hash_destroy(&CG(const_filenames));
 	zend_stack_destroy(&CG(context_stack));
 }
 /* }}} */
 
-ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC) /* {{{ */
+ZEND_API zend_string *zend_set_compiled_filename(zend_string *new_compiled_filename TSRMLS_DC) /* {{{ */
 {
-	char **pp, *p;
-	int length = strlen(new_compiled_filename);
+	zend_string *p;
 
-	if (zend_hash_find(&CG(filenames_table), new_compiled_filename, length+1, (void **) &pp) == SUCCESS) {
-		CG(compiled_filename) = *pp;
-		return *pp;
+	p = zend_hash_find_ptr(&CG(filenames_table), new_compiled_filename);
+	if (p != NULL) {
+		CG(compiled_filename) = p;
+		return p;
 	}
-	p = estrndup(new_compiled_filename, length);
-	zend_hash_update(&CG(filenames_table), new_compiled_filename, length+1, &p, sizeof(char *), (void **) &pp);
+	p = STR_COPY(new_compiled_filename);
+	zend_hash_update_ptr(&CG(filenames_table), new_compiled_filename, p);
 	CG(compiled_filename) = p;
 	return p;
 }
 /* }}} */
 
-ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC) /* {{{ */
+ZEND_API void zend_restore_compiled_filename(zend_string *original_compiled_filename TSRMLS_DC) /* {{{ */
 {
 	CG(compiled_filename) = original_compiled_filename;
 }
 /* }}} */
 
-ZEND_API char *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
+ZEND_API zend_string *zend_get_compiled_filename(TSRMLS_D) /* {{{ */
 {
 	return CG(compiled_filename);
 }
@@ -292,22 +305,21 @@ ZEND_API zend_bool zend_is_compiling(TSRMLS_D) /* {{{ */
 
 static zend_uint get_temporary_variable(zend_op_array *op_array) /* {{{ */
 {
-	return (zend_uint)(zend_uintptr_t)EX_TMP_VAR_NUM(0, (op_array->T)++);
+	return (zend_uint)op_array->T++;
 }
 /* }}} */
 
-static int lookup_cv(zend_op_array *op_array, char* name, int name_len, ulong hash TSRMLS_DC) /* {{{ */
-{
+static int lookup_cv(zend_op_array *op_array, zend_string* name TSRMLS_DC) /* {{{ */{
 	int i = 0;
-	ulong hash_value = hash ? hash : zend_inline_hash_func(name, name_len+1);
+	ulong hash_value = STR_HASH_VAL(name);
 
 	while (i < op_array->last_var) {
-		if (op_array->vars[i].name == name ||
-		    (op_array->vars[i].hash_value == hash_value &&
-		     op_array->vars[i].name_len == name_len &&
-		     memcmp(op_array->vars[i].name, name, name_len) == 0)) {
-			str_efree(name);
-			return i;
+		if (op_array->vars[i]->val == name->val ||
+		    (op_array->vars[i]->h == hash_value &&
+		     op_array->vars[i]->len == name->len &&
+		     memcmp(op_array->vars[i]->val, name->val, name->len) == 0)) {
+			STR_RELEASE(name);
+			return (int)EX_VAR_NUM_2(NULL, i);
 		}
 		i++;
 	}
@@ -315,12 +327,11 @@ static int lookup_cv(zend_op_array *op_array, char* name, int name_len, ulong ha
 	op_array->last_var++;
 	if (op_array->last_var > CG(context).vars_size) {
 		CG(context).vars_size += 16; /* FIXME */
-		op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_compiled_variable));
+		op_array->vars = erealloc(op_array->vars, CG(context).vars_size * sizeof(zend_string*));
 	}
-	op_array->vars[i].name = zend_new_interned_string(name, name_len + 1, 1 TSRMLS_CC);
-	op_array->vars[i].name_len = name_len;
-	op_array->vars[i].hash_value = hash_value;
-	return i;
+
+	op_array->vars[i] = zend_new_interned_string(name TSRMLS_CC);
+	return (int)EX_VAR_NUM_2(NULL, i);
 }
 /* }}} */
 
@@ -330,30 +341,30 @@ void zend_del_literal(zend_op_array *op_array, int n) /* {{{ */
 	if (n + 1 == op_array->last_literal) {
 		op_array->last_literal--;
 	} else {
-		Z_TYPE(CONSTANT_EX(op_array, n)) = IS_NULL;
+		ZVAL_UNDEF(&CONSTANT_EX(op_array, n));
 	}
 }
 /* }}} */
 
 /* Common part of zend_add_literal and zend_append_individual_literal */
-static inline void zend_insert_literal(zend_op_array *op_array, const zval *zv, int literal_position TSRMLS_DC) /* {{{ */
+static inline void zend_insert_literal(zend_op_array *op_array, zval *zv, int literal_position TSRMLS_DC) /* {{{ */
 {
 	if (Z_TYPE_P(zv) == IS_STRING || Z_TYPE_P(zv) == IS_CONSTANT) {
-		zval *z = (zval*)zv;
-		Z_STRVAL_P(z) = (char*)zend_new_interned_string(Z_STRVAL_P(zv), Z_STRLEN_P(zv) + 1, 1 TSRMLS_CC);
+		STR_HASH_VAL(Z_STR_P(zv));
+		Z_STR_P(zv) = zend_new_interned_string(Z_STR_P(zv) TSRMLS_CC);
+		if (IS_INTERNED(Z_STR_P(zv))) {
+			Z_TYPE_FLAGS_P(zv) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+		}
 	}
-	CONSTANT_EX(op_array, literal_position) = *zv;
-	Z_SET_REFCOUNT(CONSTANT_EX(op_array, literal_position), 2);
-	Z_SET_ISREF(CONSTANT_EX(op_array, literal_position));
-	op_array->literals[literal_position].hash_value = 0;
-	op_array->literals[literal_position].cache_slot = -1;
+	ZVAL_COPY_VALUE(&CONSTANT_EX(op_array, literal_position), zv);
+	Z_CACHE_SLOT(op_array->literals[literal_position]) = -1;
 }
 /* }}} */
 
 /* Is used while compiling a function, using the context to keep track
    of an approximate size to avoid to relocate to often.
    Literals are truncated to actual size in the second compiler pass (pass_two()). */
-int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 {
 	int i = op_array->last_literal;
 	op_array->last_literal++;
@@ -361,99 +372,83 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ *
 		while (i >= CG(context).literals_size) {
 			CG(context).literals_size += 16; /* FIXME */
 		}
-		op_array->literals = (zend_literal*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zend_literal));
+		op_array->literals = (zval*)erealloc(op_array->literals, CG(context).literals_size * sizeof(zval));
 	}
 	zend_insert_literal(op_array, zv, i TSRMLS_CC);
 	return i;
 }
 /* }}} */
 
-/* Is used after normal compilation to append an additional literal.
-   Allocation is done precisely here. */
-int zend_append_individual_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
-{
-	int i = op_array->last_literal;
-	op_array->last_literal++;
-	op_array->literals = (zend_literal*)erealloc(op_array->literals, (i + 1) * sizeof(zend_literal));
-	zend_insert_literal(op_array, zv, i TSRMLS_CC);
-	return i;
-}
-/* }}} */
-
-int zend_add_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_func_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 {
 	int ret;
-	char *lc_name;
+	zend_string *lc_name;
 	zval c;
-	int lc_literal;
 
 	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+	    &op_array->literals[op_array->last_literal - 1] == zv &&
+	    Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
 		/* we already have function name as last literal (do nothing) */
 		ret = op_array->last_literal - 1;
 	} else {
 		ret = zend_add_literal(op_array, zv TSRMLS_CC);
 	}
 
-	lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
-	ZVAL_STRINGL(&c, lc_name, Z_STRLEN_P(zv), 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
+	zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+	ZVAL_NEW_STR(&c, lc_name);
+	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 
 	return ret;
 }
 /* }}} */
 
-int zend_add_ns_func_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_ns_func_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 {
 	int ret;
-	char *lc_name;
+	zend_string *lc_name;
 	const char *ns_separator;
 	int lc_len;
 	zval c;
-	int lc_literal;
 
 	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+	    &op_array->literals[op_array->last_literal - 1] == zv &&
+	    Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
 		/* we already have function name as last literal (do nothing) */
 		ret = op_array->last_literal - 1;
 	} else {
 		ret = zend_add_literal(op_array, zv TSRMLS_CC);
 	}
 
-	lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), Z_STRLEN_P(zv));
-	ZVAL_STRINGL(&c, lc_name, Z_STRLEN_P(zv), 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
+	zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
+	ZVAL_NEW_STR(&c, lc_name);
+	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 
 	ns_separator = (const char*)zend_memrchr(Z_STRVAL_P(zv), '\\', Z_STRLEN_P(zv));
 
 	if (ns_separator != NULL) {
 		ns_separator += 1;
 		lc_len = Z_STRLEN_P(zv) - (ns_separator - Z_STRVAL_P(zv));
-		lc_name = zend_str_tolower_dup(ns_separator, lc_len);
-		ZVAL_STRINGL(&c, lc_name, lc_len, 0);
-		lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-		CALCULATE_LITERAL_HASH(lc_literal);
+		lc_name = STR_ALLOC(lc_len, 0);
+		zend_str_tolower_copy(lc_name->val, ns_separator, lc_len);
+		ZVAL_NEW_STR(&c, lc_name);
+		zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 	}
 
 	return ret;
 }
 /* }}} */
 
-int zend_add_class_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC) /* {{{ */
+static int zend_add_class_name_literal(zend_op_array *op_array, zval *zv TSRMLS_DC) /* {{{ */
 {
 	int ret;
-	char *lc_name;
-	int lc_len;
+	zend_string *lc_name;
 	zval c;
-	int lc_literal;
 
 	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+	    &op_array->literals[op_array->last_literal - 1] == zv &&
+	    Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
 		/* we already have function name as last literal (do nothing) */
 		ret = op_array->last_literal - 1;
 	} else {
@@ -461,15 +456,14 @@ int zend_add_class_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_D
 	}
 
 	if (Z_STRVAL_P(zv)[0] == '\\') {
-		lc_len = Z_STRLEN_P(zv) - 1;
-		lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv) + 1, lc_len);
+		lc_name = STR_ALLOC(Z_STRLEN_P(zv) - 1, 0);
+		zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv) + 1, Z_STRLEN_P(zv) - 1);
 	} else {
-		lc_len = Z_STRLEN_P(zv);
-		lc_name = zend_str_tolower_dup(Z_STRVAL_P(zv), lc_len);
+		lc_name = STR_ALLOC(Z_STRLEN_P(zv), 0);
+		zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(zv), Z_STRLEN_P(zv));
 	}
-	ZVAL_STRINGL(&c, lc_name, lc_len, 0);
-	lc_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(lc_literal);
+	ZVAL_NEW_STR(&c, lc_name);
+	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 
 	GET_CACHE_SLOT(ret);
 
@@ -477,17 +471,18 @@ int zend_add_class_name_literal(zend_op_array *op_array, const zval *zv TSRMLS_D
 }
 /* }}} */
 
-int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unqualified TSRMLS_DC) /* {{{ */
+static int zend_add_const_name_literal(zend_op_array *op_array, zval *zv, int unqualified TSRMLS_DC) /* {{{ */
 {
-	int ret, tmp_literal;
-	char *name, *tmp_name;
+	int ret;
+	char *name;
+	zend_string *tmp_name;
 	const char *ns_separator;
 	int name_len, ns_len;
 	zval c;
 
 	if (op_array->last_literal > 0 &&
-	    &op_array->literals[op_array->last_literal - 1].constant == zv &&
-	    op_array->literals[op_array->last_literal - 1].cache_slot == -1) {
+	    &op_array->literals[op_array->last_literal - 1] == zv &&
+	    Z_CACHE_SLOT(op_array->literals[op_array->last_literal - 1]) == -1) {
 		/* we already have function name as last literal (do nothing) */
 		ret = op_array->last_literal - 1;
 	} else {
@@ -511,17 +506,16 @@ int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unq
 
 	if (ns_len) {
 		/* lowercased namespace name & original constant name */
-		tmp_name = estrndup(name, name_len);
-		zend_str_tolower(tmp_name, ns_len);
-		ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-		tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-		CALCULATE_LITERAL_HASH(tmp_literal);
+		tmp_name = STR_INIT(name, name_len, 0);
+		zend_str_tolower(tmp_name->val, ns_len);
+		ZVAL_NEW_STR(&c, tmp_name);
+		zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 
 		/* lowercased namespace name & lowercased constant name */
-		tmp_name = zend_str_tolower_dup(name, name_len);
-		ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-		tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-		CALCULATE_LITERAL_HASH(tmp_literal);
+		tmp_name = STR_ALLOC(name_len, 0);
+		zend_str_tolower_copy(tmp_name->val, name, name_len);
+		ZVAL_NEW_STR(&c, tmp_name);
+		zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 	}
 
 	if (ns_len) {
@@ -534,24 +528,29 @@ int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unq
 	}
 
 	/* original constant name */
-	tmp_name = estrndup(name, name_len);
-	ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-	tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(tmp_literal);
+	tmp_name = STR_INIT(name, name_len, 0);
+	ZVAL_NEW_STR(&c, tmp_name);
+	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 
 	/* lowercased constant name */
-	tmp_name = zend_str_tolower_dup(name, name_len);
-	ZVAL_STRINGL(&c, tmp_name, name_len, 0);
-	tmp_literal = zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
-	CALCULATE_LITERAL_HASH(tmp_literal);
+	tmp_name = STR_ALLOC(name_len, 0);
+	zend_str_tolower_copy(tmp_name->val, name, name_len);
+	ZVAL_NEW_STR(&c, tmp_name);
+	zend_add_literal(CG(active_op_array), &c TSRMLS_CC);
 
 	return ret;
 }
 /* }}} */
 
-#define LITERAL_STRINGL(op, str, len, copy) do { \
+#define LITERAL_STR(op, str) do { \
+		zval _c; \
+		ZVAL_STR(&_c, str); \
+		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
+	} while (0)
+
+#define LITERAL_STRINGL(op, str, len) do { \
 		zval _c; \
-		ZVAL_STRINGL(&_c, str, len, copy); \
+		ZVAL_STRINGL(&_c, str, len); \
 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
 	} while (0)
 
@@ -569,7 +568,7 @@ int zend_add_const_name_literal(zend_op_array *op_array, const zval *zv, int unq
 
 #define LITERAL_NULL(op) do { \
 		zval _c; \
-		INIT_ZVAL(	_c); \
+		ZVAL_NULL(&_c); \
 		op.constant = zend_add_literal(CG(active_op_array), &_c TSRMLS_CC); \
 	} while (0)
 
@@ -581,7 +580,7 @@ static inline zend_bool zend_is_function_or_method_call(const znode *variable) /
 }
 /* }}} */
 
-void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
+void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -594,7 +593,7 @@ void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const zno
 }
 /* }}} */
 
-void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
+void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -609,7 +608,7 @@ void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC)
 
 #define MAKE_NOP(opline)	{ opline->opcode = ZEND_NOP;  memset(&opline->result,0,sizeof(opline->result)); memset(&opline->op1,0,sizeof(opline->op1)); memset(&opline->op2,0,sizeof(opline->op2)); opline->result_type=opline->op1_type=opline->op2_type=IS_UNUSED;  }
 
-static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {{{ */
+static void zend_do_op_data(zend_op *data_op, znode *value TSRMLS_DC) /* {{{ */
 {
 	data_op->opcode = ZEND_OP_DATA;
 	SET_NODE(data_op->op1, value);
@@ -617,7 +616,7 @@ static void zend_do_op_data(zend_op *data_op, const znode *value TSRMLS_DC) /* {
 }
 /* }}} */
 
-void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
+void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 {
 	int last_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -665,21 +664,18 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
 	zend_llist *fetch_list_ptr;
 
 	if (varname->op_type == IS_CONST) {
-		ulong hash;
-
 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
 			convert_to_string(&varname->u.constant);
 		}
 
-		hash = str_hash(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
-		if (!zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC) &&
+		if (!zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC) &&
 		    !(Z_STRLEN(varname->u.constant) == (sizeof("this")-1) &&
 		      !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this") - 1)) &&
 		    (CG(active_op_array)->last == 0 ||
 		     CG(active_op_array)->opcodes[CG(active_op_array)->last-1].opcode != ZEND_BEGIN_SILENCE)) {
 			result->op_type = IS_CV;
-			result->u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), hash TSRMLS_CC);
-			Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[result->u.op.var].name;
+			result->u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
+			Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)];
 			result->EA = 0;
 			return;
 		}
@@ -701,8 +697,7 @@ void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar
 	opline_ptr->extended_value = ZEND_FETCH_LOCAL;
 
 	if (varname->op_type == IS_CONST) {
-		CALCULATE_LITERAL_HASH(opline_ptr->op1.constant);
-		if (zend_is_auto_global_quick(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC)) {
+		if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) {
 			opline_ptr->extended_value = ZEND_FETCH_GLOBAL;
 		}
 	}
@@ -744,8 +739,7 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
 		opline.result_type = IS_VAR;
 		opline.result.var = get_temporary_variable(CG(active_op_array));
 		opline.op1_type = IS_CONST;
-		LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[result->u.op.var].name), CG(active_op_array)->vars[result->u.op.var].name_len, 0);
-		CALCULATE_LITERAL_HASH(opline.op1.constant);
+		LITERAL_STR(opline.op1, STR_COPY(CG(active_op_array)->vars[EX_VAR_TO_NUM(result->u.op.var)]));
 		GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
 		if (class_node.op_type == IS_CONST) {
 			opline.op2_type = IS_CONST;
@@ -769,8 +763,7 @@ void zend_do_fetch_static_member(znode *result, znode *class_name TSRMLS_DC) /*
 			opline.result_type = IS_VAR;
 			opline.result.var = get_temporary_variable(CG(active_op_array));
 			opline.op1_type = IS_CONST;
-			LITERAL_STRINGL(opline.op1, estrdup(CG(active_op_array)->vars[opline_ptr->op1.var].name), CG(active_op_array)->vars[opline_ptr->op1.var].name_len, 0);
-			CALCULATE_LITERAL_HASH(opline.op1.constant);
+			LITERAL_STR(opline.op1, STR_COPY(CG(active_op_array)->vars[EX_VAR_TO_NUM(opline_ptr->op1.var)]));
 			GET_POLYMORPHIC_CACHE_SLOT(opline.op1.constant);
 			if (class_node.op_type == IS_CONST) {
 				opline.op2_type = IS_CONST;
@@ -808,7 +801,7 @@ void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC
 }
 /* }}} */
 
-void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC) /* {{{ */
+void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC) /* {{{ */
 {
 	zend_op opline;
 	zend_llist *fetch_list_ptr;
@@ -839,8 +832,6 @@ void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS
 		if (numeric) {
 			zval_dtor(&CONSTANT(opline.op2.constant));
 			ZVAL_LONG(&CONSTANT(opline.op2.constant), index);
-		} else {
-			CALCULATE_LITERAL_HASH(opline.op2.constant);
 		}
 	}
 
@@ -850,13 +841,13 @@ void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS
 }
 /* }}} */
 
-void fetch_string_offset(znode *result, const znode *parent, const znode *offset TSRMLS_DC) /* {{{ */
+void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC) /* {{{ */
 {
 	fetch_array_dim(result, parent, offset TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_print(znode *result, const znode *arg TSRMLS_DC) /* {{{ */
+void zend_do_print(znode *result, znode *arg TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -869,7 +860,7 @@ void zend_do_print(znode *result, const znode *arg TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_echo(const znode *arg TSRMLS_DC) /* {{{ */
+void zend_do_echo(znode *arg TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -892,7 +883,7 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const
 
 	if (Z_LVAL(modifiers->u.constant) & ZEND_ACC_ABSTRACT) {
 		if(Z_LVAL(modifiers->u.constant) & ZEND_ACC_PRIVATE) {
-			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
+			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot be declared private", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 		}
 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
 			zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -902,11 +893,11 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const
 			SET_UNUSED(opline->op2);
 		} else {
 			/* we had code in the function body */
-			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
+			zend_error_noreturn(E_COMPILE_ERROR, "%s function %s::%s() cannot contain body", method_type, CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 		}
 	} else {
 		if (Z_LVAL(body->u.constant) == ZEND_ACC_ABSTRACT) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
+			zend_error_noreturn(E_COMPILE_ERROR, "Non-abstract method %s::%s() must contain body", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 		}
 	}
 }
@@ -917,7 +908,7 @@ static zend_bool opline_is_fetch_this(const zend_op *opline TSRMLS_DC) /* {{{ */
 	if ((opline->opcode == ZEND_FETCH_W) && (opline->op1_type == IS_CONST)
 		&& (Z_TYPE(CONSTANT(opline->op1.constant)) == IS_STRING)
 		&& ((opline->extended_value & ZEND_FETCH_STATIC_MEMBER) != ZEND_FETCH_STATIC_MEMBER)
-		&& (Z_HASH_P(&CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
+		&& (Z_STRHASH(CONSTANT(opline->op1.constant)) == THIS_HASHVAL)
 		&& (Z_STRLEN(CONSTANT(opline->op1.constant)) == (sizeof("this")-1))
 		&& !memcmp(Z_STRVAL(CONSTANT(opline->op1.constant)), "this", sizeof("this") - 1)) {
 		return 1;
@@ -948,10 +939,8 @@ void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {
 				opline->result_type = IS_VAR;
 				opline->result.var = get_temporary_variable(CG(active_op_array));
 				opline->op1_type = IS_CONST;
-				LITERAL_STRINGL(opline->op1,
-					CG(active_op_array)->vars[value->u.op.var].name,
-					CG(active_op_array)->vars[value->u.op.var].name_len, 1);
-				CALCULATE_LITERAL_HASH(opline->op1.constant);
+				LITERAL_STR(opline->op1,
+					STR_COPY(CG(active_op_array)->vars[EX_VAR_TO_NUM(value->u.op.var)]));
 				SET_UNUSED(opline->op2);
 				opline->extended_value = ZEND_FETCH_LOCAL;
 				GET_NODE(value, opline->result);
@@ -1030,7 +1019,7 @@ void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC) /* {
 }
 /* }}} */
 
-void zend_do_assign_ref(znode *result, const znode *lvar, const znode *rvar TSRMLS_DC) /* {{{ */
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
 
@@ -1097,7 +1086,7 @@ static inline void do_end_loop(int cont_addr, int has_loop_var TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-void zend_do_while_cond(const znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
+void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC) /* {{{ */
 {
 	int while_cond_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -1131,7 +1120,7 @@ void zend_do_while_end(const znode *while_token, const znode *close_bracket_toke
 }
 /* }}} */
 
-void zend_do_for_cond(const znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC) /* {{{ */
 {
 	int for_cond_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -1175,7 +1164,7 @@ void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
+void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
 {
 	int last_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
@@ -1202,7 +1191,7 @@ void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC
 }
 /* }}} */
 
-void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
+void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC) /* {{{ */
 {
 	int last_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
@@ -1229,7 +1218,7 @@ void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_D
 }
 /* }}} */
 
-void zend_do_if_cond(const znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC) /* {{{ */
 {
 	int if_cond_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -1326,8 +1315,8 @@ void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS
 
 				this_var = opline_ptr->result.var;
 				if (CG(active_op_array)->this_var == -1) {
-					CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STRVAL(CONSTANT(opline_ptr->op1.constant)), Z_STRLEN(CONSTANT(opline_ptr->op1.constant)), Z_HASH_P(&CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC);
-					Z_TYPE(CONSTANT(opline_ptr->op1.constant)) = IS_NULL;
+					CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), Z_STR(CONSTANT(opline_ptr->op1.constant)) TSRMLS_CC);
+					ZVAL_UNDEF(&CONSTANT(opline_ptr->op1.constant));
 				} else {
 					zend_del_literal(CG(active_op_array), opline_ptr->op1.constant);
 				}
@@ -1338,7 +1327,7 @@ void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS
 					variable->u.op.var = CG(active_op_array)->this_var;
 				}
 			} else if (CG(active_op_array)->this_var == -1) {
-				CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1, THIS_HASHVAL TSRMLS_CC);
+				CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), STR_INIT("this", sizeof("this")-1, 0) TSRMLS_CC);
 			}
 		}
 
@@ -1399,7 +1388,7 @@ void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS
 }
 /* }}} */
 
-void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
+void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
 
@@ -1410,12 +1399,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;
 	}
 
@@ -1432,7 +1421,7 @@ void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC) /
 }
 /* }}} */
 
-void zend_do_add_variable(znode *result, const znode *op1, const znode *op2 TSRMLS_DC) /* {{{ */
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -1535,18 +1524,17 @@ int zend_do_verify_access_types(const znode *current_access_type, const znode *n
 void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC) /* {{{ */
 {
 	zend_op_array op_array;
-	char *name = Z_STRVAL(function_name->u.constant);
-	int name_len = Z_STRLEN(function_name->u.constant);
+	zend_string *name = Z_STR(function_name->u.constant);
 	int function_begin_line = function_token->u.op.opline_num;
 	zend_uint fn_flags;
-	const char *lcname;
+	zend_string *lcname;
 	zend_bool orig_interactive;
 	ALLOCA_FLAG(use_heap)
 
 	if (is_method) {
 		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
 			if ((Z_LVAL(fn_flags_znode->u.constant) & ~(ZEND_ACC_STATIC|ZEND_ACC_PUBLIC))) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name, Z_STRVAL(function_name->u.constant));
+				zend_error_noreturn(E_COMPILE_ERROR, "Access type for interface method %s::%s() must be omitted", CG(active_class_entry)->name->val, Z_STRVAL(function_name->u.constant));
 			}
 			Z_LVAL(fn_flags_znode->u.constant) |= ZEND_ACC_ABSTRACT; /* propagates to the rest of the parser */
 		}
@@ -1555,7 +1543,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 		fn_flags = 0;
 	}
 	if ((fn_flags & ZEND_ACC_STATIC) && (fn_flags & ZEND_ACC_ABSTRACT) && !(CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
+		zend_error(E_STRICT, "Static function %s%s%s() should not be abstract", is_method ? CG(active_class_entry)->name->val : "", is_method ? "::" : "", Z_STRVAL(function_name->u.constant));
 	}
 
 	function_token->u.op_array = CG(active_op_array);
@@ -1577,12 +1565,13 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 	op_array.line_start = zend_get_compiled_lineno(TSRMLS_C);
 
 	if (is_method) {
-		zend_ulong hash;
-
-		lcname = zend_new_interned_string(zend_str_tolower_dup(name, name_len), name_len + 1, 1 TSRMLS_CC);
-		hash = str_hash(lcname, name_len);
-		if (zend_hash_quick_add(&CG(active_class_entry)->function_table, lcname, name_len+1, hash, &op_array, sizeof(zend_op_array), (void **) &CG(active_op_array)) == FAILURE) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::%s()", CG(active_class_entry)->name, name);
+		lcname = STR_ALLOC(name->len, 0);
+		zend_str_tolower_copy(lcname->val, name->val, name->len);
+		lcname = zend_new_interned_string(lcname TSRMLS_CC);
+		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);
 		}
 
 		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));
@@ -1597,40 +1586,40 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 		}
 
 		if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
-			if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
+			if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
 				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
 					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
 				}
-			} else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
 				}
 
-			} else if ((name_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static");
 				}
@@ -1638,63 +1627,63 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 		} else {
 			char *class_lcname;
 
-			class_lcname = do_alloca(CG(active_class_entry)->name_length + 1, use_heap);
-			zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name, CG(active_class_entry)->name_length);
+			class_lcname = do_alloca(CG(active_class_entry)->name->len + 1, use_heap);
+			zend_str_tolower_copy(class_lcname, CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
 			/* Improve after RC: cache the lowercase class name */
 
-			if ((CG(active_class_entry)->name_length == name_len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname, name_len))) {
+			if ((CG(active_class_entry)->name->len == name->len) && ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) && (!memcmp(class_lcname, lcname->val, name->len))) {
 				if (!CG(active_class_entry)->constructor) {
 					CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
 				}
-			} else if ((name_len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)))) {
+			} else if ((name->len == sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME)-1))) {
 				if (CG(active_class_entry)->constructor) {
-					zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name);
+					zend_error(E_STRICT, "Redefining already defined constructor for class %s", CG(active_class_entry)->name->val);
 				}
 				CG(active_class_entry)->constructor = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DESTRUCTOR_FUNC_NAME, sizeof(ZEND_DESTRUCTOR_FUNC_NAME)-1))) {
 				CG(active_class_entry)->destructor = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_CLONE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CLONE_FUNC_NAME, sizeof(ZEND_CLONE_FUNC_NAME)-1))) {
 				CG(active_class_entry)->clone = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_CALL_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALL_FUNC_NAME, sizeof(ZEND_CALL_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __call() must have public visibility and cannot be static");
 				}
 				CG(active_class_entry)->__call = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_CALLSTATIC_FUNC_NAME, sizeof(ZEND_CALLSTATIC_FUNC_NAME)-1))) {
 				if ((fn_flags & (ZEND_ACC_PPP_MASK ^ ZEND_ACC_PUBLIC)) || (fn_flags & ZEND_ACC_STATIC) == 0) {
 					zend_error(E_WARNING, "The magic method __callStatic() must have public visibility and be static");
 				}
 				CG(active_class_entry)->__callstatic = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_GET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_GET_FUNC_NAME, sizeof(ZEND_GET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __get() must have public visibility and cannot be static");
 				}
 				CG(active_class_entry)->__get = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_SET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_SET_FUNC_NAME, sizeof(ZEND_SET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __set() must have public visibility and cannot be static");
 				}
 				CG(active_class_entry)->__set = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_UNSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_UNSET_FUNC_NAME, sizeof(ZEND_UNSET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __unset() must have public visibility and cannot be static");
 				}
 				CG(active_class_entry)->__unset = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_ISSET_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_ISSET_FUNC_NAME, sizeof(ZEND_ISSET_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __isset() must have public visibility and cannot be static");
 				}
 				CG(active_class_entry)->__isset = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_TOSTRING_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_TOSTRING_FUNC_NAME, sizeof(ZEND_TOSTRING_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __toString() must have public visibility and cannot be static");
 				}
 				CG(active_class_entry)->__tostring = (zend_function *) CG(active_op_array);
-			} else if ((name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_INVOKE_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __invoke() must have public visibility and cannot be static");
 				}
-			} else if ((name_len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
+			} else if ((name->len == sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1) && (!memcmp(lcname->val, ZEND_DEBUGINFO_FUNC_NAME, sizeof(ZEND_DEBUGINFO_FUNC_NAME)-1))) {
 				if (fn_flags & ((ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC) ^ ZEND_ACC_PUBLIC)) {
 					zend_error(E_WARNING, "The magic method __debugInfo() must have public visibility and cannot be static");
 				}
@@ -1705,34 +1694,34 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 			free_alloca(class_lcname, use_heap);
 		}
 
-		str_efree(lcname);
+		STR_RELEASE(lcname);
 	} else {
 		zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		zval key;
-		zval **ns_name;
+		zval *ns_name;
 
-		if (CG(current_namespace)) {
+		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 			/* Prefix function name with current namespace name */
 			znode tmp;
 
-			tmp.u.constant = *CG(current_namespace);
-			zval_copy_ctor(&tmp.u.constant);
+			ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 			zend_do_build_namespace_name(&tmp, &tmp, function_name TSRMLS_CC);
-			op_array.function_name = Z_STRVAL(tmp.u.constant);
-			name_len = Z_STRLEN(tmp.u.constant);
-			lcname = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), name_len);
+			op_array.function_name = Z_STR(tmp.u.constant);
+			lcname = STR_ALLOC(Z_STRLEN(tmp.u.constant), 0);
+			zend_str_tolower_copy(lcname->val, Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
 		} else {
-			lcname = zend_str_tolower_dup(name, name_len);
+			lcname = STR_ALLOC(name->len, 0);
+			zend_str_tolower_copy(lcname->val, name->val, name->len);
 		}
 
 		/* Function name must not conflict with import names */
 		if (CG(current_import_function) &&
-		    zend_hash_find(CG(current_import_function), lcname, Z_STRLEN(function_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
+		    (ns_name = zend_hash_find(CG(current_import_function), lcname)) != NULL) {
 
-			char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name));
+			char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
 
-			if (Z_STRLEN_PP(ns_name) != Z_STRLEN(function_name->u.constant) ||
-				memcmp(tmp, lcname, Z_STRLEN(function_name->u.constant))) {
+			if (Z_STRLEN_P(ns_name) != Z_STRLEN(function_name->u.constant) ||
+				memcmp(tmp, lcname->val, Z_STRLEN(function_name->u.constant))) {
 				zend_error(E_COMPILE_ERROR, "Cannot declare function %s because the name is already in use", Z_STRVAL(function_name->u.constant));
 			}
 			efree(tmp);
@@ -1740,17 +1729,17 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 
 		opline->opcode = ZEND_DECLARE_FUNCTION;
 		opline->op1_type = IS_CONST;
-		build_runtime_defined_function_key(&key, lcname, name_len TSRMLS_CC);
+		build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC);
 		opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
-		Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
 		opline->op2_type = IS_CONST;
-		LITERAL_STRINGL(opline->op2, lcname, name_len, 1);
-		CALCULATE_LITERAL_HASH(opline->op2.constant);
+		LITERAL_STR(opline->op2, STR_COPY(lcname));
 		opline->extended_value = ZEND_DECLARE_FUNCTION;
-		zend_hash_quick_update(CG(function_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &op_array, sizeof(zend_op_array), (void **) &CG(active_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_efree(lcname);
+		STR_RELEASE(lcname);
 	}
 
 	if (CG(compiler_options) & ZEND_COMPILE_EXTENDED_INFO) {
@@ -1784,9 +1773,7 @@ void zend_do_begin_function_declaration(znode *function_token, znode *function_n
 
 	if (CG(doc_comment)) {
 		CG(active_op_array)->doc_comment = CG(doc_comment);
-		CG(active_op_array)->doc_comment_len = CG(doc_comment_len);
 		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
 	}
 }
 /* }}} */
@@ -1799,7 +1786,7 @@ void zend_do_begin_lambda_function_declaration(znode *result, znode *function_to
 	zend_op       *current_op;
 
 	function_name.op_type = IS_CONST;
-	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1, 1);
+	ZVAL_STRINGL(&function_name.u.constant, "{closure}", sizeof("{closure}")-1);
 
 	zend_do_begin_function_declaration(function_token, &function_name, 0, return_reference, NULL TSRMLS_CC);
 
@@ -1844,8 +1831,8 @@ void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /*
 	} else {
 		/* we don't care if the function name is longer, in fact lowercasing only
 		 * the beginning of the name speeds up the check process */
-		name_len = strlen(CG(active_op_array)->function_name);
-		zend_str_tolower_copy(lcname, CG(active_op_array)->function_name, MIN(name_len, sizeof(lcname)-1));
+		name_len = CG(active_op_array)->function_name->len;
+		zend_str_tolower_copy(lcname, CG(active_op_array)->function_name->val, MIN(name_len, sizeof(lcname)-1));
 		lcname[sizeof(lcname)-1] = '\0'; /* zend_str_tolower_copy won't necessarily set the zero byte */
 		if (name_len == sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1 && !memcmp(lcname, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)) && CG(active_op_array)->num_args != 1) {
 			zend_error_noreturn(E_COMPILE_ERROR, "%s() must take exactly 1 argument", ZEND_AUTOLOAD_FUNC_NAME);
@@ -1862,20 +1849,20 @@ void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC) /*
 }
 /* }}} */
 
-void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */
+void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_uchar pass_by_reference, zend_bool is_variadic TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
 	zend_arg_info *cur_arg_info;
 	znode var;
 
-	if (zend_is_auto_global(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant) TSRMLS_CC)) {
+	if (zend_is_auto_global(Z_STR(varname->u.constant) TSRMLS_CC)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot re-assign auto-global variable %s", Z_STRVAL(varname->u.constant));
 	} else {
 		var.op_type = IS_CV;
-		var.u.op.var = lookup_cv(CG(active_op_array), Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant), 0 TSRMLS_CC);
-		Z_STRVAL(varname->u.constant) = (char*)CG(active_op_array)->vars[var.u.op.var].name;
+		var.u.op.var = lookup_cv(CG(active_op_array), Z_STR(varname->u.constant) TSRMLS_CC);
+		Z_STR(varname->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(var.u.op.var)];
 		var.EA = 0;
-		if (CG(active_op_array)->vars[var.u.op.var].hash_value == THIS_HASHVAL &&
+		if (Z_STRHASH(varname->u.constant) == THIS_HASHVAL &&
 			Z_STRLEN(varname->u.constant) == sizeof("this")-1 &&
 		    !memcmp(Z_STRVAL(varname->u.constant), "this", sizeof("this")-1)) {
 			if (CG(active_op_array)->scope &&
@@ -1915,7 +1902,7 @@ void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initializ
 	}
 	CG(active_op_array)->arg_info = erealloc(CG(active_op_array)->arg_info, sizeof(zend_arg_info)*(CG(active_op_array)->num_args));
 	cur_arg_info = &CG(active_op_array)->arg_info[CG(active_op_array)->num_args-1];
-	cur_arg_info->name = zend_new_interned_string(estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)), Z_STRLEN(varname->u.constant) + 1, 1 TSRMLS_CC);
+	cur_arg_info->name = estrndup(Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant));
 	cur_arg_info->name_len = Z_STRLEN(varname->u.constant);
 	cur_arg_info->type_hint = 0;
 	cur_arg_info->pass_by_reference = pass_by_reference;
@@ -1927,17 +1914,17 @@ void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initializ
 	if (class_type->op_type != IS_UNUSED) {
 		cur_arg_info->allow_null = 0;
 
-		if (class_type->u.constant.type != IS_NULL) {
-			if (class_type->u.constant.type == IS_ARRAY) {
+		if (Z_TYPE(class_type->u.constant) != IS_NULL) {
+			if (Z_TYPE(class_type->u.constant) == IS_ARRAY) {
 				cur_arg_info->type_hint = IS_ARRAY;
 				if (op == ZEND_RECV_INIT) {
 					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
 						cur_arg_info->allow_null = 1;
-					} else if (Z_TYPE(initialization->u.constant) != IS_ARRAY) {
+					} else if (Z_TYPE(initialization->u.constant) != IS_ARRAY && Z_TYPE(initialization->u.constant) != IS_CONSTANT_ARRAY) {
 						zend_error_noreturn(E_COMPILE_ERROR, "Default value for parameters with array type hint can only be an array or NULL");
 					}
 				}
-			} else if (class_type->u.constant.type == IS_CALLABLE) {
+			} else if (Z_TYPE(class_type->u.constant) == IS_CALLABLE) {
 				cur_arg_info->type_hint = IS_CALLABLE;
 				if (op == ZEND_RECV_INIT) {
 					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
@@ -1951,9 +1938,19 @@ void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initializ
 				if (ZEND_FETCH_CLASS_DEFAULT == zend_get_class_fetch_type(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant))) {
 					zend_resolve_class_name(class_type TSRMLS_CC);
 				}
-				Z_STRVAL(class_type->u.constant) = (char*)zend_new_interned_string(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant) + 1, 1 TSRMLS_CC);
+				Z_STR(class_type->u.constant) = zend_new_interned_string(Z_STR(class_type->u.constant) TSRMLS_CC);
+				if (IS_INTERNED(Z_STR(class_type->u.constant))) {
+					Z_TYPE_FLAGS(class_type->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+				}
+// TODO: for now we have to copy it ???
+#if 1
+				cur_arg_info->class_name = estrndup(Z_STRVAL(class_type->u.constant), Z_STRLEN(class_type->u.constant));
+				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
+				STR_RELEASE(Z_STR(class_type->u.constant));
+#else
 				cur_arg_info->class_name = Z_STRVAL(class_type->u.constant);
 				cur_arg_info->class_name_len = Z_STRLEN(class_type->u.constant);
+#endif
 				if (op == ZEND_RECV_INIT) {
 					if (Z_TYPE(initialization->u.constant) == IS_NULL || (Z_TYPE(initialization->u.constant) == IS_CONSTANT && !strcasecmp(Z_STRVAL(initialization->u.constant), "NULL")) || Z_TYPE(initialization->u.constant) == IS_CONSTANT_AST) {
 						cur_arg_info->allow_null = 1;
@@ -1964,18 +1961,22 @@ void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initializ
 			}
 		}
 	}
+
+	if (cur_arg_info->class_name || cur_arg_info->type_hint) {
+		CG(active_op_array)->fn_flags |= ZEND_ACC_HAS_TYPE_HINTS;
+	}
 }
 /* }}} */
 
 int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC) /* {{{ */
 {
 	zend_function *function;
-	char *lcname;
+	zend_string *lcname;
 	char *is_compound = memchr(Z_STRVAL(function_name->u.constant), '\\', Z_STRLEN(function_name->u.constant));
 
 	zend_resolve_function_name(function_name, &check_namespace TSRMLS_CC);
 
-	if (check_namespace && CG(current_namespace) && !is_compound) {
+	if (check_namespace && Z_TYPE(CG(current_namespace)) != IS_UNDEF && !is_compound) {
 			/* We assume we call function from the current namespace
 			if it is not prefixed. */
 
@@ -1985,16 +1986,17 @@ int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace
 			return 1;
 	}
 
-	lcname = zend_str_tolower_dup(Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
-	if ((zend_hash_find(CG(function_table), lcname, Z_STRLEN(function_name->u.constant)+1, (void **) &function)==FAILURE) ||
+	lcname = STR_ALLOC(Z_STRLEN(function_name->u.constant), 0);
+	zend_str_tolower_copy(lcname->val, Z_STRVAL(function_name->u.constant), Z_STRLEN(function_name->u.constant));
+	if (((function = zend_hash_find_ptr(CG(function_table), lcname)) == NULL) ||
 	 	((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_FUNCTIONS) &&
  		(function->type == ZEND_INTERNAL_FUNCTION))) {
  			zend_do_begin_dynamic_function_call(function_name, 0 TSRMLS_CC);
  			efree(lcname);
  			return 1; /* Dynamic */
  	}
-	efree(Z_STRVAL(function_name->u.constant));
-	Z_STRVAL(function_name->u.constant) = lcname;
+	STR_RELEASE(Z_STR(function_name->u.constant));
+	Z_STR(function_name->u.constant) = lcname;
 
 	zend_push_function_call_entry(function TSRMLS_CC);
 	if (CG(context).nested_calls + 1 > CG(active_op_array)->nested_calls) {
@@ -2028,7 +2030,7 @@ void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */
 			if (Z_TYPE(name) != IS_STRING) {
 				zend_error_noreturn(E_COMPILE_ERROR, "Method name must be a string");
 			}
-			Z_STRVAL(name) = str_estrndup(Z_STRVAL(name), Z_STRLEN(name));
+			Z_STR(name) = STR_COPY(Z_STR(name));
 			FREE_POLYMORPHIC_CACHE_SLOT(last_op->op2.constant);
 			last_op->op2.constant =
 				zend_add_func_name_literal(CG(active_op_array), &name TSRMLS_CC);
@@ -2060,7 +2062,7 @@ void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_clone(znode *result, const znode *expr TSRMLS_DC) /* {{{ */
+void zend_do_clone(znode *result, znode *expr TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -2112,8 +2114,9 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace
 {
 	znode tmp;
 	int len;
-	zval **ns;
-	char *lookup_name, *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
+	zval *ns;
+	zend_string *lookup_name;
+	char *compound = memchr(Z_STRVAL(element_name->u.constant), '\\', Z_STRLEN(element_name->u.constant));
 
 	if (Z_STRVAL(element_name->u.constant)[0] == '\\') {
 		/* name starts with \ so it is known and unambiguos, nothing to do here but shorten it */
@@ -2127,54 +2130,54 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace
 	}
 
 	if (current_import_sub) {
-		len = Z_STRLEN(element_name->u.constant)+1;
+		len = Z_STRLEN(element_name->u.constant);
 		if (case_sensitive) {
-			lookup_name = estrndup(Z_STRVAL(element_name->u.constant), len);
+			lookup_name = STR_INIT(Z_STRVAL(element_name->u.constant), len, 0);
 		} else {
-			lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
+			lookup_name = STR_ALLOC(len, 0);
+			zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len);
 		}
 		/* Check if function/const matches imported name */
-		if (zend_hash_find(current_import_sub, lookup_name, len, (void**)&ns) == SUCCESS) {
+		if ((ns = zend_hash_find(current_import_sub, lookup_name)) != NULL) {
 			zval_dtor(&element_name->u.constant);
-			element_name->u.constant = **ns;
-			zval_copy_ctor(&element_name->u.constant);
-			efree(lookup_name);
+			ZVAL_DUP(&element_name->u.constant, ns);
+			STR_FREE(lookup_name);
 			*check_namespace = 0;
 			return;
 		}
-		efree(lookup_name);
+		STR_FREE(lookup_name);
 	}
 
 	if (compound && CG(current_import)) {
 		len = compound - Z_STRVAL(element_name->u.constant);
 		/* namespace is always lowercase */
-		lookup_name = zend_str_tolower_dup(Z_STRVAL(element_name->u.constant), len);
+		lookup_name = STR_ALLOC(len, 0);
+		zend_str_tolower_copy(lookup_name->val, Z_STRVAL(element_name->u.constant), len);
 		/* Check if first part of compound name is an import name */
-		if (zend_hash_find(CG(current_import), lookup_name, len+1, (void**)&ns) == SUCCESS) {
+		if ((ns = zend_hash_find(CG(current_import), lookup_name)) != NULL) {
 			/* Substitute import name */
 			tmp.op_type = IS_CONST;
-			tmp.u.constant = **ns;
-			zval_copy_ctor(&tmp.u.constant);
+			ZVAL_DUP(&tmp.u.constant, ns);
 			len += 1;
 			Z_STRLEN(element_name->u.constant) -= len;
 			memmove(Z_STRVAL(element_name->u.constant), Z_STRVAL(element_name->u.constant)+len, Z_STRLEN(element_name->u.constant)+1);
 			zend_do_build_namespace_name(&tmp, &tmp, element_name TSRMLS_CC);
 			*element_name = tmp;
-			efree(lookup_name);
+			STR_FREE(lookup_name);
 			*check_namespace = 0;
 			return;
 		}
-		efree(lookup_name);
+		STR_FREE(lookup_name);
 	}
 
-	if (CG(current_namespace)) {
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 		tmp = *element_name;
-		Z_STRLEN(tmp.u.constant) = sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN_P(CG(current_namespace));
-		Z_STRVAL(tmp.u.constant) = (char *) emalloc(Z_STRLEN(tmp.u.constant)+1);
-		memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
-		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace))]), "\\", sizeof("\\")-1);
-		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN_P(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
-		str_efree(Z_STRVAL(element_name->u.constant));
+		Z_STR(tmp.u.constant) = STR_ALLOC(sizeof("\\")-1 + Z_STRLEN(element_name->u.constant) + Z_STRLEN(CG(current_namespace)), 0);
+		Z_TYPE_FLAGS(tmp.u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
+		memcpy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
+		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace))]), "\\", sizeof("\\")-1);
+		memcpy(&(Z_STRVAL(tmp.u.constant)[Z_STRLEN(CG(current_namespace)) + sizeof("\\")-1]), Z_STRVAL(element_name->u.constant), Z_STRLEN(element_name->u.constant)+1);
+		STR_RELEASE(Z_STR(element_name->u.constant));
 		*element_name = tmp;
 	}
 }
@@ -2207,7 +2210,7 @@ void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static
 			}
 			zval_dtor(&class_name->u.constant);
 			class_name->op_type = IS_CONST;
-			ZVAL_STRINGL(&class_name->u.constant, CG(active_class_entry)->name, CG(active_class_entry)->name_length, 1);
+			ZVAL_STR(&class_name->u.constant, STR_COPY(CG(active_class_entry)->name));
 			*result = *class_name;
 			break;
         case ZEND_FETCH_CLASS_STATIC:
@@ -2225,7 +2228,7 @@ void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static
 					);
 			}
 			constant_name.op_type = IS_CONST;
-			ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1, 1);
+			ZVAL_STRINGL(&constant_name.u.constant, "class", sizeof("class")-1);
 			zend_do_fetch_constant(result, class_name, &constant_name, ZEND_RT, 1 TSRMLS_CC);
 			break;
 		case ZEND_FETCH_CLASS_DEFAULT:
@@ -2242,8 +2245,8 @@ void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static
 void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */
 {
 	char *compound;
-	char *lcname;
-	zval **ns;
+	zend_string *lcname;
+	zval *ns;
 	znode tmp;
 	int len;
 
@@ -2252,11 +2255,11 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */
 		/* This is a compound class name that contains namespace prefix */
 		if (Z_STRVAL(class_name->u.constant)[0] == '\\') {
 			/* The STRING name has "\" prefix */
-			Z_STRLEN(class_name->u.constant) -= 1;
-			memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant)+1);
-			Z_STRVAL(class_name->u.constant) = erealloc(
-			Z_STRVAL(class_name->u.constant),
-			Z_STRLEN(class_name->u.constant) + 1);
+			memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+1, Z_STRLEN(class_name->u.constant));
+			Z_STR(class_name->u.constant) = STR_REALLOC(
+				Z_STR(class_name->u.constant),
+				Z_STRLEN(class_name->u.constant) - 1, 0);
+			Z_TYPE_FLAGS(class_name->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
 
 			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));
@@ -2264,51 +2267,49 @@ void zend_resolve_class_name(znode *class_name TSRMLS_DC) /* {{{ */
 		} else {
 			if (CG(current_import)) {
 				len = compound - Z_STRVAL(class_name->u.constant);
-				lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), len);
+				lcname = STR_ALLOC(len, 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), len);
 				/* Check if first part of compound name is an import name */
-				if (zend_hash_find(CG(current_import), lcname, len+1, (void**)&ns) == SUCCESS) {
+				if ((ns = zend_hash_find(CG(current_import), lcname)) != NULL) {
 					/* Substitute import name */
 					tmp.op_type = IS_CONST;
-					tmp.u.constant = **ns;
-					zval_copy_ctor(&tmp.u.constant);
+					ZVAL_DUP(&tmp.u.constant, ns);
 					len += 1;
 					Z_STRLEN(class_name->u.constant) -= len;
 					memmove(Z_STRVAL(class_name->u.constant), Z_STRVAL(class_name->u.constant)+len, Z_STRLEN(class_name->u.constant)+1);
 					zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
 					*class_name = tmp;
-					efree(lcname);
+					STR_FREE(lcname);
 					return;
 				}
-				efree(lcname);
+				STR_FREE(lcname);
 			}
 			/* Here name is not prefixed with \ and not imported */
-			if (CG(current_namespace)) {
+			if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 				tmp.op_type = IS_CONST;
-				tmp.u.constant = *CG(current_namespace);
-				zval_copy_ctor(&tmp.u.constant);
+				ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 				zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
 				*class_name = tmp;
 			}
 		}
-	} else if (CG(current_import) || CG(current_namespace)) {
+	} else if (CG(current_import) || Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 		/* this is a plain name (without \) */
-		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+		lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0);
+		zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 
 		if (CG(current_import) &&
-		    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns) == SUCCESS) {
+		    (ns = zend_hash_find(CG(current_import), lcname)) != NULL) {
 		    /* The given name is an import name. Substitute it. */
 			zval_dtor(&class_name->u.constant);
-			class_name->u.constant = **ns;
-			zval_copy_ctor(&class_name->u.constant);
-		} else if (CG(current_namespace)) {
+			ZVAL_DUP(&class_name->u.constant, ns);
+		} else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 			/* plain name, no import - prepend current namespace to it */
 			tmp.op_type = IS_CONST;
-			tmp.u.constant = *CG(current_namespace);
-			zval_copy_ctor(&tmp.u.constant);
+			ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 			zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
 			*class_name = tmp;
 		}
-		efree(lcname);
+		STR_FREE(lcname);
 	}
 }
 /* }}} */
@@ -2354,19 +2355,25 @@ void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
+static void ptr_dtor(zval *zv) /* {{{ */
+{
+	efree(Z_PTR_P(zv));
+}
+/* }}} */
+
 void zend_do_label(znode *label TSRMLS_DC) /* {{{ */
 {
 	zend_label dest;
 
 	if (!CG(context).labels) {
 		ALLOC_HASHTABLE(CG(context).labels);
-		zend_hash_init(CG(context).labels, 4, NULL, NULL, 0);
+		zend_hash_init(CG(context).labels, 8, NULL, ptr_dtor, 0);
 	}
 
 	dest.brk_cont = CG(context).current_brk_cont;
 	dest.opline_num = get_next_op_number(CG(active_op_array));
 
-	if (zend_hash_add(CG(context).labels, Z_STRVAL(label->u.constant), Z_STRLEN(label->u.constant) + 1, (void**)&dest, sizeof(zend_label), NULL) == FAILURE) {
+	if (zend_hash_add_mem(CG(context).labels, Z_STR(label->u.constant), &dest, sizeof(zend_label)) == NULL) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Label '%s' already defined", Z_STRVAL(label->u.constant));
 	}
 
@@ -2387,7 +2394,7 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2
 		label = &CONSTANT_EX(op_array, opline->op2.constant);
 	}
 	if (CG(context).labels == NULL ||
-	    zend_hash_find(CG(context).labels, Z_STRVAL_P(label), Z_STRLEN_P(label)+1, (void**)&dest) == FAILURE) {
+	    (dest = zend_hash_find_ptr(CG(context).labels, Z_STR_P(label))) == NULL) {
 
 		if (pass2) {
 			CG(in_compilation) = 1;
@@ -2403,7 +2410,7 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2
 
 	opline->op1.opline_num = dest->opline_num;
 	zval_dtor(label);
-	Z_TYPE_P(label) = IS_NULL;
+	ZVAL_NULL(label);
 
 	/* Check that we are not moving into loop or switch */
 	current = opline->extended_value;
@@ -2435,7 +2442,7 @@ void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2
 }
 /* }}} */
 
-void zend_do_goto(const znode *label TSRMLS_DC) /* {{{ */
+void zend_do_goto(znode *label TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -2475,19 +2482,21 @@ void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_c
 	}
 
 	if (is_class_member) {
-		length = sizeof("::")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
-		Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "::", sizeof("::")-1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("::")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
-		str_efree(Z_STRVAL(name->u.constant));
-		Z_STRLEN(result->u.constant) = length;
+		int old_len = Z_STRLEN(result->u.constant);
+		length = sizeof("::")-1 + old_len + Z_STRLEN(name->u.constant);
+		Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0);
+		Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
+		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 {
-		length = sizeof("\\")-1 + Z_STRLEN(result->u.constant) + Z_STRLEN(name->u.constant);
-		Z_STRVAL(result->u.constant) = str_erealloc(Z_STRVAL(result->u.constant), length+1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant)], "\\", sizeof("\\")-1);
-		memcpy(&Z_STRVAL(result->u.constant)[Z_STRLEN(result->u.constant) + sizeof("\\")-1], Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1);
-		str_efree(Z_STRVAL(name->u.constant));
-		Z_STRLEN(result->u.constant) = length;
+		int old_len = Z_STRLEN(result->u.constant);
+		length = sizeof("\\")-1 + old_len + Z_STRLEN(name->u.constant);
+		Z_STR(result->u.constant) = STR_REALLOC(Z_STR(result->u.constant), length, 0);
+		Z_TYPE_FLAGS(result->u.constant) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
+		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));
 	}
 }
 /* }}} */
@@ -2571,7 +2580,6 @@ void zend_do_end_function_call(znode *function_name, znode *result, int is_metho
 			SET_NODE(opline->op1, function_name);
 			SET_UNUSED(opline->op2);
 			opline->op2.num = CG(context).nested_calls;
-			CALCULATE_LITERAL_HASH(opline->op1.constant);
 			GET_CACHE_SLOT(opline->op1.constant);
 		} else {
 			opline->opcode = ZEND_DO_FCALL_BY_NAME;
@@ -2627,7 +2635,7 @@ void zend_do_pass_param(znode *param, zend_uchar op TSRMLS_DC) /* {{{ */
 			zend_error_noreturn(E_COMPILE_ERROR,
 						"Call-time pass-by-reference has been removed; "
 						"If you would like to pass argument by reference, modify the declaration of %s().",
-						function_ptr->common.function_name);
+						function_ptr->common.function_name->val);
 		} else {
 			zend_error_noreturn(E_COMPILE_ERROR, "Call-time pass-by-reference has been removed");
 		}
@@ -2729,7 +2737,7 @@ void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */
 		 * computed at compile time, thus we need access to EX(call). In order to have it we
 		 * retroactively emit a ZEND_INIT_FCALL_BY_NAME opcode. */
 		zval func_name;
-		ZVAL_STRING(&func_name, fcall->fbc->common.function_name, 1);
+		ZVAL_STR(&func_name, STR_COPY(fcall->fbc->common.function_name));
 
 		opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 		opline->opcode = ZEND_INIT_FCALL_BY_NAME;
@@ -2751,7 +2759,7 @@ void zend_do_unpack_params(znode *params TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int generate_free_switch_expr(const zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */
+static int generate_free_switch_expr(zend_switch_entry *switch_entry TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
 
@@ -2798,7 +2806,7 @@ void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
 
 	if (do_end_vparse) {
 		if (returns_reference && !zend_is_function_or_method_call(expr)) {
-			zend_do_end_variable_parse(expr, BP_VAR_W, 0 TSRMLS_CC);
+			zend_do_end_variable_parse(expr, BP_VAR_W, 1 TSRMLS_CC);
 		} else {
 			zend_do_end_variable_parse(expr, BP_VAR_R, 0 TSRMLS_CC);
 		}
@@ -2848,7 +2856,7 @@ void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */
+void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
 
@@ -2860,7 +2868,7 @@ void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_v
 
 	if (is_variable) {
 		if ((CG(active_op_array)->fn_flags & ZEND_ACC_RETURN_REFERENCE) && !zend_is_function_or_method_call(value)) {
-			zend_do_end_variable_parse(value, BP_VAR_W, 0 TSRMLS_CC);
+			zend_do_end_variable_parse(value, BP_VAR_W, 1 TSRMLS_CC);
 		} else {
 			zend_do_end_variable_parse(value, BP_VAR_R, 0 TSRMLS_CC);
 		}
@@ -3006,8 +3014,8 @@ void zend_do_begin_catch(znode *catch_token, znode *class_name, znode *catch_var
 	opline->op1_type = IS_CONST;
 	opline->op1.constant = zend_add_class_name_literal(CG(active_op_array), &catch_class.u.constant TSRMLS_CC);
 	opline->op2_type = IS_CV;
-	opline->op2.var = lookup_cv(CG(active_op_array), Z_STRVAL(catch_var->u.constant), Z_STRLEN(catch_var->u.constant), 0 TSRMLS_CC);
-	Z_STRVAL(catch_var->u.constant) = (char*)CG(active_op_array)->vars[opline->op2.var].name;
+	opline->op2.var = lookup_cv(CG(active_op_array), Z_STR(catch_var->u.constant) TSRMLS_CC);
+	Z_STR(catch_var->u.constant) = CG(active_op_array)->vars[EX_VAR_TO_NUM(opline->op2.var)];
 	opline->result.num = 0; /* 1 means it's the last catch in the block */
 
 	catch_token->u.op.opline_num = catch_op_number;
@@ -3063,7 +3071,7 @@ void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_to
 }
 /* }}} */
 
-void zend_do_throw(const znode *expr TSRMLS_DC) /* {{{ */
+void zend_do_throw(znode *expr TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
 
@@ -3082,13 +3090,16 @@ ZEND_API void function_add_ref(zend_function *function) /* {{{ */
 		(*op_array->refcount)++;
 		if (op_array->static_variables) {
 			HashTable *static_variables = op_array->static_variables;
-			zval *tmp_zval;
 
 			ALLOC_HASHTABLE(op_array->static_variables);
 			zend_hash_init(op_array->static_variables, zend_hash_num_elements(static_variables), NULL, ZVAL_PTR_DTOR, 0);
-			zend_hash_copy(op_array->static_variables, static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_zval, sizeof(zval *));
+			zend_hash_copy(op_array->static_variables, static_variables, zval_add_ref);
 		}
 		op_array->run_time_cache = NULL;
+	} else if (function->type == ZEND_INTERNAL_FUNCTION) {
+		if (function->common.function_name) {
+			STR_ADDREF(function->common.function_name);
+		}
 	}
 }
 /* }}} */
@@ -3150,36 +3161,47 @@ static void do_inherit_parent_constructor(zend_class_entry *ce) /* {{{ */
 	if (ce->constructor) {
 		if (ce->parent->constructor && ce->parent->constructor->common.fn_flags & ZEND_ACC_FINAL) {
 			zend_error(E_ERROR, "Cannot override final %s::%s() with %s::%s()",
-				ce->parent->name, ce->parent->constructor->common.function_name,
-				ce->name, ce->constructor->common.function_name
+				ce->parent->name->val, ce->parent->constructor->common.function_name->val,
+				ce->name->val, ce->constructor->common.function_name->val
 				);
 		}
 		return;
 	}
 
-	if (zend_hash_find(&ce->parent->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), (void **)&function)==SUCCESS) {
+	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 */
-		zend_hash_update(&ce->function_table, ZEND_CONSTRUCTOR_FUNC_NAME, sizeof(ZEND_CONSTRUCTOR_FUNC_NAME), function, sizeof(zend_function), (void**)&new_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 */
-		char *lc_class_name;
-		char *lc_parent_class_name;
-
-		lc_class_name = zend_str_tolower_dup(ce->name, ce->name_length);
-		if (!zend_hash_exists(&ce->function_table, lc_class_name, ce->name_length+1)) {
-			lc_parent_class_name = zend_str_tolower_dup(ce->parent->name, ce->parent->name_length);
-			if (!zend_hash_exists(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1) &&
-					zend_hash_find(&ce->parent->function_table, lc_parent_class_name, ce->parent->name_length+1, (void **)&function)==SUCCESS) {
+		zend_string *lc_class_name;
+		zend_string *lc_parent_class_name;
+
+		lc_class_name = STR_ALLOC(ce->name->len, 0);
+		zend_str_tolower_copy(lc_class_name->val, ce->name->val, ce->name->len);
+		if (!zend_hash_exists(&ce->function_table, lc_class_name)) {
+			lc_parent_class_name = STR_ALLOC(ce->parent->name->len, 0);
+			zend_str_tolower_copy(lc_parent_class_name->val, ce->parent->name->val, ce->parent->name->len);
+			if (!zend_hash_exists(&ce->function_table, lc_parent_class_name) &&
+					(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(&ce->function_table, lc_parent_class_name, ce->parent->name_length+1, function, sizeof(zend_function), (void**)&new_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);
 				}
 			}
-			efree(lc_parent_class_name);
+			STR_RELEASE(lc_parent_class_name);
 		}
-		efree(lc_class_name);
+		STR_FREE(lc_class_name);
 	}
 	ce->constructor = ce->parent->constructor;
 }
@@ -3200,13 +3222,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;
 }
 /* }}} */
 
@@ -3279,54 +3312,56 @@ static zend_bool zend_do_perform_implementation_check(const zend_function *fe, c
 		}
 
 		if (fe_arg_info->class_name) {
-			const char *fe_class_name, *proto_class_name;
-			zend_uint fe_class_name_len, proto_class_name_len;
+			zend_string *fe_class_name, *proto_class_name;
 
 			if (!strcasecmp(fe_arg_info->class_name, "parent") && proto->common.scope) {
-				fe_class_name = proto->common.scope->name;
-				fe_class_name_len = proto->common.scope->name_length;
+				fe_class_name = STR_COPY(proto->common.scope->name);
 			} else if (!strcasecmp(fe_arg_info->class_name, "self") && fe->common.scope) {
-				fe_class_name = fe->common.scope->name;
-				fe_class_name_len = fe->common.scope->name_length;
+				fe_class_name = STR_COPY(fe->common.scope->name);
 			} else {
-				fe_class_name = fe_arg_info->class_name;
-				fe_class_name_len = fe_arg_info->class_name_len;
+				fe_class_name = STR_INIT(
+					fe_arg_info->class_name,
+					fe_arg_info->class_name_len, 0);
 			}
 
 			if (!strcasecmp(proto_arg_info->class_name, "parent") && proto->common.scope && proto->common.scope->parent) {
-				proto_class_name = proto->common.scope->parent->name;
-				proto_class_name_len = proto->common.scope->parent->name_length;
+				proto_class_name = STR_COPY(proto->common.scope->parent->name);
 			} else if (!strcasecmp(proto_arg_info->class_name, "self") && proto->common.scope) {
-				proto_class_name = proto->common.scope->name;
-				proto_class_name_len = proto->common.scope->name_length;
+				proto_class_name = STR_COPY(proto->common.scope->name);
 			} else {
-				proto_class_name = proto_arg_info->class_name;
-				proto_class_name_len = proto_arg_info->class_name_len;
+				proto_class_name = STR_INIT(
+					proto_arg_info->class_name,
+					proto_arg_info->class_name_len, 0);
 			}
 
-			if (strcasecmp(fe_class_name, proto_class_name)!=0) {
+			if (strcasecmp(fe_class_name->val, proto_class_name->val)!=0) {
 				const char *colon;
 
 				if (fe->common.type != ZEND_USER_FUNCTION) {
+					STR_RELEASE(proto_class_name);
+					STR_RELEASE(fe_class_name);
 					return 0;
-			    } else if (strchr(proto_class_name, '\\') != NULL ||
-						(colon = zend_memrchr(fe_class_name, '\\', fe_class_name_len)) == NULL ||
-						strcasecmp(colon+1, proto_class_name) != 0) {
-					zend_class_entry **fe_ce, **proto_ce;
-					int found, found2;
+			    } else if (strchr(proto_class_name->val, '\\') != NULL ||
+						(colon = zend_memrchr(fe_class_name->val, '\\', fe_class_name->len)) == NULL ||
+						strcasecmp(colon+1, proto_class_name->val) != 0) {
+					zend_class_entry *fe_ce, *proto_ce;
 
-					found = zend_lookup_class(fe_class_name, fe_class_name_len, &fe_ce TSRMLS_CC);
-					found2 = zend_lookup_class(proto_class_name, proto_class_name_len, &proto_ce TSRMLS_CC);
+					fe_ce = zend_lookup_class(fe_class_name TSRMLS_CC);
+					proto_ce = zend_lookup_class(proto_class_name TSRMLS_CC);
 
 					/* Check for class alias */
-					if (found != SUCCESS || found2 != SUCCESS ||
-							(*fe_ce)->type == ZEND_INTERNAL_CLASS ||
-							(*proto_ce)->type == ZEND_INTERNAL_CLASS ||
-							*fe_ce != *proto_ce) {
+					if (!fe_ce || !proto_ce ||
+							fe_ce->type == ZEND_INTERNAL_CLASS ||
+							proto_ce->type == ZEND_INTERNAL_CLASS ||
+							fe_ce != proto_ce) {
+						STR_RELEASE(proto_class_name);
+						STR_RELEASE(fe_class_name);
 						return 0;
 					}
 				}
 			}
+			STR_RELEASE(proto_class_name);
+			STR_RELEASE(fe_class_name);
 		}
 		if (fe_arg_info->type_hint != proto_arg_info->type_hint) {
 			/* Incompatible type hint */
@@ -3361,16 +3396,16 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{
 	}
 
 	if (fptr->common.scope) {
-		memcpy(offset, fptr->common.scope->name, fptr->common.scope->name_length);
-		offset += fptr->common.scope->name_length;
+		memcpy(offset, fptr->common.scope->name->val, fptr->common.scope->name->len);
+		offset += fptr->common.scope->name->len;
 		*(offset++) = ':';
 		*(offset++) = ':';
 	}
 
 	{
-		size_t name_len = strlen(fptr->common.function_name);
+		size_t name_len = fptr->common.function_name->len;
 		REALLOC_BUF_IF_EXCEED(buf, offset, length, name_len);
-		memcpy(offset, fptr->common.function_name, name_len);
+		memcpy(offset, fptr->common.function_name->val, name_len);
 		offset += name_len;
 	}
 
@@ -3385,11 +3420,11 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{
 				const char *class_name;
 				zend_uint class_name_len;
 				if (!strcasecmp(arg_info->class_name, "self") && fptr->common.scope ) {
-					class_name = fptr->common.scope->name;
-					class_name_len = fptr->common.scope->name_length;
+					class_name = fptr->common.scope->name->val;
+					class_name_len = fptr->common.scope->name->len;
 				} else if (!strcasecmp(arg_info->class_name, "parent") && fptr->common.scope->parent) {
-					class_name = fptr->common.scope->parent->name;
-					class_name_len = fptr->common.scope->parent->name_length;
+					class_name = fptr->common.scope->parent->name->val;
+					class_name_len = fptr->common.scope->parent->name->len;
 				} else {
 					class_name = arg_info->class_name;
 					class_name_len = arg_info->class_name_len;
@@ -3455,46 +3490,41 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{
 						}
 					}
 					if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
-						zval *zv, zv_copy;
-						int use_copy;
-						ALLOC_ZVAL(zv);
-						*zv = *precv->op2.zv;
-						zval_copy_ctor(zv);
-						INIT_PZVAL(zv);
+						zval zv;
+
+						ZVAL_DUP(&zv, precv->op2.zv);
 						zval_update_constant_ex(&zv, 1, fptr->common.scope TSRMLS_CC);
-						if (Z_TYPE_P(zv) == IS_BOOL) {
-							if (Z_LVAL_P(zv)) {
+						if (Z_TYPE(zv) == IS_BOOL) {
+							if (Z_LVAL(zv)) {
 								memcpy(offset, "true", 4);
 								offset += 4;
 							} else {
 								memcpy(offset, "false", 5);
 								offset += 5;
 							}
-						} else if (Z_TYPE_P(zv) == IS_NULL) {
+						} else if (Z_TYPE(zv) == IS_NULL) {
 							memcpy(offset, "NULL", 4);
 							offset += 4;
-						} else if (Z_TYPE_P(zv) == IS_STRING) {
+						} else if (Z_TYPE(zv) == IS_STRING) {
 							*(offset++) = '\'';
-							REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN_P(zv), 10));
-							memcpy(offset, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 10));
-							offset += MIN(Z_STRLEN_P(zv), 10);
-							if (Z_STRLEN_P(zv) > 10) {
+							REALLOC_BUF_IF_EXCEED(buf, offset, length, MIN(Z_STRLEN(zv), 10));
+							memcpy(offset, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 10));
+							offset += MIN(Z_STRLEN(zv), 10);
+							if (Z_STRLEN(zv) > 10) {
 								*(offset++) = '.';
 								*(offset++) = '.';
 								*(offset++) = '.';
 							}
 							*(offset++) = '\'';
-						} else if (Z_TYPE_P(zv) == IS_ARRAY) {
+						} else if (Z_TYPE(zv) == IS_ARRAY) {
 							memcpy(offset, "Array", 5);
 							offset += 5;
 						} else {
-							zend_make_printable_zval(zv, &zv_copy, &use_copy);
-							REALLOC_BUF_IF_EXCEED(buf, offset, length, Z_STRLEN(zv_copy));
-							memcpy(offset, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy));
-							offset += Z_STRLEN(zv_copy);
-							if (use_copy) {
-								zval_dtor(&zv_copy);
-							}
+							zend_string *str = zval_get_string(&zv);
+							REALLOC_BUF_IF_EXCEED(buf, offset, length, str->len);
+							memcpy(offset, str->val, str->len);
+							offset += str->len;
+							STR_RELEASE(str);
 						}
 						zval_ptr_dtor(&zv);
 					}
@@ -3529,13 +3559,13 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function *
 		&& parent->common.scope != (child->common.prototype ? child->common.prototype->common.scope : child->common.scope)
 		&& child->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_IMPLEMENTED_ABSTRACT)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Can't inherit abstract function %s::%s() (previously declared abstract in %s)",
-			parent->common.scope->name,
-			child->common.function_name,
-			child->common.prototype ? child->common.prototype->common.scope->name : child->common.scope->name);
+			parent->common.scope->name->val,
+			child->common.function_name->val,
+			child->common.prototype ? child->common.prototype->common.scope->name->val : child->common.scope->name->val);
 	}
 
 	if (parent_flags & ZEND_ACC_FINAL) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name);
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot override final method %s::%s()", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val);
 	}
 
 	child_flags	= child->common.fn_flags;
@@ -3543,15 +3573,15 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function *
 	 */
 	if ((child_flags & ZEND_ACC_STATIC) != (parent_flags & ZEND_ACC_STATIC)) {
 		if (child->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non static method %s::%s() static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 		} else {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot make static method %s::%s() non static in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 		}
 	}
 
 	/* Disallow making an inherited method abstract. */
 	if ((child_flags & ZEND_ACC_ABSTRACT) && !(parent_flags & ZEND_ACC_ABSTRACT)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name, ZEND_FN_SCOPE_NAME(child));
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot make non abstract method %s::%s() abstract in class %s", ZEND_FN_SCOPE_NAME(parent), child->common.function_name->val, ZEND_FN_SCOPE_NAME(child));
 	}
 
 	if (parent_flags & ZEND_ACC_CHANGED) {
@@ -3560,7 +3590,7 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function *
 		/* Prevent derived classes from restricting access that was available in parent classes
 		 */
 		if ((child_flags & ZEND_ACC_PPP_MASK) > (parent_flags & ZEND_ACC_PPP_MASK)) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
+			zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::%s() must be %s (as in class %s)%s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_visibility_string(parent_flags), ZEND_FN_SCOPE_NAME(parent), (parent_flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
 		} else if (((child_flags & ZEND_ACC_PPP_MASK) < (parent_flags & ZEND_ACC_PPP_MASK))
 			&& ((parent_flags & ZEND_ACC_PPP_MASK) & ZEND_ACC_PRIVATE)) {
 			child->common.fn_flags |= ZEND_ACC_CHANGED;
@@ -3579,25 +3609,26 @@ static void do_inheritance_check_on_method(zend_function *child, zend_function *
 
 	if (child->common.prototype && (child->common.prototype->common.fn_flags & ZEND_ACC_ABSTRACT)) {
 		if (!zend_do_perform_implementation_check(child, child->common.prototype TSRMLS_CC)) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, zend_get_function_declaration(child->common.prototype TSRMLS_CC));
+			zend_error_noreturn(E_COMPILE_ERROR, "Declaration of %s::%s() must be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, zend_get_function_declaration(child->common.prototype TSRMLS_CC));
 		}
-	} else if (EG(error_reporting) & E_STRICT || EG(user_error_handler)) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
+	} else if (EG(error_reporting) & E_STRICT || Z_TYPE(EG(user_error_handler)) != IS_UNDEF) { /* Check E_STRICT (or custom error handler) before the check so that we save some time */
 		if (!zend_do_perform_implementation_check(child, parent TSRMLS_CC)) {
 			char *method_prototype = zend_get_function_declaration(parent TSRMLS_CC);
-			zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name, method_prototype);
+			zend_error(E_STRICT, "Declaration of %s::%s() should be compatible with %s", ZEND_FN_SCOPE_NAME(child), child->common.function_name->val, method_prototype);
 			efree(method_prototype);
 		}
 	}
 }
 /* }}} */
 
-static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_function *parent, const zend_hash_key *hash_key, zend_class_entry *child_ce) /* {{{ */
+static zend_bool do_inherit_method_check(HashTable *child_function_table, zval *zv, const zend_hash_key *hash_key, zend_class_entry *child_ce) /* {{{ */
 {
+	zend_function *parent = Z_PTR_P(zv);
 	zend_uint parent_flags = parent->common.fn_flags;
 	zend_function *child;
 	TSRMLS_FETCH();
 
-	if (zend_hash_quick_find(child_function_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child)==FAILURE) {
+	if ((child = zend_hash_find_ptr(child_function_table, hash_key->key)) == NULL) {
 		if (parent_flags & (ZEND_ACC_ABSTRACT)) {
 			child_ce->ce_flags |= ZEND_ACC_IMPLICIT_ABSTRACT_CLASS;
 		}
@@ -3610,16 +3641,17 @@ static zend_bool do_inherit_method_check(HashTable *child_function_table, zend_f
 }
 /* }}} */
 
-static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_property_info *parent_info, const zend_hash_key *hash_key, zend_class_entry *ce) /* {{{ */
+static zend_bool do_inherit_property_access_check(HashTable *target_ht, zval *zv, const zend_hash_key *hash_key, zend_class_entry *ce) /* {{{ */
 {
+    zend_property_info *parent_info = Z_PTR_P(zv);
 	zend_property_info *child_info;
 	zend_class_entry *parent_ce = ce->parent;
 
 	if (parent_info->flags & (ZEND_ACC_PRIVATE|ZEND_ACC_SHADOW)) {
-		if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
+		if ((child_info = zend_hash_find_ptr(&ce->properties_info, hash_key->key)) != NULL) {
 			child_info->flags |= ZEND_ACC_CHANGED;
 		} else {
-			zend_hash_quick_update(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, parent_info, sizeof(zend_property_info), (void **) &child_info);
+			child_info = zend_hash_update_mem(&ce->properties_info, hash_key->key, parent_info, sizeof(zend_property_info));
 			if(ce->type & ZEND_INTERNAL_CLASS) {
 				zend_duplicate_property_info_internal(child_info);
 			} else {
@@ -3631,11 +3663,11 @@ static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_pro
 		return 0; /* don't copy access information to child */
 	}
 
-	if (zend_hash_quick_find(&ce->properties_info, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void **) &child_info)==SUCCESS) {
+	if ((child_info = zend_hash_find_ptr(&ce->properties_info, hash_key->key)) != NULL) {
 		if ((parent_info->flags & ZEND_ACC_STATIC) != (child_info->flags & ZEND_ACC_STATIC)) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s%s::$%s as %s%s::$%s",
-				(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name, hash_key->arKey,
-				(child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name, hash_key->arKey);
+				(parent_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", parent_ce->name->val, hash_key->key->val,
+				(child_info->flags & ZEND_ACC_STATIC) ? "static " : "non static ", ce->name->val, hash_key->key->val);
 
 		}
 
@@ -3644,11 +3676,11 @@ static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_pro
 		}
 
 		if ((child_info->flags & ZEND_ACC_PPP_MASK) > (parent_info->flags & ZEND_ACC_PPP_MASK)) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name, hash_key->arKey, zend_visibility_string(parent_info->flags), parent_ce->name, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
+			zend_error_noreturn(E_COMPILE_ERROR, "Access level to %s::$%s must be %s (as in class %s)%s", ce->name->val, hash_key->key->val, zend_visibility_string(parent_info->flags), parent_ce->name->val, (parent_info->flags&ZEND_ACC_PUBLIC) ? "" : " or weaker");
 		} else if ((child_info->flags & ZEND_ACC_STATIC) == 0) {
 			zval_ptr_dtor(&(ce->default_properties_table[parent_info->offset]));
 			ce->default_properties_table[parent_info->offset] = ce->default_properties_table[child_info->offset];
-			ce->default_properties_table[child_info->offset] = NULL;
+			ZVAL_UNDEF(&ce->default_properties_table[child_info->offset]);
 			child_info->offset = parent_info->offset;
 		}
 		return 0;	/* Don't copy from parent */
@@ -3661,10 +3693,10 @@ static zend_bool do_inherit_property_access_check(HashTable *target_ht, zend_pro
 static inline void do_implement_interface(zend_class_entry *ce, zend_class_entry *iface TSRMLS_DC) /* {{{ */
 {
 	if (!(ce->ce_flags & ZEND_ACC_INTERFACE) && iface->interface_gets_implemented && iface->interface_gets_implemented(iface, ce TSRMLS_CC) == FAILURE) {
-		zend_error(E_CORE_ERROR, "Class %s could not implement interface %s", ce->name, iface->name);
+		zend_error(E_CORE_ERROR, "Class %s could not implement interface %s", ce->name->val, iface->name->val);
 	}
 	if (ce == iface) {
-		zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name);
+		zend_error(E_ERROR, "Interface %s cannot implement itself", ce->name->val);
 	}
 }
 /* }}} */
@@ -3707,32 +3739,44 @@ ZEND_API void zend_do_inherit_interfaces(zend_class_entry *ce, const zend_class_
 /* }}} */
 
 #ifdef ZTS
-static void zval_internal_ctor(zval **p) /* {{{ */
-{
-	zval *orig_ptr = *p;
-
-	ALLOC_ZVAL(*p);
-	MAKE_COPY_ZVAL(&orig_ptr, *p);
-}
-/* }}} */
-
 # define zval_property_ctor(parent_ce, ce) \
-	((void (*)(void *)) (((parent_ce)->type != (ce)->type) ? zval_internal_ctor : zval_add_ref))
+	(((parent_ce)->type != (ce)->type) ? ZVAL_COPY_CTOR : zval_add_ref)
 #else
 # define zval_property_ctor(parent_ce, ce) \
-	((void (*)(void *)) zval_add_ref)
+	zval_add_ref
 #endif
 
+static int do_inherit_class_constant(zval *zv TSRMLS_DC, int num_args, va_list args, const zend_hash_key *hash_key) /* {{{ */
+{
+	zend_class_entry *ce = va_arg(args, zend_class_entry *);
+	zend_class_entry *parent_ce = va_arg(args, zend_class_entry *);
+
+	if (hash_key->key) {
+		if (!Z_ISREF_P(zv)) {
+			if (parent_ce->type == ZEND_INTERNAL_CLASS) {
+				ZVAL_NEW_PERSISTENT_REF(zv, zv);
+			} else {
+				ZVAL_NEW_REF(zv, zv);
+			}
+		}
+		if (zend_hash_add(&ce->constants_table, hash_key->key, zv)) {
+			Z_ADDREF_P(zv);
+		}
+	}
+	return ZEND_HASH_APPLY_KEEP;
+}
+/* }}} */
+
 ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent_ce TSRMLS_DC) /* {{{ */
 {
 	zend_property_info *property_info;
 
 	if ((ce->ce_flags & ZEND_ACC_INTERFACE)
 		&& !(parent_ce->ce_flags & ZEND_ACC_INTERFACE)) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name, parent_ce->name);
+		zend_error_noreturn(E_COMPILE_ERROR, "Interface %s may not inherit from class (%s)", ce->name->val, parent_ce->name->val);
 	}
 	if (parent_ce->ce_flags & ZEND_ACC_FINAL_CLASS) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name, parent_ce->name);
+		zend_error_noreturn(E_COMPILE_ERROR, "Class %s may not inherit from final class (%s)", ce->name->val, parent_ce->name->val);
 	}
 
 	ce->parent = parent_ce;
@@ -3751,29 +3795,21 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 	if (parent_ce->default_properties_count) {
 		int i = ce->default_properties_count + parent_ce->default_properties_count;
 
-		ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(void*) * i, ce->type == ZEND_INTERNAL_CLASS);
+		ce->default_properties_table = perealloc(ce->default_properties_table, sizeof(zval) * i, ce->type == ZEND_INTERNAL_CLASS);
 		if (ce->default_properties_count) {
 			while (i-- > parent_ce->default_properties_count) {
 				ce->default_properties_table[i] = ce->default_properties_table[i - parent_ce->default_properties_count];
 			}
 		}
 		for (i = 0; i < parent_ce->default_properties_count; i++) {
-			ce->default_properties_table[i] = parent_ce->default_properties_table[i];
-			if (ce->default_properties_table[i]) {
 #ifdef ZTS
-				if (parent_ce->type != ce->type) {
-					zval *p;
-
-					ALLOC_ZVAL(p);
-					MAKE_COPY_ZVAL(&ce->default_properties_table[i], p);
-					ce->default_properties_table[i] = p;
-				} else {
-					Z_ADDREF_P(ce->default_properties_table[i]);
-				}
-#else
-				Z_ADDREF_P(ce->default_properties_table[i]);
-#endif
+			if (parent_ce->type != ce->type) {
+				ZVAL_DUP(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
+				continue;
 			}
+#endif
+
+			ZVAL_COPY(&ce->default_properties_table[i], &parent_ce->default_properties_table[i]);
 		}
 		ce->default_properties_count += parent_ce->default_properties_count;
 	}
@@ -3784,7 +3820,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 		if (parent_ce->default_static_members_count) {
 			int i = ce->default_static_members_count + parent_ce->default_static_members_count;
 
-			ce->default_static_members_table = erealloc(ce->default_static_members_table, sizeof(void*) * i);
+			ce->default_static_members_table = erealloc(ce->default_static_members_table, sizeof(zval) * i);
 			if (ce->default_static_members_count) {
 				while (i-- > parent_ce->default_static_members_count) {
 					ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
@@ -3793,7 +3829,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 			for (i = 0; i < parent_ce->default_static_members_count; i++) {
 				SEPARATE_ZVAL_TO_MAKE_IS_REF(&CE_STATIC_MEMBERS(parent_ce)[i]);
 				ce->default_static_members_table[i] = CE_STATIC_MEMBERS(parent_ce)[i];
-				Z_ADDREF_P(ce->default_static_members_table[i]);
+				Z_ADDREF(ce->default_static_members_table[i]);
 			}
 			ce->default_static_members_count += parent_ce->default_static_members_count;
 			ce->static_members_table = ce->default_static_members_table;
@@ -3802,7 +3838,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 		if (parent_ce->default_static_members_count) {
 			int i = ce->default_static_members_count + parent_ce->default_static_members_count;
 
-			ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(void*) * i, ce->type == ZEND_INTERNAL_CLASS);
+			ce->default_static_members_table = perealloc(ce->default_static_members_table, sizeof(zval) * i, ce->type == ZEND_INTERNAL_CLASS);
 			if (ce->default_static_members_count) {
 				while (i-- > parent_ce->default_static_members_count) {
 					ce->default_static_members_table[i] = ce->default_static_members_table[i - parent_ce->default_static_members_count];
@@ -3811,7 +3847,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 			for (i = 0; i < parent_ce->default_static_members_count; i++) {
 				SEPARATE_ZVAL_TO_MAKE_IS_REF(&parent_ce->default_static_members_table[i]);
 				ce->default_static_members_table[i] = parent_ce->default_static_members_table[i];
-				Z_ADDREF_P(ce->default_static_members_table[i]);
+				Z_ADDREF(ce->default_static_members_table[i]);
 			}
 			ce->default_static_members_count += parent_ce->default_static_members_count;
 			if (ce->type == ZEND_USER_CLASS) {
@@ -3820,9 +3856,7 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 		}
 	}
 
-	for (zend_hash_internal_pointer_reset(&ce->properties_info);
-	zend_hash_get_current_data(&ce->properties_info, (void *) &property_info) == SUCCESS;
-	zend_hash_move_forward(&ce->properties_info)) {
+	ZEND_HASH_FOREACH_PTR(&ce->properties_info, property_info) {
 		if (property_info->ce == ce) {
 			if (property_info->flags & ZEND_ACC_STATIC) {
 				property_info->offset += parent_ce->default_static_members_count;
@@ -3830,12 +3864,12 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 				property_info->offset += parent_ce->default_properties_count;
 			}
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
-	zend_hash_merge_ex(&ce->properties_info, &parent_ce->properties_info, (copy_ctor_func_t) (ce->type & ZEND_INTERNAL_CLASS ? zend_duplicate_property_info_internal : zend_duplicate_property_info), sizeof(zend_property_info), (merge_checker_func_t) do_inherit_property_access_check, ce);
+	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), NULL, sizeof(zval *), 0);
-	zend_hash_merge_ex(&ce->function_table, &parent_ce->function_table, (copy_ctor_func_t) do_inherit_method, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);
+	zend_hash_apply_with_arguments(&parent_ce->constants_table TSRMLS_CC, (apply_func_args_t)do_inherit_class_constant, 2, ce, parent_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) {
@@ -3848,13 +3882,15 @@ ZEND_API void zend_do_inheritance(zend_class_entry *ce, zend_class_entry *parent
 }
 /* }}} */
 
-static zend_bool do_inherit_constant_check(HashTable *child_constants_table, const zval **parent_constant, const zend_hash_key *hash_key, const zend_class_entry *iface) /* {{{ */
+static zend_bool do_inherit_constant_check(HashTable *child_constants_table, zval *parent_constant, const zend_hash_key *hash_key, const zend_class_entry *iface) /* {{{ */
 {
-	zval **old_constant;
+	zval *old_constant;
 
-	if (zend_hash_quick_find(child_constants_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, (void**)&old_constant) == SUCCESS) {
-		if (*old_constant != *parent_constant) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", hash_key->arKey, iface->name);
+	if ((old_constant = zend_hash_find(child_constants_table, hash_key->key)) != NULL) {
+		if (!Z_ISREF_P(old_constant) ||
+		    !Z_ISREF_P(parent_constant) ||
+		    Z_REFVAL_P(old_constant) != Z_REFVAL_P(parent_constant)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot inherit previously-inherited or override constant %s from interface %s", hash_key->key->val, iface->name->val);
 		}
 		return 0;
 	}
@@ -3862,12 +3898,28 @@ static zend_bool do_inherit_constant_check(HashTable *child_constants_table, con
 }
 /* }}} */
 
-static int do_interface_constant_check(zval **val TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */
+static int do_interface_constant_check(zval *val TSRMLS_DC, int num_args, va_list args, const zend_hash_key *key) /* {{{ */
 {
 	zend_class_entry **iface = va_arg(args, zend_class_entry**);
 
-	do_inherit_constant_check(&(*iface)->constants_table, (const zval **) val, key, *iface);
+	do_inherit_constant_check(&(*iface)->constants_table, val, key, *iface);
+
+	return ZEND_HASH_APPLY_KEEP;
+}
+/* }}} */
+
+static int do_inherit_iface_constant(zval *zv TSRMLS_DC, int num_args, va_list args, const zend_hash_key *hash_key) /* {{{ */
+{
+	zend_class_entry *ce = va_arg(args, zend_class_entry *);
+	zend_class_entry *iface = va_arg(args, zend_class_entry *);
 
+	if (hash_key->key && do_inherit_constant_check(&ce->constants_table, zv, hash_key, iface)) {
+		if (!Z_ISREF_P(zv)) {
+			ZVAL_NEW_REF(zv, zv);
+		}
+		Z_ADDREF_P(zv);
+		zend_hash_update(&ce->constants_table, hash_key->key, zv);
+	}
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
@@ -3886,7 +3938,7 @@ ZEND_API void zend_do_implement_interface(zend_class_entry *ce, zend_class_entry
 			if (i < parent_iface_num) {
 				ignore = 1;
 			} else {
-				zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name, iface->name);
+				zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot implement previously implemented interface %s", ce->name->val, iface->name->val);
 			}
 		}
 	}
@@ -3903,8 +3955,8 @@ 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, sizeof(zval *), (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, sizeof(zend_function), (merge_checker_func_t) do_inherit_method_check, ce);
+		zend_hash_apply_with_arguments(&iface->constants_table TSRMLS_CC, (apply_func_args_t)do_inherit_iface_constant, 2, ce, iface);
+		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);
@@ -3953,60 +4005,59 @@ static zend_bool zend_traits_method_compatibility_check(zend_function *fn, zend_
 }
 /* }}} */
 
-static void zend_add_magic_methods(zend_class_entry* ce, const char* mname, uint mname_len, zend_function* fe TSRMLS_DC) /* {{{ */
+static void zend_add_magic_methods(zend_class_entry* ce, zend_string* mname, zend_function* fe TSRMLS_DC) /* {{{ */
 {
-	if (!strncmp(mname, ZEND_CLONE_FUNC_NAME, mname_len)) {
+	if (!strncmp(mname->val, ZEND_CLONE_FUNC_NAME, mname->len)) {
 		ce->clone = fe; fe->common.fn_flags |= ZEND_ACC_CLONE;
-	} else if (!strncmp(mname, ZEND_CONSTRUCTOR_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_CONSTRUCTOR_FUNC_NAME, mname->len)) {
 		if (ce->constructor) {
-			zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name);
+			zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
 		}
 		ce->constructor = fe; fe->common.fn_flags |= ZEND_ACC_CTOR;
-	} else if (!strncmp(mname, ZEND_DESTRUCTOR_FUNC_NAME,  mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_DESTRUCTOR_FUNC_NAME,  mname->len)) {
 		ce->destructor = fe; fe->common.fn_flags |= ZEND_ACC_DTOR;
-	} else if (!strncmp(mname, ZEND_GET_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_GET_FUNC_NAME, mname->len)) {
 		ce->__get = fe;
-	} else if (!strncmp(mname, ZEND_SET_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_SET_FUNC_NAME, mname->len)) {
 		ce->__set = fe;
-	} else if (!strncmp(mname, ZEND_CALL_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_CALL_FUNC_NAME, mname->len)) {
 		ce->__call = fe;
-	} else if (!strncmp(mname, ZEND_UNSET_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_UNSET_FUNC_NAME, mname->len)) {
 		ce->__unset = fe;
-	} else if (!strncmp(mname, ZEND_ISSET_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_ISSET_FUNC_NAME, mname->len)) {
 		ce->__isset = fe;
-	} else if (!strncmp(mname, ZEND_CALLSTATIC_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_CALLSTATIC_FUNC_NAME, mname->len)) {
 		ce->__callstatic = fe;
-	} else if (!strncmp(mname, ZEND_TOSTRING_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_TOSTRING_FUNC_NAME, mname->len)) {
 		ce->__tostring = fe;
-	} else if (!strncmp(mname, ZEND_DEBUGINFO_FUNC_NAME, mname_len)) {
+	} else if (!strncmp(mname->val, ZEND_DEBUGINFO_FUNC_NAME, mname->len)) {
 		ce->__debugInfo = fe;
-	} else if (ce->name_length + 1 == mname_len) {
-		char *lowercase_name = emalloc(ce->name_length + 1);
-		zend_str_tolower_copy(lowercase_name, ce->name, ce->name_length);
-		lowercase_name = (char*)zend_new_interned_string(lowercase_name, ce->name_length + 1, 1 TSRMLS_CC);
-		if (!memcmp(mname, lowercase_name, mname_len)) {
+	} else if (ce->name->len == mname->len) {
+		zend_string *lowercase_name = STR_ALLOC(ce->name->len, 0);
+		zend_str_tolower_copy(lowercase_name->val, ce->name->val, ce->name->len);
+		lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
+		if (!memcmp(mname->val, lowercase_name->val, mname->len)) {
 			if (ce->constructor) {
-				zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name);
+				zend_error_noreturn(E_COMPILE_ERROR, "%s has colliding constructor definitions coming from traits", ce->name->val);
 			}
 			ce->constructor = fe;
 			fe->common.fn_flags |= ZEND_ACC_CTOR;
 		}
-		str_efree(lowercase_name);
+		STR_RELEASE(lowercase_name);
 	}
 }
 /* }}} */
 
-static void zend_add_trait_method(zend_class_entry *ce, const char *name, const char *arKey, uint nKeyLength, zend_function *fn, HashTable **overriden TSRMLS_DC) /* {{{ */
+static void zend_add_trait_method(zend_class_entry *ce, const char *name, zend_string *key, zend_function *fn, HashTable **overriden TSRMLS_DC) /* {{{ */
 {
 	zend_function *existing_fn = NULL;
-	ulong h = zend_hash_func(arKey, nKeyLength);
 
-	if (zend_hash_quick_find(&ce->function_table, arKey, nKeyLength, h, (void**) &existing_fn) == SUCCESS) {
+	if ((existing_fn = zend_hash_find_ptr(&ce->function_table, key)) != NULL) {
 		if (existing_fn->common.scope == ce) {
 			/* members from the current class override trait methods */
 			/* use temporary *overriden HashTable to detect hidden conflict */
 			if (*overriden) {
-				if (zend_hash_quick_find(*overriden, arKey, nKeyLength, h, (void**) &existing_fn) == SUCCESS) {
+				if ((existing_fn = zend_hash_find_ptr(*overriden, key)) != NULL) {
 					if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 						/* Make sure the trait method is compatible with previosly declared abstract method */
 						if (!zend_traits_method_compatibility_check(fn, existing_fn TSRMLS_CC)) {
@@ -4026,9 +4077,9 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, const
 				}
 			} else {
 				ALLOC_HASHTABLE(*overriden);
-				zend_hash_init_ex(*overriden, 2, NULL, NULL, 0, 0);
+				zend_hash_init_ex(*overriden, 8, NULL, ptr_dtor, 0, 0);
 			}
-			zend_hash_quick_update(*overriden, arKey, nKeyLength, h, fn, sizeof(zend_function), (void**)&fn);
+			fn = zend_hash_update_mem(*overriden, key, fn, sizeof(zend_function));
 			return;
 		} else if (existing_fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 			/* Make sure the trait method is compatible with previosly declared abstract method */
@@ -4049,12 +4100,12 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, const
 			/* two traits can't define the same non-abstract method */
 #if 1
 			zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s has not been applied, because there are collisions with other trait methods on %s",
-				name, ce->name);
+				name, ce->name->val);
 #else		/* TODO: better error message */
 			zend_error_noreturn(E_COMPILE_ERROR, "Trait method %s::%s has not been applied as %s::%s, because of collision with %s::%s",
-				fn->common.scope->name, fn->common.function_name,
-				ce->name, name,
-				existing_fn->common.scope->name, existing_fn->common.function_name);
+				fn->common.scope->name->val, fn->common.function_name->val,
+				ce->name->val, name,
+				existing_fn->common.scope->name->val, existing_fn->common.function_name->val);
 #endif
 		} else {
 			/* inherited members are overridden by members inserted by traits */
@@ -4064,13 +4115,15 @@ static void zend_add_trait_method(zend_class_entry *ce, const char *name, const
 	}
 
 	function_add_ref(fn);
-	zend_hash_quick_update(&ce->function_table, arKey, nKeyLength, h, fn, sizeof(zend_function), (void**)&fn);
-	zend_add_magic_methods(ce, arKey, nKeyLength, fn TSRMLS_CC);
+	fn = zend_hash_update_mem(&ce->function_table, key, fn, sizeof(zend_function));
+	zend_add_magic_methods(ce, key, fn TSRMLS_CC);
 }
 /* }}} */
 
-static int zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce TSRMLS_DC) /* {{{ */
+static int zend_fixup_trait_method(zval *zv, zend_class_entry *ce TSRMLS_DC) /* {{{ */
 {
+	zend_function *fn = Z_PTR_P(zv);
+		
 	if ((fn->common.scope->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 
 		fn->common.scope = ce;
@@ -4086,22 +4139,22 @@ static int zend_fixup_trait_method(zend_function *fn, zend_class_entry *ce TSRML
 }
 /* }}} */
 
-static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int zend_traits_copy_functions(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
+	zend_function     *fn = Z_PTR_P(zv);
 	zend_class_entry  *ce;
 	HashTable         **overriden;
 	zend_trait_alias  *alias, **alias_ptr;
 	HashTable         *exclude_table;
-	char              *lcname;
+	zend_string       *lcname;
 	unsigned int       fnname_len;
 	zend_function      fn_copy;
-	void              *dummy;
 
 	ce            = va_arg(args, zend_class_entry*);
 	overriden     = va_arg(args, HashTable**);
 	exclude_table = va_arg(args, HashTable*);
 
-	fnname_len = hash_key->nKeyLength - 1;
+	fnname_len = hash_key->key->len;
 
 	/* apply aliases which are qualified with a class name, there should not be any ambiguity */
 	if (ce->trait_aliases) {
@@ -4111,8 +4164,8 @@ static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args,
 			/* Scope unset or equal to the function we compare to, and the alias applies to fn */
 			if (alias->alias != NULL
 				&& (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
-				&& alias->trait_method->mname_len == fnname_len
-				&& (zend_binary_strcasecmp(alias->trait_method->method_name, alias->trait_method->mname_len, hash_key->arKey, fnname_len) == 0)) {
+				&& alias->trait_method->method_name->len == fnname_len
+				&& (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, hash_key->key->val, fnname_len) == 0)) {
 				fn_copy = *fn;
 
 				/* if it is 0, no modifieres has been changed */
@@ -4120,9 +4173,10 @@ static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args,
 					fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
 				}
 
-				lcname = zend_str_tolower_dup(alias->alias, alias->alias_len);
-				zend_add_trait_method(ce, alias->alias, lcname, alias->alias_len+1, &fn_copy, overriden TSRMLS_CC);
-				efree(lcname);
+				lcname = STR_ALLOC(alias->alias->len, 0);
+				zend_str_tolower_copy(lcname->val, alias->alias->val, alias->alias->len);
+				zend_add_trait_method(ce, alias->alias->val, lcname, &fn_copy, overriden TSRMLS_CC);
+				STR_RELEASE(lcname);
 
 				/* Record the trait from which this alias was resolved. */
 				if (!alias->trait_method->ce) {
@@ -4134,9 +4188,9 @@ static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args,
 		}
 	}
 
-	lcname = (char *) hash_key->arKey;
+	lcname = hash_key->key;
 
-	if (exclude_table == NULL || zend_hash_find(exclude_table, lcname, fnname_len, &dummy) == FAILURE) {
+	if (exclude_table == NULL || zend_hash_find(exclude_table, lcname) == NULL) {
 		/* is not in hashtable, thus, function is not to be excluded */
 		fn_copy = *fn;
 
@@ -4148,8 +4202,8 @@ static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args,
 				/* Scope unset or equal to the function we compare to, and the alias applies to fn */
 				if (alias->alias == NULL && alias->modifiers != 0
 					&& (!alias->trait_method->ce || fn->common.scope == alias->trait_method->ce)
-					&& (alias->trait_method->mname_len == fnname_len)
-					&& (zend_binary_strcasecmp(alias->trait_method->method_name, alias->trait_method->mname_len, lcname, fnname_len) == 0)) {
+					&& (alias->trait_method->method_name->len == fnname_len)
+					&& (zend_binary_strcasecmp(alias->trait_method->method_name->val, alias->trait_method->method_name->len, lcname->val, fnname_len) == 0)) {
 
 					fn_copy.common.fn_flags = alias->modifiers | (fn->common.fn_flags ^ (fn->common.fn_flags & ZEND_ACC_PPP_MASK));
 
@@ -4163,7 +4217,7 @@ static int zend_traits_copy_functions(zend_function *fn TSRMLS_DC, int num_args,
 			}
 		}
 
-		zend_add_trait_method(ce, fn->common.function_name, lcname, fnname_len+1, &fn_copy, overriden TSRMLS_CC);
+		zend_add_trait_method(ce, fn->common.function_name->val, lcname, &fn_copy, overriden TSRMLS_CC);
 	}
 
 	return ZEND_HASH_APPLY_KEEP;
@@ -4175,7 +4229,7 @@ static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait
 	zend_uint i;
 
 	if ((trait->ce_flags & ZEND_ACC_TRAIT) != ZEND_ACC_TRAIT) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name);
+		zend_error_noreturn(E_COMPILE_ERROR, "Class %s is not a trait, Only traits may be used in 'as' and 'insteadof' statements", trait->name->val);
 	}
 
 	for (i = 0; i < ce->num_traits; i++) {
@@ -4183,7 +4237,7 @@ static void zend_check_trait_usage(zend_class_entry *ce, zend_class_entry *trait
 			return;
 		}
 	}
-	zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name, ce->name);
+	zend_error_noreturn(E_COMPILE_ERROR, "Required Trait %s wasn't added to %s", trait->name->val, ce->name->val);
 }
 /* }}} */
 
@@ -4192,7 +4246,7 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /*
 	size_t i, j = 0;
 	zend_trait_precedence *cur_precedence;
 	zend_trait_method_reference *cur_method_ref;
-	char *lcname;
+	zend_string *lcname;
 	zend_bool method_exists;
 
 	/* resolve class references */
@@ -4202,24 +4256,25 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /*
 			/** Resolve classes for all precedence operations. */
 			if (cur_precedence->exclude_from_classes) {
 				cur_method_ref = cur_precedence->trait_method;
-				if (!(cur_precedence->trait_method->ce = zend_fetch_class(cur_method_ref->class_name, cur_method_ref->cname_len,
+				if (!(cur_precedence->trait_method->ce = zend_fetch_class(cur_method_ref->class_name,
 								ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
 					zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name);
 				}
 				zend_check_trait_usage(ce, cur_precedence->trait_method->ce TSRMLS_CC);
 
 				/** Ensure that the prefered method is actually available. */
-				lcname = zend_str_tolower_dup(cur_method_ref->method_name,
-											  cur_method_ref->mname_len);
+				lcname = STR_ALLOC(cur_method_ref->method_name->len, 0);
+				zend_str_tolower_copy(lcname->val, 
+					cur_method_ref->method_name->val,
+					cur_method_ref->method_name->len);
 				method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
-												 lcname,
-												 cur_method_ref->mname_len + 1);
-				efree(lcname);
+												 lcname);
+				STR_FREE(lcname);
 				if (!method_exists) {
 					zend_error_noreturn(E_COMPILE_ERROR,
 							   "A precedence rule was defined for %s::%s but this method does not exist",
-							   cur_method_ref->ce->name,
-							   cur_method_ref->method_name);
+							   cur_method_ref->ce->name->val,
+							   cur_method_ref->method_name->val);
 				}
 
 				/** With the other traits, we are more permissive.
@@ -4229,27 +4284,26 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /*
 					is consistent in itself.
 				 */
 				j = 0;
-				while (cur_precedence->exclude_from_classes[j]) {
-					char* class_name = (char*)cur_precedence->exclude_from_classes[j];
-					zend_uint name_length = strlen(class_name);
+				while (cur_precedence->exclude_from_classes[j].class_name) {
+					zend_string* class_name = cur_precedence->exclude_from_classes[j].class_name;
 
-					if (!(cur_precedence->exclude_from_classes[j] = zend_fetch_class(class_name, name_length, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
-						zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", class_name);
+					if (!(cur_precedence->exclude_from_classes[j].ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_TRAIT |ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
+						zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", class_name->val);
 					}
-					zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j] TSRMLS_CC);
+					zend_check_trait_usage(ce, cur_precedence->exclude_from_classes[j].ce TSRMLS_CC);
 
 					/* make sure that the trait method is not from a class mentioned in
 					 exclude_from_classes, for consistency */
-					if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[i]) {
+					if (cur_precedence->trait_method->ce == cur_precedence->exclude_from_classes[i].ce) {
 						zend_error_noreturn(E_COMPILE_ERROR,
 								   "Inconsistent insteadof definition. "
 								   "The method %s is to be used from %s, but %s is also on the exclude list",
-								   cur_method_ref->method_name,
-								   cur_precedence->trait_method->ce->name,
-								   cur_precedence->trait_method->ce->name);
+								   cur_method_ref->method_name->val,
+								   cur_precedence->trait_method->ce->name->val,
+								   cur_precedence->trait_method->ce->name->val);
 					}
 
-					efree(class_name);
+					STR_RELEASE(class_name);
 					j++;
 				}
 			}
@@ -4263,20 +4317,22 @@ static void zend_traits_init_trait_structures(zend_class_entry *ce TSRMLS_DC) /*
 			/** For all aliases with an explicit class name, resolve the class now. */
 			if (ce->trait_aliases[i]->trait_method->class_name) {
 				cur_method_ref = ce->trait_aliases[i]->trait_method;
-				if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, cur_method_ref->cname_len, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
-					zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name);
+				if (!(cur_method_ref->ce = zend_fetch_class(cur_method_ref->class_name, ZEND_FETCH_CLASS_TRAIT|ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC))) {
+					zend_error_noreturn(E_COMPILE_ERROR, "Could not find trait %s", cur_method_ref->class_name->val);
 				}
 				zend_check_trait_usage(ce, cur_method_ref->ce TSRMLS_CC);
 
 				/** And, ensure that the referenced method is resolvable, too. */
-				lcname = zend_str_tolower_dup(cur_method_ref->method_name,
-						cur_method_ref->mname_len);
+				lcname = STR_ALLOC(cur_method_ref->method_name->len, 0);
+				zend_str_tolower_copy(lcname->val,
+					cur_method_ref->method_name->val,
+					cur_method_ref->method_name->len);
 				method_exists = zend_hash_exists(&cur_method_ref->ce->function_table,
-						lcname, cur_method_ref->mname_len + 1);
-				efree(lcname);
+						lcname);
+				STR_FREE(lcname);
 
 				if (!method_exists) {
-					zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name, cur_method_ref->method_name);
+					zend_error_noreturn(E_COMPILE_ERROR, "An alias was defined for %s::%s but this method does not exist", cur_method_ref->ce->name->val, cur_method_ref->method_name->val);
 				}
 			}
 			i++;
@@ -4295,16 +4351,18 @@ static void zend_traits_compile_exclude_table(HashTable* exclude_table, zend_tra
 	while (precedences[i]) {
 		if (precedences[i]->exclude_from_classes) {
 			j = 0;
-			while (precedences[i]->exclude_from_classes[j]) {
-				if (precedences[i]->exclude_from_classes[j] == trait) {
-					zend_uint lcname_len = precedences[i]->trait_method->mname_len;
-					char *lcname = zend_str_tolower_dup(precedences[i]->trait_method->method_name, lcname_len);
-
-					if (zend_hash_add(exclude_table, lcname, lcname_len, NULL, 0, NULL) == FAILURE) {
-						efree(lcname);
-						zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name, trait->name);
+			while (precedences[i]->exclude_from_classes[j].ce) {
+				if (precedences[i]->exclude_from_classes[j].ce == trait) {
+					zend_string *lcname = STR_ALLOC(precedences[i]->trait_method->method_name->len, 0);
+										
+					zend_str_tolower_copy(lcname->val,
+						precedences[i]->trait_method->method_name->val,
+						precedences[i]->trait_method->method_name->len);
+					if (zend_hash_add_empty_element(exclude_table, lcname) == NULL) {
+						STR_RELEASE(lcname);
+						zend_error_noreturn(E_COMPILE_ERROR, "Failed to evaluate a trait precedence (%s). Method of trait %s was defined to be excluded multiple times", precedences[i]->trait_method->method_name->val, trait->name->val);
 					}
-					efree(lcname);
+					STR_RELEASE(lcname);
 				}
 				++j;
 			}
@@ -4324,7 +4382,7 @@ static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{
 			HashTable exclude_table;
 
 			/* TODO: revisit this start size, may be its not optimal */
-			zend_hash_init_ex(&exclude_table, 2, NULL, NULL, 0, 0);
+			zend_hash_init_ex(&exclude_table, 8, NULL, NULL, 0, 0);
 
 			zend_traits_compile_exclude_table(&exclude_table, ce->trait_precedences, ce->traits[i]);
 
@@ -4346,13 +4404,13 @@ static void zend_do_traits_method_binding(zend_class_entry *ce TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, const char* prop_name, int prop_name_length, ulong prop_hash, zend_class_entry *coliding_ce) /* {{{ */
+static zend_class_entry* find_first_definition(zend_class_entry *ce, size_t current_trait, zend_string *prop_name, zend_class_entry *coliding_ce) /* {{{ */
 {
 	size_t i;
 
 	if (coliding_ce == ce) {
 		for (i = 0; i < current_trait; i++) {
-			if (zend_hash_quick_exists(&ce->traits[i]->properties_info, prop_name, prop_name_length+1, prop_hash)) {
+			if (zend_hash_exists(&ce->traits[i]->properties_info, prop_name)) {
 				return ce->traits[i];
 			}
 		}
@@ -4368,14 +4426,12 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {
 	zend_property_info *property_info;
 	zend_property_info *coliding_prop;
 	zval compare_result;
-	const char* prop_name;
-	int   prop_name_length;
-	ulong prop_hash;
+	zend_string* prop_name;
 	const char* class_name_unused;
 	zend_bool not_compatible;
 	zval* prop_value;
-	char* doc_comment;
 	zend_uint flags;
+	zend_string *doc_comment;
 
 	/* In the following steps the properties are inserted into the property table
 	 * for that, a very strict approach is applied:
@@ -4383,28 +4439,27 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {
 	 * - if compatible, then strict notice
 	 */
 	for (i = 0; i < ce->num_traits; i++) {
-		for (zend_hash_internal_pointer_reset(&ce->traits[i]->properties_info);
-			 zend_hash_get_current_data(&ce->traits[i]->properties_info, (void *) &property_info) == SUCCESS;
-			 zend_hash_move_forward(&ce->traits[i]->properties_info)) {
+		ZEND_HASH_FOREACH_PTR(&ce->traits[i]->properties_info, property_info) {
 			/* first get the unmangeld name if necessary,
 			 * then check whether the property is already there
 			 */
 			flags = property_info->flags;
 			if ((flags & ZEND_ACC_PPP_MASK) == ZEND_ACC_PUBLIC) {
-				prop_hash = property_info->h;
-				prop_name = property_info->name;
-				prop_name_length = property_info->name_length;
+				prop_name = STR_COPY(property_info->name);
 			} else {
+				const char *pname;
+				int pname_len;
+
 				/* for private and protected we need to unmangle the names */
-				zend_unmangle_property_name_ex(property_info->name, property_info->name_length,
-											&class_name_unused, &prop_name, &prop_name_length);
-				prop_hash = zend_get_hash_value(prop_name, prop_name_length + 1);
+				zend_unmangle_property_name_ex(property_info->name->val, property_info->name->len,
+											&class_name_unused, &pname, &pname_len);
+				prop_name = STR_INIT(pname, pname_len, 0);
 			}
 
 			/* next: check for conflicts with current class */
-			if (zend_hash_quick_find(&ce->properties_info, prop_name, prop_name_length+1, prop_hash, (void **) &coliding_prop) == SUCCESS) {
+			if ((coliding_prop = zend_hash_find_ptr(&ce->properties_info, prop_name)) != NULL) {
 				if (coliding_prop->flags & ZEND_ACC_SHADOW) {
-					zend_hash_quick_del(&ce->properties_info, prop_name, prop_name_length+1, prop_hash);
+					zend_hash_del(&ce->properties_info, prop_name);
 					flags |= ZEND_ACC_CHANGED;
 				} else {
 					if ((coliding_prop->flags & (ZEND_ACC_PPP_MASK | ZEND_ACC_STATIC))
@@ -4412,13 +4467,13 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {
 						/* flags are identical, now the value needs to be checked */
 						if (flags & ZEND_ACC_STATIC) {
 							not_compatible = (FAILURE == compare_function(&compare_result,
-											  ce->default_static_members_table[coliding_prop->offset],
-											  ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
+											  &ce->default_static_members_table[coliding_prop->offset],
+											  &ce->traits[i]->default_static_members_table[property_info->offset] TSRMLS_CC))
 								  || (Z_LVAL(compare_result) != 0);
 						} else {
 							not_compatible = (FAILURE == compare_function(&compare_result,
-											  ce->default_properties_table[coliding_prop->offset],
-											  ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
+											  &ce->default_properties_table[coliding_prop->offset],
+											  &ce->traits[i]->default_properties_table[property_info->offset] TSRMLS_CC))
 								  || (Z_LVAL(compare_result) != 0);
 						}
 					} else {
@@ -4429,17 +4484,18 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {
 					if (not_compatible) {
 						zend_error_noreturn(E_COMPILE_ERROR,
 							   "%s and %s define the same property ($%s) in the composition of %s. However, the definition differs and is considered incompatible. Class was composed",
-								find_first_definition(ce, i, prop_name, prop_name_length, prop_hash, coliding_prop->ce)->name,
-								property_info->ce->name,
-								prop_name,
-								ce->name);
+								find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
+								property_info->ce->name->val,
+								prop_name->val,
+								ce->name->val);
 					} else {
 						zend_error(E_STRICT,
 							   "%s and %s define the same property ($%s) in the composition of %s. This might be incompatible, to improve maintainability consider using accessor methods in traits instead. Class was composed",
-								find_first_definition(ce, i, prop_name, prop_name_length, prop_hash, coliding_prop->ce)->name,
-								property_info->ce->name,
-								prop_name,
-								ce->name);
+								find_first_definition(ce, i, prop_name, coliding_prop->ce)->name->val,
+								property_info->ce->name->val,
+								prop_name->val,
+								ce->name->val);
+						STR_RELEASE(prop_name);
 						continue;
 					}
 				}
@@ -4447,17 +4503,18 @@ static void zend_do_traits_property_binding(zend_class_entry *ce TSRMLS_DC) /* {
 
 			/* property not found, so lets add it */
 			if (flags & ZEND_ACC_STATIC) {
-				prop_value = ce->traits[i]->default_static_members_table[property_info->offset];
+				prop_value = &ce->traits[i]->default_static_members_table[property_info->offset];
 			} else {
-				prop_value = ce->traits[i]->default_properties_table[property_info->offset];
+				prop_value = &ce->traits[i]->default_properties_table[property_info->offset];
 			}
-			Z_ADDREF_P(prop_value);
+			if (Z_REFCOUNTED_P(prop_value)) Z_ADDREF_P(prop_value);
 
-			doc_comment = property_info->doc_comment ? estrndup(property_info->doc_comment, property_info->doc_comment_len) : NULL;
-			zend_declare_property_ex(ce, prop_name, prop_name_length,
+			doc_comment = property_info->doc_comment ? STR_COPY(property_info->doc_comment) : NULL;
+			zend_declare_property_ex(ce, prop_name,
 									 prop_value, flags,
-								     doc_comment, property_info->doc_comment_len TSRMLS_CC);
-		}
+								     doc_comment TSRMLS_CC);
+			STR_RELEASE(prop_name);
+		} ZEND_HASH_FOREACH_END();
 	}
 }
 /* }}} */
@@ -4466,7 +4523,7 @@ static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce
 {
 	int i = 0;
 	zend_trait_alias* cur_alias;
-	char* lc_method_name;
+	zend_string* lc_method_name;
 
 	if (ce->trait_aliases) {
 		while (ce->trait_aliases[i]) {
@@ -4478,8 +4535,8 @@ static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce
 					/** Plain old inconsistency/typo/bug */
 					zend_error_noreturn(E_COMPILE_ERROR,
 							   "An alias (%s) was defined for method %s(), but this method does not exist",
-							   cur_alias->alias,
-							   cur_alias->trait_method->method_name);
+							   cur_alias->alias->val,
+							   cur_alias->trait_method->method_name->val);
 				} else {
 					/** Here are two possible cases:
 						1) this is an attempt to modifiy the visibility
@@ -4489,20 +4546,22 @@ static void zend_do_check_for_inconsistent_traits_aliasing(zend_class_entry *ce
 						2) it is just a plain old inconsitency/typo/bug
 						   as in the case where alias is set. */
 
-					lc_method_name = zend_str_tolower_dup(cur_alias->trait_method->method_name,
-														  cur_alias->trait_method->mname_len);
+					lc_method_name = STR_ALLOC(cur_alias->trait_method->method_name->len, 0);
+					zend_str_tolower_copy(
+						lc_method_name->val,
+						cur_alias->trait_method->method_name->val,
+						cur_alias->trait_method->method_name->len);
 					if (zend_hash_exists(&ce->function_table,
-										 lc_method_name,
-										 cur_alias->trait_method->mname_len+1)) {
-						efree(lc_method_name);
+										 lc_method_name)) {
+						STR_FREE(lc_method_name);
 						zend_error_noreturn(E_COMPILE_ERROR,
 								   "The modifiers for the trait alias %s() need to be changed in the same statment in which the alias is defined. Error",
-								   cur_alias->trait_method->method_name);
+								   cur_alias->trait_method->method_name->val);
 					} else {
-						efree(lc_method_name);
+						STR_FREE(lc_method_name);
 						zend_error_noreturn(E_COMPILE_ERROR,
 								   "The modifiers of the trait method %s() are changed, but this method does not exist. Error",
-								   cur_alias->trait_method->method_name);
+								   cur_alias->trait_method->method_name->val);
 
 					}
 				}
@@ -4544,7 +4603,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) {
@@ -4555,20 +4614,23 @@ ZEND_API int do_bind_function(const zend_op_array *op_array, zend_op *opline, Ha
 		op2 = opline->op2.zv;
 	}
 
-	zend_hash_quick_find(function_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void *) &function);
-	if (zend_hash_quick_add(function_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), function, sizeof(zend_function), NULL)==FAILURE) {
+	function = zend_hash_find_ptr(function_table, Z_STR_P(op1));
+	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;
 
-		if (zend_hash_quick_find(function_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), (void *) &old_function)==SUCCESS
+		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) {
 			zend_error(error_level, "Cannot redeclare %s() (previously declared in %s:%d)",
-						function->common.function_name,
-						old_function->op_array.filename,
+						function->common.function_name->val,
+						old_function->op_array.filename->val,
 						old_function->op_array.opcodes[0].lineno);
 		} else {
-			zend_error(error_level, "Cannot redeclare %s()", function->common.function_name);
+			zend_error(error_level, "Cannot redeclare %s()", function->common.function_name->val);
 		}
 		return FAILURE;
 	} else {
@@ -4588,15 +4650,12 @@ void zend_prepare_reference(znode *result, znode *class_name, znode *method_name
 	   zend_do_begin_class_declaration is also just using that string */
 	if (class_name) {
 		zend_resolve_class_name(class_name TSRMLS_CC);
-		method_ref->class_name = Z_STRVAL(class_name->u.constant);
-		method_ref->cname_len  = Z_STRLEN(class_name->u.constant);
+		method_ref->class_name = Z_STR(class_name->u.constant);
 	} else {
 		method_ref->class_name = NULL;
-		method_ref->cname_len  = 0;
 	}
 
-	method_ref->method_name = Z_STRVAL(method_name->u.constant);
-	method_ref->mname_len   = Z_STRLEN(method_name->u.constant);
+	method_ref->method_name = Z_STR(method_name->u.constant);
 
 	result->u.op.ptr = method_ref;
 	result->op_type = IS_TMP_VAR;
@@ -4623,8 +4682,7 @@ void zend_add_trait_alias(znode *method_reference, znode *modifiers, znode *alia
 	trait_alias->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
 	trait_alias->modifiers = Z_LVAL(modifiers->u.constant);
 	if (alias) {
-		trait_alias->alias = Z_STRVAL(alias->u.constant);
-		trait_alias->alias_len = Z_STRLEN(alias->u.constant);
+		trait_alias->alias = Z_STR(alias->u.constant);
 	} else {
 		trait_alias->alias = NULL;
 	}
@@ -4638,7 +4696,7 @@ void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS
 	zend_trait_precedence *trait_precedence = emalloc(sizeof(zend_trait_precedence));
 
 	trait_precedence->trait_method = (zend_trait_method_reference*)method_reference->u.op.ptr;
-	trait_precedence->exclude_from_classes = (zend_class_entry**) trait_list->u.op.ptr;
+	trait_precedence->exclude_from_classes = trait_list->u.op.ptr;
 
 	zend_add_to_list(&ce->trait_precedences, trait_precedence TSRMLS_CC);
 }
@@ -4646,7 +4704,7 @@ void zend_add_trait_precedence(znode *method_reference, znode *trait_list TSRMLS
 
 ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry *ce, **pce;
+	zend_class_entry *ce;
 	zval *op1, *op2;
 
 	if (compile_time) {
@@ -4656,14 +4714,12 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
 		op1 = opline->op1.zv;
 		op2 = opline->op2.zv;
 	}
-	if (zend_hash_quick_find(class_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void **) &pce)==FAILURE) {
+	if ((ce = zend_hash_find_ptr(class_table, Z_STR_P(op1))) == NULL) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Internal Zend error - Missing class information for %s", Z_STRVAL_P(op1));
 		return NULL;
-	} else {
-		ce = *pce;
 	}
 	ce->refcount++;
-	if (zend_hash_quick_add(class_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), &ce, sizeof(zend_class_entry *), NULL)==FAILURE) {
+	if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
 		ce->refcount--;
 		if (!compile_time) {
 			/* If we're in compile time, in practice, it's quite possible
@@ -4671,7 +4727,7 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
 			 * so we shut up about it.  This allows the if (!defined('FOO')) { return; }
 			 * approach to work.
 			 */
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
 		}
 		return NULL;
 	} else {
@@ -4685,8 +4741,7 @@ ZEND_API zend_class_entry *do_bind_class(const zend_op_array* op_array, const ze
 
 ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_class_entry *parent_ce, zend_bool compile_time TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry *ce, **pce;
-	int found_ce;
+	zend_class_entry *ce;
 	zval *op1, *op2;
 
 	if (compile_time) {
@@ -4697,9 +4752,9 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
 		op2 = opline->op2.zv;
 	}
 
-	found_ce = zend_hash_quick_find(class_table, Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_HASH_P(op1), (void **) &pce);
+	ce = zend_hash_find_ptr(class_table, Z_STR_P(op1));
 
-	if (found_ce == FAILURE) {
+	if (!ce) {
 		if (!compile_time) {
 			/* If we're in compile time, in practice, it's quite possible
 			 * that we'll never reach this class declaration at runtime,
@@ -4709,14 +4764,12 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", Z_STRVAL_P(op2));
 		}
 		return NULL;
-	} else {
-		ce = *pce;
 	}
 
 	if (parent_ce->ce_flags & ZEND_ACC_INTERFACE) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name, parent_ce->name);
+		zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from interface %s", ce->name->val, parent_ce->name->val);
 	} else if ((parent_ce->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name, parent_ce->name);
+		zend_error_noreturn(E_COMPILE_ERROR, "Class %s cannot extend from trait %s", ce->name->val, parent_ce->name->val);
 	}
 
 	zend_do_inheritance(ce, parent_ce TSRMLS_CC);
@@ -4724,8 +4777,8 @@ ZEND_API zend_class_entry *do_bind_inherited_class(const zend_op_array *op_array
 	ce->refcount++;
 
 	/* Register the derived class */
-	if (zend_hash_quick_add(class_table, Z_STRVAL_P(op2), Z_STRLEN_P(op2)+1, Z_HASH_P(op2), pce, sizeof(zend_class_entry *), NULL)==FAILURE) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name);
+	if (zend_hash_add_ptr(class_table, Z_STR_P(op2), ce) == NULL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare class %s", ce->name->val);
 	}
 	return ce;
 }
@@ -4757,12 +4810,12 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 			{
 				zend_op *fetch_class_opline = opline-1;
 				zval *parent_name;
-				zend_class_entry **pce;
+				zend_class_entry *ce;
 
 				parent_name = &CONSTANT(fetch_class_opline->op2.constant);
-				if ((zend_lookup_class(Z_STRVAL_P(parent_name), Z_STRLEN_P(parent_name), &pce TSRMLS_CC) == FAILURE) ||
+				if (((ce = zend_lookup_class(Z_STR_P(parent_name) TSRMLS_CC)) == NULL) ||
 				    ((CG(compiler_options) & ZEND_COMPILE_IGNORE_INTERNAL_CLASSES) &&
-				     ((*pce)->type == ZEND_INTERNAL_CLASS))) {
+				     (ce->type == ZEND_INTERNAL_CLASS))) {
 				    if (CG(compiler_options) & ZEND_COMPILE_DELAYED_BINDING) {
 						zend_uint *opline_num = &CG(active_op_array)->early_binding;
 
@@ -4776,7 +4829,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 					}
 					return;
 				}
-				if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), *pce, 1 TSRMLS_CC) == NULL) {
+				if (do_bind_inherited_class(CG(active_op_array), opline, CG(class_table), ce, 1 TSRMLS_CC) == NULL) {
 					return;
 				}
 				/* clear unnecessary ZEND_FETCH_CLASS opcode */
@@ -4798,7 +4851,7 @@ void zend_do_early_binding(TSRMLS_D) /* {{{ */
 			return;
 	}
 
-	zend_hash_quick_del(table, Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)), Z_HASH_P(&CONSTANT(opline->op1.constant)));
+	zend_hash_del(table, Z_STR(CONSTANT(opline->op1.constant)));
 	zend_del_literal(CG(active_op_array), opline->op1.constant);
 	zend_del_literal(CG(active_op_array), opline->op2.constant);
 	MAKE_NOP(opline);
@@ -4810,12 +4863,12 @@ ZEND_API void zend_do_delayed_early_binding(const zend_op_array *op_array TSRMLS
 	if (op_array->early_binding != -1) {
 		zend_bool orig_in_compilation = CG(in_compilation);
 		zend_uint opline_num = op_array->early_binding;
-		zend_class_entry **pce;
+		zend_class_entry *ce;
 
 		CG(in_compilation) = 1;
 		while (opline_num != -1) {
-			if (zend_lookup_class(Z_STRVAL_P(op_array->opcodes[opline_num-1].op2.zv), Z_STRLEN_P(op_array->opcodes[opline_num-1].op2.zv), &pce TSRMLS_CC) == SUCCESS) {
-				do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), *pce, 0 TSRMLS_CC);
+			if ((ce = zend_lookup_class(Z_STR_P(op_array->opcodes[opline_num-1].op2.zv) TSRMLS_CC)) != NULL) {
+				do_bind_inherited_class(op_array, &op_array->opcodes[opline_num], EG(class_table), ce, 0 TSRMLS_CC);
 			}
 			opline_num = op_array->opcodes[opline_num].result.opline_num;
 		}
@@ -4845,7 +4898,7 @@ void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_boolean_or_end(znode *result, const znode *expr1, const znode *expr2, znode *op_token TSRMLS_DC) /* {{{ */
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -4880,7 +4933,7 @@ void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC) /* {{{ *
 }
 /* }}} */
 
-void zend_do_boolean_and_end(znode *result, const znode *expr1, const znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -4901,7 +4954,7 @@ void zend_do_do_while_begin(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, const znode *expr TSRMLS_DC) /* {{{ */
+void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -4916,7 +4969,7 @@ void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket,
 }
 /* }}} */
 
-void zend_do_brk_cont(zend_uchar op, const znode *expr TSRMLS_DC) /* {{{ */
+void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -4995,7 +5048,7 @@ void zend_do_switch_end(const znode *case_list TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_case_before_statement(const znode *case_list, znode *case_token, const znode *case_expr TSRMLS_DC) /* {{{ */
+void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	int next_op_number;
@@ -5081,46 +5134,47 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
 	zend_op *opline;
 	int doing_inheritance = 0;
 	zend_class_entry *new_class_entry;
-	char *lcname;
+	zend_string *lcname;
 	int error = 0;
-	zval **ns_name, key;
+	zval *ns_name, key;
 
 	if (CG(active_class_entry)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Class declarations may not be nested");
 		return;
 	}
 
-	lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+	lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0);
+	zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 
-	if (!(strcmp(lcname, "self") && strcmp(lcname, "parent"))) {
-		efree(lcname);
+	if (!(strcmp(lcname->val, "self") && strcmp(lcname->val, "parent"))) {
+		STR_FREE(lcname);
 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as class name as it is reserved", Z_STRVAL(class_name->u.constant));
 	}
 
 	/* Class name must not conflict with import names */
 	if (CG(current_import) &&
-	    zend_hash_find(CG(current_import), lcname, Z_STRLEN(class_name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
+	    (ns_name = zend_hash_find(CG(current_import), lcname)) != NULL) {
 		error = 1;
 	}
 
-	if (CG(current_namespace)) {
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 		/* Prefix class name with name of current namespace */
 		znode tmp;
 
 		tmp.op_type = IS_CONST;
-		tmp.u.constant = *CG(current_namespace);
-		zval_copy_ctor(&tmp.u.constant);
+		ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 		zend_do_build_namespace_name(&tmp, &tmp, class_name TSRMLS_CC);
 		*class_name = tmp;
-		efree(lcname);
-		lcname = zend_str_tolower_dup(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
+		STR_FREE(lcname);
+		lcname = STR_ALLOC(Z_STRLEN(class_name->u.constant), 0);
+		zend_str_tolower_copy(lcname->val, Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant));
 	}
 
 	if (error) {
-		char *tmp = zend_str_tolower_dup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name));
+		char *tmp = zend_str_tolower_dup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
 
-		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(class_name->u.constant) ||
-			memcmp(tmp, lcname, Z_STRLEN(class_name->u.constant))) {
+		if (Z_STRLEN_P(ns_name) != Z_STRLEN(class_name->u.constant) ||
+			memcmp(tmp, lcname->val, Z_STRLEN(class_name->u.constant))) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare class %s because the name is already in use", Z_STRVAL(class_name->u.constant));
 		}
 		efree(tmp);
@@ -5128,8 +5182,7 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
 
 	new_class_entry = emalloc(sizeof(zend_class_entry));
 	new_class_entry->type = ZEND_USER_CLASS;
-	new_class_entry->name = zend_new_interned_string(Z_STRVAL(class_name->u.constant), Z_STRLEN(class_name->u.constant) + 1, 1 TSRMLS_CC);
-	new_class_entry->name_length = Z_STRLEN(class_name->u.constant);
+	new_class_entry->name = zend_new_interned_string(Z_STR(class_name->u.constant) TSRMLS_CC);
 
 	zend_initialize_class_data(new_class_entry, 1 TSRMLS_CC);
 	new_class_entry->info.user.filename = zend_get_compiled_filename(TSRMLS_C);
@@ -5155,16 +5208,15 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
 
 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->op1_type = IS_CONST;
-	build_runtime_defined_function_key(&key, lcname, new_class_entry->name_length TSRMLS_CC);
+	build_runtime_defined_function_key(&key, lcname->val, lcname->len TSRMLS_CC);
 	opline->op1.constant = zend_add_literal(CG(active_op_array), &key TSRMLS_CC);
-	Z_HASH_P(&CONSTANT(opline->op1.constant)) = zend_hash_func(Z_STRVAL(CONSTANT(opline->op1.constant)), Z_STRLEN(CONSTANT(opline->op1.constant)));
 
 	opline->op2_type = IS_CONST;
 
 	if (doing_inheritance) {
 		/* Make sure a trait does not try to extend a class */
 		if ((new_class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-			zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the 'use' keyword. Error", new_class_entry->name);
+			zend_error_noreturn(E_COMPILE_ERROR, "A trait (%s) cannot extend a class. Traits can only be composed from other traits with the 'use' keyword. Error", new_class_entry->name->val);
 		}
 
 		opline->extended_value = parent_class_name->u.op.var;
@@ -5173,10 +5225,9 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
 		opline->opcode = ZEND_DECLARE_CLASS;
 	}
 
-	LITERAL_STRINGL(opline->op2, lcname, new_class_entry->name_length, 0);
-	CALCULATE_LITERAL_HASH(opline->op2.constant);
+	LITERAL_STR(opline->op2, lcname);
 
-	zend_hash_quick_update(CG(class_table), Z_STRVAL(key), Z_STRLEN(key), Z_HASH_P(&CONSTANT(opline->op1.constant)), &new_class_entry, sizeof(zend_class_entry *), NULL);
+	zend_hash_update_ptr(CG(class_table), Z_STR(key), new_class_entry);
 	CG(active_class_entry) = new_class_entry;
 
 	opline->result.var = get_temporary_variable(CG(active_op_array));
@@ -5185,9 +5236,7 @@ void zend_do_begin_class_declaration(const znode *class_token, znode *class_name
 
 	if (CG(doc_comment)) {
 		CG(active_class_entry)->info.user.doc_comment = CG(doc_comment);
-		CG(active_class_entry)->info.user.doc_comment_len = CG(doc_comment_len);
 		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
 	}
 }
 /* }}} */
@@ -5209,19 +5258,19 @@ void zend_do_end_class_declaration(const znode *class_token, const znode *parent
 	if (ce->constructor) {
 		ce->constructor->common.fn_flags |= ZEND_ACC_CTOR;
 		if (ce->constructor->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name, ce->constructor->common.function_name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Constructor %s::%s() cannot be static", ce->name->val, ce->constructor->common.function_name->val);
 		}
 	}
 	if (ce->destructor) {
 		ce->destructor->common.fn_flags |= ZEND_ACC_DTOR;
 		if (ce->destructor->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name, ce->destructor->common.function_name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Destructor %s::%s() cannot be static", ce->name->val, ce->destructor->common.function_name->val);
 		}
 	}
 	if (ce->clone) {
 		ce->clone->common.fn_flags |= ZEND_ACC_CLONE;
 		if (ce->clone->common.fn_flags & ZEND_ACC_STATIC) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name, ce->clone->common.function_name);
+			zend_error_noreturn(E_COMPILE_ERROR, "Clone method %s::%s() cannot be static", ce->name->val, ce->clone->common.function_name->val);
 		}
 	}
 
@@ -5272,7 +5321,7 @@ void zend_do_implements_interface(znode *interface_name TSRMLS_DC) /* {{{ */
 	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use '%s' as interface on '%s' since it is a Trait",
 							 Z_STRVAL(interface_name->u.constant),
-							 CG(active_class_entry)->name);
+							 CG(active_class_entry)->name->val);
 	}
 
 	switch (zend_get_class_fetch_type(Z_STRVAL(interface_name->u.constant), Z_STRLEN(interface_name->u.constant))) {
@@ -5303,7 +5352,7 @@ void zend_do_use_trait(znode *trait_name TSRMLS_DC) /* {{{ */
 	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE)) {
 		zend_error_noreturn(E_COMPILE_ERROR,
 				"Cannot use traits inside of interfaces. %s is used in %s",
-				Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name);
+				Z_STRVAL(trait_name->u.constant), CG(active_class_entry)->name->val);
 	}
 
 
@@ -5328,19 +5377,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;
 }
 /* }}} */
 
@@ -5392,12 +5439,11 @@ ZEND_API int zend_unmangle_property_name_ex(const char *mangled_property, int le
 }
 /* }}} */
 
-void zend_do_declare_property(const znode *var_name, const znode *value, zend_uint access_type TSRMLS_DC) /* {{{ */
+void zend_do_declare_property(znode *var_name, znode *value, zend_uint access_type TSRMLS_DC) /* {{{ */
 {
-	zval *property;
+	zval property;
 	zend_property_info *existing_property_info;
-	char *comment = NULL;
-	int comment_len = 0;
+	zend_string *comment = NULL;
 
 	if (CG(active_class_entry)->ce_flags & ZEND_ACC_INTERFACE) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Interfaces may not include member variables");
@@ -5409,64 +5455,65 @@ void zend_do_declare_property(const znode *var_name, const znode *value, zend_ui
 
 	if (access_type & ZEND_ACC_FINAL) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot declare property %s::$%s final, the final modifier is allowed only for methods and classes",
-				   CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
+				   CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
 	}
 
-	if (zend_hash_find(&CG(active_class_entry)->properties_info, Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, (void **) &existing_property_info)==SUCCESS) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
+	if ((existing_property_info = zend_hash_find_ptr(&CG(active_class_entry)->properties_info, Z_STR(var_name->u.constant))) != NULL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare %s::$%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
 	}
-	ALLOC_ZVAL(property);
 
 	if (value) {
-		*property = value->u.constant;
+		ZVAL_COPY_VALUE(&property, &value->u.constant);
 	} else {
-		INIT_PZVAL(property);
-		Z_TYPE_P(property) = IS_NULL;
+		ZVAL_NULL(&property);
 	}
 
 	if (CG(doc_comment)) {
 		comment = CG(doc_comment);
-		comment_len = CG(doc_comment_len);
 		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
 	}
 
-	zend_declare_property_ex(CG(active_class_entry), zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant) + 1, 0 TSRMLS_CC), Z_STRLEN(var_name->u.constant), property, access_type, comment, comment_len TSRMLS_CC);
-	efree(Z_STRVAL(var_name->u.constant));
+	Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
+	if (IS_INTERNED(Z_STR(var_name->u.constant))) {
+		Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+	}
+	zend_declare_property_ex(CG(active_class_entry), Z_STR(var_name->u.constant), &property, access_type, comment TSRMLS_CC);
+	STR_RELEASE(Z_STR(var_name->u.constant));
 }
 /* }}} */
 
-void zend_do_declare_class_constant(znode *var_name, const znode *value TSRMLS_DC) /* {{{ */
+void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC) /* {{{ */
 {
-	zval *property;
-	const char *cname = NULL;
-	zend_ulong hash;
+	zval property;
 
+	if(Z_TYPE(value->u.constant) == IS_CONSTANT_ARRAY) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Arrays are not allowed in class constants");
+		return;
+	}
 	if ((CG(active_class_entry)->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Traits cannot have constants");
 		return;
 	}
 
-	ALLOC_ZVAL(property);
-	*property = value->u.constant;
+	ZVAL_COPY_VALUE(&property, &value->u.constant);
 
-	cname = zend_new_interned_string(Z_STRVAL(var_name->u.constant), Z_STRLEN(var_name->u.constant)+1, 0 TSRMLS_CC);
-	hash = str_hash(cname, Z_STRLEN(var_name->u.constant));
-	if (zend_hash_quick_add(&CG(active_class_entry)->constants_table, cname, Z_STRLEN(var_name->u.constant)+1, hash, &property, sizeof(zval *), NULL) == FAILURE) {
-		FREE_ZVAL(property);
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name, Z_STRVAL(var_name->u.constant));
+	Z_STR(var_name->u.constant) = zend_new_interned_string(Z_STR(var_name->u.constant) TSRMLS_CC);
+	if (IS_INTERNED(Z_STR(var_name->u.constant))) {
+		Z_TYPE_FLAGS(var_name->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+	}
+	if (zend_hash_add(&CG(active_class_entry)->constants_table, Z_STR(var_name->u.constant), &property) == NULL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redefine class constant %s::%s", CG(active_class_entry)->name->val, Z_STRVAL(var_name->u.constant));
 	}
 	FREE_PNODE(var_name);
 
 	if (CG(doc_comment)) {
-		efree(CG(doc_comment));
+		STR_RELEASE(CG(doc_comment));
 		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
 	}
 }
 /* }}} */
 
-void zend_do_fetch_property(znode *result, znode *object, const znode *property TSRMLS_DC) /* {{{ */
+void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC) /* {{{ */
 {
 	zend_op opline;
 	zend_llist *fetch_list_ptr;
@@ -5507,7 +5554,6 @@ void zend_do_fetch_property(znode *result, znode *object, const znode *property
 					break;
 			}
 			if (opline_ptr->op2_type == IS_CONST && Z_TYPE(CONSTANT(opline_ptr->op2.constant)) == IS_STRING) {
-				CALCULATE_LITERAL_HASH(opline_ptr->op2.constant);
 				GET_POLYMORPHIC_CACHE_SLOT(opline_ptr->op2.constant);
 			}
 			GET_NODE(result, opline_ptr->result);
@@ -5532,7 +5578,6 @@ void zend_do_fetch_property(znode *result, znode *object, const znode *property
 	SET_NODE(opline.op1, object);
 	SET_NODE(opline.op2, property);
 	if (opline.op2_type == IS_CONST && Z_TYPE(CONSTANT(opline.op2.constant)) == IS_STRING) {
-		CALCULATE_LITERAL_HASH(opline.op2.constant);
 		GET_POLYMORPHIC_CACHE_SLOT(opline.op2.constant);
 	}
 	GET_NODE(result, opline.result);
@@ -5543,19 +5588,18 @@ void zend_do_fetch_property(znode *result, znode *object, const znode *property
 
 void zend_do_halt_compiler_register(TSRMLS_D) /* {{{ */
 {
-	char *name, *cfilename;
+	zend_string *name;
+	zend_string *cfilename;
 	char haltoff[] = "__COMPILER_HALT_OFFSET__";
-	int len, clen;
 
 	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);
-	clen = strlen(cfilename);
-	zend_mangle_property_name(&name, &len, haltoff, sizeof(haltoff) - 1, cfilename, clen, 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);
@@ -5616,12 +5660,12 @@ void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC) /*
 static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal_constants_substitution TSRMLS_DC) /* {{{ */
 {
 	zend_constant *c = NULL;
+	char *lookup_name;
 
 	if (Z_STRVAL_P(const_name)[0] == '\\') {
-		if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name), (void **) &c) == FAILURE) {
-			char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
-
-			if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name), (void **) &c)==SUCCESS) {
+		if ((c = zend_hash_str_find_ptr(EG(zend_constants), Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1)) == NULL) {
+			lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name)+1, Z_STRLEN_P(const_name)-1);
+			if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)-1)) != NULL) {
 				if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
 					efree(lookup_name);
 					return c;
@@ -5630,10 +5674,9 @@ static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal
 			efree(lookup_name);
 			return NULL;
 		}
-	} else if (zend_hash_find(EG(zend_constants), Z_STRVAL_P(const_name), Z_STRLEN_P(const_name)+1, (void **) &c) == FAILURE) {
-		char *lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
-
-		if (zend_hash_find(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name)+1, (void **) &c)==SUCCESS) {
+	} else if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(const_name))) == NULL) {
+		lookup_name = zend_str_tolower_dup(Z_STRVAL_P(const_name), Z_STRLEN_P(const_name));
+		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, Z_STRLEN_P(const_name))) != NULL) {
 			if ((c->flags & CONST_CT_SUBST) && !(c->flags & CONST_CS)) {
 				efree(lookup_name);
 				return c;
@@ -5648,7 +5691,7 @@ static zend_constant* zend_get_ct_const(const zval *const_name, int all_internal
 	if (all_internal_constants_substitution &&
 	    (c->flags & CONST_PERSISTENT) &&
 	    !(CG(compiler_options) & ZEND_COMPILE_NO_CONSTANT_SUBSTITUTION) &&
-	    !IS_CONSTANT_TYPE(Z_TYPE(c->value))) {
+	    !Z_CONSTANT(c->value)) {
 		return c;
 	}
 	return NULL;
@@ -5664,7 +5707,6 @@ static int zend_constant_ct_subst(znode *result, zval *const_name, int all_inter
 		result->op_type = IS_CONST;
 		result->u.constant = c->value;
 		zval_copy_ctor(&result->u.constant);
-		INIT_PZVAL(&result->u.constant);
 		return 1;
 	}
 	return 0;
@@ -5692,7 +5734,11 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
 				}
 				zend_do_build_full_name(NULL, constant_container, constant_name, 1 TSRMLS_CC);
 				*result = *constant_container;
-				result->u.constant.type = IS_CONSTANT | fetch_type;
+				Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
+				if (IS_INTERNED(Z_STR(result->u.constant))) {
+					Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+				}
+				Z_CONST_FLAGS(result->u.constant) = fetch_type;
 				break;
 			case ZEND_RT:
 				if (constant_container->op_type == IS_CONST &&
@@ -5713,7 +5759,6 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
 					SET_NODE(opline->op1, constant_container);
 				}
 				SET_NODE(opline->op2, constant_name);
-				CALCULATE_LITERAL_HASH(opline->op2.constant);
 				if (opline->op1_type == IS_CONST) {
 					GET_CACHE_SLOT(opline->op2.constant);
 				} else {
@@ -5742,7 +5787,11 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
 			}
 
 			*result = *constant_name;
-			result->u.constant.type = IS_CONSTANT | fetch_type;
+			Z_TYPE_INFO(result->u.constant) = IS_CONSTANT_EX;
+			if (IS_INTERNED(Z_STR(result->u.constant))) {
+				Z_TYPE_FLAGS(result->u.constant) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+			}
+			Z_CONST_FLAGS(result->u.constant) = fetch_type;
 			break;
 		case ZEND_RT:
 			compound = memchr(Z_STRVAL(constant_name->u.constant), '\\', Z_STRLEN(constant_name->u.constant));
@@ -5766,7 +5815,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
 				opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 0 TSRMLS_CC);
 			} else {
 				opline->extended_value = IS_CONSTANT_UNQUALIFIED;
-				if (CG(current_namespace)) {
+				if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 					opline->extended_value |= IS_CONSTANT_IN_NAMESPACE;
 					opline->op2.constant = zend_add_const_name_literal(CG(active_op_array), &constant_name->u.constant, 1 TSRMLS_CC);
 				} else {
@@ -5779,7 +5828,7 @@ void zend_do_fetch_constant(znode *result, znode *constant_container, znode *con
 }
 /* }}} */
 
-void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC) /* {{{ */
+void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -5802,8 +5851,7 @@ void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC) /* {{{ */
 	opline->opcode = ZEND_DO_FCALL;
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	opline->result_type = IS_VAR;
-	LITERAL_STRINGL(opline->op1, estrndup("shell_exec", sizeof("shell_exec")-1), sizeof("shell_exec")-1, 0);
-	CALCULATE_LITERAL_HASH(opline->op1.constant);
+	LITERAL_STR(opline->op1, STR_INIT("shell_exec", sizeof("shell_exec")-1, 0));
 	opline->op1_type = IS_CONST;
 	GET_CACHE_SLOT(opline->op1.constant);
 	opline->extended_value = 1;
@@ -5820,15 +5868,20 @@ void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_init_array(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
+void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
 {
+	int op_num = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
+	result->u.op.opline_num = op_num;
+
 	opline->opcode = ZEND_INIT_ARRAY;
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	opline->result_type = IS_TMP_VAR;
-	GET_NODE(result, opline->result);
+	opline->extended_value = is_ref; /* extval = size << 2 | not_packed << 1 | is_ref */
+
 	if (expr) {
+		opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */
 		SET_NODE(opline->op1, expr);
 		if (offset) {
 			SET_NODE(opline->op2, offset);
@@ -5836,12 +5889,11 @@ void zend_do_init_array(znode *result, const znode *expr, const znode *offset, z
 				ulong index;
 				int numeric = 0;
 
+				opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
 				ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1);
 				if (numeric) {
 					zval_dtor(&CONSTANT(opline->op2.constant));
 					ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
-				} else {
-					CALCULATE_LITERAL_HASH(opline->op2.constant);
 				}
 			}
 		} else {
@@ -5851,16 +5903,17 @@ void zend_do_init_array(znode *result, const znode *expr, const znode *offset, z
 		SET_UNUSED(opline->op1);
 		SET_UNUSED(opline->op2);
 	}
-	opline->extended_value = is_ref;
 }
 /* }}} */
 
-void zend_do_add_array_element(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
+	zend_op *init_opline = &CG(active_op_array)->opcodes[result->u.op.opline_num];
+	init_opline->extended_value += 1 << ZEND_ARRAY_SIZE_SHIFT; /* increment size */
 
 	opline->opcode = ZEND_ADD_ARRAY_ELEMENT;
-	SET_NODE(opline->result, result);
+	COPY_NODE(opline->result, init_opline->result);
 	SET_NODE(opline->op1, expr);
 	if (offset) {
 		SET_NODE(opline->op2, offset);
@@ -5868,12 +5921,11 @@ void zend_do_add_array_element(znode *result, const znode *expr, const znode *of
 			ulong index;
 			int numeric = 0;
 
+			init_opline->extended_value |= ZEND_ARRAY_NOT_PACKED;
 			ZEND_HANDLE_NUMERIC_EX(Z_STRVAL(CONSTANT(opline->op2.constant)), Z_STRLEN(CONSTANT(opline->op2.constant))+1, index, numeric = 1);
 			if (numeric) {
 				zval_dtor(&CONSTANT(opline->op2.constant));
 				ZVAL_LONG(&CONSTANT(opline->op2.constant), index);
-			} else {
-				CALCULATE_LITERAL_HASH(opline->op2.constant);
 			}
 		}
 	} else {
@@ -5883,30 +5935,56 @@ void zend_do_add_array_element(znode *result, const znode *expr, const znode *of
 }
 /* }}} */
 
-void zend_do_add_static_array_element(zval *result, zval *offset, const zval *expr) /* {{{ */
+void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC) /* {{{ */
 {
+	zend_op *init_opline = &CG(active_op_array)->opcodes[array_node->u.op.opline_num];
+	GET_NODE(result, init_opline->result);
+}
+/* }}} */
+
+void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr TSRMLS_DC) /* {{{ */
+{
+	zval element;
+
+	ZVAL_COPY_VALUE(&element, &expr->u.constant);
 	if (offset) {
-		switch (Z_TYPE_P(offset)) {
+		switch (Z_TYPE(offset->u.constant)) {
+			case IS_CONSTANT:
+				Z_GC_FLAGS(offset->u.constant) |= IS_STR_CONSTANT;
+				if (Z_CONST_FLAGS(offset->u.constant) & IS_CONSTANT_UNQUALIFIED) {
+					Z_GC_FLAGS(offset->u.constant) |= IS_STR_CONSTANT_UNQUALIFIED;
+				}
+				zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STR(offset->u.constant), &element);
+				zval_dtor(&offset->u.constant);
+				break;
+			case IS_CONSTANT_AST: {
+				zend_string *key;
+				key = STR_INIT((char*)&Z_AST(offset->u.constant), sizeof(zend_ast*), 0);
+				GC_FLAGS(key) |= IS_STR_AST;
+				zend_symtable_update(Z_ARRVAL(result->u.constant), key, &element);
+				STR_RELEASE(key);
+				break;
+			}
 			case IS_STRING:
-				zend_symtable_update(Z_ARRVAL_P(result), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, &expr, sizeof(zval *), NULL);
-				zval_dtor(offset);
+				zend_symtable_update(Z_ARRVAL(result->u.constant), Z_STR(offset->u.constant), &element);
+				zval_dtor(&offset->u.constant);
 				break;
 			case IS_NULL:
-				zend_symtable_update(Z_ARRVAL_P(result), "", 1, &expr, sizeof(zval *), NULL);
+				zend_symtable_update(Z_ARRVAL(result->u.constant), STR_EMPTY_ALLOC(), &element);
 				break;
 			case IS_LONG:
 			case IS_BOOL:
-				zend_hash_index_update(Z_ARRVAL_P(result), Z_LVAL_P(offset), &expr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL(result->u.constant), Z_LVAL(offset->u.constant), &element);
 				break;
 			case IS_DOUBLE:
-				zend_hash_index_update(Z_ARRVAL_P(result), zend_dval_to_lval(Z_DVAL_P(offset)), &expr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL(result->u.constant), zend_dval_to_lval(Z_DVAL(offset->u.constant)), &element);
 				break;
-			case IS_ARRAY:
+			case IS_CONSTANT_ARRAY:
 				zend_error(E_ERROR, "Illegal offset type");
 				break;
 		}
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL_P(result), &expr, sizeof(zval *), NULL);
+		zend_hash_next_index_insert(Z_ARRVAL(result->u.constant), &element);
 	}
 }
 /* }}} */
@@ -6044,28 +6122,27 @@ void zend_add_to_list(void *result, void *item TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_fetch_static_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
+void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC) /* {{{ */
 {
-	zval *tmp;
+	zval tmp;
 	zend_op *opline;
 	znode lval;
 	znode result;
 
-	ALLOC_ZVAL(tmp);
-
 	if (static_assignment) {
-		*tmp = static_assignment->u.constant;
+		ZVAL_COPY_VALUE(&tmp, &static_assignment->u.constant);
 	} else {
-		INIT_ZVAL(*tmp);
+		ZVAL_NULL(&tmp);
+		Z_CONST_FLAGS(tmp) = 0;
 	}
 	if (!CG(active_op_array)->static_variables) {
 		if (CG(active_op_array)->scope) {
 			CG(active_op_array)->scope->ce_flags |= ZEND_HAS_STATIC_IN_METHODS;
 		}
 		ALLOC_HASHTABLE(CG(active_op_array)->static_variables);
-		zend_hash_init(CG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_init(CG(active_op_array)->static_variables, 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
-	zend_hash_update(CG(active_op_array)->static_variables, Z_STRVAL(varname->u.constant), Z_STRLEN(varname->u.constant)+1, &tmp, sizeof(zval *), NULL);
+	zend_hash_update(CG(active_op_array)->static_variables, Z_STR(varname->u.constant), &tmp);
 
 	if (varname->op_type == IS_CONST) {
 		if (Z_TYPE(varname->u.constant) != IS_STRING) {
@@ -6078,9 +6155,6 @@ void zend_do_fetch_static_variable(znode *varname, const znode *static_assignmen
 	opline->result_type = IS_VAR;
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	SET_NODE(opline->op1, varname);
-	if (opline->op1_type == IS_CONST) {
-		CALCULATE_LITERAL_HASH(opline->op1.constant);
-	}
 	SET_UNUSED(opline->op2);
 	opline->extended_value = ZEND_FETCH_STATIC;
 	GET_NODE(&result, opline->result);
@@ -6115,10 +6189,7 @@ void zend_do_fetch_lexical_variable(znode *varname, zend_bool is_ref TSRMLS_DC)
 
 	value.op_type = IS_CONST;
 	ZVAL_NULL(&value.u.constant);
-	Z_TYPE(value.u.constant) |= is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
-	Z_SET_REFCOUNT_P(&value.u.constant, 1);
-	Z_UNSET_ISREF_P(&value.u.constant);
-
+	Z_CONST_FLAGS(value.u.constant) = is_ref ? IS_LEXICAL_REF : IS_LEXICAL_VAR;
 	zend_do_fetch_static_variable(varname, &value, is_ref ? ZEND_FETCH_STATIC : ZEND_FETCH_LEXICAL TSRMLS_CC);
 }
 /* }}} */
@@ -6140,9 +6211,6 @@ void zend_do_fetch_global_variable(znode *varname, const znode *static_assignmen
 	opline->result_type = IS_VAR;
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	SET_NODE(opline->op1, varname);
-	if (opline->op1_type == IS_CONST) {
-		CALCULATE_LITERAL_HASH(opline->op1.constant);
-	}
 	SET_UNUSED(opline->op2);
 	opline->extended_value = fetch_type;
 	GET_NODE(&result, opline->result);
@@ -6157,12 +6225,12 @@ void zend_do_fetch_global_variable(znode *varname, const znode *static_assignmen
 }
 /* }}} */
 
-void zend_do_cast(znode *result, const znode *expr, int type TSRMLS_DC) /* {{{ */
+void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
 	opline->opcode = ZEND_CAST;
-	opline->result_type = IS_TMP_VAR;
+	opline->result_type = IS_VAR;
 	opline->result.var = get_temporary_variable(CG(active_op_array));
 	SET_NODE(opline->op1, expr);
 	SET_UNUSED(opline->op2);
@@ -6171,7 +6239,7 @@ void zend_do_cast(znode *result, const znode *expr, int type TSRMLS_DC) /* {{{ *
 }
 /* }}} */
 
-void zend_do_include_or_eval(int type, znode *result, const znode *op1 TSRMLS_DC) /* {{{ */
+void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC) /* {{{ */
 {
 	zend_do_extended_fcall_begin(TSRMLS_C);
 	{
@@ -6202,12 +6270,13 @@ void zend_do_indirect_references(znode *result, const znode *num_references, zno
 	fetch_simple_variable(result, variable, 1 TSRMLS_CC);
 	/* there is a chance someone is accessing $this */
 	if (CG(active_op_array)->scope && CG(active_op_array)->this_var == -1) {
-		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), estrndup("this", sizeof("this")-1), sizeof("this")-1, THIS_HASHVAL TSRMLS_CC);
+		zend_string *key = STR_INIT("this", sizeof("this")-1, 0);
+		CG(active_op_array)->this_var = lookup_cv(CG(active_op_array), key TSRMLS_CC);
 	}
 }
 /* }}} */
 
-void zend_do_unset(const znode *variable TSRMLS_DC) /* {{{ */
+void zend_do_unset(znode *variable TSRMLS_DC) /* {{{ */
 {
 	zend_op *last_op;
 
@@ -6288,7 +6357,7 @@ void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC
 }
 /* }}} */
 
-void zend_do_instanceof(znode *result, const znode *expr, const znode *class_znode, int type TSRMLS_DC) /* {{{ */
+void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC) /* {{{ */
 {
 	int last_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
@@ -6365,7 +6434,13 @@ void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, zno
 
 	opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 	opline->opcode = ZEND_OP_DATA;
-	SET_UNUSED(opline->op1);
+	/* Allocate enough space to keep HashPointer on VM stack */
+	opline->op1_type = IS_TMP_VAR;
+	opline->op1.var = get_temporary_variable(CG(active_op_array));
+	if (sizeof(HashPointer) > sizeof(zval)) {
+		/* Make shure 1 zval is enough for HashPointer (2 must be enough) */
+		get_temporary_variable(CG(active_op_array));
+	}
 	SET_UNUSED(opline->op2);
 	SET_UNUSED(opline->result);
 }
@@ -6495,7 +6570,7 @@ void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC) /* {{{ */
 		convert_to_long(&val->u.constant);
 		CG(declarables).ticks = val->u.constant;
 	} else if (!zend_binary_strcasecmp(Z_STRVAL(var->u.constant), Z_STRLEN(var->u.constant), "encoding", sizeof("encoding")-1)) {
-		if ((Z_TYPE(val->u.constant) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+		if (Z_TYPE(val->u.constant) == IS_CONSTANT) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use constants as encoding");
 		}
 
@@ -6564,7 +6639,7 @@ void zend_do_declare_end(const znode *declare_token TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_exit(znode *result, const znode *message TSRMLS_DC) /* {{{ */
+void zend_do_exit(znode *result, znode *message TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -6573,8 +6648,7 @@ void zend_do_exit(znode *result, const znode *message TSRMLS_DC) /* {{{ */
 	SET_UNUSED(opline->op2);
 
 	result->op_type = IS_CONST;
-	Z_TYPE(result->u.constant) = IS_BOOL;
-	Z_LVAL(result->u.constant) = 1;
+	ZVAL_BOOL(&result->u.constant, 1);
 }
 /* }}} */
 
@@ -6591,7 +6665,7 @@ void zend_do_begin_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_end_silence(const znode *strudel_token TSRMLS_DC) /* {{{ */
+void zend_do_end_silence(znode *strudel_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -6601,7 +6675,7 @@ void zend_do_end_silence(const znode *strudel_token TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
 {
 	int op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
@@ -6625,7 +6699,7 @@ void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TS
 }
 /* }}} */
 
-void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *jmp_token, const znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -6654,7 +6728,7 @@ void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *
 }
 /* }}} */
 
-void zend_do_begin_qm_op(const znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
+void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
 {
 	int jmpz_op_number = get_next_op_number(CG(active_op_array));
 	zend_op *opline;
@@ -6671,7 +6745,7 @@ void zend_do_begin_qm_op(const znode *cond, znode *qm_token TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -6698,7 +6772,7 @@ void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_toke
 }
 /* }}} */
 
-void zend_do_qm_false(znode *result, const znode *false_value, const znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline = get_next_op(CG(active_op_array) TSRMLS_CC);
 
@@ -6785,13 +6859,13 @@ void zend_do_ticks(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-zend_bool zend_is_auto_global_quick(const char *name, uint name_len, ulong hash TSRMLS_DC) /* {{{ */
+zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC) /* {{{ */
 {
 	zend_auto_global *auto_global;
 
-	if (zend_hash_quick_find(CG(auto_globals), name, name_len+1, hash, (void **) &auto_global)==SUCCESS) {
+	if ((auto_global = zend_hash_find_ptr(CG(auto_globals), name)) != NULL) {
 		if (auto_global->armed) {
-			auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
+			auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
 		}
 		return 1;
 	}
@@ -6799,31 +6873,30 @@ zend_bool zend_is_auto_global_quick(const char *name, uint name_len, ulong hash
 }
 /* }}} */
 
-zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC) /* {{{ */
-{
-	return zend_is_auto_global_quick(name, name_len, zend_hash_func(name, name_len+1) TSRMLS_CC);
-}
-/* }}} */
-
-int zend_register_auto_global(const char *name, uint name_len, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
+int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC) /* {{{ */
 {
 	zend_auto_global auto_global;
+	int retval;
 
-	auto_global.name = zend_new_interned_string((char*)name, name_len + 1, 0 TSRMLS_CC);
-	auto_global.name_len = name_len;
+	auto_global.name = zend_new_interned_string(name TSRMLS_CC);
 	auto_global.auto_global_callback = auto_global_callback;
 	auto_global.jit = jit;
 
-	return zend_hash_add(CG(auto_globals), name, name_len+1, &auto_global, sizeof(zend_auto_global), NULL);
+	retval = zend_hash_add_mem(CG(auto_globals), name, &auto_global, sizeof(zend_auto_global)) != NULL ? SUCCESS : FAILURE;
+
+	STR_RELEASE(auto_global.name);
+	return retval;
 }
 /* }}} */
 
-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) {
-		auto_global->armed = auto_global->auto_global_callback(auto_global->name, auto_global->name_len TSRMLS_CC);
+		auto_global->armed = auto_global->auto_global_callback(auto_global->name TSRMLS_CC);
 	} else {
 		auto_global->armed = 0;
 	}
@@ -6847,7 +6920,7 @@ int zendlex(znode *zendlval TSRMLS_DC) /* {{{ */
 	}
 
 again:
-	Z_TYPE(zendlval->u.constant) = IS_LONG;
+	Z_TYPE_INFO(zendlval->u.constant) = IS_LONG;
 	retval = lex_scan(&zendlval->u.constant TSRMLS_CC);
 	switch (retval) {
 		case T_COMMENT:
@@ -6870,7 +6943,6 @@ again:
 			break;
 	}
 
-	INIT_PZVAL(&zendlval->u.constant);
 	zendlval->op_type = IS_CONST;
 	return retval;
 }
@@ -6886,9 +6958,9 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify
 
 	ce->default_properties_table = NULL;
 	ce->default_static_members_table = NULL;
-	zend_hash_init_ex(&ce->properties_info, 0, NULL, (dtor_func_t) (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
-	zend_hash_init_ex(&ce->constants_table, 0, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
-	zend_hash_init_ex(&ce->function_table, 0, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
+	zend_hash_init_ex(&ce->properties_info, 8, NULL, (persistent_hashes ? zend_destroy_property_info_internal : zend_destroy_property_info), persistent_hashes, 0);
+	zend_hash_init_ex(&ce->constants_table, 8, NULL, zval_ptr_dtor_func, persistent_hashes, 0);
+	zend_hash_init_ex(&ce->function_table, 8, NULL, ZEND_FUNCTION_DTOR, persistent_hashes, 0);
 
 	if (ce->type == ZEND_INTERNAL_CLASS) {
 #ifdef ZTS
@@ -6897,17 +6969,16 @@ ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify
 		if (CG(static_members_table) && n >= CG(last_static_member)) {
 			/* Support for run-time declaration: dl() */
 			CG(last_static_member) = n+1;
-			CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval**));
+			CG(static_members_table) = realloc(CG(static_members_table), (n+1)*sizeof(zval*));
 			CG(static_members_table)[n] = NULL;
 		}
-		ce->static_members_table = (zval**)(zend_intptr_t)n;
+		ce->static_members_table = (zval*)(zend_intptr_t)n;
 #else
 		ce->static_members_table = NULL;
 #endif
 	} else {
 		ce->static_members_table = ce->default_static_members_table;
 		ce->info.user.doc_comment = NULL;
-		ce->info.user.doc_comment_len = 0;
 	}
 
 	ce->default_properties_count = 0;
@@ -6966,12 +7037,9 @@ int zend_get_class_fetch_type(const char *class_name, uint class_name_len) /* {{
 }
 /* }}} */
 
-ZEND_API const char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len) /* {{{ */
+ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var) /* {{{ */
 {
-	if (name_len) {
-		*name_len = op_array->vars[var].name_len;
-	}
-	return op_array->vars[var].name;
+	return op_array->vars[EX_VAR_TO_NUM(var)];
 }
 /* }}} */
 
@@ -6982,34 +7050,31 @@ void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRM
 		if (Z_TYPE(result->u.constant) == IS_STRING &&
 		    Z_STRLEN(result->u.constant) == 0) {
 			/* namespace\ */
-			if (CG(current_namespace)) {
+			if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 				znode tmp;
 
 				zval_dtor(&result->u.constant);
 				tmp.op_type = IS_CONST;
-				tmp.u.constant = *CG(current_namespace);
-				zval_copy_ctor(&tmp.u.constant);
+				ZVAL_DUP(&tmp.u.constant, &CG(current_namespace));
 				zend_do_build_namespace_name(result, NULL, &tmp TSRMLS_CC);
 			}
 		}
 	} else {
 		result->op_type = IS_CONST;
-		Z_TYPE(result->u.constant) = IS_STRING;
-		Z_STRVAL(result->u.constant) = NULL;
-		Z_STRLEN(result->u.constant) = 0;
+		ZVAL_EMPTY_STRING(&result->u.constant);
 	}
 	/* prefix = result */
 	zend_do_build_full_name(NULL, result, name, 0 TSRMLS_CC);
 }
 /* }}} */
 
-void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */
+void zend_do_begin_namespace(znode *name, zend_bool with_bracket TSRMLS_DC) /* {{{ */
 {
 	char *lcname;
 
 	/* handle mixed syntax declaration or nested namespaces */
 	if (!CG(has_bracketed_namespaces)) {
-		if (CG(current_namespace)) {
+		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 			/* previous namespace declarations were unbracketed */
 			if (with_bracket) {
 				zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
@@ -7019,12 +7084,12 @@ void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC
 		/* previous namespace declarations were bracketed */
 		if (!with_bracket) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Cannot mix bracketed namespace declarations with unbracketed namespace declarations");
-		} else if (CG(current_namespace) || CG(in_namespace)) {
+		} else if (Z_TYPE(CG(current_namespace)) != IS_UNDEF || CG(in_namespace)) {
 			zend_error_noreturn(E_COMPILE_ERROR, "Namespace declarations cannot be nested");
 		}
 	}
 
-	if (((!with_bracket && !CG(current_namespace)) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) {
+	if (((!with_bracket && Z_TYPE(CG(current_namespace)) == IS_UNDEF) || (with_bracket && !CG(has_bracketed_namespaces))) && CG(active_op_array)->last > 0) {
 		/* ignore ZEND_EXT_STMT and ZEND_TICKS */
 		int num = CG(active_op_array)->last;
 		while (num > 0 &&
@@ -7052,17 +7117,14 @@ void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC
 		}
 		efree(lcname);
 
-		if (CG(current_namespace)) {
-			zval_dtor(CG(current_namespace));
-		} else {
-			ALLOC_ZVAL(CG(current_namespace));
+		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
+			zval_dtor(&CG(current_namespace));
 		}
-		*CG(current_namespace) = name->u.constant;
+		ZVAL_COPY_VALUE(&CG(current_namespace), &name->u.constant);
 	} else {
-		if (CG(current_namespace)) {
-			zval_dtor(CG(current_namespace));
-			FREE_ZVAL(CG(current_namespace));
-			CG(current_namespace) = NULL;
+		if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
+			zval_dtor(&CG(current_namespace));
+			ZVAL_UNDEF(&CG(current_namespace));
 		}
 	}
 
@@ -7085,27 +7147,25 @@ void zend_do_begin_namespace(const znode *name, zend_bool with_bracket TSRMLS_DC
 	}
 
 	if (CG(doc_comment)) {
-		efree(CG(doc_comment));
+		STR_RELEASE(CG(doc_comment));
 		CG(doc_comment) = NULL;
-		CG(doc_comment_len) = 0;
 	}
 }
 /* }}} */
 
 void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{{ */
 {
-	char *lcname;
-	zval *name, *ns, tmp;
+	zend_string *lcname;
+	zval *name, ns, tmp;
 	zend_bool warn = 0;
-	zend_class_entry **pce;
+	zend_class_entry *ce;
 
 	if (!CG(current_import)) {
 		CG(current_import) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import), 0, NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_init(CG(current_import), 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
 
-	MAKE_STD_ZVAL(ns);
-	ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0);
+	ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0);
 	if (new_name) {
 		name = &new_name->u.constant;
 	} else {
@@ -7114,55 +7174,56 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{
 		/* The form "use A\B" is eqivalent to "use A\B as B".
 		   So we extract the last part of compound name to use as a new_name */
 		name = &tmp;
-		p = zend_memrchr(Z_STRVAL_P(ns), '\\', Z_STRLEN_P(ns));
+		p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
 		if (p) {
-			ZVAL_STRING(name, p+1, 1);
+			ZVAL_STRING(name, p+1);
 		} else {
-			ZVAL_ZVAL(name, ns, 1, 0);
-			warn = !is_global && !CG(current_namespace);
+			ZVAL_ZVAL(name, &ns, 1, 0);
+			warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF;
 		}
 	}
 
-	lcname = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name));
+	lcname = STR_ALLOC(Z_STRLEN_P(name), 0);
+	zend_str_tolower_copy(lcname->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
 
 	if (((Z_STRLEN_P(name) == sizeof("self")-1) &&
-				!memcmp(lcname, "self", sizeof("self")-1)) ||
+				!memcmp(lcname->val, "self", sizeof("self")-1)) ||
 			((Z_STRLEN_P(name) == sizeof("parent")-1) &&
-	   !memcmp(lcname, "parent", sizeof("parent")-1))) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL_P(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
+	   !memcmp(lcname->val, "parent", sizeof("parent")-1))) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because '%s' is a special class name", Z_STRVAL(ns), Z_STRVAL_P(name), Z_STRVAL_P(name));
 	}
 
-	if (CG(current_namespace)) {
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 		/* Prefix import name with current namespace name to avoid conflicts with classes */
-		char *c_ns_name = emalloc(Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) + 1);
+		zend_string *c_ns_name = STR_ALLOC(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
 
-		zend_str_tolower_copy(c_ns_name, Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
-		c_ns_name[Z_STRLEN_P(CG(current_namespace))] = '\\';
-		memcpy(c_ns_name+Z_STRLEN_P(CG(current_namespace))+1, lcname, Z_STRLEN_P(name)+1);
-		if (zend_hash_exists(CG(class_table), c_ns_name, Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name)+1)) {
-			char *tmp2 = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
+		zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
+		c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
+		memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lcname->val, Z_STRLEN_P(name)+1);
+		if (zend_hash_exists(CG(class_table), c_ns_name)) {
+			char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 
-			if (Z_STRLEN_P(ns) != Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
-				memcmp(tmp2, c_ns_name, Z_STRLEN_P(ns))) {
-				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+			if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
+				memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 			}
 			efree(tmp2);
 		}
-		efree(c_ns_name);
-	} else if (zend_hash_find(CG(class_table), lcname, Z_STRLEN_P(name)+1, (void**)&pce) == SUCCESS &&
-	           (*pce)->type == ZEND_USER_CLASS &&
-	           (*pce)->info.user.filename == CG(compiled_filename)) {
-		char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
+		STR_FREE(c_ns_name);
+	} else if ((ce = zend_hash_find_ptr(CG(class_table), lcname)) != NULL &&
+	           ce->type == ZEND_USER_CLASS &&
+	           ce->info.user.filename == CG(compiled_filename)) {
+		char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 
-		if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) ||
-			memcmp(c_tmp, lcname, Z_STRLEN_P(ns))) {
-			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+		if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
+			memcmp(c_tmp, lcname->val, Z_STRLEN(ns))) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 		}
 		efree(c_tmp);
 	}
 
-	if (zend_hash_add(CG(current_import), lcname, Z_STRLEN_P(name)+1, &ns, sizeof(zval*), NULL) != SUCCESS) {
-		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+	if (zend_hash_add(CG(current_import), lcname, &ns) == NULL) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Cannot use %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 	}
 	if (warn) {
 		if (!strcmp(Z_STRVAL_P(name), "strict")) {
@@ -7170,19 +7231,18 @@ void zend_do_use(znode *ns_name, znode *new_name, int is_global TSRMLS_DC) /* {{
 		}
 		zend_error(E_WARNING, "The use statement with non-compound name '%s' has no effect", Z_STRVAL_P(name));
 	}
-	efree(lcname);
+	STR_RELEASE(lcname);
 	zval_dtor(name);
 }
 /* }}} */
 
 void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int is_function, zend_bool case_sensitive, HashTable *current_import_sub, HashTable *lookup_table TSRMLS_DC) /* {{{ */
 {
-	char *lookup_name;
-	zval *name, *ns, tmp;
+	zend_string *lookup_name;
+	zval *name, ns, tmp;
 	zend_bool warn = 0;
 
-	MAKE_STD_ZVAL(ns);
-	ZVAL_ZVAL(ns, &ns_name->u.constant, 0, 0);
+	ZVAL_ZVAL(&ns, &ns_name->u.constant, 0, 0);
 	if (new_name) {
 		name = &new_name->u.constant;
 	} else {
@@ -7191,71 +7251,72 @@ void zend_do_use_non_class(znode *ns_name, znode *new_name, int is_global, int i
 		/* The form "use A\B" is eqivalent to "use A\B as B".
 		   So we extract the last part of compound name to use as a new_name */
 		name = &tmp;
-		p = zend_memrchr(Z_STRVAL_P(ns), '\\', Z_STRLEN_P(ns));
+		p = zend_memrchr(Z_STRVAL(ns), '\\', Z_STRLEN(ns));
 		if (p) {
-			ZVAL_STRING(name, p+1, 1);
+			ZVAL_STRING(name, p+1);
 		} else {
-			ZVAL_ZVAL(name, ns, 1, 0);
-			warn = !is_global && !CG(current_namespace);
+			ZVAL_ZVAL(name, &ns, 1, 0);
+			warn = !is_global && Z_TYPE(CG(current_namespace)) == IS_UNDEF;
 		}
 	}
 
 	if (case_sensitive) {
-		lookup_name = estrndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
+		lookup_name = STR_COPY(Z_STR_P(name));
 	} else {
-		lookup_name = zend_str_tolower_dup(Z_STRVAL_P(name), Z_STRLEN_P(name));
+		lookup_name = STR_ALLOC(Z_STRLEN_P(name), 0);
+		zend_str_tolower_copy(lookup_name->val, Z_STRVAL_P(name), Z_STRLEN_P(name));
 	}
 
-	if (CG(current_namespace)) {
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 		/* Prefix import name with current namespace name to avoid conflicts with functions/consts */
-		char *c_ns_name = emalloc(Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) + 1);
+		zend_string *c_ns_name = STR_ALLOC(Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name), 0);
 
-		zend_str_tolower_copy(c_ns_name, Z_STRVAL_P(CG(current_namespace)), Z_STRLEN_P(CG(current_namespace)));
-		c_ns_name[Z_STRLEN_P(CG(current_namespace))] = '\\';
-		memcpy(c_ns_name+Z_STRLEN_P(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1);
-		if (zend_hash_exists(lookup_table, c_ns_name, Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name)+1)) {
-			char *tmp2 = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
+		zend_str_tolower_copy(c_ns_name->val, Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
+		c_ns_name->val[Z_STRLEN(CG(current_namespace))] = '\\';
+		memcpy(c_ns_name->val+Z_STRLEN(CG(current_namespace))+1, lookup_name, Z_STRLEN_P(name)+1);
+		if (zend_hash_exists(lookup_table, c_ns_name)) {
+			char *tmp2 = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 
-			if (Z_STRLEN_P(ns) != Z_STRLEN_P(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
-				memcmp(tmp2, c_ns_name, Z_STRLEN_P(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+			if (Z_STRLEN(ns) != Z_STRLEN(CG(current_namespace)) + 1 + Z_STRLEN_P(name) ||
+				memcmp(tmp2, c_ns_name->val, Z_STRLEN(ns))) {
+				zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
 			}
 			efree(tmp2);
 		}
-		efree(c_ns_name);
+		STR_FREE(c_ns_name);
 	} else if (is_function) {
 		zend_function *function;
 
-		if (zend_hash_find(lookup_table, lookup_name, Z_STRLEN_P(name)+1, (void **) &function) == SUCCESS && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename, CG(compiled_filename)) == 0) {
-			char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
+		if ((function = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && function->type == ZEND_USER_FUNCTION && strcmp(function->op_array.filename->val, CG(compiled_filename)->val) == 0) {
+			char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 
-			if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) ||
-				memcmp(c_tmp, lookup_name, Z_STRLEN_P(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+			if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
+				memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
+				zend_error(E_COMPILE_ERROR, "Cannot use function %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 			}
 			efree(c_tmp);
 		}
 	} else {
-		const char *filename;
+		zend_string *filename;
 
-		if (zend_hash_find(lookup_table, lookup_name, Z_STRLEN_P(name)+1, (void **) &filename) == SUCCESS && strcmp(filename, CG(compiled_filename)) == 0) {
-			char *c_tmp = zend_str_tolower_dup(Z_STRVAL_P(ns), Z_STRLEN_P(ns));
+		if ((filename = zend_hash_find_ptr(lookup_table, lookup_name)) != NULL && strcmp(filename->val, CG(compiled_filename)->val) == 0) {
+			char *c_tmp = zend_str_tolower_dup(Z_STRVAL(ns), Z_STRLEN(ns));
 
-			if (Z_STRLEN_P(ns) != Z_STRLEN_P(name) ||
-				memcmp(c_tmp, lookup_name, Z_STRLEN_P(ns))) {
-				zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+			if (Z_STRLEN(ns) != Z_STRLEN_P(name) ||
+				memcmp(c_tmp, lookup_name->val, Z_STRLEN(ns))) {
+				zend_error(E_COMPILE_ERROR, "Cannot use const %s as %s because the name is already in use", Z_STRVAL(ns), Z_STRVAL_P(name));
 			}
 			efree(c_tmp);
 		}
 	}
 
-	if (zend_hash_add(current_import_sub, lookup_name, Z_STRLEN_P(name)+1, &ns, sizeof(zval*), NULL) != SUCCESS) {
-		zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL_P(ns), Z_STRVAL_P(name));
+	if (zend_hash_add(current_import_sub, lookup_name, &ns) == NULL) {
+		zend_error(E_COMPILE_ERROR, "Cannot use %s %s as %s because the name is already in use", is_function ? "function" : "const", Z_STRVAL(ns), Z_STRVAL_P(name));
 	}
 	if (warn) {
 		zend_error(E_WARNING, "The use %s statement with non-compound name '%s' has no effect", is_function ? "function" : "const", Z_STRVAL_P(name));
 	}
-	efree(lookup_name);
+	STR_RELEASE(lookup_name);
 	zval_dtor(name);
 }
 /* }}} */
@@ -7264,7 +7325,7 @@ void zend_do_use_function(znode *ns_name, znode *new_name, int is_global TSRMLS_
 {
 	if (!CG(current_import_function)) {
 		CG(current_import_function) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import_function), 0, NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_init(CG(current_import_function), 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
 
 	zend_do_use_non_class(ns_name, new_name, is_global, 1, 0, CG(current_import_function), CG(function_table) TSRMLS_CC);
@@ -7275,7 +7336,7 @@ void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC)
 {
 	if (!CG(current_import_const)) {
 		CG(current_import_const) = emalloc(sizeof(HashTable));
-		zend_hash_init(CG(current_import_const), 0, NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_init(CG(current_import_const), 8, NULL, ZVAL_PTR_DTOR, 0);
 	}
 
 	zend_do_use_non_class(ns_name, new_name, is_global, 0, 1, CG(current_import_const), &CG(const_filenames) TSRMLS_CC);
@@ -7285,30 +7346,34 @@ void zend_do_use_const(znode *ns_name, znode *new_name, int is_global TSRMLS_DC)
 void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
 {
 	zend_op *opline;
-	zval **ns_name;
+	zval *ns_name;
+
+	if(Z_TYPE(value->u.constant) == IS_CONSTANT_ARRAY) {
+		zend_error_noreturn(E_COMPILE_ERROR, "Arrays are not allowed as constants");
+	}
 
 	if (zend_get_ct_const(&name->u.constant, 0 TSRMLS_CC)) {
 		zend_error_noreturn(E_COMPILE_ERROR, "Cannot redeclare constant '%s'", Z_STRVAL(name->u.constant));
 	}
 
-	if (CG(current_namespace)) {
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
 		/* Prefix constant name with name of current namespace, lowercased */
 		znode tmp;
 
 		tmp.op_type = IS_CONST;
-		tmp.u.constant = *CG(current_namespace);
-		Z_STRVAL(tmp.u.constant) = zend_str_tolower_dup(Z_STRVAL(tmp.u.constant), Z_STRLEN(tmp.u.constant));
+		ZVAL_NEW_STR(&tmp.u.constant, STR_ALLOC(Z_STRLEN(CG(current_namespace)), 0));
+		zend_str_tolower_copy(Z_STRVAL(tmp.u.constant), Z_STRVAL(CG(current_namespace)), Z_STRLEN(CG(current_namespace)));
 		zend_do_build_namespace_name(&tmp, &tmp, name TSRMLS_CC);
 		*name = tmp;
 	}
 
 	/* Constant name must not conflict with import names */
 	if (CG(current_import_const) &&
-	    zend_hash_find(CG(current_import_const), Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1, (void**)&ns_name) == SUCCESS) {
+	    (ns_name = zend_hash_find(CG(current_import_const), Z_STR(name->u.constant))) != NULL) {
 
-		char *tmp = estrndup(Z_STRVAL_PP(ns_name), Z_STRLEN_PP(ns_name));
+		char *tmp = estrndup(Z_STRVAL_P(ns_name), Z_STRLEN_P(ns_name));
 
-		if (Z_STRLEN_PP(ns_name) != Z_STRLEN(name->u.constant) ||
+		if (Z_STRLEN_P(ns_name) != Z_STRLEN(name->u.constant) ||
 			memcmp(tmp, Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant))) {
 			zend_error(E_COMPILE_ERROR, "Cannot declare const %s because the name is already in use", Z_STRVAL(name->u.constant));
 		}
@@ -7321,7 +7386,7 @@ void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC) /* {{{ */
 	SET_NODE(opline->op1, name);
 	SET_NODE(opline->op2, value);
 
-	zend_hash_add(&CG(const_filenames), Z_STRVAL(name->u.constant), Z_STRLEN(name->u.constant)+1, CG(compiled_filename), strlen(CG(compiled_filename))+1, NULL);
+	zend_hash_add_ptr(&CG(const_filenames), Z_STR(name->u.constant), CG(compiled_filename));
 }
 /* }}} */
 
@@ -7336,10 +7401,9 @@ void zend_verify_namespace(TSRMLS_D) /* {{{ */
 void zend_do_end_namespace(TSRMLS_D) /* {{{ */
 {
 	CG(in_namespace) = 0;
-	if (CG(current_namespace)) {
-		zval_dtor(CG(current_namespace));
-		FREE_ZVAL(CG(current_namespace));
-		CG(current_namespace) = NULL;
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
+		zval_dtor(&CG(current_namespace));
+		ZVAL_UNDEF(&CG(current_namespace));
 	}
 	if (CG(current_import)) {
 		zend_hash_destroy(CG(current_import));
@@ -7369,14 +7433,13 @@ void zend_do_end_compilation(TSRMLS_D) /* {{{ */
 void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC) /* {{{ */
 {
 	if (ast->kind == ZEND_CONST) {
-		result->u.constant = *ast->u.val;
+		ZVAL_COPY_VALUE(&result->u.constant, &ast->u.val);
 		efree(ast);
 	} else if (zend_ast_is_ct_constant(ast)) {
 		zend_ast_evaluate(&result->u.constant, ast, NULL TSRMLS_CC);
 		zend_ast_destroy(ast);
 	} else {
-		Z_TYPE(result->u.constant) = IS_CONSTANT_AST;
-		Z_AST(result->u.constant) = ast;
+		ZVAL_NEW_AST(&result->u.constant, ast);
 	}
 }
 /* }}} */
diff --git a/Zend/zend_compile.h b/Zend/zend_compile.h
index 99d3704b76..4288a3b705 100644
--- a/Zend/zend_compile.h
+++ b/Zend/zend_compile.h
@@ -45,10 +45,9 @@
 #define RESET_DOC_COMMENT()        \
     {                              \
         if (CG(doc_comment)) {     \
-          efree(CG(doc_comment));  \
+          STR_RELEASE(CG(doc_comment));  \
           CG(doc_comment) = NULL;  \
         }                          \
-        CG(doc_comment_len) = 0;   \
     }
 
 typedef struct _zend_op_array zend_op_array;
@@ -66,15 +65,6 @@ typedef struct _zend_compiler_context {
 	HashTable *labels;
 } zend_compiler_context;
 
-typedef struct _zend_literal {
-	zval       constant;
-	zend_ulong hash_value;
-	zend_uint  cache_slot;
-} zend_literal;
-
-#define Z_HASH_P(zv) \
-	(((zend_literal*)(zv))->hash_value)
-
 typedef union _znode_op {
 	zend_uint      constant;
 	zend_uint      var;
@@ -83,7 +73,6 @@ typedef union _znode_op {
 	zend_uint      opline_num; /*  Needs to be signed */
 	zend_op       *jmp_addr;
 	zval          *zv;
-	zend_literal  *literal;
 	void          *ptr;        /* Used for passing pointers from the compile to execution phase, currently used for traits */
 } znode_op;
 
@@ -142,9 +131,9 @@ typedef struct _zend_try_catch_element {
 } zend_try_catch_element;
 
 #if SIZEOF_LONG == 8
-#define THIS_HASHVAL 210728972157UL
+#define THIS_HASHVAL 6385726429UL
 #else
-#define THIS_HASHVAL 275574653UL
+#define THIS_HASHVAL 2090759133UL
 #endif
 
 /* method flags (types) */
@@ -222,20 +211,18 @@ char *zend_visibility_string(zend_uint fn_flags);
 
 typedef struct _zend_property_info {
 	zend_uint flags;
-	const char *name;
-	int name_length;
+	zend_string *name;
 	ulong h;
 	int offset;
-	const char *doc_comment;
-	int doc_comment_len;
+	zend_string *doc_comment;
 	zend_class_entry *ce;
 } zend_property_info;
 
 
 typedef struct _zend_arg_info {
-	const char *name;
+	const char *name;			// TODO: convert into zend_string ???
 	zend_uint name_len;
-	const char *class_name;
+	const char *class_name;		// TODO: convert into zend_string ???
 	zend_uint class_name_len;
 	zend_uchar type_hint;
 	zend_uchar pass_by_reference;
@@ -258,19 +245,13 @@ typedef struct _zend_internal_function_info {
 	zend_bool _is_variadic;
 } zend_internal_function_info;
 
-typedef struct _zend_compiled_variable {
-	const char *name;
-	int name_len;
-	ulong hash_value;
-} zend_compiled_variable;
-
 struct _zend_op_array {
 	/* Common elements */
 	zend_uchar type;
-	const char *function_name;
+	zend_string *function_name;
 	zend_class_entry *scope;
 	zend_uint fn_flags;
-	union _zend_function *prototype;
+	zend_function *prototype;
 	zend_uint num_args;
 	zend_uint required_num_args;
 	zend_arg_info *arg_info;
@@ -281,7 +262,7 @@ struct _zend_op_array {
 	zend_op *opcodes;
 	zend_uint last;
 
-	zend_compiled_variable *vars;
+	zend_string **vars;
 	int last_var;
 
 	zend_uint T;
@@ -301,14 +282,13 @@ struct _zend_op_array {
 
 	zend_uint this_var;
 
-	const char *filename;
+	zend_string *filename;
 	zend_uint line_start;
 	zend_uint line_end;
-	const char *doc_comment;
-	zend_uint doc_comment_len;
+	zend_string *doc_comment;
 	zend_uint early_binding; /* the linked list of delayed declarations */
 
-	zend_literal *literals;
+	zval *literals;
 	int last_literal;
 
 	void **run_time_cache;
@@ -324,10 +304,10 @@ struct _zend_op_array {
 typedef struct _zend_internal_function {
 	/* Common elements */
 	zend_uchar type;
-	const char * function_name;
+	zend_string* function_name;
 	zend_class_entry *scope;
 	zend_uint fn_flags;
-	union _zend_function *prototype;
+	zend_function *prototype;
 	zend_uint num_args;
 	zend_uint required_num_args;
 	zend_arg_info *arg_info;
@@ -337,14 +317,14 @@ typedef struct _zend_internal_function {
 	struct _zend_module_entry *module;
 } zend_internal_function;
 
-#define ZEND_FN_SCOPE_NAME(function)  ((function) && (function)->common.scope ? (function)->common.scope->name : "")
+#define ZEND_FN_SCOPE_NAME(function)  ((function) && (function)->common.scope ? (function)->common.scope->name->val : "")
 
-typedef union _zend_function {
+union _zend_function {
 	zend_uchar type;	/* MUST be the first element of this struct! */
 
 	struct {
 		zend_uchar type;  /* never used */
-		const char *function_name;
+		zend_string *function_name;
 		zend_class_entry *scope;
 		zend_uint fn_flags;
 		union _zend_function *prototype;
@@ -355,12 +335,12 @@ typedef union _zend_function {
 
 	zend_op_array op_array;
 	zend_internal_function internal_function;
-} zend_function;
+};
 
 
 typedef struct _zend_function_state {
 	zend_function *function;
-	void **arguments;
+	zval *arguments;
 } zend_function_state;
 
 typedef struct _zend_function_call_entry {
@@ -382,43 +362,51 @@ typedef struct _list_llist_element {
 	znode value;
 } list_llist_element;
 
-union _temp_variable;
-
 typedef struct _call_slot {
 	zend_function     *fbc;
-	zval              *object;
 	zend_class_entry  *called_scope;
+	zend_object       *object;
 	zend_uint          num_additional_args;
 	zend_bool          is_ctor_call;
 	zend_bool          is_ctor_result_used;
 } call_slot;
 
+typedef enum _vm_frame_kind {
+	VM_FRAME_NESTED_FUNCTION,	/* stackless VM call to function */
+	VM_FRAME_NESTED_CODE,		/* stackless VM call to include/require/eval */
+	VM_FRAME_TOP_FUNCTION,		/* direct VM call to function from external C code */
+	VM_FRAME_TOP_CODE			/* direct VM call to "main" code from external C code */
+} vm_frame_kind;
+
 struct _zend_execute_data {
-	struct _zend_op *opline;
-	zend_function_state function_state;
-	zend_op_array *op_array;
-	zval *object;
-	HashTable *symbol_table;
-	struct _zend_execute_data *prev_execute_data;
-	zval *old_error_reporting;
-	zend_bool nested;
-	zval **original_return_value;
-	zend_class_entry *current_scope;
-	zend_class_entry *current_called_scope;
-	zval *current_this;
+	struct _zend_op     *opline;           /* executed opline                */
+	zend_op_array       *op_array;         /* executed op_array              */
+	zend_function_state  function_state;   /* called function and arguments  */
+	zend_object         *object;           /* current $this                  */
+	zend_class_entry    *scope;            /* function scope (self)          */
+	zend_class_entry    *called_scope;     /* function called scope (static) */
+	zend_array          *symbol_table;
+	void               **run_time_cache;
+	zend_execute_data   *prev_execute_data;
+	zval                *return_value;
+	vm_frame_kind        frame_kind;
+	// TODO: simplify call sequence and remove call_* ???
+	zval old_error_reporting;
 	struct _zend_op *fast_ret; /* used by FAST_CALL/FAST_RET (finally keyword) */
-	zval *delayed_exception;
+	zend_object *delayed_exception;
 	call_slot *call_slots;
 	call_slot *call;
 };
 
 #define EX(element) execute_data.element
 
-#define EX_TMP_VAR(ex, n)	   ((temp_variable*)(((char*)(ex)) + ((int)(n))))
-#define EX_TMP_VAR_NUM(ex, n)  (EX_TMP_VAR(ex, 0) - (1 + (n)))
+#define EX_VAR_2(ex, n)			((zval*)(((char*)(ex)) + ((int)(n))))
+#define EX_VAR_NUM_2(ex, n)     (((zval*)(((char*)(ex))+ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data))))+(n))
 
-#define EX_CV_NUM(ex, n)       (((zval***)(((char*)(ex))+ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data))))+(n))
+#define EX_VAR(n)				EX_VAR_2(execute_data, n)
+#define EX_VAR_NUM(n)			EX_VAR_NUM_2(execute_data, n)
 
+#define EX_VAR_TO_NUM(n)		(EX_VAR_2(NULL, n) - EX_VAR_NUM_2(NULL, 0))
 
 #define IS_CONST	(1<<0)
 #define IS_TMP_VAR	(1<<1)
@@ -444,9 +432,9 @@ ZEND_API int lex_scan(zval *zendlval TSRMLS_DC);
 void startup_scanner(TSRMLS_D);
 void shutdown_scanner(TSRMLS_D);
 
-ZEND_API char *zend_set_compiled_filename(const char *new_compiled_filename TSRMLS_DC);
-ZEND_API void zend_restore_compiled_filename(char *original_compiled_filename TSRMLS_DC);
-ZEND_API char *zend_get_compiled_filename(TSRMLS_D);
+ZEND_API zend_string *zend_set_compiled_filename(zend_string *new_compiled_filename TSRMLS_DC);
+ZEND_API void zend_restore_compiled_filename(zend_string *original_compiled_filename TSRMLS_DC);
+ZEND_API zend_string *zend_get_compiled_filename(TSRMLS_D);
 ZEND_API int zend_get_compiled_lineno(TSRMLS_D);
 ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D);
 
@@ -454,7 +442,7 @@ void zend_resolve_non_class_name(znode *element_name, zend_bool *check_namespace
 void zend_resolve_function_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
 void zend_resolve_const_name(znode *element_name, zend_bool *check_namespace TSRMLS_DC);
 void zend_resolve_class_name(znode *class_name TSRMLS_DC);
-ZEND_API const char* zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var, int* name_len);
+ZEND_API zend_string *zend_get_compiled_variable_name(const zend_op_array *op_array, zend_uint var);
 
 #ifdef ZTS
 const char *zend_get_zendtext(TSRMLS_D);
@@ -463,44 +451,44 @@ int zend_get_zendleng(TSRMLS_D);
 
 
 /* parser-driven code generators */
-void zend_do_binary_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC);
-void zend_do_unary_op(zend_uchar op, znode *result, const znode *op1 TSRMLS_DC);
-void zend_do_binary_assign_op(zend_uchar op, znode *result, const znode *op1, const znode *op2 TSRMLS_DC);
+void zend_do_binary_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_unary_op(zend_uchar op, znode *result, znode *op1 TSRMLS_DC);
+void zend_do_binary_assign_op(zend_uchar op, znode *result, znode *op1, znode *op2 TSRMLS_DC);
 void zend_do_assign(znode *result, znode *variable, znode *value TSRMLS_DC);
-void zend_do_assign_ref(znode *result, const znode *lvar, const znode *rvar TSRMLS_DC);
+void zend_do_assign_ref(znode *result, znode *lvar, znode *rvar TSRMLS_DC);
 void fetch_simple_variable(znode *result, znode *varname, int bp TSRMLS_DC);
 void fetch_simple_variable_ex(znode *result, znode *varname, int bp, zend_uchar op TSRMLS_DC);
 void zend_do_indirect_references(znode *result, const znode *num_references, znode *variable TSRMLS_DC);
-void zend_do_fetch_static_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC);
+void zend_do_fetch_static_variable(znode *varname, znode *static_assignment, int fetch_type TSRMLS_DC);
 void zend_do_fetch_global_variable(znode *varname, const znode *static_assignment, int fetch_type TSRMLS_DC);
 
 void fetch_array_begin(znode *result, znode *varname, znode *first_dim TSRMLS_DC);
-void fetch_array_dim(znode *result, const znode *parent, const znode *dim TSRMLS_DC);
-void fetch_string_offset(znode *result, const znode *parent, const znode *offset TSRMLS_DC);
+void fetch_array_dim(znode *result, znode *parent, znode *dim TSRMLS_DC);
+void fetch_string_offset(znode *result, znode *parent, znode *offset TSRMLS_DC);
 void zend_do_fetch_static_member(znode *result, znode *class_znode TSRMLS_DC);
-void zend_do_print(znode *result, const znode *arg TSRMLS_DC);
-void zend_do_echo(const znode *arg TSRMLS_DC);
+void zend_do_print(znode *result, znode *arg TSRMLS_DC);
+void zend_do_echo(znode *arg TSRMLS_DC);
 typedef int (*unary_op_type)(zval *, zval * TSRMLS_DC);
 typedef int (*binary_op_type)(zval *, zval *, zval * TSRMLS_DC);
 ZEND_API unary_op_type get_unary_op(int opcode);
 ZEND_API binary_op_type get_binary_op(int opcode);
 
-void zend_do_while_cond(const znode *expr, znode *close_bracket_token TSRMLS_DC);
+void zend_do_while_cond(znode *expr, znode *close_bracket_token TSRMLS_DC);
 void zend_do_while_end(const znode *while_token, const znode *close_bracket_token TSRMLS_DC);
 void zend_do_do_while_begin(TSRMLS_D);
-void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, const znode *expr TSRMLS_DC);
+void zend_do_do_while_end(const znode *do_token, const znode *expr_open_bracket, znode *expr TSRMLS_DC);
 
 
-void zend_do_if_cond(const znode *cond, znode *closing_bracket_token TSRMLS_DC);
+void zend_do_if_cond(znode *cond, znode *closing_bracket_token TSRMLS_DC);
 void zend_do_if_after_statement(const znode *closing_bracket_token, unsigned char initialize TSRMLS_DC);
 void zend_do_if_end(TSRMLS_D);
 
-void zend_do_for_cond(const znode *expr, znode *second_semicolon_token TSRMLS_DC);
+void zend_do_for_cond(znode *expr, znode *second_semicolon_token TSRMLS_DC);
 void zend_do_for_before_statement(const znode *cond_start, const znode *second_semicolon_token TSRMLS_DC);
 void zend_do_for_end(const znode *second_semicolon_token TSRMLS_DC);
 
-void zend_do_pre_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC);
-void zend_do_post_incdec(znode *result, const znode *op1, zend_uchar op TSRMLS_DC);
+void zend_do_pre_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
+void zend_do_post_incdec(znode *result, znode *op1, zend_uchar op TSRMLS_DC);
 
 void zend_do_begin_variable_parse(TSRMLS_D);
 void zend_do_end_variable_parse(znode *variable, int type, int arg_offset TSRMLS_DC);
@@ -509,23 +497,23 @@ void zend_check_writable_variable(const znode *variable);
 
 void zend_do_free(znode *op1 TSRMLS_DC);
 
-void zend_do_add_string(znode *result, const znode *op1, znode *op2 TSRMLS_DC);
-void zend_do_add_variable(znode *result, const znode *op1, const znode *op2 TSRMLS_DC);
+void zend_do_add_string(znode *result, znode *op1, znode *op2 TSRMLS_DC);
+void zend_do_add_variable(znode *result, znode *op1, znode *op2 TSRMLS_DC);
 
 int zend_do_verify_access_types(const znode *current_access_type, const znode *new_modifier);
 void zend_do_begin_function_declaration(znode *function_token, znode *function_name, int is_method, int return_reference, znode *fn_flags_znode TSRMLS_DC);
 void zend_do_end_function_declaration(const znode *function_token TSRMLS_DC);
-void zend_do_receive_param(zend_uchar op, znode *varname, const znode *initialization, znode *class_type, zend_bool pass_by_reference, zend_bool is_variadic TSRMLS_DC);
+void zend_do_receive_param(zend_uchar op, znode *varname, znode *initialization, znode *class_type, zend_bool pass_by_reference, zend_bool is_variadic TSRMLS_DC);
 int zend_do_begin_function_call(znode *function_name, zend_bool check_namespace TSRMLS_DC);
 void zend_do_begin_method_call(znode *left_bracket TSRMLS_DC);
-void zend_do_clone(znode *result, const znode *expr TSRMLS_DC);
+void zend_do_clone(znode *result, znode *expr TSRMLS_DC);
 void zend_do_begin_dynamic_function_call(znode *function_name, int prefix_len TSRMLS_DC);
 void zend_do_fetch_class(znode *result, znode *class_name TSRMLS_DC);
 void zend_do_build_full_name(znode *result, znode *prefix, znode *name, int is_class_member TSRMLS_DC);
 int zend_do_begin_class_member_function_call(znode *class_name, znode *method_name TSRMLS_DC);
 void zend_do_end_function_call(znode *function_name, znode *result, int is_method, int is_dynamic_fcall TSRMLS_DC);
 void zend_do_return(znode *expr, int do_end_vparse TSRMLS_DC);
-void zend_do_yield(znode *result, znode *value, const znode *key, zend_bool is_variable TSRMLS_DC);
+void zend_do_yield(znode *result, znode *value, znode *key, zend_bool is_variable TSRMLS_DC);
 void zend_do_handle_exception(TSRMLS_D);
 
 void zend_do_begin_lambda_function_declaration(znode *result, znode *function_token, int return_reference, int is_static TSRMLS_DC);
@@ -537,7 +525,7 @@ void zend_do_bind_catch(znode *try_token, znode *catch_token TSRMLS_DC);
 void zend_do_end_catch(znode *catch_token TSRMLS_DC);
 void zend_do_finally(znode *finally_token TSRMLS_DC);
 void zend_do_end_finally(znode *try_token, znode* catch_token, znode *finally_token TSRMLS_DC);
-void zend_do_throw(const znode *expr TSRMLS_DC);
+void zend_do_throw(znode *expr 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_API zend_class_entry *do_bind_class(const zend_op_array *op_array, const zend_op *opline, HashTable *class_table, zend_bool compile_time TSRMLS_DC);
@@ -564,24 +552,24 @@ void zend_do_unpack_params(znode *params TSRMLS_DC);
 
 
 void zend_do_boolean_or_begin(znode *expr1, znode *op_token TSRMLS_DC);
-void zend_do_boolean_or_end(znode *result, const znode *expr1, const znode *expr2, znode *op_token TSRMLS_DC);
+void zend_do_boolean_or_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC);
 void zend_do_boolean_and_begin(znode *expr1, znode *op_token TSRMLS_DC);
-void zend_do_boolean_and_end(znode *result, const znode *expr1, const znode *expr2, const znode *op_token TSRMLS_DC);
+void zend_do_boolean_and_end(znode *result, znode *expr1, znode *expr2, const znode *op_token TSRMLS_DC);
 
-void zend_do_brk_cont(zend_uchar op, const znode *expr TSRMLS_DC);
+void zend_do_brk_cont(zend_uchar op, znode *expr TSRMLS_DC);
 
 void zend_do_switch_cond(const znode *cond TSRMLS_DC);
 void zend_do_switch_end(const znode *case_list TSRMLS_DC);
-void zend_do_case_before_statement(const znode *case_list, znode *case_token, const znode *case_expr TSRMLS_DC);
+void zend_do_case_before_statement(const znode *case_list, znode *case_token, znode *case_expr TSRMLS_DC);
 void zend_do_case_after_statement(znode *result, const znode *case_token TSRMLS_DC);
 void zend_do_default_before_statement(const znode *case_list, znode *default_token TSRMLS_DC);
 
 void zend_do_begin_class_declaration(const znode *class_token, znode *class_name, const znode *parent_class_name TSRMLS_DC);
 void zend_do_end_class_declaration(const znode *class_token, const znode *parent_token TSRMLS_DC);
-void zend_do_declare_property(const znode *var_name, const znode *value, zend_uint access_type TSRMLS_DC);
-void zend_do_declare_class_constant(znode *var_name, const znode *value TSRMLS_DC);
+void zend_do_declare_property(znode *var_name, znode *value, zend_uint access_type TSRMLS_DC);
+void zend_do_declare_class_constant(znode *var_name, znode *value TSRMLS_DC);
 
-void zend_do_fetch_property(znode *result, znode *object, const znode *property TSRMLS_DC);
+void zend_do_fetch_property(znode *result, znode *object, znode *property TSRMLS_DC);
 
 void zend_do_halt_compiler_register(TSRMLS_D);
 
@@ -594,11 +582,12 @@ void zend_do_end_new_object(znode *result, const znode *new_token TSRMLS_DC);
 
 void zend_do_fetch_constant(znode *result, znode *constant_container, znode *constant_name, int mode, zend_bool check_namespace TSRMLS_DC);
 
-void zend_do_shell_exec(znode *result, const znode *cmd TSRMLS_DC);
+void zend_do_shell_exec(znode *result, znode *cmd TSRMLS_DC);
 
-void zend_do_init_array(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_add_array_element(znode *result, const znode *expr, const znode *offset, zend_bool is_ref TSRMLS_DC);
-void zend_do_add_static_array_element(zval *result, zval *offset, const zval *expr);
+void zend_do_init_array(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
+void zend_do_add_array_element(znode *result, znode *expr, znode *offset, zend_bool is_ref TSRMLS_DC);
+void zend_do_end_array(znode *result, const znode *array_node TSRMLS_DC);
+void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr TSRMLS_DC);
 void zend_do_list_init(TSRMLS_D);
 void zend_do_list_end(znode *result, znode *expr TSRMLS_DC);
 void zend_do_add_list_element(const znode *element TSRMLS_DC);
@@ -610,13 +599,13 @@ void zend_init_list(void *result, void *item TSRMLS_DC);
 void zend_add_to_list(void *result, void *item TSRMLS_DC);
 
 
-void zend_do_cast(znode *result, const znode *expr, int type TSRMLS_DC);
-void zend_do_include_or_eval(int type, znode *result, const znode *op1 TSRMLS_DC);
+void zend_do_cast(znode *result, znode *expr, int type TSRMLS_DC);
+void zend_do_include_or_eval(int type, znode *result, znode *op1 TSRMLS_DC);
 
-void zend_do_unset(const znode *variable TSRMLS_DC);
+void zend_do_unset(znode *variable TSRMLS_DC);
 void zend_do_isset_or_isempty(int type, znode *result, znode *variable TSRMLS_DC);
 
-void zend_do_instanceof(znode *result, const znode *expr, const znode *class_znode, int type TSRMLS_DC);
+void zend_do_instanceof(znode *result, znode *expr, znode *class_znode, int type TSRMLS_DC);
 
 void zend_do_foreach_begin(znode *foreach_token, znode *open_brackets_token, znode *array, znode *as_token, int variable TSRMLS_DC);
 void zend_do_foreach_cont(znode *foreach_token, const znode *open_brackets_token, const znode *as_token, znode *value, znode *key TSRMLS_DC);
@@ -626,17 +615,17 @@ void zend_do_declare_begin(TSRMLS_D);
 void zend_do_declare_stmt(znode *var, znode *val TSRMLS_DC);
 void zend_do_declare_end(const znode *declare_token TSRMLS_DC);
 
-void zend_do_exit(znode *result, const znode *message TSRMLS_DC);
+void zend_do_exit(znode *result, znode *message TSRMLS_DC);
 
 void zend_do_begin_silence(znode *strudel_token TSRMLS_DC);
-void zend_do_end_silence(const znode *strudel_token TSRMLS_DC);
+void zend_do_end_silence(znode *strudel_token TSRMLS_DC);
 
-void zend_do_jmp_set(const znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC);
-void zend_do_jmp_set_else(znode *result, const znode *false_value, const znode *jmp_token, const znode *colon_token TSRMLS_DC);
+void zend_do_jmp_set(znode *value, znode *jmp_token, znode *colon_token TSRMLS_DC);
+void zend_do_jmp_set_else(znode *result, znode *false_value, const znode *jmp_token, znode *colon_token TSRMLS_DC);
 
-void zend_do_begin_qm_op(const znode *cond, znode *qm_token TSRMLS_DC);
-void zend_do_qm_true(const znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC);
-void zend_do_qm_false(znode *result, const znode *false_value, const znode *qm_token, const znode *colon_token TSRMLS_DC);
+void zend_do_begin_qm_op(znode *cond, znode *qm_token TSRMLS_DC);
+void zend_do_qm_true(znode *true_value, znode *qm_token, znode *colon_token TSRMLS_DC);
+void zend_do_qm_false(znode *result, znode *false_value, znode *qm_token, const znode *colon_token TSRMLS_DC);
 
 void zend_do_extended_info(TSRMLS_D);
 void zend_do_extended_fcall_begin(TSRMLS_D);
@@ -648,7 +637,7 @@ void zend_do_abstract_method(const znode *function_name, znode *modifiers, const
 
 void zend_do_declare_constant(znode *name, znode *value TSRMLS_DC);
 void zend_do_build_namespace_name(znode *result, znode *prefix, znode *name TSRMLS_DC);
-void zend_do_begin_namespace(const znode *name, zend_bool with_brackets TSRMLS_DC);
+void zend_do_begin_namespace(znode *name, zend_bool with_brackets TSRMLS_DC);
 void zend_do_end_namespace(TSRMLS_D);
 void zend_verify_namespace(TSRMLS_D);
 void zend_do_use(znode *name, znode *new_name, int is_global TSRMLS_DC);
@@ -661,7 +650,7 @@ void zend_do_constant_expression(znode *result, zend_ast *ast TSRMLS_DC);
 void zend_do_resolve_class_name(znode *result, znode *class_name, int is_static TSRMLS_DC);
 
 void zend_do_label(znode *label TSRMLS_DC);
-void zend_do_goto(const znode *label TSRMLS_DC);
+void zend_do_goto(znode *label TSRMLS_DC);
 void zend_resolve_goto_label(zend_op_array *op_array, zend_op *opline, int pass2 TSRMLS_DC);
 void zend_release_labels(int temporary TSRMLS_DC);
 
@@ -675,30 +664,28 @@ ZEND_API void function_add_ref(zend_function *function);
 ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC);
 ZEND_API zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC);
 ZEND_API zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC);
-ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval **retval, int file_count, ...);
+ZEND_API int zend_execute_scripts(int type TSRMLS_DC, zval *retval, int file_count, ...);
 ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC);
 ZEND_API void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_size TSRMLS_DC);
 ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC);
 ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC);
-ZEND_API int zend_cleanup_class_data(zend_class_entry **pce TSRMLS_DC);
-ZEND_API int zend_cleanup_user_class_data(zend_class_entry **pce TSRMLS_DC);
+ZEND_API void zend_cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC);
 ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC);
 ZEND_API void zend_cleanup_internal_classes(TSRMLS_D);
-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 zend_cleanup_op_array_data(zend_op_array *op_array);
 
 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 (*)(void *)) zend_function_dtor
-#define ZEND_CLASS_DTOR (void (*)(void *)) 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);
@@ -715,24 +702,22 @@ ZEND_API char *zend_make_compiled_string_description(const char *name TSRMLS_DC)
 ZEND_API void zend_initialize_class_data(zend_class_entry *ce, zend_bool nullify_handlers TSRMLS_DC);
 int zend_get_class_fetch_type(const char *class_name, uint class_name_len);
 
-typedef zend_bool (*zend_auto_global_callback)(const char *name, uint name_len TSRMLS_DC);
+typedef zend_bool (*zend_auto_global_callback)(zend_string *name TSRMLS_DC);
 typedef struct _zend_auto_global {
-	const char *name;
-	uint name_len;
+	zend_string *name;
 	zend_auto_global_callback auto_global_callback;
 	zend_bool jit;
 	zend_bool armed;
 } zend_auto_global;
 
-ZEND_API int zend_register_auto_global(const char *name, uint name_len, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC);
+ZEND_API int zend_register_auto_global(zend_string *name, zend_bool jit, zend_auto_global_callback auto_global_callback TSRMLS_DC);
 ZEND_API void zend_activate_auto_globals(TSRMLS_D);
-ZEND_API zend_bool zend_is_auto_global(const char *name, uint name_len TSRMLS_DC);
-ZEND_API zend_bool zend_is_auto_global_quick(const char *name, uint name_len, ulong hashval TSRMLS_DC);
+ZEND_API zend_bool zend_is_auto_global(zend_string *name TSRMLS_DC);
 ZEND_API size_t zend_dirname(char *path, size_t len);
 
 int zendlex(znode *zendlval TSRMLS_DC);
 
-int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC);
+int zend_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC);
 
 /* BEGIN: OPCODES */
 
@@ -838,11 +823,11 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC);
 #define ZEND_SEND_PREFER_REF 2
 
 #define CHECK_ARG_SEND_TYPE(zf, arg_num, m) \
-	((zf)->common.arg_info && \
-	(arg_num <= (zf)->common.num_args \
+	(EXPECTED((zf)->common.arg_info != NULL) && \
+	(EXPECTED(arg_num <= (zf)->common.num_args) \
 		? ((zf)->common.arg_info[arg_num-1].pass_by_reference & (m)) \
-		: ((zf)->common.fn_flags & ZEND_ACC_VARIADIC) \
-			? ((zf)->common.arg_info[(zf)->common.num_args-1].pass_by_reference & (m)) : 0))
+		: (UNEXPECTED((zf)->common.fn_flags & ZEND_ACC_VARIADIC) != 0) && \
+		   ((zf)->common.arg_info[(zf)->common.num_args-1].pass_by_reference & (m))))
 
 #define ARG_MUST_BE_SENT_BY_REF(zf, arg_num) \
 	CHECK_ARG_SEND_TYPE(zf, arg_num, ZEND_SEND_BY_REF)
@@ -864,6 +849,10 @@ int zend_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC);
 #define ZEND_FAST_RET_TO_CATCH		1
 #define ZEND_FAST_RET_TO_FINALLY	2
 
+#define ZEND_ARRAY_ELEMENT_REF		(1<<0)
+#define ZEND_ARRAY_NOT_PACKED		(1<<1)
+#define ZEND_ARRAY_SIZE_SHIFT		2
+
 END_EXTERN_C()
 
 #define ZEND_CLONE_FUNC_NAME		"__clone"
diff --git a/Zend/zend_constants.c b/Zend/zend_constants.c
index 0f44f58a77..a25fe2bdb5 100644
--- a/Zend/zend_constants.c
+++ b/Zend/zend_constants.c
@@ -27,40 +27,57 @@
 #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);
+	}
+	if (c->name) {
+		STR_RELEASE(c->name);
 	}
-	str_free(c->name);
+	pefree(c, c->flags & CONST_PERSISTENT);
 }
 
 
-void copy_zend_constant(zend_constant *c)
+static void copy_zend_constant(zval *zv)
 {
-	c->name = str_strndup(c->name, c->name_len - 1);
+	zend_constant *c = Z_PTR_P(zv);
+
+	Z_PTR_P(zv) = pemalloc(sizeof(zend_constant), c->flags & CONST_PERSISTENT);
+	memcpy(Z_PTR_P(zv), c, sizeof(zend_constant));
+
+	c = Z_PTR_P(zv);
+	c->name = STR_COPY(c->name);
 	if (!(c->flags & CONST_PERSISTENT)) {
 		zval_copy_ctor(&c->value);
+	} else {
+		if (Z_TYPE(c->value) == IS_STRING) {
+			Z_STR(c->value) = STR_DUP(Z_STR(c->value), 1);
+		}
 	}
 }
 
 
 void zend_copy_constants(HashTable *target, HashTable *source)
 {
-	zend_constant tmp_constant;
-
-	zend_hash_copy(target, source, (copy_ctor_func_t) copy_zend_constant, &tmp_constant, sizeof(zend_constant));
+	zend_hash_copy(target, source, copy_zend_constant);
 }
 
 
-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;
 }
 
@@ -85,9 +102,7 @@ int zend_startup_constants(TSRMLS_D)
 {
 	EG(zend_constants) = (HashTable *) malloc(sizeof(HashTable));
 
-	if (zend_hash_init(EG(zend_constants), 20, NULL, ZEND_CONSTANT_DTOR, 1)==FAILURE) {
-		return FAILURE;
-	}
+	zend_hash_init(EG(zend_constants), 128, NULL, ZEND_CONSTANT_DTOR, 1);
 	return SUCCESS;
 }
 
@@ -137,9 +152,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);
 	}
 }
 
@@ -149,8 +164,7 @@ ZEND_API void zend_register_null_constant(const char *name, uint name_len, int f
 	
 	ZVAL_NULL(&c.value);
 	c.flags = flags;
-	c.name = zend_strndup(name, name_len-1);
-	c.name_len = name_len;
+	c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT);
 	c.module_number = module_number;
 	zend_register_constant(&c TSRMLS_CC);
 }
@@ -161,8 +175,7 @@ ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_
 	
 	ZVAL_BOOL(&c.value, bval);
 	c.flags = flags;
-	c.name = zend_strndup(name, name_len-1);
-	c.name_len = name_len;
+	c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT);
 	c.module_number = module_number;
 	zend_register_constant(&c TSRMLS_CC);
 }
@@ -173,8 +186,7 @@ ZEND_API void zend_register_long_constant(const char *name, uint name_len, long
 	
 	ZVAL_LONG(&c.value, lval);
 	c.flags = flags;
-	c.name = zend_strndup(name, name_len-1);
-	c.name_len = name_len;
+	c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT);
 	c.module_number = module_number;
 	zend_register_constant(&c TSRMLS_CC);
 }
@@ -186,8 +198,7 @@ ZEND_API void zend_register_double_constant(const char *name, uint name_len, dou
 	
 	ZVAL_DOUBLE(&c.value, dval);
 	c.flags = flags;
-	c.name = zend_strndup(name, name_len-1);
-	c.name_len = name_len;
+	c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT);
 	c.module_number = module_number;
 	zend_register_constant(&c TSRMLS_CC);
 }
@@ -197,10 +208,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_NEW_STR(&c.value, STR_INIT(strval, strlen, flags & CONST_PERSISTENT));
 	c.flags = flags;
-	c.name = zend_strndup(name, name_len-1);
-	c.name_len = name_len;
+	c.name = STR_INIT(name, name_len, flags & CONST_PERSISTENT);
 	c.module_number = module_number;
 	zend_register_constant(&c TSRMLS_CC);
 }
@@ -211,119 +221,133 @@ ZEND_API void zend_register_string_constant(const char *name, uint name_len, cha
 	zend_register_stringl_constant(name, name_len, strval, strlen(strval), flags, module_number TSRMLS_CC);
 }
 
-static int zend_get_special_constant(const char *name, uint name_len, zend_constant **c TSRMLS_DC)
+static zend_constant *zend_get_special_constant(const char *name, uint name_len TSRMLS_DC)
 {
-	int ret;
+	zend_constant *c;
 	static char haltoff[] = "__COMPILER_HALT_OFFSET__";
 
 	if (!EG(in_execution)) {
-		return 0;
+		return NULL;
 	} else if (name_len == sizeof("__CLASS__")-1 &&
 	          !memcmp(name, "__CLASS__", sizeof("__CLASS__")-1)) {
-		zend_constant tmp;
 
 		/* Returned constants may be cached, so they have to be stored */
 		if (EG(scope) && EG(scope)->name) {
 			int const_name_len;
-			char *const_name;
-			ALLOCA_FLAG(use_heap)
+			zend_string *const_name;
 			
-			const_name_len = sizeof("\0__CLASS__") + EG(scope)->name_length;
-			const_name = do_alloca(const_name_len, use_heap);
-			memcpy(const_name, "\0__CLASS__", sizeof("\0__CLASS__")-1);
-			zend_str_tolower_copy(const_name + sizeof("\0__CLASS__")-1, EG(scope)->name, EG(scope)->name_length);
-			if (zend_hash_find(EG(zend_constants), const_name, const_name_len, (void**)c) == FAILURE) {
-				zend_hash_add(EG(zend_constants), const_name, const_name_len, (void*)&tmp, sizeof(zend_constant), (void**)c);
-				memset(*c, 0, sizeof(zend_constant));
-				Z_STRVAL((**c).value) = estrndup(EG(scope)->name, EG(scope)->name_length);
-				Z_STRLEN((**c).value) = EG(scope)->name_length;
-				Z_TYPE((**c).value) = IS_STRING;
+			const_name_len = sizeof("\0__CLASS__") + EG(scope)->name->len;
+			const_name = STR_ALLOC(const_name_len, 0);
+			memcpy(const_name->val, "\0__CLASS__", sizeof("\0__CLASS__")-1);
+			zend_str_tolower_copy(const_name->val + sizeof("\0__CLASS__")-1, EG(scope)->name->val, EG(scope)->name->len);
+			if ((c = zend_hash_find_ptr(EG(zend_constants), const_name)) == NULL) {
+				c = emalloc(sizeof(zend_constant));
+				memset(c, 0, sizeof(zend_constant));
+				ZVAL_STR(&c->value, STR_COPY(EG(scope)->name));
+				zend_hash_add_ptr(EG(zend_constants), const_name, c);
 			}
-			free_alloca(const_name, use_heap);
+			STR_RELEASE(const_name);
 		} else {
-			if (zend_hash_find(EG(zend_constants), "\0__CLASS__", sizeof("\0__CLASS__"), (void**)c) == FAILURE) {
-				zend_hash_add(EG(zend_constants), "\0__CLASS__", sizeof("\0__CLASS__"), (void*)&tmp, sizeof(zend_constant), (void**)c);
-				memset(*c, 0, sizeof(zend_constant));
-				Z_STRVAL((**c).value) = estrndup("", 0);
-				Z_STRLEN((**c).value) = 0;
-				Z_TYPE((**c).value) = IS_STRING;
+			zend_string *const_name = STR_INIT("\0__CLASS__", sizeof("\0__CLASS__")-1, 0);
+			if ((c = zend_hash_find_ptr(EG(zend_constants), const_name)) == NULL) {
+				c = emalloc(sizeof(zend_constant));
+				memset(c, 0, sizeof(zend_constant));
+				ZVAL_EMPTY_STRING(&c->value);
+				zend_hash_add_ptr(EG(zend_constants), const_name, c);
 			}
+			STR_RELEASE(const_name);
 		}
-		return 1;
+		return c;
 	} 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);
-		ret = zend_hash_find(EG(zend_constants), haltname, len+1, (void **) c);
-		efree(haltname);
-		return (ret == SUCCESS);
+		c = zend_hash_find_ptr(EG(zend_constants), haltname);
+		STR_FREE(haltname);
+		return c;
 	} else {
-		return 0;
+		return NULL;
 	}
 }
 
 
-ZEND_API int zend_get_constant(const char *name, uint name_len, zval *result TSRMLS_DC)
+ZEND_API zval *zend_get_constant_str(const char *name, uint name_len TSRMLS_DC)
 {
 	zend_constant *c;
-	int retval = 1;
-	char *lookup_name;
+	ALLOCA_FLAG(use_heap)
 
-	if (zend_hash_find(EG(zend_constants), name, name_len+1, (void **) &c) == FAILURE) {
-		lookup_name = zend_str_tolower_dup(name, name_len);
-
-		if (zend_hash_find(EG(zend_constants), lookup_name, name_len+1, (void **) &c)==SUCCESS) {
+	if ((c = zend_hash_str_find_ptr(EG(zend_constants), name, name_len)) == NULL) {
+		char *lcname = do_alloca(name_len + 1, use_heap);
+		zend_str_tolower_copy(lcname, name, name_len);
+		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, name_len)) != NULL) {
 			if (c->flags & CONST_CS) {
-				retval=0;
+				c = NULL;
 			}
 		} else {
-			retval = zend_get_special_constant(name, name_len, &c TSRMLS_CC);
+			c = zend_get_special_constant(name, name_len TSRMLS_CC);
 		}
-		efree(lookup_name);
+		free_alloca(lcname, use_heap);
 	}
 
-	if (retval) {
-		*result = c->value;
-		zval_copy_ctor(result);
-		Z_SET_REFCOUNT_P(result, 1);
-		Z_UNSET_ISREF_P(result);
+	return c ? &c->value : NULL;
+}
+
+ZEND_API zval *zend_get_constant(zend_string *name TSRMLS_DC)
+{
+	zend_constant *c;
+	ALLOCA_FLAG(use_heap)
+
+	if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) {
+		char *lcname = do_alloca(name->len + 1, use_heap);
+		zend_str_tolower_copy(lcname, name->val, name->len);
+		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, name->len)) != NULL) {
+			if (c->flags & CONST_CS) {
+				c = NULL;
+			}
+		} else {
+			c = zend_get_special_constant(name->val, name->len TSRMLS_CC);
+		}
+		free_alloca(lcname, use_heap);
 	}
 
-	return retval;
+	return c ? &c->value : NULL;
 }
 
-ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result, zend_class_entry *scope, ulong flags TSRMLS_DC)
+ZEND_API zval *zend_get_constant_ex(zend_string *cname, zend_class_entry *scope, ulong flags TSRMLS_DC)
 {
 	zend_constant *c;
-	int retval = 1;
 	const char *colon;
 	zend_class_entry *ce = NULL;
-	char *class_name;
-	zval **ret_constant;
+	zend_string *class_name;
+	const char *name = cname->val;
+	uint name_len = cname->len;
 
 	/* Skip leading \\ */
 	if (name[0] == '\\') {
 		name += 1;
 		name_len -= 1;
+		cname = NULL;
 	}
 
-
 	if ((colon = zend_memrchr(name, ':', name_len)) &&
 	    colon > name && (*(colon - 1) == ':')) {
 		int class_name_len = colon - name - 1;
 		int const_name_len = name_len - class_name_len - 2;
-		const char *constant_name = colon + 1;
+		zend_string *constant_name = STR_INIT(colon + 1, const_name_len, 0);
 		char *lcname;
+		zval *ret_constant = NULL;
+		ALLOCA_FLAG(use_heap)
 
-		class_name = estrndup(name, class_name_len);
-		lcname = zend_str_tolower_dup(class_name, class_name_len);
+		class_name = STR_INIT(name, class_name_len, 0);
+		lcname = do_alloca(class_name_len + 1, use_heap);
+		zend_str_tolower_copy(lcname, name, class_name_len);
 		if (!scope) {
 			if (EG(in_execution)) {
 				scope = EG(scope);
@@ -338,9 +362,7 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 				ce = scope;
 			} else {
 				zend_error(E_ERROR, "Cannot access self:: when no class scope is active");
-				retval = 0;
 			}
-			efree(lcname);
 		} else if (class_name_len == sizeof("parent")-1 &&
 		           !memcmp(lcname, "parent", sizeof("parent")-1)) {
 			if (!scope) {
@@ -350,7 +372,6 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 			} else {
 				ce = scope->parent;
 			}
-			efree(lcname);
 		} else if (class_name_len == sizeof("static")-1 &&
 		           !memcmp(lcname, "static", sizeof("static")-1)) {
 			if (EG(called_scope)) {
@@ -358,23 +379,26 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 			} else {
 				zend_error(E_ERROR, "Cannot access static:: when no class scope is active");
 			}
-			efree(lcname);
 		} else {
-			efree(lcname);
-			ce = zend_fetch_class(class_name, class_name_len, flags TSRMLS_CC);
+			ce = zend_fetch_class(class_name, flags TSRMLS_CC);
 		}
-		if (retval && ce) {
-			if (zend_hash_find(&ce->constants_table, constant_name, const_name_len+1, (void **) &ret_constant) != SUCCESS) {
-				retval = 0;
+		free_alloca(lcname, use_heap);
+		if (ce) {
+			ret_constant = zend_hash_find(&ce->constants_table, constant_name);
+			if (ret_constant == NULL) {
 				if ((flags & ZEND_FETCH_CLASS_SILENT) == 0) {
-					zend_error(E_ERROR, "Undefined class constant '%s::%s'", class_name, constant_name);
+					zend_error(E_ERROR, "Undefined class constant '%s::%s'", class_name->val, constant_name->val);
 				}
+			} else if (Z_ISREF_P(ret_constant)) {
+				ret_constant = Z_REFVAL_P(ret_constant);
 			}
-		} else if (!ce) {
-			retval = 0;
 		}
-		efree(class_name);
-		goto finish;
+		STR_FREE(class_name);
+		STR_FREE(constant_name);
+		if (ret_constant && Z_CONSTANT_P(ret_constant)) {
+			zval_update_constant_ex(ret_constant, 1, ce TSRMLS_CC);
+		}
+		return ret_constant;
 	}
 
 	/* non-class constant */
@@ -384,138 +408,130 @@ ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result,
 		int const_name_len = name_len - prefix_len - 1;
 		const char *constant_name = colon + 1;
 		char *lcname;
-		int found_const = 0;
+		int lcname_len;
+		ALLOCA_FLAG(use_heap)
 
-		lcname = zend_str_tolower_dup(name, prefix_len);
+		lcname_len = prefix_len + 1 + const_name_len;
+		lcname = do_alloca(lcname_len + 1, use_heap);
+		zend_str_tolower_copy(lcname, name, prefix_len);
 		/* Check for namespace constant */
 
-		/* Concatenate lowercase namespace name and constant name */
-		lcname = erealloc(lcname, prefix_len + 1 + const_name_len + 1);
 		lcname[prefix_len] = '\\';
 		memcpy(lcname + prefix_len + 1, constant_name, const_name_len + 1);
 
-		if (zend_hash_find(EG(zend_constants), lcname, prefix_len + 1 + const_name_len + 1, (void **) &c) == SUCCESS) {
-			found_const = 1;
-		} else {
+		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) == NULL) {
 			/* try lowercase */
 			zend_str_tolower(lcname + prefix_len + 1, const_name_len);
-			if (zend_hash_find(EG(zend_constants), lcname, prefix_len + 1 + const_name_len + 1, (void **) &c) == SUCCESS) {
-				if ((c->flags & CONST_CS) == 0) {
-					found_const = 1;
+			if ((c = zend_hash_str_find_ptr(EG(zend_constants), lcname, lcname_len)) != NULL) {
+				if ((c->flags & CONST_CS) != 0) {
+					c = NULL;
 				}
 			}
 		}
-		efree(lcname);
-		if(found_const) {
-			*result = c->value;
-			zval_update_constant_ex(&result, 1, NULL TSRMLS_CC);
-			zval_copy_ctor(result);
-			Z_SET_REFCOUNT_P(result, 1);
-			Z_UNSET_ISREF_P(result);
-			return 1;
+		free_alloca(lcname, use_heap);
+		if (c) {
+			return &c->value;
 		}
 		/* name requires runtime resolution, need to check non-namespaced name */
 		if ((flags & IS_CONSTANT_UNQUALIFIED) != 0) {
-			name = constant_name;
-			name_len = const_name_len;
-			return zend_get_constant(name, name_len, result TSRMLS_CC);
-		}
-		retval = 0;
-finish:
-		if (retval) {
-			zval_update_constant_ex(ret_constant, 1, ce TSRMLS_CC);
-			*result = **ret_constant;
-			zval_copy_ctor(result);
-			INIT_PZVAL(result);
+			return zend_get_constant_str(constant_name, const_name_len TSRMLS_CC);
 		}
-
-		return retval;
+		return NULL;
 	}
 
-	return zend_get_constant(name, name_len, result TSRMLS_CC);
+	if (cname) {
+		return zend_get_constant(cname TSRMLS_CC);
+	} else {
+		return zend_get_constant_str(name, name_len TSRMLS_CC);
+	}
 }
 
-zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC)
+zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC)
 {
 	zend_constant *c;
 
-	if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
+	if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
 		key++;
-		if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
+		if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
 		    (c->flags & CONST_CS) != 0) {
 			if ((flags & (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) == (IS_CONSTANT_IN_NAMESPACE|IS_CONSTANT_UNQUALIFIED)) {
 				key++;
-				if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE) {
+				if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL) {
 				    key++;
-					if (zend_hash_quick_find(EG(zend_constants), Z_STRVAL(key->constant), Z_STRLEN(key->constant) + 1, key->hash_value, (void **) &c) == FAILURE ||
+					if ((c = zend_hash_find_ptr(EG(zend_constants), Z_STR_P(key))) == NULL ||
 					    (c->flags & CONST_CS) != 0) {
 
 						key--;
-						if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
-							return NULL;
-						}
+						c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRLEN_P(key) TSRMLS_CC);
 					}
 				}
 			} else {
 				key--;
-				if (!zend_get_special_constant(Z_STRVAL(key->constant), Z_STRLEN(key->constant), &c TSRMLS_CC)) {
-					return NULL;
-				}
+				c = zend_get_special_constant(Z_STRVAL_P(key), Z_STRLEN_P(key) TSRMLS_CC);
 			}
 		}
 	}
 	return c;
 }
 
+static void* zend_hash_add_constant(HashTable *ht, zend_string *key, zend_constant *c)
+{
+	void *ret;
+	zend_constant *copy = pemalloc(sizeof(zend_constant), c->flags & CONST_PERSISTENT);
+
+	memcpy(copy, c, sizeof(zend_constant));
+	ret = zend_hash_add_ptr(ht, key, copy);
+	if (!ret) {
+		pefree(copy, c->flags & CONST_PERSISTENT);
+	}
+	return ret;
+}
+
 ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC)
 {
-	char *lowercase_name = NULL;
-	char *name;
+	zend_string *lowercase_name = NULL;
+	zend_string *name;
 	int ret = SUCCESS;
-	ulong chash;
 
 #if 0
 	printf("Registering constant for module %d\n", c->module_number);
 #endif
 
 	if (!(c->flags & CONST_CS)) {
-		/* keep in mind that c->name_len already contains the '\0' */
-		lowercase_name = estrndup(c->name, c->name_len-1);
-		zend_str_tolower(lowercase_name, c->name_len-1);
-		lowercase_name = (char*)zend_new_interned_string(lowercase_name, c->name_len, 1 TSRMLS_CC);
+		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, '\\');
+		char *slash = strrchr(c->name->val, '\\');
 		if (slash) {
-			lowercase_name = estrndup(c->name, c->name_len-1);
-			zend_str_tolower(lowercase_name, slash-c->name);
-			lowercase_name = (char*)zend_new_interned_string(lowercase_name, c->name_len, 1 TSRMLS_CC);
+			lowercase_name = STR_INIT(c->name->val, c->name->len, c->flags & CONST_PERSISTENT);
+			zend_str_tolower(lowercase_name->val, slash - c->name->val);
+			lowercase_name = zend_new_interned_string(lowercase_name TSRMLS_CC);
 			name = lowercase_name;
 		} else {
 			name = c->name;
 		}
 	}
-	chash = str_hash(name, c->name_len-1);
 
 	/* Check if the user is trying to define the internal pseudo constant name __COMPILER_HALT_OFFSET__ */
-	if ((c->name_len == sizeof("__COMPILER_HALT_OFFSET__")
-		&& !memcmp(name, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1))
-		|| zend_hash_quick_add(EG(zend_constants), name, c->name_len, chash, (void *) c, sizeof(zend_constant), NULL)==FAILURE) {
+	if ((c->name->len == sizeof("__COMPILER_HALT_OFFSET__")-1
+		&& !memcmp(name->val, "__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__")-1))
+		|| zend_hash_add_constant(EG(zend_constants), name, c) == NULL) {
 		
 		/* The internal __COMPILER_HALT_OFFSET__ is prefixed by NULL byte */
-		if (c->name[0] == '\0' && c->name_len > sizeof("\0__COMPILER_HALT_OFFSET__")
-			&& memcmp(name, "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
-			name++;
+		if (c->name->val[0] == '\0' && c->name->len > sizeof("\0__COMPILER_HALT_OFFSET__")-1
+			&& memcmp(name->val, "\0__COMPILER_HALT_OFFSET__", sizeof("\0__COMPILER_HALT_OFFSET__")) == 0) {
 		}
-		zend_error(E_NOTICE,"Constant %s already defined", name);
-		str_free(c->name);
+		zend_error(E_NOTICE,"Constant %s already defined", name->val);
+		STR_RELEASE(c->name);
 		if (!(c->flags & CONST_PERSISTENT)) {
 			zval_dtor(&c->value);
 		}
 		ret = FAILURE;
 	}
 	if (lowercase_name) {
-		str_efree(lowercase_name);
+		STR_RELEASE(lowercase_name);
 	}
 	return ret;
 }
diff --git a/Zend/zend_constants.h b/Zend/zend_constants.h
index a40db3a8af..09a5dac63d 100644
--- a/Zend/zend_constants.h
+++ b/Zend/zend_constants.h
@@ -33,17 +33,16 @@
 typedef struct _zend_constant {
 	zval value;
 	int flags;
-	char *name;
-	uint name_len;
+	zend_string *name;
 	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)
@@ -52,22 +51,23 @@ 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);
 void clean_non_persistent_constants(TSRMLS_D);
-ZEND_API int zend_get_constant(const char *name, uint name_len, zval *result TSRMLS_DC);
-ZEND_API int zend_get_constant_ex(const char *name, uint name_len, zval *result, zend_class_entry *scope, ulong flags TSRMLS_DC);
+ZEND_API zval *zend_get_constant(zend_string *name TSRMLS_DC);
+ZEND_API zval *zend_get_constant_str(const char *name, uint name_len TSRMLS_DC);
+ZEND_API zval *zend_get_constant_ex(zend_string *name, zend_class_entry *scope, ulong flags TSRMLS_DC);
 ZEND_API void zend_register_bool_constant(const char *name, uint name_len, zend_bool bval, int flags, int module_number TSRMLS_DC);
 ZEND_API void zend_register_null_constant(const char *name, uint name_len, int flags, int module_number TSRMLS_DC);
 ZEND_API void zend_register_long_constant(const char *name, uint name_len, long lval, int flags, int module_number TSRMLS_DC);
@@ -76,11 +76,10 @@ ZEND_API void zend_register_string_constant(const char *name, uint name_len, cha
 ZEND_API void zend_register_stringl_constant(const char *name, uint name_len, char *strval, uint strlen, int flags, int module_number TSRMLS_DC);
 ZEND_API int zend_register_constant(zend_constant *c TSRMLS_DC);
 void zend_copy_constants(HashTable *target, HashTable *sourc);
-void copy_zend_constant(zend_constant *c);
-zend_constant *zend_quick_get_constant(const zend_literal *key, ulong flags TSRMLS_DC);
+zend_constant *zend_quick_get_constant(const zval *key, ulong flags TSRMLS_DC);
 END_EXTERN_C()
 
-#define ZEND_CONSTANT_DTOR (void (*)(void *)) free_zend_constant
+#define ZEND_CONSTANT_DTOR free_zend_constant
 
 #endif
 
diff --git a/Zend/zend_dtrace.c b/Zend/zend_dtrace.c
index 51bd1f421c..8d854f1ef8 100644
--- a/Zend/zend_dtrace.c
+++ b/Zend/zend_dtrace.c
@@ -81,7 +81,7 @@ ZEND_API void dtrace_execute_ex(zend_execute_data *execute_data TSRMLS_DC)
 	}
 }
 
-ZEND_API void dtrace_execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci, int return_value_used TSRMLS_DC)
+ZEND_API void dtrace_execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci TSRMLS_DC)
 {
 	int lineno;
 	const char *filename;
@@ -94,7 +94,7 @@ ZEND_API void dtrace_execute_internal(zend_execute_data *execute_data_ptr, zend_
 		DTRACE_EXECUTE_ENTRY((char *)filename, lineno);
 	}
 
-	execute_internal(execute_data_ptr, fci, return_value_used TSRMLS_CC);
+	execute_internal(execute_data_ptr, fci TSRMLS_CC);
 
 	if (DTRACE_EXECUTE_RETURN_ENABLED()) {
 		DTRACE_EXECUTE_RETURN((char *)filename, lineno);
diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
index e4570269e3..137d9c97f8 100644
--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -34,26 +34,29 @@ static zend_class_entry *error_exception_ce;
 static zend_object_handlers default_exception_handlers;
 ZEND_API void (*zend_throw_exception_hook)(zval *ex TSRMLS_DC);
 
-void zend_exception_set_previous(zval *exception, zval *add_previous TSRMLS_DC)
+void zend_exception_set_previous(zend_object *exception, zend_object *add_previous TSRMLS_DC)
 {
-	zval *previous;
+    zval tmp, *previous, zv, *pzv;
 
 	if (exception == add_previous || !add_previous || !exception) {
 		return;
 	}
-	if (Z_TYPE_P(add_previous) != IS_OBJECT && !instanceof_function(Z_OBJCE_P(add_previous), default_exception_ce TSRMLS_CC)) {
+	ZVAL_OBJ(&tmp, add_previous);
+	if (!instanceof_function(Z_OBJCE(tmp), default_exception_ce TSRMLS_CC)) {
 		zend_error(E_ERROR, "Cannot set non exception as previous exception");
 		return;
 	}
-	while (exception && exception != add_previous && Z_OBJ_HANDLE_P(exception) != Z_OBJ_HANDLE_P(add_previous)) {
-		previous = zend_read_property(default_exception_ce, exception, "previous", sizeof("previous")-1, 1 TSRMLS_CC);
+	ZVAL_OBJ(&zv, exception);
+	pzv = &zv;
+	do {
+		previous = zend_read_property(default_exception_ce, pzv, "previous", sizeof("previous")-1, 1 TSRMLS_CC);
 		if (Z_TYPE_P(previous) == IS_NULL) {
-			zend_update_property(default_exception_ce, exception, "previous", sizeof("previous")-1, add_previous TSRMLS_CC);
-			Z_DELREF_P(add_previous);
+			zend_update_property(default_exception_ce, pzv, "previous", sizeof("previous")-1, &tmp TSRMLS_CC);
+			GC_REFCOUNT(add_previous)--;
 			return;
 		}
-		exception = previous;
-	}
+		pzv = previous;
+	} while (pzv && Z_OBJ_P(pzv) != add_previous);
 }
 
 void zend_exception_save(TSRMLS_D) /* {{{ */
@@ -89,7 +92,7 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */
 		zend_uint name_len;
 
 		if (exception != NULL) {
-			zend_get_object_classname(exception, &classname, &name_len TSRMLS_CC);
+			zend_get_object_classname(Z_OBJ_P(exception), &classname, &name_len TSRMLS_CC);
 			DTRACE_EXCEPTION_THROWN((char *)classname);
 		} else {
 			DTRACE_EXCEPTION_THROWN(NULL);
@@ -98,9 +101,9 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */
 #endif /* HAVE_DTRACE */
 
 	if (exception != NULL) {
-		zval *previous = EG(exception);
-		zend_exception_set_previous(exception, EG(exception) TSRMLS_CC);
-		EG(exception) = exception;
+		zend_object *previous = EG(exception);
+		zend_exception_set_previous(Z_OBJ_P(exception), EG(exception) TSRMLS_CC);
+		EG(exception) = Z_OBJ_P(exception);
 		if (previous) {
 			return;
 		}
@@ -129,13 +132,14 @@ void zend_throw_exception_internal(zval *exception TSRMLS_DC) /* {{{ */
 ZEND_API void zend_clear_exception(TSRMLS_D) /* {{{ */
 {
 	if (EG(prev_exception)) {
-		zval_ptr_dtor(&EG(prev_exception));
+				
+		OBJ_RELEASE(EG(prev_exception));
 		EG(prev_exception) = NULL;
 	}
 	if (!EG(exception)) {
 		return;
 	}
-	zval_ptr_dtor(&EG(exception));
+	OBJ_RELEASE(EG(exception));
 	EG(exception) = NULL;
 	EG(current_execute_data)->opline = EG(opline_before_exception);
 #if ZEND_DEBUG
@@ -144,37 +148,35 @@ ZEND_API void zend_clear_exception(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-static zend_object_value zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces TSRMLS_DC) /* {{{ */
+static zend_object *zend_default_exception_new_ex(zend_class_entry *class_type, int skip_top_traces TSRMLS_DC) /* {{{ */
 {
 	zval obj;
 	zend_object *object;
-	zval *trace;
+	zval trace;
 
-	Z_OBJVAL(obj) = zend_objects_new(&object, class_type TSRMLS_CC);
+	Z_OBJ(obj) = object = zend_objects_new(class_type TSRMLS_CC);
 	Z_OBJ_HT(obj) = &default_exception_handlers;
 
 	object_properties_init(object, class_type);
 
-	ALLOC_ZVAL(trace);
-	Z_UNSET_ISREF_P(trace);
-	Z_SET_REFCOUNT_P(trace, 0);
-	zend_fetch_debug_backtrace(trace, skip_top_traces, 0, 0 TSRMLS_CC);
+	zend_fetch_debug_backtrace(&trace, skip_top_traces, 0, 0 TSRMLS_CC);
+	Z_SET_REFCOUNT(trace, 0);
 
 	zend_update_property_string(default_exception_ce, &obj, "file", sizeof("file")-1, zend_get_executed_filename(TSRMLS_C) TSRMLS_CC);
 	zend_update_property_long(default_exception_ce, &obj, "line", sizeof("line")-1, zend_get_executed_lineno(TSRMLS_C) TSRMLS_CC);
-	zend_update_property(default_exception_ce, &obj, "trace", sizeof("trace")-1, trace TSRMLS_CC);
+	zend_update_property(default_exception_ce, &obj, "trace", sizeof("trace")-1, &trace TSRMLS_CC);
 
-	return Z_OBJVAL(obj);
+	return object;
 }
 /* }}} */
 
-static zend_object_value zend_default_exception_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *zend_default_exception_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
 	return zend_default_exception_new_ex(class_type, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static zend_object_value zend_error_exception_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *zend_error_exception_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
 	return zend_default_exception_new_ex(class_type, 2 TSRMLS_CC);
 }
@@ -193,19 +195,19 @@ ZEND_METHOD(exception, __clone)
    Exception constructor */
 ZEND_METHOD(exception, __construct)
 {
-	char  *message = NULL;
+	zend_string *message = NULL;
 	long   code = 0;
 	zval  *object, *previous = NULL;
-	int    argc = ZEND_NUM_ARGS(), message_len;
+	int    argc = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|slO!", &message, &message_len, &code, &previous, default_exception_ce) == FAILURE) {
+	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, argc TSRMLS_CC, "|SlO!", &message, &code, &previous, default_exception_ce) == FAILURE) {
 		zend_error(E_ERROR, "Wrong parameters for Exception([string $exception [, long $code [, Exception $previous = NULL]]])");
 	}
 
 	object = getThis();
 
 	if (message) {
-		zend_update_property_stringl(default_exception_ce, object, "message", sizeof("message")-1, message, message_len TSRMLS_CC);
+		zend_update_property_str(default_exception_ce, object, "message", sizeof("message")-1, message TSRMLS_CC);
 	}
 
 	if (code) {
@@ -268,9 +270,7 @@ static void _default_exception_get_entry(zval *object, char *name, int name_len,
 
 	value = zend_read_property(default_exception_ce, object, name, name_len, 0 TSRMLS_CC);
 
-	*return_value = *value;
-	zval_copy_ctor(return_value);
-	INIT_PZVAL(return_value);
+	ZVAL_DUP_DEREF(return_value, value);
 }
 /* }}} */
 
@@ -335,45 +335,46 @@ ZEND_METHOD(error_exception, getSeverity)
 /* }}} */
 
 /* {{{ gettraceasstring() macros */
-#define TRACE_APPEND_CHR(chr)                                            \
-	*str = (char*)erealloc(*str, *len + 1 + 1);                          \
-	(*str)[(*len)++] = chr
+#define TRACE_APPEND_CHR(chr)                                        \
+	str = STR_REALLOC(str, str->len + 1, 0);                         \
+    str->val[str->len - 1] = chr
 
-#define TRACE_APPEND_STRL(val, vallen)                                   \
-	{                                                                    \
-		int l = vallen;                                                  \
-		*str = (char*)erealloc(*str, *len + l + 1);                      \
-		memcpy((*str) + *len, val, l);                                   \
-		*len += l;                                                       \
+#define TRACE_APPEND_STRL(v, l)                                      \
+	{                                                                \
+		str = STR_REALLOC(str, str->len + (l), 0);                   \
+		memcpy(str->val + str->len - (l), (v), (l));                 \
 	}
 
-#define TRACE_APPEND_STR(val)                                            \
-	TRACE_APPEND_STRL(val, sizeof(val)-1)
+#define TRACE_APPEND_STR(v)                                          \
+	TRACE_APPEND_STRL((v), sizeof((v))-1)
 
-#define TRACE_APPEND_KEY(key)                                                   \
-	if (zend_hash_find(ht, key, sizeof(key), (void**)&tmp) == SUCCESS) {    \
-		if (Z_TYPE_PP(tmp) != IS_STRING) {                              \
-			zend_error(E_WARNING, "Value for %s is no string", key); \
-			TRACE_APPEND_STR("[unknown]");                          \
-		} else {                                                        \
-			TRACE_APPEND_STRL(Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));  \
-		}                                                               \
-	}
+#define TRACE_APPEND_KEY(key) do {                                          \
+		tmp = zend_hash_str_find(ht, key, sizeof(key)-1);                   \
+		if (tmp) {                                                          \
+			if (Z_TYPE_P(tmp) != IS_STRING) {                               \
+				zend_error(E_WARNING, "Value for %s is no string", key);    \
+				TRACE_APPEND_STR("[unknown]");                              \
+			} else {                                                        \
+				TRACE_APPEND_STRL(Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));        \
+			}                                                               \
+		} \
+	} while (0)
 
 
-#define TRACE_ARG_APPEND(vallen)								\
-	*str = (char*)erealloc(*str, *len + 1 + vallen);					\
-	memmove((*str) + *len - l_added + 1 + vallen, (*str) + *len - l_added + 1, l_added);
+#define TRACE_ARG_APPEND(vallen) do { \
+		int len = str->len; \
+		str = STR_REALLOC(str, len + vallen, 0); \
+		memmove(str->val + len - l_added + 1 + vallen, str->val + len - l_added + 1, l_added); \
+	} while (0)
 
 /* }}} */
 
-static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int _build_trace_args(zval *arg TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
-	char **str;
-	int *len;
+	zend_string *str, **str_ptr;
 
-	str = va_arg(args, char**);
-	len = va_arg(args, int*);
+	str_ptr = va_arg(args, zend_string**);
+	str = *str_ptr;
 
 	/* the trivial way would be to do:
 	 * convert_to_string_ex(arg);
@@ -381,48 +382,49 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 	 * but that could cause some E_NOTICE and also damn long lines.
 	 */
 
-	switch (Z_TYPE_PP(arg)) {
+	ZVAL_DEREF(arg);
+	switch (Z_TYPE_P(arg)) {
 		case IS_NULL:
 			TRACE_APPEND_STR("NULL, ");
 			break;
 		case IS_STRING: {
 			int l_added;
 			TRACE_APPEND_CHR('\'');
-			if (Z_STRLEN_PP(arg) > 15) {
-				TRACE_APPEND_STRL(Z_STRVAL_PP(arg), 15);
+			if (Z_STRLEN_P(arg) > 15) {
+				TRACE_APPEND_STRL(Z_STRVAL_P(arg), 15);
 				TRACE_APPEND_STR("...', ");
 				l_added = 15 + 6 + 1; /* +1 because of while (--l_added) */
 			} else {
-				l_added = Z_STRLEN_PP(arg);
-				TRACE_APPEND_STRL(Z_STRVAL_PP(arg), l_added);
+				l_added = Z_STRLEN_P(arg);
+				TRACE_APPEND_STRL(Z_STRVAL_P(arg), l_added);
 				TRACE_APPEND_STR("', ");
 				l_added += 3 + 1;
 			}
 			while (--l_added) {
-				unsigned char chr = (*str)[*len - l_added];
+				unsigned char chr = str->val[str->len - l_added];
 				if (chr < 32 || chr == '\\' || chr > 126) {
-					(*str)[*len - l_added] = '\\';
+					str->val[str->len - l_added] = '\\';
 
 					switch (chr) {
 						case '\n':
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = 'n';
+							str->val[str->len - l_added] = 'n';
 							break;
 						case '\r':
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = 'r';
+							str->val[str->len - l_added] = 'r';
 							break;
 						case '\t':
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = 't';
+							str->val[str->len - l_added] = 't';
 							break;
 						case '\f':
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = 'f';
+							str->val[str->len - l_added] = 'f';
 							break;
 						case '\v':
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = 'v';
+							str->val[str->len - l_added] = 'v';
 							break;
 #ifndef PHP_WIN32
 						case '\e':
@@ -430,43 +432,48 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 						case VK_ESCAPE:
 #endif
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = 'e';
+							str->val[str->len - l_added] = 'e';
 							break;
 						case '\\':
 							TRACE_ARG_APPEND(1);
-							(*str)[++(*len) - l_added] = '\\';
+							str->val[str->len - l_added] = '\\';
 							break;
 						default:
 							TRACE_ARG_APPEND(3);
-							(*str)[*len - l_added + 1] = 'x';
+							str->val[str->len - l_added - 2] = 'x';
 							if ((chr >> 4) < 10) {
-								(*str)[*len - l_added + 2] = (chr >> 4) + '0';
+								str->val[str->len - l_added - 1] = (chr >> 4) + '0';
 							} else {
-								(*str)[*len - l_added + 2] = (chr >> 4) + 'A' - 10;
+								str->val[str->len - l_added - 1] = (chr >> 4) + 'A' - 10;
 							}
 							if (chr % 16 < 10) {
-								(*str)[*len - l_added + 3] = chr % 16 + '0';
+								str->val[str->len - l_added] = chr % 16 + '0';
 							} else {
-								(*str)[*len - l_added + 3] = chr % 16 + 'A' - 10;
+								str->val[str->len - l_added] = chr % 16 + 'A' - 10;
 							}
-							*len += 3;
 					}
 				}
 			}
 			break;
 		}
 		case IS_BOOL:
-			if (Z_LVAL_PP(arg)) {
+			if (Z_LVAL_P(arg)) {
 				TRACE_APPEND_STR("true, ");
 			} else {
 				TRACE_APPEND_STR("false, ");
 			}
 			break;
-		case IS_RESOURCE:
+		case IS_RESOURCE: {
+			long lval = Z_RES_HANDLE_P(arg);
+			char s_tmp[MAX_LENGTH_OF_LONG + 1];
+			int l_tmp = zend_sprintf(s_tmp, "%ld", lval);  /* SAFE */
 			TRACE_APPEND_STR("Resource id #");
-			/* break; */
+			TRACE_APPEND_STRL(s_tmp, l_tmp);
+			TRACE_APPEND_STR(", ");
+			break;
+		}
 		case IS_LONG: {
-			long lval = Z_LVAL_PP(arg);
+			long lval = Z_LVAL_P(arg);
 			char s_tmp[MAX_LENGTH_OF_LONG + 1];
 			int l_tmp = zend_sprintf(s_tmp, "%ld", lval);  /* SAFE */
 			TRACE_APPEND_STRL(s_tmp, l_tmp);
@@ -474,7 +481,7 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 			break;
 		}
 		case IS_DOUBLE: {
-			double dval = Z_DVAL_PP(arg);
+			double dval = Z_DVAL_P(arg);
 			char *s_tmp;
 			int l_tmp;
 
@@ -490,58 +497,56 @@ static int _build_trace_args(zval **arg TSRMLS_DC, int num_args, va_list args, z
 			TRACE_APPEND_STR("Array, ");
 			break;
 		case IS_OBJECT: {
-			const char *class_name;
-			zend_uint class_name_len;
-			int dup;
+			zend_string *class_name;
 
 			TRACE_APPEND_STR("Object(");
 
-			dup = zend_get_object_classname(*arg, &class_name, &class_name_len TSRMLS_CC);
-
-			TRACE_APPEND_STRL(class_name, class_name_len);
-			if(!dup) {
-				efree((char*)class_name);
-			}
+			class_name = zend_get_object_classname(Z_OBJ_P(arg) TSRMLS_CC);
 
+			TRACE_APPEND_STRL(class_name->val, class_name->len);
 			TRACE_APPEND_STR("), ");
 			break;
 		}
 		default:
 			break;
 	}
+	*str_ptr = str;
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
 
-static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int _build_trace_string(zval *frame TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
-	char *s_tmp, **str;
-	int *len, *num;
+	char *s_tmp;
+	int len, *num;
 	long line;
-	HashTable *ht = Z_ARRVAL_PP(frame);
-	zval **file, **tmp;
+	HashTable *ht = Z_ARRVAL_P(frame);
+	zval *file, *tmp;
+	zend_string *str, **str_ptr;
 
-	if (Z_TYPE_PP(frame) != IS_ARRAY) {
+	if (Z_TYPE_P(frame) != IS_ARRAY) {
 		zend_error(E_WARNING, "Expected array for frame %lu", hash_key->h);
 		return ZEND_HASH_APPLY_KEEP;
 	}
 
-	str = va_arg(args, char**);
-	len = va_arg(args, int*);
+	str_ptr = va_arg(args, zend_string**);
+	str = *str_ptr;
 	num = va_arg(args, int*);
 
 	s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 1 + 1);
-	sprintf(s_tmp, "#%d ", (*num)++);
-	TRACE_APPEND_STRL(s_tmp, strlen(s_tmp));
+	len = sprintf(s_tmp, "#%d ", (*num)++);
+	TRACE_APPEND_STRL(s_tmp, len);
 	efree(s_tmp);
-	if (zend_hash_find(ht, "file", sizeof("file"), (void**)&file) == SUCCESS) {
-		if (Z_TYPE_PP(file) != IS_STRING) {
+	file = zend_hash_str_find(ht, "file", sizeof("file")-1);
+	if (file) {
+		if (Z_TYPE_P(file) != IS_STRING) {
 			zend_error(E_WARNING, "Function name is no string");
 			TRACE_APPEND_STR("[unknown function]");
 		} else{
-			if (zend_hash_find(ht, "line", sizeof("line"), (void**)&tmp) == SUCCESS) {
-				if (Z_TYPE_PP(tmp) == IS_LONG) {
-					line = Z_LVAL_PP(tmp);
+			tmp = zend_hash_str_find(ht, "line", sizeof("line")-1);
+			if (tmp) {
+				if (Z_TYPE_P(tmp) == IS_LONG) {
+					line = Z_LVAL_P(tmp);
 				} else {
 					zend_error(E_WARNING, "Line is no long");
 					line = 0;
@@ -549,9 +554,9 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 			} else {
 				line = 0;
 			}
-			s_tmp = emalloc(Z_STRLEN_PP(file) + MAX_LENGTH_OF_LONG + 4 + 1);
-			sprintf(s_tmp, "%s(%ld): ", Z_STRVAL_PP(file), line);
-			TRACE_APPEND_STRL(s_tmp, strlen(s_tmp));
+			s_tmp = emalloc(Z_STRLEN_P(file) + MAX_LENGTH_OF_LONG + 4 + 1);
+			len = sprintf(s_tmp, "%s(%ld): ", Z_STRVAL_P(file), line);
+			TRACE_APPEND_STRL(s_tmp, len);
 			efree(s_tmp);
 		}
 	} else {
@@ -561,18 +566,20 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 	TRACE_APPEND_KEY("type");
 	TRACE_APPEND_KEY("function");
 	TRACE_APPEND_CHR('(');
-	if (zend_hash_find(ht, "args", sizeof("args"), (void**)&tmp) == SUCCESS) {
-		if (Z_TYPE_PP(tmp) == IS_ARRAY) {
-			int last_len = *len;
-			zend_hash_apply_with_arguments(Z_ARRVAL_PP(tmp) TSRMLS_CC, (apply_func_args_t)_build_trace_args, 2, str, len);
-			if (last_len != *len) {
-				*len -= 2; /* remove last ', ' */
+	tmp = zend_hash_str_find(ht, "args", sizeof("args")-1);
+	if (tmp) {
+		if (Z_TYPE_P(tmp) == IS_ARRAY) {
+			int last_len = str->len;
+			zend_hash_apply_with_arguments(Z_ARRVAL_P(tmp) TSRMLS_CC, (apply_func_args_t)_build_trace_args, 1, &str);
+			if (last_len != str->len) {
+				str->len -= 2; /* remove last ', ' */
 			}
 		} else {
 			zend_error(E_WARNING, "args element is no array");
 		}
 	}
 	TRACE_APPEND_STR(")\n");
+	*str_ptr = str;
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
@@ -582,24 +589,23 @@ static int _build_trace_string(zval **frame TSRMLS_DC, int num_args, va_list arg
 ZEND_METHOD(exception, getTraceAsString)
 {
 	zval *trace;
-	char *res, **str, *s_tmp;
-	int res_len = 0, *len = &res_len, num = 0;
+	zend_string *str;
+	int num = 0, len;
+	char s_tmp[MAX_LENGTH_OF_LONG + 7 + 1 + 1];
 
 	DEFAULT_0_PARAMS;
 	
-	res = estrdup("");
-	str = &res;
+	str = STR_ALLOC(0, 0);
 
 	trace = zend_read_property(default_exception_ce, getThis(), "trace", sizeof("trace")-1, 1 TSRMLS_CC);
-	zend_hash_apply_with_arguments(Z_ARRVAL_P(trace) TSRMLS_CC, (apply_func_args_t)_build_trace_string, 3, str, len, &num);
+	zend_hash_apply_with_arguments(Z_ARRVAL_P(trace) TSRMLS_CC, (apply_func_args_t)_build_trace_string, 2, &str, &num);
 
-	s_tmp = emalloc(1 + MAX_LENGTH_OF_LONG + 7 + 1);
-	sprintf(s_tmp, "#%d {main}", num);
-	TRACE_APPEND_STRL(s_tmp, strlen(s_tmp));
-	efree(s_tmp);
+	len = sprintf(s_tmp, "#%d {main}", num);
+	TRACE_APPEND_STRL(s_tmp, len);
+
+	str->val[str->len] = '\0';	
 
-	res[res_len] = '\0';	
-	RETURN_STRINGL(res, res_len, 0); 
+	RETURN_NEW_STR(str); 
 }
 /* }}} */
 
@@ -631,7 +637,7 @@ int zend_spprintf(char **message, int max_len, const char *format, ...) /* {{{ *
    Obtain the string representation of the Exception object */
 ZEND_METHOD(exception, __toString)
 {
-	zval message, file, line, *trace, *exception;
+	zval message, file, line, trace, *exception;
 	char *str, *prev_str;
 	int len = 0;
 	zend_fcall_info fci;
@@ -642,7 +648,7 @@ ZEND_METHOD(exception, __toString)
 	str = estrndup("", 0);
 
 	exception = getThis();
-	ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1, 1);
+	ZVAL_STRINGL(&fname, "gettraceasstring", sizeof("gettraceasstring")-1);
 
 	while (exception && Z_TYPE_P(exception) == IS_OBJECT) {
 		prev_str = str;
@@ -656,30 +662,30 @@ ZEND_METHOD(exception, __toString)
 
 		fci.size = sizeof(fci);
 		fci.function_table = &Z_OBJCE_P(exception)->function_table;
-		fci.function_name = &fname;
+		ZVAL_COPY_VALUE(&fci.function_name, &fname);
 		fci.symbol_table = NULL;
-		fci.object_ptr = exception;
-		fci.retval_ptr_ptr = &trace;
+		fci.object = Z_OBJ_P(exception);
+		fci.retval = &trace;
 		fci.param_count = 0;
 		fci.params = NULL;
 		fci.no_separation = 1;
 
 		zend_call_function(&fci, NULL TSRMLS_CC);
 
-		if (Z_TYPE_P(trace) != IS_STRING) {
+		if (Z_TYPE(trace) != IS_STRING) {
 			zval_ptr_dtor(&trace);
-			trace = NULL;
+			ZVAL_UNDEF(&trace);
 		}
 
 		if (Z_STRLEN(message) > 0) {
 			len = zend_spprintf(&str, 0, "exception '%s' with message '%s' in %s:%ld\nStack trace:\n%s%s%s",
-								Z_OBJCE_P(exception)->name, Z_STRVAL(message), Z_STRVAL(file), Z_LVAL(line),
-								(trace && Z_STRLEN_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n",
+								Z_OBJCE_P(exception)->name->val, Z_STRVAL(message), Z_STRVAL(file), Z_LVAL(line),
+								(Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n",
 								len ? "\n\nNext " : "", prev_str);
 		} else {
 			len = zend_spprintf(&str, 0, "exception '%s' in %s:%ld\nStack trace:\n%s%s%s",
-								Z_OBJCE_P(exception)->name, Z_STRVAL(file), Z_LVAL(line),
-								(trace && Z_STRLEN_P(trace)) ? Z_STRVAL_P(trace) : "#0 {main}\n",
+								Z_OBJCE_P(exception)->name->val, Z_STRVAL(file), Z_LVAL(line),
+								(Z_TYPE(trace) == IS_STRING && Z_STRLEN(trace)) ? Z_STRVAL(trace) : "#0 {main}\n",
 								len ? "\n\nNext " : "", prev_str);
 		}
 		efree(prev_str);
@@ -689,9 +695,7 @@ ZEND_METHOD(exception, __toString)
 
 		exception = zend_read_property(default_exception_ce, exception, "previous", sizeof("previous")-1, 0 TSRMLS_CC);
 
-		if (trace) {
-			zval_ptr_dtor(&trace);
-		}
+		zval_ptr_dtor(&trace);
 
 	}
 	zval_dtor(&fname);
@@ -700,7 +704,9 @@ ZEND_METHOD(exception, __toString)
 	 * the result in uncaught exception handlers without memleaks. */
 	zend_update_property_string(default_exception_ce, getThis(), "string", sizeof("string")-1, str TSRMLS_CC);
 
-	RETURN_STRINGL(str, len, 0);
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL(str, len);
+	efree(str);
 }
 /* }}} */
 
@@ -769,7 +775,7 @@ void zend_register_default_exception(TSRMLS_D) /* {{{ */
 	zend_declare_property_null(default_exception_ce, "previous", sizeof("previous")-1, ZEND_ACC_PRIVATE TSRMLS_CC);
 
 	INIT_CLASS_ENTRY(ce, "ErrorException", error_exception_functions);
-	error_exception_ce = zend_register_internal_class_ex(&ce, default_exception_ce, NULL TSRMLS_CC);
+	error_exception_ce = zend_register_internal_class_ex(&ce, default_exception_ce TSRMLS_CC);
 	error_exception_ce->create_object = zend_error_exception_new;
 	zend_declare_property_long(error_exception_ce, "severity", sizeof("severity")-1, E_ERROR, ZEND_ACC_PROTECTED TSRMLS_CC);
 }
@@ -787,11 +793,10 @@ ZEND_API zend_class_entry *zend_get_error_exception(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC) /* {{{ */
+ZEND_API zend_object *zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC) /* {{{ */
 {
-	zval *ex;
+	zval ex;
 
-	MAKE_STD_ZVAL(ex);
 	if (exception_ce) {
 		if (!instanceof_function(exception_ce, default_exception_ce TSRMLS_CC)) {
 			zend_error(E_NOTICE, "Exceptions must be derived from the Exception base class");
@@ -800,41 +805,43 @@ ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char
 	} else {
 		exception_ce = default_exception_ce;
 	}
-	object_init_ex(ex, exception_ce);
+	object_init_ex(&ex, exception_ce);
 
 
 	if (message) {
-		zend_update_property_string(default_exception_ce, ex, "message", sizeof("message")-1, message TSRMLS_CC);
+		zend_update_property_string(default_exception_ce, &ex, "message", sizeof("message")-1, message TSRMLS_CC);
 	}
 	if (code) {
-		zend_update_property_long(default_exception_ce, ex, "code", sizeof("code")-1, code TSRMLS_CC);
+		zend_update_property_long(default_exception_ce, &ex, "code", sizeof("code")-1, code TSRMLS_CC);
 	}
 
-	zend_throw_exception_internal(ex TSRMLS_CC);
-	return ex;
+	zend_throw_exception_internal(&ex TSRMLS_CC);
+	return Z_OBJ(ex);
 }
 /* }}} */
 
-ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...) /* {{{ */
+ZEND_API zend_object *zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...) /* {{{ */
 {
 	va_list arg;
 	char *message;
-	zval *zexception;
+	zend_object *obj;
 
 	va_start(arg, format);
 	zend_vspprintf(&message, 0, format, arg);
 	va_end(arg);
-	zexception = zend_throw_exception(exception_ce, message, code TSRMLS_CC);
+	obj = zend_throw_exception(exception_ce, message, code TSRMLS_CC);
 	efree(message);
-	return zexception;
+	return obj;
 }
 /* }}} */
 
-ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC) /* {{{ */
+ZEND_API zend_object *zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC) /* {{{ */
 {
-	zval *ex = zend_throw_exception(exception_ce, message, code TSRMLS_CC);
-	zend_update_property_long(default_exception_ce, ex, "severity", sizeof("severity")-1, severity TSRMLS_CC);
-	return ex;
+	zval ex;
+	zend_object *obj = zend_throw_exception(exception_ce, message, code TSRMLS_CC);
+	ZVAL_OBJ(&ex, obj);
+	zend_update_property_long(default_exception_ce, &ex, "severity", sizeof("severity")-1, severity TSRMLS_CC);
+	return obj;
 }
 /* }}} */
 
@@ -849,29 +856,36 @@ static void zend_error_va(int type, const char *file, uint lineno, const char *f
 /* }}} */
 
 /* This function doesn't return if it uses E_ERROR */
-ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC) /* {{{ */
+ZEND_API void zend_exception_error(zend_object *ex, int severity TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry *ce_exception = Z_OBJCE_P(exception);
+	zval exception;
+	zend_class_entry *ce_exception;
+	
+	ZVAL_OBJ(&exception, ex);
+	ce_exception = Z_OBJCE(exception);
 	if (instanceof_function(ce_exception, default_exception_ce TSRMLS_CC)) {
-		zval *str, *file, *line;
+		zval tmp, *str, *file, *line;
 
 		EG(exception) = NULL;
 
-		zend_call_method_with_0_params(&exception, ce_exception, NULL, "__tostring", &str);
+		zend_call_method_with_0_params(&exception, ce_exception, NULL, "__tostring", &tmp);
 		if (!EG(exception)) {
-			if (Z_TYPE_P(str) != IS_STRING) {
-				zend_error(E_WARNING, "%s::__toString() must return a string", ce_exception->name);
+			if (Z_TYPE(tmp) != IS_STRING) {
+				zend_error(E_WARNING, "%s::__toString() must return a string", ce_exception->name->val);
 			} else {
-				zend_update_property_string(default_exception_ce, exception, "string", sizeof("string")-1, EG(exception) ? ce_exception->name : Z_STRVAL_P(str) TSRMLS_CC);
+				zend_update_property_string(default_exception_ce, &exception, "string", sizeof("string")-1, EG(exception) ? ce_exception->name->val : Z_STRVAL(tmp) TSRMLS_CC);
 			}
 		}
-		zval_ptr_dtor(&str);
+		zval_ptr_dtor(&tmp);
 
 		if (EG(exception)) {
+			zval zv;
+
+			ZVAL_OBJ(&zv, EG(exception));
 			/* do the best we can to inform about the inner exception */
 			if (instanceof_function(ce_exception, default_exception_ce TSRMLS_CC)) {
-				file = zend_read_property(default_exception_ce, EG(exception), "file", sizeof("file")-1, 1 TSRMLS_CC);
-				line = zend_read_property(default_exception_ce, EG(exception), "line", sizeof("line")-1, 1 TSRMLS_CC);
+				file = zend_read_property(default_exception_ce, &zv, "file", sizeof("file")-1, 1 TSRMLS_CC);
+				line = zend_read_property(default_exception_ce, &zv, "line", sizeof("line")-1, 1 TSRMLS_CC);
 
 				convert_to_string(file);
 				file = (Z_STRLEN_P(file) > 0) ? file : NULL;
@@ -880,12 +894,12 @@ ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC) /* {
 				file = NULL;
 				line = NULL;
 			}
-			zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_LVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE_P(EG(exception))->name, ce_exception->name);
+			zend_error_va(E_WARNING, file ? Z_STRVAL_P(file) : NULL, line ? Z_LVAL_P(line) : 0, "Uncaught %s in exception handling during call to %s::__tostring()", Z_OBJCE(zv)->name->val, ce_exception->name->val);
 		}
 
-		str = zend_read_property(default_exception_ce, exception, "string", sizeof("string")-1, 1 TSRMLS_CC);
-		file = zend_read_property(default_exception_ce, exception, "file", sizeof("file")-1, 1 TSRMLS_CC);
-		line = zend_read_property(default_exception_ce, exception, "line", sizeof("line")-1, 1 TSRMLS_CC);
+		str = zend_read_property(default_exception_ce, &exception, "string", sizeof("string")-1, 1 TSRMLS_CC);
+		file = zend_read_property(default_exception_ce, &exception, "file", sizeof("file")-1, 1 TSRMLS_CC);
+		line = zend_read_property(default_exception_ce, &exception, "line", sizeof("line")-1, 1 TSRMLS_CC);
 
 		convert_to_string(str);
 		convert_to_string(file);
@@ -893,7 +907,7 @@ ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC) /* {
 
 		zend_error_va(severity, (Z_STRLEN_P(file) > 0) ? Z_STRVAL_P(file) : NULL, Z_LVAL_P(line), "Uncaught %s\n  thrown", Z_STRVAL_P(str));
 	} else {
-		zend_error(severity, "Uncaught exception '%s'", ce_exception->name);
+		zend_error(severity, "Uncaught exception '%s'", ce_exception->name->val);
 	}
 }
 /* }}} */
diff --git a/Zend/zend_exceptions.h b/Zend/zend_exceptions.h
index 2ce9c1295c..24113d6f8d 100644
--- a/Zend/zend_exceptions.h
+++ b/Zend/zend_exceptions.h
@@ -26,7 +26,7 @@
 
 BEGIN_EXTERN_C()
 
-ZEND_API void zend_exception_set_previous(zval *exception, zval *add_previous TSRMLS_DC);
+ZEND_API void zend_exception_set_previous(zend_object *exception, zend_object *add_previous TSRMLS_DC);
 ZEND_API void zend_exception_save(TSRMLS_D);
 ZEND_API void zend_exception_restore(TSRMLS_D);
 
@@ -40,17 +40,17 @@ ZEND_API void zend_register_default_classes(TSRMLS_D);
 
 /* exception_ce   NULL or zend_exception_get_default() or a derived class
  * message        NULL or the message of the exception */
-ZEND_API zval * zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC);
-ZEND_API zval * zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...);
+ZEND_API zend_object *zend_throw_exception(zend_class_entry *exception_ce, const char *message, long code TSRMLS_DC);
+ZEND_API zend_object *zend_throw_exception_ex(zend_class_entry *exception_ce, long code TSRMLS_DC, const char *format, ...);
 ZEND_API void zend_throw_exception_object(zval *exception TSRMLS_DC);
 ZEND_API void zend_clear_exception(TSRMLS_D);
 
-ZEND_API zval * zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC);
+ZEND_API zend_object *zend_throw_error_exception(zend_class_entry *exception_ce, const char *message, long code, int severity TSRMLS_DC);
 
 extern ZEND_API void (*zend_throw_exception_hook)(zval *ex TSRMLS_DC);
 
 /* show an exception using zend_error(severity,...), severity should be E_ERROR */
-ZEND_API void zend_exception_error(zval *exception, int severity TSRMLS_DC);
+ZEND_API void zend_exception_error(zend_object *exception, int severity TSRMLS_DC);
 
 /* do not export, in php it's available thru spprintf directly */
 int zend_spprintf(char **message, int max_len, const char *format, ...);
diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index bdf8b6e70f..22acd4e960 100644
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -51,7 +51,9 @@
 typedef int (*incdec_t)(zval *);
 
 #define get_zval_ptr(op_type, node, ex, should_free, type) _get_zval_ptr(op_type, node, ex, should_free, type TSRMLS_CC)
+#define get_zval_ptr_deref(op_type, node, ex, should_free, type) _get_zval_ptr_deref(op_type, node, ex, should_free, type TSRMLS_CC)
 #define get_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type TSRMLS_CC)
+#define get_zval_ptr_ptr_undef(op_type, node, ex, should_free, type) _get_zval_ptr_ptr(op_type, node, ex, should_free, type TSRMLS_CC)
 #define get_obj_zval_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr(op_type, node, ex, should_free, type TSRMLS_CC)
 #define get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type) _get_obj_zval_ptr_ptr(op_type, node, ex, should_free, type TSRMLS_CC)
 
@@ -62,60 +64,31 @@ static void zend_extension_fcall_end_handler(const zend_extension *extension, ze
 
 #define RETURN_VALUE_USED(opline) (!((opline)->result_type & EXT_TYPE_UNUSED))
 
-#define EX_T(offset) (*EX_TMP_VAR(execute_data, offset))
-#define EX_CV(var)   (*EX_CV_NUM(execute_data, var))
-
 #define TEMP_VAR_STACK_LIMIT 2000
 
-static zend_always_inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free, int unref TSRMLS_DC)
+static zend_always_inline void zend_pzval_unlock_func(zval *z, zend_free_op *should_free)
 {
-	if (!Z_DELREF_P(z)) {
+	should_free->var = NULL;
+	if (Z_REFCOUNTED_P(z) && !Z_DELREF_P(z)) {
 		Z_SET_REFCOUNT_P(z, 1);
-		Z_UNSET_ISREF_P(z);
 		should_free->var = z;
-/*		should_free->is_var = 1; */
-	} else {
-		should_free->var = 0;
-		if (unref && Z_ISREF_P(z) && Z_REFCOUNT_P(z) == 1) {
-			Z_UNSET_ISREF_P(z);
-		}
-	}
-}
-
-static zend_always_inline void zend_pzval_unlock_free_func(zval *z TSRMLS_DC)
-{
-	if (!Z_DELREF_P(z)) {
-		ZEND_ASSERT(z != &EG(uninitialized_zval));
-		GC_REMOVE_ZVAL_FROM_BUFFER(z);
-		zval_dtor(z);
-		efree(z);
+		/* should_free->is_var = 1; */
 	}
 }
 
 #undef zval_ptr_dtor
-#define zval_ptr_dtor(pzv) i_zval_ptr_dtor(*(pzv) ZEND_FILE_LINE_CC TSRMLS_CC)
-#define zval_ptr_dtor_nogc(pzv) i_zval_ptr_dtor_nogc(*(pzv) ZEND_FILE_LINE_CC TSRMLS_CC)
+#define zval_ptr_dtor(zv) i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC TSRMLS_CC)
+#define zval_ptr_dtor_nogc(zv) i_zval_ptr_dtor_nogc(zv ZEND_FILE_LINE_CC TSRMLS_CC)
 
-#define PZVAL_UNLOCK(z, f) zend_pzval_unlock_func(z, f, 1 TSRMLS_CC)
-#define PZVAL_UNLOCK_EX(z, f, u) zend_pzval_unlock_func(z, f, u TSRMLS_CC)
-#define PZVAL_UNLOCK_FREE(z) zend_pzval_unlock_free_func(z TSRMLS_CC)
-#define PZVAL_LOCK(z) Z_ADDREF_P((z))
+#define PZVAL_UNLOCK(z, f) zend_pzval_unlock_func(z, f)
+#define PZVAL_LOCK(z) if (Z_REFCOUNTED_P(z)) Z_ADDREF_P((z))
 #define SELECTIVE_PZVAL_LOCK(pzv, opline)	if (RETURN_VALUE_USED(opline)) { PZVAL_LOCK(pzv); }
 
-#define EXTRACT_ZVAL_PTR(t) do {				\
-		temp_variable *__t = (t);				\
-		__t->var.ptr = *__t->var.ptr_ptr;		\
-		__t->var.ptr_ptr = &__t->var.ptr;		\
-		if (!PZVAL_IS_REF(__t->var.ptr) && 		\
-		    Z_REFCOUNT_P(__t->var.ptr) > 2) {	\
-			SEPARATE_ZVAL(__t->var.ptr_ptr);	\
-		}										\
-	} while (0)
-
-#define AI_SET_PTR(t, val) do {				\
-		temp_variable *__t = (t);			\
-		__t->var.ptr = (val);				\
-		__t->var.ptr_ptr = &__t->var.ptr;	\
+#define EXTRACT_ZVAL_PTR(zv) do {						\
+		zval *__zv = (zv);								\
+		if (Z_TYPE_P(__zv) == IS_INDIRECT) {			\
+			ZVAL_COPY(__zv, Z_INDIRECT_P(__zv));		\
+		}												\
 	} while (0)
 
 #define FREE_OP(should_free) \
@@ -123,18 +96,18 @@ static zend_always_inline void zend_pzval_unlock_free_func(zval *z TSRMLS_DC)
 		if ((zend_uintptr_t)should_free.var & 1L) { \
 			zval_dtor((zval*)((zend_uintptr_t)should_free.var & ~1L)); \
 		} else { \
-			zval_ptr_dtor_nogc(&should_free.var); \
+			zval_ptr_dtor_nogc(should_free.var); \
 		} \
 	}
 
 #define FREE_OP_IF_VAR(should_free) \
 	if (should_free.var != NULL && (((zend_uintptr_t)should_free.var & 1L) == 0)) { \
-		zval_ptr_dtor_nogc(&should_free.var); \
+		zval_ptr_dtor_nogc(should_free.var); \
 	}
 
 #define FREE_OP_VAR_PTR(should_free) \
 	if (should_free.var) { \
-		zval_ptr_dtor_nogc(&should_free.var); \
+		zval_ptr_dtor_nogc(should_free.var); \
 	}
 
 #define TMP_FREE(z) (zval*)(((zend_uintptr_t)(z)) | 1L)
@@ -143,10 +116,9 @@ static zend_always_inline void zend_pzval_unlock_free_func(zval *z TSRMLS_DC)
 
 #define MAKE_REAL_ZVAL_PTR(val) \
 	do { \
-		zval *_tmp; \
-		ALLOC_ZVAL(_tmp); \
-		INIT_PZVAL_COPY(_tmp, (val)); \
-		(val) = _tmp; \
+		zval _tmp; \
+		ZVAL_COPY_VALUE(&_tmp, (val)); \
+		(val) = &_tmp; \
 	} while (0)
 
 /* End of zend_execute_locks.h */
@@ -167,417 +139,390 @@ static zend_always_inline void zend_pzval_unlock_free_func(zval *z TSRMLS_DC)
 #undef EX
 #define EX(element) execute_data->element
 
-ZEND_API zval** zend_get_compiled_variable_value(const zend_execute_data *execute_data, zend_uint var)
+ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data, zend_uint var)
 {
-	return EX_CV(var);
+	return EX_VAR(var);
 }
 
 static zend_always_inline zval *_get_zval_ptr_tmp(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
 {
-	return should_free->var = &EX_T(var).tmp_var;
+	zval *ret = EX_VAR(var);
+
+	should_free->var = ret;
+	return ret;
 }
 
 static zend_always_inline zval *_get_zval_ptr_var(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
 {
-	zval *ptr = EX_T(var).var.ptr;
+	zval *ret = EX_VAR(var);
 
-	return should_free->var = ptr;
+	should_free->var = ret;
+	return ret;
 }
 
-static zend_never_inline zval **_get_zval_cv_lookup(zval ***ptr, zend_uint var, int type TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_var_deref(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
 {
-	zend_compiled_variable *cv = &CV_DEF_OF(var);
+	zval *ret = EX_VAR(var);
 
-	if (!EG(active_symbol_table) ||
-	    zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
-		switch (type) {
-			case BP_VAR_R:
-			case BP_VAR_UNSET:
-				zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
-				/* break missing intentionally */
-			case BP_VAR_IS:
-				return &EG(uninitialized_zval_ptr);
-				break;
-			case BP_VAR_RW:
-				zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
-				/* break missing intentionally */
-			case BP_VAR_W:
-				Z_ADDREF(EG(uninitialized_zval));
-				if (!EG(active_symbol_table)) {
-					*ptr = (zval**)EX_CV_NUM(EG(current_execute_data), EG(active_op_array)->last_var + var);
-					**ptr = &EG(uninitialized_zval);
-				} else {
-					zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **)ptr);
-				}
-				break;
-		}
-	}
-	return *ptr;
+	should_free->var = ret;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
-static zend_never_inline zval **_get_zval_cv_lookup_BP_VAR_R(zval ***ptr, zend_uint var TSRMLS_DC)
+static zend_never_inline zval *_get_zval_cv_lookup(zval *ptr, zend_uint var, int type TSRMLS_DC)
 {
-	zend_compiled_variable *cv = &CV_DEF_OF(var);
+	zend_string *cv;
 
-	if (!EG(active_symbol_table) ||
-	    zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
-		zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
-		return &EG(uninitialized_zval_ptr);
+	switch (type) {
+		case BP_VAR_R:
+		case BP_VAR_UNSET:
+			cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
+			zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
+			/* break missing intentionally */
+		case BP_VAR_IS:
+			ptr = &EG(uninitialized_zval);
+			break;
+		case BP_VAR_RW:
+			cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
+			zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
+			/* break missing intentionally */
+		case BP_VAR_W:
+			ZVAL_NULL(ptr);
+			break;
 	}
-	return *ptr;
+	return ptr;
 }
 
-static zend_never_inline zval **_get_zval_cv_lookup_BP_VAR_UNSET(zval ***ptr, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_R(zval *ptr, zend_uint var TSRMLS_DC)
 {
-	zend_compiled_variable *cv = &CV_DEF_OF(var);
+	zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
 
-	if (!EG(active_symbol_table) ||
-	    zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
-		zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
-		return &EG(uninitialized_zval_ptr);
-	}
-	return *ptr;
+	zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
+	return &EG(uninitialized_zval);
 }
 
-static zend_never_inline zval **_get_zval_cv_lookup_BP_VAR_IS(zval ***ptr, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_UNSET(zval *ptr, zend_uint var TSRMLS_DC)
 {
-	zend_compiled_variable *cv = &CV_DEF_OF(var);
+	zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
 
-	if (!EG(active_symbol_table) ||
-	    zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
-		return &EG(uninitialized_zval_ptr);
-	}
-	return *ptr;
+	zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
+	return &EG(uninitialized_zval);
 }
 
-static zend_never_inline zval **_get_zval_cv_lookup_BP_VAR_RW(zval ***ptr, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_IS(zval *ptr, zend_uint var TSRMLS_DC)
 {
-	zend_compiled_variable *cv = &CV_DEF_OF(var);
+	return &EG(uninitialized_zval);
+}
 
-	if (!EG(active_symbol_table)) {
-		Z_ADDREF(EG(uninitialized_zval));
-		*ptr = (zval**)EX_CV_NUM(EG(current_execute_data), EG(active_op_array)->last_var + var);
-		**ptr = &EG(uninitialized_zval);
-		zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
-	} else if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
-		Z_ADDREF(EG(uninitialized_zval));
-		zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **)ptr);
-		zend_error(E_NOTICE, "Undefined variable: %s", cv->name);
-	}
-	return *ptr;
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_RW(zval *ptr, zend_uint var TSRMLS_DC)
+{
+	zend_string *cv = CV_DEF_OF(EX_VAR_TO_NUM(var));
+
+	ZVAL_NULL(ptr);
+	zend_error(E_NOTICE, "Undefined variable: %s", cv->val);
+	return ptr;
 }
 
-static zend_never_inline zval **_get_zval_cv_lookup_BP_VAR_W(zval ***ptr, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_cv_lookup_BP_VAR_W(zval *ptr, zend_uint var TSRMLS_DC)
 {
-	zend_compiled_variable *cv = &CV_DEF_OF(var);
+	ZVAL_NULL(ptr);
+	return ptr;
+}
 
-	if (!EG(active_symbol_table)) {
-		Z_ADDREF(EG(uninitialized_zval));
-		*ptr = (zval**)EX_CV_NUM(EG(current_execute_data), EG(active_op_array)->last_var + var);
-		**ptr = &EG(uninitialized_zval);
-	} else if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **)ptr)==FAILURE) {
-		Z_ADDREF(EG(uninitialized_zval));
-		zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **)ptr);
+static zend_always_inline zval *_get_zval_ptr_cv(const zend_execute_data *execute_data, zend_uint var, int type TSRMLS_DC)
+{
+	zval *ret = EX_VAR(var);
+
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup(ret, var, type TSRMLS_CC);
 	}
-	return *ptr;
+	return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv(zend_uint var, int type TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref(const zend_execute_data *execute_data, zend_uint var, int type TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(EG(current_execute_data), var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return *_get_zval_cv_lookup(ptr, var, type TSRMLS_CC);
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup(ret, var, type TSRMLS_CC);
 	}
-	return **ptr;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
 static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_R(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return *_get_zval_cv_lookup_BP_VAR_R(ptr, var TSRMLS_CC);
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup_BP_VAR_R(ret, var TSRMLS_CC);
 	}
-	return **ptr;
+	return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_R(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return *_get_zval_cv_lookup_BP_VAR_UNSET(ptr, var TSRMLS_CC);
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup_BP_VAR_R(ret, var TSRMLS_CC);
 	}
-	return **ptr;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_UNSET(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return *_get_zval_cv_lookup_BP_VAR_IS(ptr, var TSRMLS_CC);
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var TSRMLS_CC);
 	}
-	return **ptr;
+	return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_UNSET(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return *_get_zval_cv_lookup_BP_VAR_RW(ptr, var TSRMLS_CC);
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup_BP_VAR_UNSET(ret, var TSRMLS_CC);
 	}
-	return **ptr;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
-static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_IS(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return *_get_zval_cv_lookup_BP_VAR_W(ptr, var TSRMLS_CC);
+	if (Z_TYPE_P(ret) == IS_UNDEF) {
+		return _get_zval_cv_lookup_BP_VAR_IS(ret, var TSRMLS_CC);
 	}
-	return **ptr;
+	return ret;
 }
 
-static inline zval *_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_IS(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-/*	should_free->is_var = 0; */
-	switch (op_type) {
-		case IS_CONST:
-			should_free->var = 0;
-			return node->zv;
-			break;
-		case IS_TMP_VAR:
-			should_free->var = TMP_FREE(&EX_T(node->var).tmp_var);
-			return &EX_T(node->var).tmp_var;
-			break;
-		case IS_VAR:
-			return _get_zval_ptr_var(node->var, execute_data, should_free TSRMLS_CC);
-			break;
-		case IS_UNUSED:
-			should_free->var = 0;
-			return NULL;
-			break;
-		case IS_CV:
-			should_free->var = 0;
-			return _get_zval_ptr_cv(node->var, type TSRMLS_CC);
-			break;
-		EMPTY_SWITCH_DEFAULT_CASE()
+	zval *ret = EX_VAR(var);
+
+	if (Z_TYPE_P(ret) == IS_UNDEF) {
+		return _get_zval_cv_lookup_BP_VAR_IS(ret, var TSRMLS_CC);
 	}
-	return NULL;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_var(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_RW(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval** ptr_ptr = EX_T(var).var.ptr_ptr;
+	zval *ret = EX_VAR(var);
 
-	if (EXPECTED(ptr_ptr != NULL)) {
-		PZVAL_UNLOCK(*ptr_ptr, should_free);
-	} else {
-		/* string offset */
-		PZVAL_UNLOCK(EX_T(var).str_offset.str, should_free);
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup_BP_VAR_RW(ret, var TSRMLS_CC);
 	}
-	return ptr_ptr;
+	return ret;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_var_fast(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_RW(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval** ptr_ptr = EX_T(var).var.ptr_ptr;
+	zval *ret = EX_VAR(var);
 
-	if (EXPECTED(ptr_ptr != NULL)) {
-		should_free->var = *ptr_ptr;
-	} else {
-		/* string offset */
-		should_free->var = EX_T(var).str_offset.str;
+	if (UNEXPECTED(Z_TYPE_P(ret) == IS_UNDEF)) {
+		return _get_zval_cv_lookup_BP_VAR_RW(ret, var TSRMLS_CC);
 	}
-	return ptr_ptr;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_cv(zend_uint var, int type TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(EG(current_execute_data), var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return _get_zval_cv_lookup(ptr, var, type TSRMLS_CC);
+	if (Z_TYPE_P(ret) == IS_UNDEF) {
+		return _get_zval_cv_lookup_BP_VAR_W(ret, var TSRMLS_CC);
 	}
-	return *ptr;
+	return ret;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_cv_BP_VAR_R(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_undef_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
-
-	if (UNEXPECTED(*ptr == NULL)) {
-		return _get_zval_cv_lookup_BP_VAR_R(ptr, var TSRMLS_CC);
-	}
-	return *ptr;
+	return EX_VAR(var);
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_cv_BP_VAR_UNSET(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_cv_deref_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret = EX_VAR(var);
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return _get_zval_cv_lookup_BP_VAR_UNSET(ptr, var TSRMLS_CC);
+	if (Z_TYPE_P(ret) == IS_UNDEF) {
+		return _get_zval_cv_lookup_BP_VAR_W(ret, var TSRMLS_CC);
 	}
-	return *ptr;
+	ZVAL_DEREF(ret);
+	return ret;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_cv_BP_VAR_IS(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static inline zval *_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret;
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return _get_zval_cv_lookup_BP_VAR_IS(ptr, var TSRMLS_CC);
+	switch (op_type) {
+		case IS_CONST:
+			should_free->var = NULL;
+			return node->zv;
+			break;
+		case IS_TMP_VAR:
+			ret = EX_VAR(node->var);
+			should_free->var = TMP_FREE(ret);
+			return ret;
+			break;
+		case IS_VAR:
+			return _get_zval_ptr_var(node->var, execute_data, should_free TSRMLS_CC);
+			break;
+		case IS_UNUSED:
+			should_free->var = NULL;
+			return NULL;
+			break;
+		case IS_CV:
+		default:
+			should_free->var = NULL;
+			return _get_zval_ptr_cv(execute_data, node->var, type TSRMLS_CC);
+			break;
 	}
-	return *ptr;
+	return NULL;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_cv_BP_VAR_RW(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static inline zval *_get_zval_ptr_deref(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
+	zval *ret;
 
-	if (UNEXPECTED(*ptr == NULL)) {
-		return _get_zval_cv_lookup_BP_VAR_RW(ptr, var TSRMLS_CC);
+	switch (op_type) {
+		case IS_CONST:
+			should_free->var = NULL;
+			return node->zv;
+			break;
+		case IS_TMP_VAR:
+			ret = EX_VAR(node->var);
+			should_free->var = TMP_FREE(ret);
+			return ret;
+			break;
+		case IS_VAR:
+			return _get_zval_ptr_var_deref(node->var, execute_data, should_free TSRMLS_CC);
+			break;
+		case IS_UNUSED:
+			should_free->var = NULL;
+			return NULL;
+			break;
+		case IS_CV:
+		default:
+			should_free->var = NULL;
+			return _get_zval_ptr_cv_deref(execute_data, node->var, type TSRMLS_CC);
+			break;
 	}
-	return *ptr;
+	return NULL;
 }
 
-static zend_always_inline zval **_get_zval_ptr_ptr_cv_BP_VAR_W(const zend_execute_data *execute_data, zend_uint var TSRMLS_DC)
+static zend_always_inline zval *_get_zval_ptr_ptr_var(zend_uint var, const zend_execute_data *execute_data, zend_free_op *should_free TSRMLS_DC)
 {
-	zval ***ptr = EX_CV_NUM(execute_data, var);
-
-	if (UNEXPECTED(*ptr == NULL)) {
-		return _get_zval_cv_lookup_BP_VAR_W(ptr, var TSRMLS_CC);
+	zval *ret = EX_VAR(var);
+
+	if (EXPECTED(Z_TYPE_P(ret) == IS_INDIRECT)) {
+		should_free->var = NULL;
+		return Z_INDIRECT_P(ret);
+	} else if (!Z_REFCOUNTED_P(ret)) {
+		should_free->var = ret; //???
+		return ret;
+	} else {
+		PZVAL_UNLOCK(ret, should_free);
+		return ret;
 	}
-	return *ptr;
 }
 
-static inline zval **_get_zval_ptr_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
+static inline zval *_get_zval_ptr_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
 {
 	if (op_type == IS_CV) {
-		should_free->var = 0;
-		return _get_zval_ptr_ptr_cv(node->var, type TSRMLS_CC);
-	} else if (op_type == IS_VAR) {
+		should_free->var = NULL;
+		return _get_zval_ptr_cv(execute_data, node->var, type TSRMLS_CC);
+	} else /* if (op_type == IS_VAR) */ {
+		ZEND_ASSERT(op_type == IS_VAR);
 		return _get_zval_ptr_ptr_var(node->var, execute_data, should_free TSRMLS_CC);
-	} else {
-		should_free->var = 0;
-		return NULL;
 	}
 }
 
 static zend_always_inline zval *_get_obj_zval_ptr_unused(TSRMLS_D)
 {
-	if (EXPECTED(EG(This) != NULL)) {
-		return EG(This);
+	if (EXPECTED(Z_OBJ(EG(This)) != NULL)) {
+		return &EG(This);
 	} else {
 		zend_error_noreturn(E_ERROR, "Using $this when not in object context");
 		return NULL;
 	}
 }
 
-static inline zval **_get_obj_zval_ptr_ptr(int op_type, const znode_op *op, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
+static inline zval *_get_obj_zval_ptr(int op_type, znode_op *op, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
 {
 	if (op_type == IS_UNUSED) {
-		if (EXPECTED(EG(This) != NULL)) {
-			/* this should actually never be modified, _ptr_ptr is modified only when
-			   the object is empty */
-			should_free->var = 0;
+		if (EXPECTED(Z_OBJ(EG(This)) != NULL)) {
+			should_free->var = NULL;
 			return &EG(This);
 		} else {
 			zend_error_noreturn(E_ERROR, "Using $this when not in object context");
 		}
 	}
-	return get_zval_ptr_ptr(op_type, op, execute_data, should_free, type);
-}
-
-static zend_always_inline zval **_get_obj_zval_ptr_ptr_unused(TSRMLS_D)
-{
-	if (EXPECTED(EG(This) != NULL)) {
-		return &EG(This);
-	} else {
-		zend_error_noreturn(E_ERROR, "Using $this when not in object context");
-		return NULL;
-	}
+	return get_zval_ptr(op_type, op, execute_data, should_free, type);
 }
 
-static inline zval *_get_obj_zval_ptr(int op_type, znode_op *op, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
+static inline zval *_get_obj_zval_ptr_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC)
 {
 	if (op_type == IS_UNUSED) {
-		if (EXPECTED(EG(This) != NULL)) {
-			should_free->var = 0;
-			return EG(This);
+		if (EXPECTED(Z_OBJ(EG(This)) != NULL)) {
+			should_free->var = NULL;
+			return &EG(This);
 		} else {
 			zend_error_noreturn(E_ERROR, "Using $this when not in object context");
 		}
 	}
-	return get_zval_ptr(op_type, op, execute_data, should_free, type);
+	return get_zval_ptr_ptr(op_type, node, execute_data, should_free, type);
 }
 
-static void zend_assign_to_variable_reference(zval **variable_ptr_ptr, zval **value_ptr_ptr TSRMLS_DC)
+static inline void zend_assign_to_variable_reference(zval *variable_ptr, zval *value_ptr TSRMLS_DC)
 {
-	zval *variable_ptr = *variable_ptr_ptr;
-	zval *value_ptr = *value_ptr_ptr;
-
-	if (variable_ptr == &EG(error_zval) || value_ptr == &EG(error_zval)) {
-		variable_ptr_ptr = &EG(uninitialized_zval_ptr);
-	} else if (variable_ptr != value_ptr) {
-		if (!PZVAL_IS_REF(value_ptr)) {
-			/* break it away */
-			Z_DELREF_P(value_ptr);
-			if (Z_REFCOUNT_P(value_ptr)>0) {
-				ALLOC_ZVAL(*value_ptr_ptr);
-				ZVAL_COPY_VALUE(*value_ptr_ptr, value_ptr);
-				value_ptr = *value_ptr_ptr;
-				zendi_zval_copy_ctor(*value_ptr);
-			}
-			Z_SET_REFCOUNT_P(value_ptr, 1);
-			Z_SET_ISREF_P(value_ptr);
-		}
-
-		*variable_ptr_ptr = value_ptr;
+	if (EXPECTED(variable_ptr != value_ptr)) {
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
 		Z_ADDREF_P(value_ptr);
-
-		zval_ptr_dtor(&variable_ptr);
+		zval_ptr_dtor(variable_ptr);
+		ZVAL_COPY_VALUE(variable_ptr, value_ptr);
 	} else if (!Z_ISREF_P(variable_ptr)) {
-		if (variable_ptr_ptr == value_ptr_ptr) {
-			SEPARATE_ZVAL(variable_ptr_ptr);
-		} else if (variable_ptr==&EG(uninitialized_zval)
-			|| Z_REFCOUNT_P(variable_ptr)>2) {
-			/* we need to separate */
-			Z_SET_REFCOUNT_P(variable_ptr, Z_REFCOUNT_P(variable_ptr) - 2);
-			ALLOC_ZVAL(*variable_ptr_ptr);
-			ZVAL_COPY_VALUE(*variable_ptr_ptr, variable_ptr);
-			zval_copy_ctor(*variable_ptr_ptr);
-			*value_ptr_ptr = *variable_ptr_ptr;
-			Z_SET_REFCOUNT_PP(variable_ptr_ptr, 2);
-		}
-		Z_SET_ISREF_PP(variable_ptr_ptr);
+		ZVAL_NEW_REF(variable_ptr, variable_ptr);
 	}
 }
 
 /* this should modify object only if it's empty */
-static inline void make_real_object(zval **object_ptr TSRMLS_DC)
+static inline zval* make_real_object(zval *object_ptr TSRMLS_DC)
 {
-	if (Z_TYPE_PP(object_ptr) == IS_NULL
-		|| (Z_TYPE_PP(object_ptr) == IS_BOOL && Z_LVAL_PP(object_ptr) == 0)
-		|| (Z_TYPE_PP(object_ptr) == IS_STRING && Z_STRLEN_PP(object_ptr) == 0)
-	) {
-		SEPARATE_ZVAL_IF_NOT_REF(object_ptr);
-		zval_dtor(*object_ptr);
-		object_init(*object_ptr);
-		zend_error(E_WARNING, "Creating default object from empty value");
+	zval *object = object_ptr;
+
+	ZVAL_DEREF(object);
+	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
+		if (Z_TYPE_P(object) == IS_NULL
+			|| (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0)
+			|| (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
+			if (EXPECTED(object == object_ptr)) {
+				/* object_ptr is not a reference */
+				SEPARATE_ZVAL(object);
+			}
+			zval_dtor(object);
+			object_init(object);
+			zend_error(E_WARNING, "Creating default object from empty value");
+		}
 	}
+	return object;
 }
 
-ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC)
+ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC)
 {
-	*pce = zend_fetch_class(cur_arg_info->class_name, cur_arg_info->class_name_len, (fetch_type | ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
-
-	*class_name = (*pce) ? (*pce)->name: cur_arg_info->class_name;
+	zend_string *key = STR_INIT(cur_arg_info->class_name, cur_arg_info->class_name_len, 0);
+	*pce = zend_fetch_class(key, (fetch_type | ZEND_FETCH_CLASS_AUTO | ZEND_FETCH_CLASS_NO_AUTOLOAD) TSRMLS_CC);
+	STR_FREE(key);
+	*class_name = (*pce) ? (*pce)->name->val : (char*)cur_arg_info->class_name;
 	if (*pce && (*pce)->ce_flags & ZEND_ACC_INTERFACE) {
 		return "implement interface ";
 	} else {
@@ -585,81 +530,71 @@ ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ul
 	}
 }
 
-ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC)
+ZEND_API void zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC)
 {
 	zend_execute_data *ptr = EG(current_execute_data)->prev_execute_data;
-	const char *fname = zf->common.function_name;
-	char *fsep;
+	const char *fname = zf->common.function_name->val;
+	const char *fsep;
 	const char *fclass;
 
 	if (zf->common.scope) {
 		fsep =  "::";
-		fclass = zf->common.scope->name;
+		fclass = zf->common.scope->name->val;
 	} else {
 		fsep =  "";
 		fclass = "";
 	}
 
 	if (ptr && ptr->op_array) {
-		zend_error(error_type, "Argument %d passed to %s%s%s() must %s%s, %s%s given, called in %s on line %d and defined", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind, ptr->op_array->filename, ptr->opline->lineno);
+		zend_error(error_type, "Argument %d passed to %s%s%s() must %s%s, %s%s given, called in %s on line %d and defined", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind, ptr->op_array->filename->val, ptr->opline->lineno);
 	} else {
 		zend_error(error_type, "Argument %d passed to %s%s%s() must %s%s, %s%s given", arg_num, fclass, fsep, fname, need_msg, need_kind, given_msg, given_kind);
 	}
-	return 0;
 }
 
-static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC)
+static void zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zval *arg, ulong fetch_type TSRMLS_DC)
 {
 	zend_arg_info *cur_arg_info;
 	char *need_msg;
 	zend_class_entry *ce;
 
-	if (!zf->common.arg_info) {
-		return 1;
+	if (UNEXPECTED(!zf->common.arg_info)) {
+		return;
 	}
 
-	if (arg_num <= zf->common.num_args) {
+	if (EXPECTED(arg_num <= zf->common.num_args)) {
 		cur_arg_info = &zf->common.arg_info[arg_num-1];
 	} else if (zf->common.fn_flags & ZEND_ACC_VARIADIC) {
 		cur_arg_info = &zf->common.arg_info[zf->common.num_args-1];
 	} else {
-		return 1;
+		return;
 	}
 
 	if (cur_arg_info->class_name) {
-		const char *class_name;
+		char *class_name;
 
-		if (!arg) {
-			need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
-			return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, "none", "" TSRMLS_CC);
-		}
+		ZVAL_DEREF(arg);
 		if (Z_TYPE_P(arg) == IS_OBJECT) {
 			need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
 			if (!ce || !instanceof_function(Z_OBJCE_P(arg), ce TSRMLS_CC)) {
-				return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, "instance of ", Z_OBJCE_P(arg)->name TSRMLS_CC);
+				zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, "instance of ", Z_OBJCE_P(arg)->name->val TSRMLS_CC);
 			}
 		} else if (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null) {
 			need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
-			return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, zend_zval_type_name(arg), "" TSRMLS_CC);
+			zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, zend_zval_type_name(arg), "" TSRMLS_CC);
 		}
 	} else if (cur_arg_info->type_hint) {
 		switch(cur_arg_info->type_hint) {
 			case IS_ARRAY:
-				if (!arg) {
-					return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be of the type array", "", "none", "" TSRMLS_CC);
-				}
-
+				ZVAL_DEREF(arg);
 				if (Z_TYPE_P(arg) != IS_ARRAY && (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null)) {
-					return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be of the type array", "", zend_zval_type_name(arg), "" TSRMLS_CC);
+					zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be of the type array", "", zend_zval_type_name(arg), "" TSRMLS_CC);
 				}
 				break;
 
 			case IS_CALLABLE:
-				if (!arg) {
-					return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be callable", "", "none", "" TSRMLS_CC);
-				}
 				if (!zend_is_callable(arg, IS_CALLABLE_CHECK_SILENT, NULL TSRMLS_CC) && (Z_TYPE_P(arg) != IS_NULL || !cur_arg_info->allow_null)) {
-					return zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be callable", "", zend_zval_type_name(arg), "" TSRMLS_CC);
+					zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be callable", "", zend_zval_type_name(arg), "" TSRMLS_CC);
 				}
 				break;
 
@@ -667,20 +602,77 @@ static inline int zend_verify_arg_type(zend_function *zf, zend_uint arg_num, zva
 				zend_error(E_ERROR, "Unknown typehint");
 		}
 	}
-	return 1;
 }
 
-static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval *property_name, int value_type, znode_op *value_op, const zend_execute_data *execute_data, int opcode, const zend_literal *key TSRMLS_DC)
+static inline int zend_verify_missing_arg_type(zend_function *zf, zend_uint arg_num, ulong fetch_type TSRMLS_DC)
+{
+	zend_arg_info *cur_arg_info;
+	char *need_msg;
+	zend_class_entry *ce;
+
+	if (UNEXPECTED(!zf->common.arg_info)) {
+		return 1;
+	}
+
+	if (EXPECTED(arg_num <= zf->common.num_args)) {
+		cur_arg_info = &zf->common.arg_info[arg_num-1];
+	} else if (zf->common.fn_flags & ZEND_ACC_VARIADIC) {
+		cur_arg_info = &zf->common.arg_info[zf->common.num_args-1];
+	} else {
+		return 1;
+	}
+
+	if (cur_arg_info->class_name) {
+		char *class_name;
+
+		need_msg = zend_verify_arg_class_kind(cur_arg_info, fetch_type, &class_name, &ce TSRMLS_CC);
+		zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, need_msg, class_name, "none", "" TSRMLS_CC);
+	} else if (cur_arg_info->type_hint) {
+		switch(cur_arg_info->type_hint) {
+			case IS_ARRAY:
+				zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be of the type array", "", "none", "" TSRMLS_CC);
+				break;
+
+			case IS_CALLABLE:
+				zend_verify_arg_error(E_RECOVERABLE_ERROR, zf, arg_num, "be callable", "", "none", "" TSRMLS_CC);
+				break;
+
+			default:
+				zend_error(E_ERROR, "Unknown typehint");
+		}
+	}
+	return 0;
+}
+
+static void zend_verify_missing_arg(zend_execute_data *execute_data, zend_uint arg_num TSRMLS_DC)
+{
+	if (EXPECTED(!(EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS)) ||
+	    zend_verify_missing_arg_type((zend_function *) EX(op_array), arg_num, EX(opline)->extended_value TSRMLS_CC)) {
+		const char *class_name = EX(op_array)->scope ? EX(op_array)->scope->name->val : "";
+		const char *space = EX(op_array)->scope ? "::" : "";
+		const char *func_name = EX(op_array)->function_name ? EX(op_array)->function_name->val : "main";
+		zend_execute_data *ptr = EX(prev_execute_data);
+
+		if(ptr && ptr->op_array) {
+			zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", arg_num, class_name, space, func_name, ptr->op_array->filename->val, ptr->opline->lineno);
+		} else {
+			zend_error(E_WARNING, "Missing argument %u for %s%s%s()", arg_num, class_name, space, func_name);
+		}
+	}
+}
+
+static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *property_name, int value_type, znode_op *value_op, const zend_execute_data *execute_data, int opcode, zend_uint cache_slot TSRMLS_DC)
 {
-	zval *object = *object_ptr;
 	zend_free_op free_value;
  	zval *value = get_zval_ptr(value_type, value_op, execute_data, &free_value, BP_VAR_R);
+ 	zval tmp;
+ 	zval *object = object_ptr;
 
+ 	ZVAL_DEREF(object);
 	if (Z_TYPE_P(object) != IS_OBJECT) {
 		if (object == &EG(error_zval)) {
  			if (retval) {
-				*retval = &EG(uninitialized_zval);
-				PZVAL_LOCK(*retval);
+ 				ZVAL_NULL(retval);
 			}
 			FREE_OP(free_value);
 			return;
@@ -688,28 +680,38 @@ static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval
 		if (Z_TYPE_P(object) == IS_NULL ||
 		    (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0) ||
 		    (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
-			SEPARATE_ZVAL_IF_NOT_REF(object_ptr);
-			object = *object_ptr;
-			Z_ADDREF_P(object);
-			zend_error(E_WARNING, "Creating default object from empty value");
-			if (Z_REFCOUNT_P(object) == 1) {
-				/* object was removed by error handler, nothing to assign to */
-				zval_ptr_dtor(&object);
-				if (retval) {
-					*retval = &EG(uninitialized_zval);
-					PZVAL_LOCK(*retval);
+//??? The following block may handle only non-interned empty string,
+//??? but it doesn't work anyway
+//??? see: Zend/tests/bug54265.phpt
+#if 0
+			if (Z_REFCOUNTED_P(object)) {
+				if (!Z_ISREF_P(object_ptr)) {
+					SEPARATE_ZVAL(object);
+				}
+				Z_ADDREF_P(object);
+				zend_error(E_WARNING, "Creating default object from empty value");
+				if (Z_REFCOUNT_P(object) == 1) {
+					/* object was removed by error handler, nothing to assign to */
+					zval_ptr_dtor(object);
+					if (retval) {
+						ZVAL_NULL(retval);
+					}
+					FREE_OP(free_value);
+					return;
 				}
-				FREE_OP(free_value);
-				return;
+				Z_DELREF_P(object);
+			} else {
+				zend_error(E_WARNING, "Creating default object from empty value");
 			}
-			Z_DELREF_P(object);
+#else
+			zend_error(E_WARNING, "Creating default object from empty value");
+#endif
 			zval_dtor(object);
 			object_init(object);
 		} else {
 			zend_error(E_WARNING, "Attempt to assign property of non-object");
 			if (retval) {
-				*retval = &EG(uninitialized_zval);
-				PZVAL_LOCK(*retval);
+				ZVAL_NULL(retval);
 			}
 			FREE_OP(free_value);
 			return;
@@ -718,40 +720,29 @@ static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval
 
 	/* separate our value if necessary */
 	if (value_type == IS_TMP_VAR) {
-		zval *orig_value = value;
-
-		ALLOC_ZVAL(value);
-		ZVAL_COPY_VALUE(value, orig_value);
-		Z_UNSET_ISREF_P(value);
-		Z_SET_REFCOUNT_P(value, 0);
+		ZVAL_DEREF(value);
+		ZVAL_COPY_VALUE(&tmp, value);
+		value = &tmp;
 	} else if (value_type == IS_CONST) {
-		zval *orig_value = value;
-
-		ALLOC_ZVAL(value);
-		ZVAL_COPY_VALUE(value, orig_value);
-		Z_UNSET_ISREF_P(value);
-		Z_SET_REFCOUNT_P(value, 0);
-		zval_copy_ctor(value);
+		ZVAL_DUP(&tmp, value);
+		value = &tmp;
+	} else if (Z_REFCOUNTED_P(value)) {
+		Z_ADDREF_P(value);
 	}
 
-
-	Z_ADDREF_P(value);
 	if (opcode == ZEND_ASSIGN_OBJ) {
 		if (!Z_OBJ_HT_P(object)->write_property) {
 			zend_error(E_WARNING, "Attempt to assign property of non-object");
 			if (retval) {
-				*retval = &EG(uninitialized_zval);
-				PZVAL_LOCK(&EG(uninitialized_zval));
+				ZVAL_NULL(retval);
 			}
-			if (value_type == IS_TMP_VAR) {
-				FREE_ZVAL(value);
-			} else if (value_type == IS_CONST) {
-				zval_ptr_dtor(&value);
+			if (value_type == IS_CONST) {
+				zval_ptr_dtor(value);
 			}
 			FREE_OP(free_value);
 			return;
 		}
-		Z_OBJ_HT_P(object)->write_property(object, property_name, value, key TSRMLS_CC);
+		Z_OBJ_HT_P(object)->write_property(object, property_name, value, cache_slot TSRMLS_CC);
 	} else {
 		/* Note:  property_name in this case is really the array index! */
 		if (!Z_OBJ_HT_P(object)->write_dimension) {
@@ -761,186 +752,215 @@ static inline void zend_assign_to_object(zval **retval, zval **object_ptr, zval
 	}
 
 	if (retval && !EG(exception)) {
-		*retval = value;
-		PZVAL_LOCK(value);
+		ZVAL_COPY(retval, value);
 	}
-	zval_ptr_dtor(&value);
+	zval_ptr_dtor(value);
 	FREE_OP_IF_VAR(free_value);
 }
 
-static inline int zend_assign_to_string_offset(const temp_variable *T, const zval *value, int value_type TSRMLS_DC)
+static void zend_assign_to_string_offset(zval *str_offset, zval *value, int value_type, zval *result TSRMLS_DC)
 {
-	zval *str = T->str_offset.str;
-	zend_uint offset = T->str_offset.offset;
-	if (Z_TYPE_P(str) == IS_STRING) {
-		if ((int)offset < 0) {
-			zend_error(E_WARNING, "Illegal string offset:  %d", offset);
-			return 0;
+	zval *str = Z_STR_OFFSET_STR_P(str_offset);
+	zend_uint offset = Z_STR_OFFSET_IDX_P(str_offset);
+	zend_string *old_str;
+
+	if ((int)offset < 0) {
+		zend_error(E_WARNING, "Illegal string offset:  %d", offset);
+		STR_RELEASE(Z_STR_P(str));
+		if (result) {
+			ZVAL_NULL(result);
 		}
+		return;
+	}
+
+	old_str = Z_STR_P(str);
+	if (offset >= Z_STRLEN_P(str)) {
+		int old_len = Z_STRLEN_P(str);
+		Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), offset + 1, 0);
+		Z_TYPE_INFO_P(str) = IS_STRING_EX;
+		memset(Z_STRVAL_P(str) + old_len, ' ', offset - old_len);
+		Z_STRVAL_P(str)[offset+1] = 0;
+	} else if (IS_INTERNED(Z_STR_P(str))) {
+		Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+		Z_TYPE_INFO_P(str) = IS_STRING_EX;
+	}
+
+	if (Z_TYPE_P(value) != IS_STRING) {
+		zval tmp;
 
-		if (offset >= Z_STRLEN_P(str)) {
-			Z_STRVAL_P(str) = str_erealloc(Z_STRVAL_P(str), offset+1+1);
-			memset(Z_STRVAL_P(str) + Z_STRLEN_P(str), ' ', offset - Z_STRLEN_P(str));
-			Z_STRVAL_P(str)[offset+1] = 0;
-			Z_STRLEN_P(str) = offset+1;
-		} else if (IS_INTERNED(Z_STRVAL_P(str))) {
-			Z_STRVAL_P(str) = estrndup(Z_STRVAL_P(str), Z_STRLEN_P(str));
+		ZVAL_COPY_VALUE(&tmp, value);
+		if (value_type != IS_TMP_VAR) {
+			zval_opt_copy_ctor(&tmp);
 		}
+		convert_to_string(&tmp);
+		Z_STRVAL_P(str)[offset] = Z_STRVAL(tmp)[0];
+		zval_dtor(&tmp);
+	} else {
+		Z_STRVAL_P(str)[offset] = Z_STRVAL_P(value)[0];
+		if (value_type == IS_TMP_VAR) {
+			/* we can safely free final_value here
+			 * because separation is done only
+			 * in case value_type == IS_VAR */
+			zval_dtor(value);
+		}
+	}
+	/*
+	 * the value of an assignment to a string offset is undefined
+	T(result->u.var).var = &T->str_offset.str;
+	*/
 
-		if (Z_TYPE_P(value) != IS_STRING) {
-			zval tmp;
+	STR_RELEASE(old_str);
+	if (result) {
+		zend_uchar c = (zend_uchar)Z_STRVAL_P(str)[offset];
 
-			ZVAL_COPY_VALUE(&tmp, value);
-			if (value_type != IS_TMP_VAR) {
-				zval_copy_ctor(&tmp);
-			}
-			convert_to_string(&tmp);
-			Z_STRVAL_P(str)[offset] = Z_STRVAL(tmp)[0];
-			str_efree(Z_STRVAL(tmp));
+		if (CG(one_char_string)[c]) {
+			ZVAL_INT_STR(result, CG(one_char_string)[c]);
 		} else {
-			Z_STRVAL_P(str)[offset] = Z_STRVAL_P(value)[0];
-			if (value_type == IS_TMP_VAR) {
-				/* we can safely free final_value here
-				 * because separation is done only
-				 * in case value_type == IS_VAR */
-				str_efree(Z_STRVAL_P(value));
-			}
+			ZVAL_NEW_STR(result, STR_INIT(Z_STRVAL_P(str) + offset, 1, 0));
 		}
-		/*
-		 * the value of an assignment to a string offset is undefined
-		T(result->u.var).var = &T->str_offset.str;
-		*/
 	}
-	return 1;
 }
 
-
-static inline zval* zend_assign_tmp_to_variable(zval **variable_ptr_ptr, zval *value TSRMLS_DC)
+static inline zval* zend_assign_tmp_to_variable(zval *variable_ptr, zval *value TSRMLS_DC)
 {
-	zval *variable_ptr = *variable_ptr_ptr;
-	zval garbage;
+	ZVAL_DEREF(variable_ptr);
 
-	if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
-	    UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
-		Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr_ptr, value TSRMLS_CC);
-		return variable_ptr;
-	}
+	if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
+		zend_refcounted *garbage;
 
- 	if (UNEXPECTED(Z_REFCOUNT_P(variable_ptr) > 1) &&
- 	    EXPECTED(!PZVAL_IS_REF(variable_ptr))) {
- 	    /* we need to split */
-		Z_DELREF_P(variable_ptr);
-		GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr);
-		ALLOC_ZVAL(variable_ptr);
-		INIT_PZVAL_COPY(variable_ptr, value);
-		*variable_ptr_ptr = variable_ptr;
-		return variable_ptr;
-	} else {
-		if (EXPECTED(Z_TYPE_P(variable_ptr) <= IS_BOOL)) {
-			/* nothing to destroy */
-			ZVAL_COPY_VALUE(variable_ptr, value);
+		if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
+		    UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
+			Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr, value TSRMLS_CC);
+			return variable_ptr;
+		}
+
+		garbage = Z_COUNTED_P(variable_ptr);
+		if (UNEXPECTED(GC_REFCOUNT(garbage) > 1)) {
+			/* we need to split */
+			GC_REFCOUNT(garbage)--;
+			/* optimized version of GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr) */
+			if ((Z_COLLECTABLE_P(variable_ptr)) &&
+	    		UNEXPECTED(!GC_INFO(garbage))) {
+				gc_possible_root(garbage TSRMLS_CC);
+			}
 		} else {
-			ZVAL_COPY_VALUE(&garbage, variable_ptr);
 			ZVAL_COPY_VALUE(variable_ptr, value);
-			_zval_dtor_func(&garbage ZEND_FILE_LINE_CC);
+			_zval_dtor_func(garbage ZEND_FILE_LINE_CC);
+			return variable_ptr;
 		}
-		return variable_ptr;
 	}
+
+	ZVAL_COPY_VALUE(variable_ptr, value);
+	
+	return variable_ptr;
 }
 
-static inline zval* zend_assign_const_to_variable(zval **variable_ptr_ptr, zval *value TSRMLS_DC)
+static inline zval* zend_assign_const_to_variable(zval *variable_ptr, zval *value TSRMLS_DC)
 {
-	zval *variable_ptr = *variable_ptr_ptr;
-	zval garbage;
+	ZVAL_DEREF(variable_ptr);
 
-	if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
-	    UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
-		Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr_ptr, value TSRMLS_CC);
-		return variable_ptr;
-	}
+	if (UNEXPECTED(Z_REFCOUNTED_P(variable_ptr))) {
+		zend_refcounted *garbage;
 
- 	if (UNEXPECTED(Z_REFCOUNT_P(variable_ptr) > 1) &&
- 	    EXPECTED(!PZVAL_IS_REF(variable_ptr))) {
-		/* we need to split */
-		Z_DELREF_P(variable_ptr);
-		GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr);
-		ALLOC_ZVAL(variable_ptr);
-		INIT_PZVAL_COPY(variable_ptr, value);
-		zval_copy_ctor(variable_ptr);
-		*variable_ptr_ptr = variable_ptr;
-		return variable_ptr;
- 	} else {
-		if (EXPECTED(Z_TYPE_P(variable_ptr) <= IS_BOOL)) {
-			/* nothing to destroy */
-			ZVAL_COPY_VALUE(variable_ptr, value);
-			zendi_zval_copy_ctor(*variable_ptr);
-		} else {
-			ZVAL_COPY_VALUE(&garbage, variable_ptr);
+		if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
+		    UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
+			Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr, value TSRMLS_CC);
+			return variable_ptr;
+		}
+
+		garbage = Z_COUNTED_P(variable_ptr);
+		if (UNEXPECTED(GC_REFCOUNT(garbage) > 1)) {
+			/* we need to split */
+			GC_REFCOUNT(garbage)--;
+			/* optimized version of GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr) */
+			if (Z_COLLECTABLE_P(variable_ptr) &&
+	    		UNEXPECTED(!GC_INFO(garbage))) {
+				gc_possible_root(garbage TSRMLS_CC);
+			}
+	 	} else {
 			ZVAL_COPY_VALUE(variable_ptr, value);
-			zendi_zval_copy_ctor(*variable_ptr);
-			_zval_dtor_func(&garbage ZEND_FILE_LINE_CC);
+			/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
+			if (UNEXPECTED(Z_OPT_COPYABLE_P(variable_ptr))) {
+				_zval_copy_ctor_func(variable_ptr ZEND_FILE_LINE_CC);
+			}
+			_zval_dtor_func(garbage ZEND_FILE_LINE_CC);
+			return variable_ptr;
 		}
-		return variable_ptr;
 	}
+	
+	ZVAL_COPY_VALUE(variable_ptr, value);
+	/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
+	if (UNEXPECTED(Z_OPT_COPYABLE_P(variable_ptr))) {
+		_zval_copy_ctor_func(variable_ptr ZEND_FILE_LINE_CC);
+	}
+
+	return variable_ptr;
 }
 
-static inline zval* zend_assign_to_variable(zval **variable_ptr_ptr, zval *value TSRMLS_DC)
+static inline zval* zend_assign_to_variable(zval *variable_ptr, zval *value TSRMLS_DC)
 {
-	zval *variable_ptr = *variable_ptr_ptr;
-	zval garbage;
+	zend_refcounted *garbage;
+	zval *is_ref = NULL;
 
-	if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
-	    UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
-		Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr_ptr, value TSRMLS_CC);
+	if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {	
+		if (EXPECTED(!Z_ISREF_P(value))) {
+			ZVAL_COPY(variable_ptr, value);
+		} else {
+			goto assign_ref;
+		}
 		return variable_ptr;
+	} else if (Z_ISREF_P(variable_ptr)) {
+		is_ref = variable_ptr;
+		variable_ptr = Z_REFVAL_P(variable_ptr);
 	}
 
- 	if (EXPECTED(!PZVAL_IS_REF(variable_ptr))) {
+	if (EXPECTED(!Z_REFCOUNTED_P(variable_ptr))) {
+		goto assign_simple;
+	} else if (Z_TYPE_P(variable_ptr) == IS_OBJECT &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(variable_ptr, set) != NULL)) {
+		Z_OBJ_HANDLER_P(variable_ptr, set)(variable_ptr, value TSRMLS_CC);
+	} else if (EXPECTED(variable_ptr != value)) {
 		if (Z_REFCOUNT_P(variable_ptr)==1) {
-			if (UNEXPECTED(variable_ptr == value)) {
+			garbage = Z_COUNTED_P(variable_ptr);
+			if (EXPECTED(!Z_ISREF_P(value))) {
+				if (!is_ref) {
+					ZVAL_COPY(variable_ptr, value);
+				} else {
+					ZVAL_DUP(variable_ptr, value);
+				}
+			} else if (is_ref == value) {
 				return variable_ptr;
-			} else if (EXPECTED(!PZVAL_IS_REF(value))) {
-				Z_ADDREF_P(value);
-				*variable_ptr_ptr = value;
-				ZEND_ASSERT(variable_ptr != &EG(uninitialized_zval));
-				GC_REMOVE_ZVAL_FROM_BUFFER(variable_ptr);
-				zval_dtor(variable_ptr);
-				efree(variable_ptr);
-				return value;
 			} else {
-				goto copy_value;
-			}
+				if (Z_REFCOUNT_P(value) == 1) {
+					ZVAL_UNREF(value);
+					ZVAL_COPY(variable_ptr, value);
+				} else {
+					ZVAL_DUP(variable_ptr, Z_REFVAL_P(value));
+				}
+			}				
+			_zval_dtor_func(garbage ZEND_FILE_LINE_CC);
 		} else { /* we need to split */
 			Z_DELREF_P(variable_ptr);
 			GC_ZVAL_CHECK_POSSIBLE_ROOT(variable_ptr);
-			if (PZVAL_IS_REF(value)) {
-				ALLOC_ZVAL(variable_ptr);
-				*variable_ptr_ptr = variable_ptr;
-				INIT_PZVAL_COPY(variable_ptr, value);
-				zval_copy_ctor(variable_ptr);
-				return variable_ptr;
-			} else {
-				*variable_ptr_ptr = value;
-				Z_ADDREF_P(value);
-				return value;
-			}
-		}
- 	} else {
-		if (EXPECTED(variable_ptr != value)) {
-copy_value:
-			if (EXPECTED(Z_TYPE_P(variable_ptr) <= IS_BOOL)) {
-				/* nothing to destroy */
-				ZVAL_COPY_VALUE(variable_ptr, value);
-				zendi_zval_copy_ctor(*variable_ptr);
-			} else {
-				ZVAL_COPY_VALUE(&garbage, variable_ptr);
-				ZVAL_COPY_VALUE(variable_ptr, value);
-				zendi_zval_copy_ctor(*variable_ptr);
-				_zval_dtor_func(&garbage ZEND_FILE_LINE_CC);
+assign_simple:
+			if (EXPECTED(!Z_ISREF_P(value))) {
+				if (!is_ref) {
+					ZVAL_COPY(variable_ptr, value);
+				} else {
+					ZVAL_DUP(variable_ptr, value);
+				}
+			} else if (is_ref != value) {
+assign_ref:
+				if (Z_REFCOUNT_P(value) == 1) {
+					ZVAL_UNREF(value);
+					ZVAL_COPY(variable_ptr, value);
+				} else {
+					ZVAL_DUP(variable_ptr, Z_REFVAL_P(value));
+				}
 			}
 		}
-		return variable_ptr;
 	}
+	return variable_ptr;
 }
 
 /* Utility Functions for Extensions */
@@ -968,404 +988,370 @@ static void zend_extension_fcall_end_handler(const zend_extension *extension, ze
 }
 
 
-static inline HashTable *zend_get_target_symbol_table(int fetch_type TSRMLS_DC)
+static zend_always_inline HashTable *zend_get_target_symbol_table(int fetch_type TSRMLS_DC)
 {
-	switch (fetch_type) {
-		case ZEND_FETCH_LOCAL:
-			if (!EG(active_symbol_table)) {
-				zend_rebuild_symbol_table(TSRMLS_C);
-			}
-			return EG(active_symbol_table);
-			break;
-		case ZEND_FETCH_GLOBAL:
-		case ZEND_FETCH_GLOBAL_LOCK:
-			return &EG(symbol_table);
-			break;
-		case ZEND_FETCH_STATIC:
-			if (!EG(active_op_array)->static_variables) {
-				ALLOC_HASHTABLE(EG(active_op_array)->static_variables);
-				zend_hash_init(EG(active_op_array)->static_variables, 2, NULL, ZVAL_PTR_DTOR, 0);
-			}
-			return EG(active_op_array)->static_variables;
-			break;
-		EMPTY_SWITCH_DEFAULT_CASE()
+	HashTable *ht;
+
+	if (EXPECTED(fetch_type == ZEND_FETCH_GLOBAL_LOCK) || 
+	    EXPECTED(fetch_type == ZEND_FETCH_GLOBAL)) {
+		ht = &EG(symbol_table).ht;
+	} else if (EXPECTED(fetch_type == ZEND_FETCH_STATIC)) {
+		ZEND_ASSERT(EG(active_op_array)->static_variables != NULL);
+		ht = EG(active_op_array)->static_variables;
+	} else {
+		ZEND_ASSERT(fetch_type == ZEND_FETCH_LOCAL);
+		if (!EG(active_symbol_table)) {
+			zend_rebuild_symbol_table(TSRMLS_C);
+		}
+		ht = &EG(active_symbol_table)->ht;
 	}
-	return NULL;
+	return ht;
 }
 
-static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type TSRMLS_DC)
+static zend_always_inline zval *zend_fetch_dimension_address_inner(HashTable *ht, const zval *dim, int dim_type, int type TSRMLS_DC)
 {
-	zval **retval;
-	char *offset_key;
-	int offset_key_length;
+	zval *retval;
+	zend_string *offset_key;
 	ulong hval;
 
-	switch (dim->type) {
-		case IS_NULL:
-			offset_key = "";
-			offset_key_length = 0;
-			hval = zend_inline_hash_func("", 1);
-			goto fetch_string_dim;
-
-		case IS_STRING:
-
-			offset_key = dim->value.str.val;
-			offset_key_length = dim->value.str.len;
-
-			if (dim_type == IS_CONST) {
-				hval = Z_HASH_P(dim);
-			} else {
-				ZEND_HANDLE_NUMERIC_EX(offset_key, offset_key_length+1, hval, goto num_index);
-				hval = str_hash(offset_key, offset_key_length);
+	if (EXPECTED(Z_TYPE_P(dim) == IS_LONG)) {
+		hval = Z_LVAL_P(dim);
+num_index:
+		retval = zend_hash_index_find(ht, hval);
+		if (retval == NULL) {
+			switch (type) {
+				case BP_VAR_R:
+					zend_error(E_NOTICE,"Undefined offset: %ld", hval);
+					/* break missing intentionally */
+				case BP_VAR_UNSET:
+				case BP_VAR_IS:
+					retval = &EG(uninitialized_zval);
+					break;
+				case BP_VAR_RW:
+					zend_error(E_NOTICE,"Undefined offset: %ld", hval);
+					/* break missing intentionally */
+				case BP_VAR_W:
+					retval = zend_hash_index_update(ht, hval, &EG(uninitialized_zval));
+					break;
 			}
-fetch_string_dim:
-			if (zend_hash_quick_find(ht, offset_key, offset_key_length+1, hval, (void **) &retval) == FAILURE) {
-				switch (type) {
-					case BP_VAR_R:
-						zend_error(E_NOTICE, "Undefined index: %s", offset_key);
-						/* break missing intentionally */
-					case BP_VAR_UNSET:
-					case BP_VAR_IS:
-						retval = &EG(uninitialized_zval_ptr);
-						break;
-					case BP_VAR_RW:
-						zend_error(E_NOTICE,"Undefined index: %s", offset_key);
-						/* break missing intentionally */
-					case BP_VAR_W: {
-							zval *new_zval = &EG(uninitialized_zval);
-
-							Z_ADDREF_P(new_zval);
-							zend_hash_quick_update(ht, offset_key, offset_key_length+1, hval, &new_zval, sizeof(zval *), (void **) &retval);
-						}
-						break;
+		}
+	} else if (EXPECTED(Z_TYPE_P(dim) == IS_STRING)) {
+		offset_key = Z_STR_P(dim);
+		if (dim_type != IS_CONST) {
+			ZEND_HANDLE_NUMERIC_EX(offset_key->val, offset_key->len+1, hval, goto num_index);
+		}
+str_index:
+		retval = zend_hash_find(ht, offset_key);
+		if (retval) {
+			/* support for $GLOBALS[...] */
+			if (UNEXPECTED(Z_TYPE_P(retval) == IS_INDIRECT)) {
+				retval = Z_INDIRECT_P(retval);
+				if (UNEXPECTED(Z_TYPE_P(retval) == IS_UNDEF)) {
+					switch (type) {
+						case BP_VAR_R:
+							zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
+							/* break missing intentionally */
+						case BP_VAR_UNSET:
+						case BP_VAR_IS:
+							retval = &EG(uninitialized_zval);
+							break;
+						case BP_VAR_RW:
+							zend_error(E_NOTICE,"Undefined index: %s", offset_key->val);
+							/* break missing intentionally */
+						case BP_VAR_W:
+							ZVAL_NULL(retval);
+							break;
+					}
 				}
 			}
-			break;
-		case IS_DOUBLE:
-			hval = zend_dval_to_lval(Z_DVAL_P(dim));
-			goto num_index;
-		case IS_RESOURCE:
-			zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(dim), Z_LVAL_P(dim));
-			/* Fall Through */
-		case IS_BOOL:
-		case IS_LONG:
-			hval = Z_LVAL_P(dim);
-num_index:
-			if (zend_hash_index_find(ht, hval, (void **) &retval) == FAILURE) {
-				switch (type) {
-					case BP_VAR_R:
-						zend_error(E_NOTICE,"Undefined offset: %ld", hval);
-						/* break missing intentionally */
-					case BP_VAR_UNSET:
-					case BP_VAR_IS:
-						retval = &EG(uninitialized_zval_ptr);
-						break;
-					case BP_VAR_RW:
-						zend_error(E_NOTICE,"Undefined offset: %ld", hval);
-						/* break missing intentionally */
-					case BP_VAR_W: {
-						zval *new_zval = &EG(uninitialized_zval);
-
-						Z_ADDREF_P(new_zval);
-						zend_hash_index_update(ht, hval, &new_zval, sizeof(zval *), (void **) &retval);
-					}
+		} else { 
+			switch (type) {
+				case BP_VAR_R:
+					zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
+					/* break missing intentionally */
+				case BP_VAR_UNSET:
+				case BP_VAR_IS:
+					retval = &EG(uninitialized_zval);
+					break;
+				case BP_VAR_RW:
+					zend_error(E_NOTICE,"Undefined index: %s", offset_key->val);
+					/* break missing intentionally */
+				case BP_VAR_W:
+					retval = zend_hash_update(ht, offset_key, &EG(uninitialized_zval));
 					break;
-				}
 			}
-			break;
-
-		default:
-			zend_error(E_WARNING, "Illegal offset type");
-			return (type == BP_VAR_W || type == BP_VAR_RW) ?
-				&EG(error_zval_ptr) : &EG(uninitialized_zval_ptr);
+		}
+	} else {
+		switch (Z_TYPE_P(dim)) {
+			case IS_NULL:
+				offset_key = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_DOUBLE:
+				hval = zend_dval_to_lval(Z_DVAL_P(dim));
+				goto num_index;
+			case IS_RESOURCE:
+				zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim));
+				hval = Z_RES_HANDLE_P(dim);
+				goto num_index;
+			case IS_BOOL:
+				hval = Z_LVAL_P(dim);
+				goto num_index;
+			default:
+				zend_error(E_WARNING, "Illegal offset type");
+				retval = (type == BP_VAR_W || type == BP_VAR_RW) ?
+					&EG(error_zval) : &EG(uninitialized_zval);
+		}
 	}
 	return retval;
 }
 
-static void zend_fetch_dimension_address(temp_variable *result, zval **container_ptr, zval *dim, int dim_type, int type TSRMLS_DC)
+static zend_always_inline void zend_fetch_dimension_address(zval *result, zval *container_ptr, zval *dim, int dim_type, int type, int is_ref TSRMLS_DC)
 {
-	zval *container = *container_ptr;
-	zval **retval;
+    zval *retval;
+    zval *container = container_ptr;
 
-	switch (Z_TYPE_P(container)) {
-
-		case IS_ARRAY:
-			if (type != BP_VAR_UNSET && Z_REFCOUNT_P(container)>1 && !PZVAL_IS_REF(container)) {
-				SEPARATE_ZVAL(container_ptr);
-				container = *container_ptr;
-			}
+	ZVAL_DEREF(container);
+	if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
+		if (container == container_ptr) {
+			SEPARATE_ZVAL(container);
+		}
 fetch_from_array:
-			if (dim == NULL) {
-				zval *new_zval = &EG(uninitialized_zval);
-
-				Z_ADDREF_P(new_zval);
-				if (zend_hash_next_index_insert(Z_ARRVAL_P(container), &new_zval, sizeof(zval *), (void **) &retval) == FAILURE) {
-					zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
-					retval = &EG(error_zval_ptr);
-					Z_DELREF_P(new_zval);
-				}
-			} else {
-				retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
+		if (dim == NULL) {
+			retval = zend_hash_next_index_insert(Z_ARRVAL_P(container), &EG(uninitialized_zval));
+			if (retval == NULL) {
+				zend_error(E_WARNING, "Cannot add element to the array as the next element is already occupied");
+				retval = &EG(error_zval);
 			}
-			result->var.ptr_ptr = retval;
-			PZVAL_LOCK(*retval);
-			return;
-			break;
-
-		case IS_NULL:
-			if (container == &EG(error_zval)) {
-				result->var.ptr_ptr = &EG(error_zval_ptr);
-				PZVAL_LOCK(EG(error_zval_ptr));
-			} else if (type != BP_VAR_UNSET) {
+		} else {
+			retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
+		}
+		if (is_ref) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+			ZVAL_COPY(result, retval);
+		} else {
+			ZVAL_INDIRECT(result, retval);
+		}
+	} else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
+		if (type != BP_VAR_UNSET && UNEXPECTED(Z_STRLEN_P(container) == 0)) {
 convert_to_array:
-				if (!PZVAL_IS_REF(container)) {
-					SEPARATE_ZVAL(container_ptr);
-					container = *container_ptr;
-				}
-				zval_dtor(container);
-				array_init(container);
-				goto fetch_from_array;
-			} else {
-				/* for read-mode only */
-				result->var.ptr_ptr = &EG(uninitialized_zval_ptr);
-				PZVAL_LOCK(EG(uninitialized_zval_ptr));
-			}
-			return;
-			break;
-
-		case IS_STRING: {
-				zval tmp;
-
-				if (type != BP_VAR_UNSET && Z_STRLEN_P(container)==0) {
-					goto convert_to_array;
-				}
-				if (dim == NULL) {
-					zend_error_noreturn(E_ERROR, "[] operator not supported for strings");
-				}
-
-				if (type != BP_VAR_UNSET) {
-					SEPARATE_ZVAL_IF_NOT_REF(container_ptr);
-				}
+			zval_dtor(container);
+			array_init(container);
+			goto fetch_from_array;
+		}
+		if (dim == NULL) {
+			zend_error_noreturn(E_ERROR, "[] operator not supported for strings");
+		}
 
-				if (Z_TYPE_P(dim) != IS_LONG) {
+		if (type != BP_VAR_UNSET) {
+			if (container == container_ptr) {
+				SEPARATE_ZVAL(container);
+			}
+		}
 
-					switch(Z_TYPE_P(dim)) {
-						/* case IS_LONG: */
-						case IS_STRING:
-							if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
-								break;
-							}
-							if (type != BP_VAR_UNSET) {
-								zend_error(E_WARNING, "Illegal string offset '%s'", dim->value.str.val);
-							}
+		if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
+			zval tmp;
 
-							break;
-						case IS_DOUBLE:
-						case IS_NULL:
-						case IS_BOOL:
-							zend_error(E_NOTICE, "String offset cast occurred");
-							break;
-						default:
-							zend_error(E_WARNING, "Illegal offset type");
-							break;
+			switch(Z_TYPE_P(dim)) {
+				case IS_STRING:
+					if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
+						break;
 					}
-
-					tmp = *dim;
-					zval_copy_ctor(&tmp);
-					convert_to_long(&tmp);
-					dim = &tmp;
-				}
-				container = *container_ptr;
-				result->str_offset.str = container;
-				PZVAL_LOCK(container);
-				result->str_offset.offset = Z_LVAL_P(dim);
-				result->str_offset.ptr_ptr = NULL;
-				return;
+					if (type != BP_VAR_UNSET) {
+						zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim));
+					}
+					break;
+				case IS_DOUBLE:
+				case IS_NULL:
+				case IS_BOOL:
+					zend_error(E_NOTICE, "String offset cast occurred");
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type");
+					break;
 			}
-			break;
 
-		case IS_OBJECT:
-			if (!Z_OBJ_HT_P(container)->read_dimension) {
-				zend_error_noreturn(E_ERROR, "Cannot use object as array");
-			} else {
-				zval *overloaded_result;
+			ZVAL_DUP(&tmp, dim);
+			convert_to_long(&tmp);
+			dim = &tmp;
+		}
 
-				if (dim_type == IS_TMP_VAR) {
-					zval *orig = dim;
-					MAKE_REAL_ZVAL_PTR(dim);
-					ZVAL_NULL(orig);
-				}
-				overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
-
-				if (overloaded_result) {
-					if (!Z_ISREF_P(overloaded_result)) {
-						if (Z_REFCOUNT_P(overloaded_result) > 0) {
-							zval *tmp = overloaded_result;
-
-							ALLOC_ZVAL(overloaded_result);
-							ZVAL_COPY_VALUE(overloaded_result, tmp);
-							zval_copy_ctor(overloaded_result);
-							Z_UNSET_ISREF_P(overloaded_result);
-							Z_SET_REFCOUNT_P(overloaded_result, 0);
-						}
-						if (Z_TYPE_P(overloaded_result) != IS_OBJECT) {
-							zend_class_entry *ce = Z_OBJCE_P(container);
-							zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ce->name);
+		if (!IS_INTERNED(Z_STR_P(container))) STR_ADDREF(Z_STR_P(container));
+		ZVAL_STR_OFFSET(result, container, Z_LVAL_P(dim));
+	} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (!Z_OBJ_HT_P(container)->read_dimension) {
+			zend_error_noreturn(E_ERROR, "Cannot use object as array");
+		} else {
+			retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result TSRMLS_CC);
+
+			if (UNEXPECTED(retval == &EG(uninitialized_zval))) {
+				ZVAL_NULL(result);
+			} else if (retval && Z_TYPE_P(retval) != IS_UNDEF) {
+				if (!Z_ISREF_P(retval)) {
+					if (Z_REFCOUNTED_P(retval) &&
+					    Z_REFCOUNT_P(retval) > 1) {
+						if (Z_TYPE_P(retval) != IS_OBJECT) {
+							Z_DELREF_P(retval);
+							ZVAL_DUP(result, retval);
+							retval = result;
+						} else {
+							ZVAL_COPY(result, retval);
+							retval = result;
 						}
 					}
-					AI_SET_PTR(result, overloaded_result);
-					PZVAL_LOCK(overloaded_result);
-				} else {
-					result->var.ptr_ptr = &EG(error_zval_ptr);
-					PZVAL_LOCK(EG(error_zval_ptr));
+					if (Z_TYPE_P(retval) != IS_OBJECT) {
+						zend_class_entry *ce = Z_OBJCE_P(container);
+						zend_error(E_NOTICE, "Indirect modification of overloaded element of %s has no effect", ce->name->val);
+					}
 				}
-				if (dim_type == IS_TMP_VAR) {
-					zval_ptr_dtor(&dim);
+				if (result != retval) {
+					if (is_ref) {
+						SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
+						ZVAL_COPY(result, retval);
+					} else {
+						ZVAL_INDIRECT(result, retval);
+					}
 				}
-			}
-			return;
-			break;
-
-		case IS_BOOL:
-			if (type != BP_VAR_UNSET && Z_LVAL_P(container)==0) {
-				goto convert_to_array;
-			}
-			/* break missing intentionally */
-
-		default:
-			if (type == BP_VAR_UNSET) {
-				zend_error(E_WARNING, "Cannot unset offset in a non-array variable");
-				result->var.ptr_ptr = &EG(uninitialized_zval_ptr);
-				PZVAL_LOCK(EG(uninitialized_zval_ptr));
 			} else {
-				zend_error(E_WARNING, "Cannot use a scalar value as an array");
-				result->var.ptr_ptr = &EG(error_zval_ptr);
-				PZVAL_LOCK(EG(error_zval_ptr));
+				ZVAL_INDIRECT(result, &EG(error_zval));
 			}
-			break;
+		}
+	} else if (EXPECTED(Z_TYPE_P(container) == IS_NULL)) {
+		if (container == &EG(error_zval)) {
+			ZVAL_INDIRECT(result, &EG(error_zval));
+		} else if (type != BP_VAR_UNSET) {
+			goto convert_to_array;
+		} else {
+			/* for read-mode only */
+			ZVAL_NULL(result);
+		}
+	} else {
+		if (type != BP_VAR_UNSET &&
+		    Z_TYPE_P(container) == IS_BOOL &&
+		    Z_LVAL_P(container)==0) {
+			goto convert_to_array;
+		}
+		if (type == BP_VAR_UNSET) {
+			zend_error(E_WARNING, "Cannot unset offset in a non-array variable");
+			ZVAL_NULL(result);
+		} else {
+			zend_error(E_WARNING, "Cannot use a scalar value as an array");
+			ZVAL_INDIRECT(result, &EG(error_zval));
+		}
 	}
 }
 
-static void zend_fetch_dimension_address_read(temp_variable *result, zval *container, zval *dim, int dim_type, int type TSRMLS_DC)
+static zend_never_inline void zend_fetch_dimension_address_W(zval *result, zval *container_ptr, zval *dim, int dim_type TSRMLS_DC)
 {
-	zval **retval;
-
-	switch (Z_TYPE_P(container)) {
-
-		case IS_ARRAY:
-			retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
-			result->var.ptr = *retval;
-			PZVAL_LOCK(*retval);
-			return;
+	zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_W, 0 TSRMLS_CC);
+}
 
-		case IS_NULL:
-			result->var.ptr = &EG(uninitialized_zval);
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			return;
+static zend_never_inline void zend_fetch_dimension_address_W_ref(zval *result, zval *container_ptr, zval *dim, int dim_type TSRMLS_DC)
+{
+	zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_W, 1 TSRMLS_CC);
+}
 
-		case IS_STRING: {
-				zval tmp;
-				zval *ptr;
-
-				if (Z_TYPE_P(dim) != IS_LONG) {
-					switch(Z_TYPE_P(dim)) {
-						/* case IS_LONG: */
-						case IS_STRING:
-							if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
-								break;
-							}
-							if (type != BP_VAR_IS) {
-								zend_error(E_WARNING, "Illegal string offset '%s'", dim->value.str.val);
-							}
-							break;
-						case IS_DOUBLE:
-						case IS_NULL:
-						case IS_BOOL:
-							if (type != BP_VAR_IS) {
-								zend_error(E_NOTICE, "String offset cast occurred");
-							}
-							break;
-						default:
-							zend_error(E_WARNING, "Illegal offset type");
-							break;
-					}
+static zend_never_inline void zend_fetch_dimension_address_RW(zval *result, zval *container_ptr, zval *dim, int dim_type TSRMLS_DC)
+{
+	zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_RW, 0 TSRMLS_CC);
+}
 
-					ZVAL_COPY_VALUE(&tmp, dim);
-					zval_copy_ctor(&tmp);
-					convert_to_long(&tmp);
-					dim = &tmp;
-				}
+static zend_never_inline void zend_fetch_dimension_address_UNSET(zval *result, zval *container_ptr, zval *dim, int dim_type TSRMLS_DC)
+{
+	zend_fetch_dimension_address(result, container_ptr, dim, dim_type, BP_VAR_UNSET, 0 TSRMLS_CC);
+}
 
-				ALLOC_ZVAL(ptr);
-				INIT_PZVAL(ptr);
-				Z_TYPE_P(ptr) = IS_STRING;
+static zend_always_inline void zend_fetch_dimension_address_read(zval *result, zval *container, zval *dim, int dim_type, int type TSRMLS_DC)
+{
+	zval *retval;
+
+	ZVAL_DEREF(container);
+	if (EXPECTED(Z_TYPE_P(container) == IS_ARRAY)) {
+		retval = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), dim, dim_type, type TSRMLS_CC);
+		ZVAL_COPY(result, retval);
+	} else if (EXPECTED(Z_TYPE_P(container) == IS_STRING)) {
+		if (UNEXPECTED(Z_TYPE_P(dim) != IS_LONG)) {
+			zval tmp;
 
-				if (Z_LVAL_P(dim) < 0 || Z_STRLEN_P(container) <= Z_LVAL_P(dim)) {
+			switch(Z_TYPE_P(dim)) {
+				/* case IS_LONG: */
+				case IS_STRING:
+					if (IS_LONG == is_numeric_string(Z_STRVAL_P(dim), Z_STRLEN_P(dim), NULL, NULL, -1)) {
+						break;
+					}
 					if (type != BP_VAR_IS) {
-						zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
+						zend_error(E_WARNING, "Illegal string offset '%s'", Z_STRVAL_P(dim));
 					}
-					Z_STRVAL_P(ptr) = STR_EMPTY_ALLOC();
-					Z_STRLEN_P(ptr) = 0;
-				} else {
-					Z_STRVAL_P(ptr) = (char*)emalloc(2);
-					Z_STRVAL_P(ptr)[0] = Z_STRVAL_P(container)[Z_LVAL_P(dim)];
-					Z_STRVAL_P(ptr)[1] = 0;
-					Z_STRLEN_P(ptr) = 1;
-				}
-				result->var.ptr = ptr;
-				return;
+					break;
+				case IS_DOUBLE:
+				case IS_NULL:
+				case IS_BOOL:
+					if (type != BP_VAR_IS) {
+						zend_error(E_NOTICE, "String offset cast occurred");
+					}
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type");
+					break;
 			}
-			break;
 
-		case IS_OBJECT:
-			if (!Z_OBJ_HT_P(container)->read_dimension) {
-				zend_error_noreturn(E_ERROR, "Cannot use object as array");
-			} else {
-				zval *overloaded_result;
+			ZVAL_DUP(&tmp, dim);
+			convert_to_long(&tmp);
+			dim = &tmp;
+		}
 
-				if (dim_type == IS_TMP_VAR) {
-					zval *orig = dim;
-					MAKE_REAL_ZVAL_PTR(dim);
-					ZVAL_NULL(orig);
-				}
-				overloaded_result = Z_OBJ_HT_P(container)->read_dimension(container, dim, type TSRMLS_CC);
+		if (UNEXPECTED(Z_LVAL_P(dim) < 0) || UNEXPECTED(Z_STRLEN_P(container) <= Z_LVAL_P(dim))) {
+			if (type != BP_VAR_IS) {
+				zend_error(E_NOTICE, "Uninitialized string offset: %ld", Z_LVAL_P(dim));
+			}
+			ZVAL_EMPTY_STRING(result);
+		} else {
+			zend_uchar c = (zend_uchar)Z_STRVAL_P(container)[Z_LVAL_P(dim)];
 
-				if (result) {
-					if (overloaded_result) {
-						result->var.ptr = overloaded_result;
-						PZVAL_LOCK(overloaded_result);
-					} else {
-						result->var.ptr = &EG(uninitialized_zval);
-						PZVAL_LOCK(&EG(uninitialized_zval));
+			if (CG(one_char_string)[c]) {
+				ZVAL_INT_STR(result, CG(one_char_string)[c]);
+			} else {
+				ZVAL_NEW_STR(result, STR_INIT(Z_STRVAL_P(container) + Z_LVAL_P(dim), 1, 0));
+			}
+		}
+	} else if (EXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (!Z_OBJ_HT_P(container)->read_dimension) {
+			zend_error_noreturn(E_ERROR, "Cannot use object as array");
+		} else {
+			retval = Z_OBJ_HT_P(container)->read_dimension(container, dim, type, result TSRMLS_CC);
+
+			if (result) {
+				if (retval) {
+					if (result != retval) {
+						ZVAL_COPY(result, retval);
 					}
-				}
-				if (dim_type == IS_TMP_VAR) {
-					zval_ptr_dtor(&dim);
+				} else {
+					ZVAL_NULL(result);
 				}
 			}
-			return;
-
-		default:
-			result->var.ptr = &EG(uninitialized_zval);
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			return;
+		}
+	} else {
+		ZVAL_NULL(result);
 	}
 }
 
-ZEND_API void zend_fetch_dimension_by_zval(zval **result, zval *container, zval *dim TSRMLS_DC) {
-	temp_variable tmp;
-	zend_fetch_dimension_address_read(&tmp, container, dim, IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
-	*result = tmp.var.ptr;
+static zend_never_inline void zend_fetch_dimension_address_read_R(zval *result, zval *container, zval *dim, int dim_type TSRMLS_DC)
+{
+	zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_R TSRMLS_CC);
+}
+
+static zend_never_inline void zend_fetch_dimension_address_read_IS(zval *result, zval *container, zval *dim, int dim_type TSRMLS_DC)
+{
+	zend_fetch_dimension_address_read(result, container, dim, dim_type, BP_VAR_IS TSRMLS_CC);
 }
 
-static void zend_fetch_property_address(temp_variable *result, zval **container_ptr, zval *prop_ptr, const zend_literal *key, int type TSRMLS_DC)
+static void zend_fetch_property_address(zval *result, zval *container_ptr, zval *prop_ptr, zend_uint cache_slot, int type, int is_ref TSRMLS_DC)
 {
-	zval *container = *container_ptr;
+	zval *container = container_ptr;
 
+	ZVAL_DEREF(container);
 	if (Z_TYPE_P(container) != IS_OBJECT) {
 		if (container == &EG(error_zval)) {
-			result->var.ptr_ptr = &EG(error_zval_ptr);
-			PZVAL_LOCK(EG(error_zval_ptr));
+			ZVAL_INDIRECT(result, &EG(error_zval));
 			return;
 		}
 
@@ -1374,44 +1360,54 @@ static void zend_fetch_property_address(temp_variable *result, zval **container_
 		    ((Z_TYPE_P(container) == IS_NULL ||
 		     (Z_TYPE_P(container) == IS_BOOL && Z_LVAL_P(container)==0) ||
 		     (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
-			if (!PZVAL_IS_REF(container)) {
-				SEPARATE_ZVAL(container_ptr);
-				container = *container_ptr;
+			if (container == container_ptr) {
+				SEPARATE_ZVAL(container);
 			}
 			object_init(container);
 		} else {
 			zend_error(E_WARNING, "Attempt to modify property of non-object");
-			result->var.ptr_ptr = &EG(error_zval_ptr);
-			PZVAL_LOCK(EG(error_zval_ptr));
+			ZVAL_INDIRECT(result, &EG(error_zval));
 			return;
 		}
 	}
 
 	if (Z_OBJ_HT_P(container)->get_property_ptr_ptr) {
-		zval **ptr_ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, key TSRMLS_CC);
-		if (NULL == ptr_ptr) {
-			zval *ptr;
-
+		zval *ptr = Z_OBJ_HT_P(container)->get_property_ptr_ptr(container, prop_ptr, type, cache_slot TSRMLS_CC);
+		if (NULL == ptr) {
 			if (Z_OBJ_HT_P(container)->read_property &&
-				(ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC)) != NULL) {
-				AI_SET_PTR(result, ptr);
-				PZVAL_LOCK(ptr);
+				(ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result TSRMLS_CC)) != NULL) {
+				if (ptr != result) {
+					if (is_ref && ptr != &EG(uninitialized_zval)) {
+						SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
+						ZVAL_COPY(result, ptr);
+					} else {
+						ZVAL_INDIRECT(result, ptr);
+					}
+				}
 			} else {
 				zend_error_noreturn(E_ERROR, "Cannot access undefined property for object with overloaded property access");
 			}
 		} else {
-			result->var.ptr_ptr = ptr_ptr;
-			PZVAL_LOCK(*ptr_ptr);
+			if (is_ref) {
+				SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
+				ZVAL_COPY(result, ptr);
+			} else {
+				ZVAL_INDIRECT(result, ptr);
+			}
 		}
 	} else if (Z_OBJ_HT_P(container)->read_property) {
-		zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, key TSRMLS_CC);
-
-		AI_SET_PTR(result, ptr);
-		PZVAL_LOCK(ptr);
+		zval *ptr = Z_OBJ_HT_P(container)->read_property(container, prop_ptr, type, cache_slot, result TSRMLS_CC);
+		if (ptr != result) {
+			if (is_ref && ptr != &EG(uninitialized_zval)) {
+				SEPARATE_ZVAL_TO_MAKE_IS_REF(ptr);
+				ZVAL_COPY(result, ptr);
+			} else {
+				ZVAL_INDIRECT(result, ptr);
+			}
+		}
 	} else {
 		zend_error(E_WARNING, "This object doesn't support property references");
-		result->var.ptr_ptr = &EG(error_zval_ptr);
-		PZVAL_LOCK(EG(error_zval_ptr));
+		ZVAL_INDIRECT(result, &EG(error_zval));
 	}
 }
 
@@ -1431,12 +1427,12 @@ static inline zend_brk_cont_element* zend_brk_cont(int nest_levels, int array_of
 			switch (brk_opline->opcode) {
 				case ZEND_SWITCH_FREE:
 					if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-						zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
+						zval_ptr_dtor(EX_VAR(brk_opline->op1.var));
 					}
 					break;
 				case ZEND_FREE:
 					if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-						zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
+						zval_dtor(EX_VAR(brk_opline->op1.var));
 					}
 					break;
 			}
@@ -1480,31 +1476,29 @@ static int zend_check_symbol(zval **pz TSRMLS_DC)
 
 ZEND_API opcode_handler_t *zend_opcode_handlers;
 
-ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci, int return_value_used TSRMLS_DC)
+ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, zend_fcall_info *fci TSRMLS_DC)
 {
 	if (fci != NULL) {
 		execute_data_ptr->function_state.function->internal_function.handler(
-			fci->param_count, *fci->retval_ptr_ptr, fci->retval_ptr_ptr,
-			fci->object_ptr, 1 TSRMLS_CC
+			fci->param_count, fci->retval TSRMLS_CC
 		);
 	} else {
-		zval **return_value_ptr = &EX_TMP_VAR(execute_data_ptr, execute_data_ptr->opline->result.var)->var.ptr;
+		zval *return_value = EX_VAR_2(execute_data_ptr, execute_data_ptr->opline->result.var);
 		execute_data_ptr->function_state.function->internal_function.handler(
-			execute_data_ptr->opline->extended_value, *return_value_ptr, return_value_ptr,
-			execute_data_ptr->object, return_value_used TSRMLS_CC
+			execute_data_ptr->opline->extended_value, return_value TSRMLS_CC
 		);
 	}
 }
 
-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);
+		zend_hash_destroy(&symbol_table->ht);
 		FREE_HASHTABLE(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;
 	}
 }
@@ -1512,12 +1506,10 @@ void zend_clean_and_cache_symbol_table(HashTable *symbol_table TSRMLS_DC) /* {{{
 
 static zend_always_inline void i_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC) /* {{{ */
 {
-	zval ***cv = EX_CV_NUM(execute_data, 0);
-	zval ***end = cv + EX(op_array)->last_var;
+	zval *cv = EX_VAR_NUM(0);
+	zval *end = cv + EX(op_array)->last_var;
 	while (cv != end) {
-		if (*cv) {
-			zval_ptr_dtor(*cv);
-		}
+		zval_ptr_dtor(cv);
 		cv++;
  	}
 }
@@ -1544,20 +1536,15 @@ void zend_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC) /*
  *                             +========================================+    |
  *                                                                           |
  *                             +========================================+    |
- *                             | TMP_VAR[op_arrat->T-1]                 |    |
- *                             | ...                                    |    |
- *     EX_TMP_VAR_NUM(0) ----> | TMP_VAR[0]                             |    |
- *                             +----------------------------------------+    |
  * EG(current_execute_data) -> | zend_execute_data                      |    |
  *                             |     EX(prev_execute_data)              |----+
  *                             +----------------------------------------+
- *     EX_CV_NUM(0) ---------> | CV[0]                                  |--+
- *                             | ...                                    |  |
- *                             | CV[op_array->last_var-1]               |  |
- *                             +----------------------------------------+  |
- *                             | Optional slot for CV[0] zval*          |<-+
+ *     EX_CV_NUM(0) ---------> | VAR[0]                                 |
  *                             | ...                                    |
- *                             | ...for CV [op_array->last_var-1] zval* |
+ *                             | VAR[op_array->last_var-1]              |
+ *                             | VAR[op_array->last_var]                |
+ *                             | ...                                    |
+ *                             | VAR[op_array->last_var+op_array->T-1]  |
  *                             +----------------------------------------+
  *           EX(call_slots) -> | CALL_SLOT[0]                           |
  *                             | ...                                    |
@@ -1571,7 +1558,7 @@ void zend_free_compiled_variables(zend_execute_data *execute_data TSRMLS_DC) /*
  *                             +----------------------------------------+
  */
 
-static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array(zend_op_array *op_array, zend_bool nested TSRMLS_DC) /* {{{ */
+static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array(zend_op_array *op_array, zval *return_value, vm_frame_kind frame_kind TSRMLS_DC) /* {{{ */
 {
 	zend_execute_data *execute_data;
 
@@ -1587,11 +1574,10 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
 	 * half the actual zval*s (which would otherwise be in the symbol table).
 	 */
 	size_t execute_data_size = ZEND_MM_ALIGNED_SIZE(sizeof(zend_execute_data));
-	size_t CVs_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval **) * op_array->last_var * (EG(active_symbol_table) ? 1 : 2));
-	size_t Ts_size = ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T;
+	size_t vars_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * (op_array->last_var + op_array->T);
 	size_t call_slots_size = ZEND_MM_ALIGNED_SIZE(sizeof(call_slot)) * op_array->nested_calls;
-	size_t stack_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * op_array->used_stack;
-	size_t total_size = execute_data_size + Ts_size + CVs_size + call_slots_size + stack_size;
+	size_t stack_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * op_array->used_stack;
+	size_t total_size = execute_data_size + vars_size + call_slots_size + stack_size;
 
 	/*
 	 * Normally the execute_data is allocated on the VM stack (because it does
@@ -1608,85 +1594,88 @@ static zend_always_inline zend_execute_data *i_create_execute_data_from_op_array
 		 * and the passed arguments
 		 */
 		int args_count = zend_vm_stack_get_args_count_ex(EG(current_execute_data));
-		size_t args_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * (args_count + 1);
+		size_t args_size = ZEND_MM_ALIGNED_SIZE(sizeof(zval)) * (args_count + 1);
 
 		total_size += args_size + execute_data_size;
 
-		EG(argument_stack) = zend_vm_stack_new_page((total_size + (sizeof(void*) - 1)) / sizeof(void*));
+		EG(argument_stack) = zend_vm_stack_new_page((total_size + (sizeof(zval) - 1)) / sizeof(zval));
 		EG(argument_stack)->prev = NULL;
-		execute_data = (zend_execute_data*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + args_size + execute_data_size + Ts_size);
+		execute_data = (zend_execute_data*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + execute_data_size + args_size);
 
 		/* copy prev_execute_data */
-		EX(prev_execute_data) = (zend_execute_data*)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + args_size);
+		EX(prev_execute_data) = (zend_execute_data*)ZEND_VM_STACK_ELEMETS(EG(argument_stack));
 		memset(EX(prev_execute_data), 0, sizeof(zend_execute_data));
 		EX(prev_execute_data)->function_state.function = (zend_function*)op_array;
-		EX(prev_execute_data)->function_state.arguments = (void**)((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(zval*)) * args_count);
+		EX(prev_execute_data)->function_state.arguments = (zval*)(((char*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + execute_data_size + args_size - sizeof(zval)));
 
 		/* copy arguments */
-		*EX(prev_execute_data)->function_state.arguments = (void*)(zend_uintptr_t)args_count;
+		ZVAL_LONG(EX(prev_execute_data)->function_state.arguments, args_count);
 		if (args_count > 0) {
-			zval **arg_src = (zval**)zend_vm_stack_get_arg_ex(EG(current_execute_data), 1);
-			zval **arg_dst = (zval**)zend_vm_stack_get_arg_ex(EX(prev_execute_data), 1);
+			zval *arg_src = zend_vm_stack_get_arg_ex(EG(current_execute_data), 1);
+			zval *arg_dst = zend_vm_stack_get_arg_ex(EX(prev_execute_data), 1);
 			int i;
 
 			for (i = 0; i < args_count; i++) {
-				arg_dst[i] = arg_src[i];
-				Z_ADDREF_P(arg_dst[i]);
+				ZVAL_COPY(arg_dst + i, arg_src + i);
 			}
 		}
 	} else {
 		execute_data = zend_vm_stack_alloc(total_size TSRMLS_CC);
-		execute_data = (zend_execute_data*)((char*)execute_data + Ts_size);
 		EX(prev_execute_data) = EG(current_execute_data);
 	}
 
-	memset(EX_CV_NUM(execute_data, 0), 0, sizeof(zval **) * op_array->last_var);
-
-	EX(call_slots) = (call_slot*)((char *)execute_data + execute_data_size + CVs_size);
-
+	EX(return_value) = return_value;
+	EX(frame_kind) = frame_kind;
+	ZVAL_UNDEF(&EX(old_error_reporting));
+	EX(delayed_exception) = NULL;
+	EX(call_slots) = (call_slot*)((char *)execute_data + execute_data_size + vars_size);
+	EX(call) = NULL;
 
+	EG(opline_ptr) = &EX(opline);
+	EX(opline) = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes;
+	EX(function_state).function = (zend_function *) op_array;
+	EX(function_state).arguments = NULL;
 	EX(op_array) = op_array;
-
-	EG(argument_stack)->top = zend_vm_stack_frame_base(execute_data);
-
-	EX(object) = NULL;
-	EX(current_this) = NULL;
-	EX(old_error_reporting) = NULL;
+	EX(object) = Z_OBJ(EG(This));
+	EX(scope) = EG(scope);
+	EX(called_scope) = EG(called_scope);
 	EX(symbol_table) = EG(active_symbol_table);
-	EX(call) = NULL;
-	EG(current_execute_data) = execute_data;
-	EX(nested) = nested;
-	EX(delayed_exception) = NULL;
 
-	if (!op_array->run_time_cache && op_array->last_cache_slot) {
-		op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*));
-	}
-
-	if (op_array->this_var != -1 && EG(This)) {
- 		Z_ADDREF_P(EG(This)); /* For $this pointer */
-		if (!EG(active_symbol_table)) {
-			EX_CV(op_array->this_var) = (zval **) EX_CV_NUM(execute_data, op_array->last_var + op_array->this_var);
-			*EX_CV(op_array->this_var) = EG(This);
-		} else {
-			if (zend_hash_add(EG(active_symbol_table), "this", sizeof("this"), &EG(This), sizeof(zval *), (void **) EX_CV_NUM(execute_data, op_array->this_var))==FAILURE) {
-				Z_DELREF_P(EG(This));
+	if (EX(symbol_table)) {
+		zend_attach_symbol_table(execute_data);
+	} else {
+		do {
+			/* Initialize CV variables */
+			zval *var = EX_VAR_NUM(0);
+			zval *end = var + op_array->last_var;
+
+			while (var != end) {
+				ZVAL_UNDEF(var);
+				var++;
 			}
+		} while (0);
+
+		if (op_array->this_var != -1 && Z_OBJ(EG(This))) {
+			ZVAL_OBJ(EX_VAR(op_array->this_var), Z_OBJ(EG(This)));
+			Z_ADDREF(EG(This));
 		}
 	}
 
-	EX(opline) = UNEXPECTED((op_array->fn_flags & ZEND_ACC_INTERACTIVE) != 0) && EG(start_op) ? EG(start_op) : op_array->opcodes;
-	EG(opline_ptr) = &EX(opline);
+	if (!op_array->run_time_cache && op_array->last_cache_slot) {
+		op_array->run_time_cache = ecalloc(op_array->last_cache_slot, sizeof(void*));
+	}
+	EX(run_time_cache) = op_array->run_time_cache;
 
-	EX(function_state).function = (zend_function *) op_array;
-	EX(function_state).arguments = NULL;
+	EG(argument_stack)->top = (zval*)zend_vm_stack_frame_base(execute_data);
+	EG(current_execute_data) = execute_data;
 
 	return execute_data;
 }
 /* }}} */
 
-ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array *op_array, zend_bool nested TSRMLS_DC) /* {{{ */
+ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array *op_array, zval *return_value, vm_frame_kind frame_kind TSRMLS_DC) /* {{{ */
 {
-	return i_create_execute_data_from_op_array(op_array, nested TSRMLS_CC);
+	return i_create_execute_data_from_op_array(op_array, return_value, frame_kind TSRMLS_CC);
 }
 /* }}} */
 
@@ -1697,16 +1686,17 @@ static zend_always_inline zend_bool zend_is_by_ref_func_arg_fetch(zend_op *oplin
 }
 /* }}} */
 
-static void **zend_vm_stack_push_args_with_copy(int count TSRMLS_DC) /* {{{ */
+static zval *zend_vm_stack_push_args_with_copy(int count TSRMLS_DC) /* {{{ */
 {
 	zend_vm_stack p = EG(argument_stack);
 
 	zend_vm_stack_extend(count + 1 TSRMLS_CC);
 
 	EG(argument_stack)->top += count;
-	*(EG(argument_stack)->top) = (void*)(zend_uintptr_t)count;
+	ZVAL_LONG(EG(argument_stack)->top, count);
 	while (count-- > 0) {
-		void *data = *(--p->top);
+		zval *data = --p->top;
+		ZVAL_COPY_VALUE(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + count, data);
 
 		if (UNEXPECTED(p->top == ZEND_VM_STACK_ELEMETS(p))) {
 			zend_vm_stack r = p;
@@ -1715,19 +1705,18 @@ static void **zend_vm_stack_push_args_with_copy(int count TSRMLS_DC) /* {{{ */
 			p = p->prev;
 			efree(r);
 		}
-		*(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) + count) = data;
 	}
 	return EG(argument_stack)->top++;
 }
 /* }}} */
 
-static zend_always_inline void** zend_vm_stack_push_args(int count TSRMLS_DC) /* {{{ */
+static zend_always_inline zval *zend_vm_stack_push_args(int count TSRMLS_DC) /* {{{ */
 {
 	if (UNEXPECTED(EG(argument_stack)->top - ZEND_VM_STACK_ELEMETS(EG(argument_stack)) < count)
 		|| UNEXPECTED(EG(argument_stack)->top == EG(argument_stack)->end)) {
 		return zend_vm_stack_push_args_with_copy(count TSRMLS_CC);
 	}
-	*(EG(argument_stack)->top) = (void*)(zend_uintptr_t)count;
+	ZVAL_LONG(EG(argument_stack)->top, count);
 	return EG(argument_stack)->top++;
 }
 /* }}} */
@@ -1785,10 +1774,6 @@ ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_e
 	return get_zval_ptr(op_type, node, execute_data, should_free, type);
 }
 
-ZEND_API zval **zend_get_zval_ptr_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC) {
-	return get_zval_ptr_ptr(op_type, node, execute_data, should_free, type);
-}
-
 /*
  * Local variables:
  * tab-width: 4
diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index d151c3413d..98e2678f53 100644
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -27,76 +27,47 @@
 #include "zend_operators.h"
 #include "zend_variables.h"
 
-typedef union _temp_variable {
-	zval tmp_var;
-	struct {
-		zval **ptr_ptr;
-		zval *ptr;
-		zend_bool fcall_returned_reference;
-	} var;
-	struct {
-		zval **ptr_ptr; /* shared with var.ptr_ptr */
-		zval *str;
-		zend_uint offset;
-	} str_offset;
-	struct {
-		zval **ptr_ptr; /* shared with var.ptr_ptr */
-		zval *ptr;      /* shared with var.ptr */
-		HashPointer fe_pos;
-	} fe;
-	zend_class_entry *class_entry;
-} temp_variable;
-
-
 BEGIN_EXTERN_C()
 struct _zend_fcall_info;
 ZEND_API extern void (*zend_execute_ex)(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API extern void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci TSRMLS_DC);
 
 void init_executor(TSRMLS_D);
 void shutdown_executor(TSRMLS_D);
 void shutdown_destructors(TSRMLS_D);
-ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array *op_array, zend_bool nested TSRMLS_DC);
-ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC);
+ZEND_API zend_execute_data *zend_create_execute_data_from_op_array(zend_op_array *op_array, zval *return_value, vm_frame_kind frame_kind TSRMLS_DC);
+ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value TSRMLS_DC);
 ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API void execute_internal(zend_execute_data *execute_data_ptr, struct _zend_fcall_info *fci TSRMLS_DC);
 ZEND_API int zend_is_true(zval *op TSRMLS_DC);
-ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC);
-ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC);
+ZEND_API zend_class_entry *zend_lookup_class(zend_string *name TSRMLS_DC);
+ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload TSRMLS_DC);
 ZEND_API int zend_eval_string(char *str, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *string_name TSRMLS_DC);
 ZEND_API int zend_eval_string_ex(char *str, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 ZEND_API int zend_eval_stringl_ex(char *str, int str_len, zval *retval_ptr, char *string_name, int handle_exceptions TSRMLS_DC);
 
-ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, const char **class_name, zend_class_entry **pce TSRMLS_DC);
-ZEND_API int zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC);
+ZEND_API char * zend_verify_arg_class_kind(const zend_arg_info *cur_arg_info, ulong fetch_type, char **class_name, zend_class_entry **pce TSRMLS_DC);
+ZEND_API void zend_verify_arg_error(int error_type, const zend_function *zf, zend_uint arg_num, const char *need_msg, const char *need_kind, const char *given_msg, const char *given_kind TSRMLS_DC);
 
 static zend_always_inline void i_zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_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);
-		efree_rel(zval_ptr);
-	} else {
-		if (Z_REFCOUNT_P(zval_ptr) == 1) {
-			Z_UNSET_ISREF_P(zval_ptr);
+	if (Z_REFCOUNTED_P(zval_ptr)) {
+		if (!Z_DELREF_P(zval_ptr)) {
+			ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
+			_zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_CC);
+		} else {
+			GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
 		}
-
-		GC_ZVAL_CHECK_POSSIBLE_ROOT(zval_ptr);
 	}
 }
 
 static zend_always_inline void i_zval_ptr_dtor_nogc(zval *zval_ptr ZEND_FILE_LINE_DC TSRMLS_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);
-		efree_rel(zval_ptr);
-	} else {
-		if (Z_REFCOUNT_P(zval_ptr) == 1) {
-			Z_UNSET_ISREF_P(zval_ptr);
+	if (Z_REFCOUNTED_P(zval_ptr)) {
+		if (!Z_DELREF_P(zval_ptr)) {
+			ZEND_ASSERT(zval_ptr != &EG(uninitialized_zval));
+			_zval_dtor_func_for_ptr(Z_COUNTED_P(zval_ptr) ZEND_FILE_LINE_CC);
 		}
 	}
 }
@@ -105,7 +76,9 @@ static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
 {
 	int result;
 
+again:
 	switch (Z_TYPE_P(op)) {
+		case IS_UNDEF:
 		case IS_NULL:
 			result = 0;
 			break;
@@ -129,7 +102,7 @@ static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
 			result = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
 			break;
 		case IS_OBJECT:
-			if(IS_ZEND_STD_OBJECT(*op)) {
+			if (IS_ZEND_STD_OBJECT(*op)) {
 				if (Z_OBJ_HT_P(op)->cast_object) {
 					zval tmp;
 					if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_BOOL TSRMLS_CC) == SUCCESS) {
@@ -137,18 +110,23 @@ static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
 						break;
 					}
 				} else if (Z_OBJ_HT_P(op)->get) {
-					zval *tmp = Z_OBJ_HT_P(op)->get(op TSRMLS_CC);
-					if(Z_TYPE_P(tmp) != IS_OBJECT) {
+					zval rv;
+					zval *tmp = Z_OBJ_HT_P(op)->get(op, &rv TSRMLS_CC);
+					if (Z_TYPE_P(tmp) != IS_OBJECT) {
 						/* for safety - avoid loop */
 						convert_to_boolean(tmp);
 						result = Z_LVAL_P(tmp);
-						zval_ptr_dtor(&tmp);
+						zval_ptr_dtor(tmp);
 						break;
 					}
 				}
 			}
 			result = 1;
 			break;
+		case IS_REFERENCE:
+			op = Z_REFVAL_P(op);
+			goto again;
+			break;
 		default:
 			result = 0;
 			break;
@@ -156,22 +134,22 @@ static zend_always_inline int i_zend_is_true(zval *op TSRMLS_DC)
 	return result;
 }
 
-ZEND_API int zval_update_constant(zval **pp, zend_bool inline_change TSRMLS_DC);
-ZEND_API int zval_update_constant_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC);
-ZEND_API int zval_update_constant_no_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC);
-ZEND_API int zval_update_constant_ex(zval **pp, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant(zval *pp, zend_bool inline_change TSRMLS_DC);
+ZEND_API int zval_update_constant_inline_change(zval *pp, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant_no_inline_change(zval *pp, zend_class_entry *scope TSRMLS_DC);
+ZEND_API int zval_update_constant_ex(zval *pp, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC);
 
 /* dedicated Zend executor functions - do not use! */
 #define ZEND_VM_STACK_PAGE_SIZE ((16 * 1024) - 16)
 
 struct _zend_vm_stack {
-	void **top;
-	void **end;
+	zval *top;
+	zval *end;
 	zend_vm_stack prev;
 };
 
 #define ZEND_VM_STACK_ELEMETS(stack) \
-	((void**)(((char*)(stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(struct _zend_vm_stack))))
+	((zval*)(((char*)(stack)) + ZEND_MM_ALIGNED_SIZE(sizeof(struct _zend_vm_stack))))
 
 #define ZEND_VM_STACK_GROW_IF_NEEDED(count)							\
 	do {															\
@@ -182,7 +160,7 @@ struct _zend_vm_stack {
 	} while (0)
 
 static zend_always_inline zend_vm_stack zend_vm_stack_new_page(int count) {
-	zend_vm_stack page = (zend_vm_stack)emalloc(ZEND_MM_ALIGNED_SIZE(sizeof(*page)) + sizeof(void*) * count);
+	zend_vm_stack page = (zend_vm_stack)emalloc(ZEND_MM_ALIGNED_SIZE(sizeof(*page)) + sizeof(zval) * count);
 
 	page->top = ZEND_VM_STACK_ELEMETS(page);
 	page->end = page->top + count;
@@ -213,132 +191,99 @@ static zend_always_inline void zend_vm_stack_extend(int count TSRMLS_DC)
 	EG(argument_stack) = p;
 }
 
-static zend_always_inline void **zend_vm_stack_top(TSRMLS_D)
+static zend_always_inline zval *zend_vm_stack_top(TSRMLS_D)
 {
 	return EG(argument_stack)->top;
 }
 
-static zend_always_inline void zend_vm_stack_push(void *ptr TSRMLS_DC)
+static zend_always_inline zval *zend_vm_stack_top_inc(TSRMLS_D)
 {
-	*(EG(argument_stack)->top++) = ptr;
+	return EG(argument_stack)->top++;
 }
 
-static zend_always_inline void *zend_vm_stack_pop(TSRMLS_D)
+static zend_always_inline void zend_vm_stack_push(zval *ptr TSRMLS_DC)
 {
-	void *el = *(--EG(argument_stack)->top);
+	ZVAL_COPY_VALUE(EG(argument_stack)->top, ptr);
+	EG(argument_stack)->top++;
+}
 
-	return el;
+static zend_always_inline zval *zend_vm_stack_pop(TSRMLS_D)
+{
+	return --EG(argument_stack)->top;
 }
 
 static zend_always_inline void *zend_vm_stack_alloc(size_t size TSRMLS_DC)
 {
-	void *ret;
-
-	size = (size + (sizeof(void*) - 1)) / sizeof(void*);
+	zval *ret;
+	int count = (size + (sizeof(zval) - 1)) / sizeof(zval);
 
-	/* the following comparison must be optimized out at compile time */
-	if (ZEND_MM_ALIGNMENT > sizeof(void*)) {
-		int extra = (ZEND_MM_ALIGNMENT - ((zend_uintptr_t)EG(argument_stack)->top & (ZEND_MM_ALIGNMENT - 1))) / sizeof(void*);
-
-		if (UNEXPECTED(size + extra + ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*) >
-		    (zend_uintptr_t)(EG(argument_stack)->end - EG(argument_stack)->top))) {
-			zend_vm_stack_extend(size TSRMLS_CC);
-		} else {
-			void **old_top = EG(argument_stack)->top;
-
-			EG(argument_stack)->top += extra;
-			/* store old top on the stack */
-			*EG(argument_stack)->top = (void*)old_top;
-			EG(argument_stack)->top += ZEND_MM_ALIGNED_SIZE(sizeof(void*)) / sizeof(void*);
-		}
-	} else {
-		ZEND_VM_STACK_GROW_IF_NEEDED((int)size);
-	}
+	ZEND_VM_STACK_GROW_IF_NEEDED(count);
 	ret = (void*)EG(argument_stack)->top;
-	EG(argument_stack)->top += size;
+	EG(argument_stack)->top += count;
 	return ret;
 }
 
-static zend_always_inline void** zend_vm_stack_frame_base(zend_execute_data *ex)
+static zend_always_inline zval* zend_vm_stack_frame_base(zend_execute_data *ex)
 {
-	return (void**)((char*)ex->call_slots +
+	return (zval*)((char*)ex->call_slots +
 		ZEND_MM_ALIGNED_SIZE(sizeof(call_slot)) * ex->op_array->nested_calls);
 }
 
-static zend_always_inline void zend_vm_stack_free_int(void *ptr TSRMLS_DC)
-{
-	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
-		zend_vm_stack p = EG(argument_stack);
-
-		EG(argument_stack) = p->prev;
-		efree(p);
-	} else {
-		EG(argument_stack)->top = (void**)ptr;
-	}
-}
-
 static zend_always_inline void zend_vm_stack_free(void *ptr TSRMLS_DC)
 {
-	if (UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (void**)ptr)) {
+	if (UNEXPECTED((void*)ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == ptr)) {
 		zend_vm_stack p = EG(argument_stack);
 
 		EG(argument_stack) = p->prev;
 		efree(p);
 	} else {
-		/* the following comparison must be optimized out at compile time */
-		if (ZEND_MM_ALIGNMENT > sizeof(void*)) {
-			ptr = (void*)(((char*)ptr) - ZEND_MM_ALIGNED_SIZE(sizeof(void*)));
-			EG(argument_stack)->top = *(void***)ptr;
-		} else {
-			EG(argument_stack)->top = (void**)ptr;
-		}
+		EG(argument_stack)->top = (zval*)ptr;
 	}
 }
 
 static zend_always_inline void zend_vm_stack_clear_multiple(int nested TSRMLS_DC)
 {
-	void **p = EG(argument_stack)->top - 1;
- 	void **end = p - (int)(zend_uintptr_t)*p;
+	zval *p = EG(argument_stack)->top - 1;
+ 	zval *end = p - Z_LVAL_P(p);
 
 	while (p != end) {
-		zval *q = (zval *) *(--p);
-		*p = NULL;
-		i_zval_ptr_dtor(q ZEND_FILE_LINE_CC TSRMLS_CC);
+		p--;
+		i_zval_ptr_dtor(p ZEND_FILE_LINE_CC TSRMLS_CC);
 	}
 	if (nested) {
 		EG(argument_stack)->top = p;
 	} else {
-		zend_vm_stack_free_int(p TSRMLS_CC);
+		zend_vm_stack_free(p TSRMLS_CC);
 	}
 }
 
 static zend_always_inline int zend_vm_stack_get_args_count_ex(zend_execute_data *ex)
 {
-	if (ex) {
-		void **p = ex->function_state.arguments;
-		return (int)(zend_uintptr_t) *p;
-	} else {
-		return 0;			
-	}
+	zval *p = ex->function_state.arguments;
+	return Z_LVAL_P(p);
 }
 
-static zend_always_inline zval** zend_vm_stack_get_arg_ex(zend_execute_data *ex, int requested_arg)
+static zend_always_inline zval* zend_vm_stack_get_arg_ex(zend_execute_data *ex, int requested_arg)
 {
-	void **p = ex->function_state.arguments;
-	int arg_count = (int)(zend_uintptr_t) *p;
+	zval *p = ex->function_state.arguments;
+	int arg_count = Z_LVAL_P(p);
 
 	if (UNEXPECTED(requested_arg > arg_count)) {
 		return NULL;
 	}
-	return (zval**)p - arg_count + requested_arg - 1;
+	return p - arg_count + requested_arg - 1;
 }
 
 static zend_always_inline int zend_vm_stack_get_args_count(TSRMLS_D)
 {
-	return zend_vm_stack_get_args_count_ex(EG(current_execute_data)->prev_execute_data);
+	if (EG(current_execute_data)->prev_execute_data) {
+		return zend_vm_stack_get_args_count_ex(EG(current_execute_data)->prev_execute_data);
+	} else {
+		return 0;
+	}
 }
 
-static zend_always_inline zval** zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
+static zend_always_inline zval* zend_vm_stack_get_arg(int requested_arg TSRMLS_DC)
 {
 	return zend_vm_stack_get_arg_ex(EG(current_execute_data)->prev_execute_data, requested_arg);
 }
@@ -356,12 +301,10 @@ ZEND_API zend_bool zend_is_executing(TSRMLS_D);
 ZEND_API void zend_set_timeout(long seconds, int reset_signals);
 ZEND_API void zend_unset_timeout(TSRMLS_D);
 ZEND_API void zend_timeout(int dummy);
-ZEND_API zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC);
-ZEND_API zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type TSRMLS_DC);
+ZEND_API zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type TSRMLS_DC);
 void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC);
 
-ZEND_API void zend_fetch_dimension_by_zval(zval **result, zval *container, zval *dim TSRMLS_DC);
-
 #ifdef ZEND_WIN32
 void zend_init_timeout_thread(void);
 void zend_shutdown_timeout_thread(void);
@@ -369,17 +312,14 @@ void zend_shutdown_timeout_thread(void);
 #define WM_UNREGISTER_ZEND_TIMEOUT		(WM_USER+2)
 #endif
 
-#define zendi_zval_copy_ctor(p) zval_copy_ctor(&(p))
-#define zendi_zval_dtor(p) zval_dtor(&(p))
-
 #define active_opline (*EG(opline_ptr))
 
 /* The following tries to resolve the classname of a zval of type object.
  * Since it is slow it should be only used in error messages.
  */
-#define Z_OBJ_CLASS_NAME_P(zval) ((zval) && Z_TYPE_P(zval) == IS_OBJECT && Z_OBJ_HT_P(zval)->get_class_entry != NULL && Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC) ? Z_OBJ_HT_P(zval)->get_class_entry(zval TSRMLS_CC)->name : "")
+#define Z_OBJ_CLASS_NAME_P(obj) (((obj) && (obj)->handlers->get_class_entry != NULL && (obj)->handlers->get_class_entry) ? (obj)->handlers->get_class_entry(obj TSRMLS_CC)->name->val : "")
 
-ZEND_API zval** zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, zend_uint var);
+ZEND_API zval* zend_get_compiled_variable_value(const zend_execute_data *execute_data_ptr, zend_uint var);
 
 #define ZEND_USER_OPCODE_CONTINUE   0 /* execute next opcode */
 #define ZEND_USER_OPCODE_RETURN     1 /* exit from executor (return from function) */
@@ -394,33 +334,49 @@ ZEND_API user_opcode_handler_t zend_get_user_opcode_handler(zend_uchar opcode);
 
 /* former zend_execute_locks.h */
 typedef struct _zend_free_op {
-	zval* var;
+	zval *var;
 /*	int   is_var; */
 } zend_free_op;
 
 ZEND_API zval *zend_get_zval_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC);
-ZEND_API zval **zend_get_zval_ptr_ptr(int op_type, const znode_op *node, const zend_execute_data *execute_data, zend_free_op *should_free, int type TSRMLS_DC);
 
 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) \
-	EG(active_op_array)->run_time_cache[(num)]
+	EX(run_time_cache)[(num)]
 
 #define CACHE_PTR(num, ptr) do { \
-		EG(active_op_array)->run_time_cache[(num)] = (ptr); \
+		EX(run_time_cache)[(num)] = (ptr); \
 	} while (0)
 
 #define CACHED_POLYMORPHIC_PTR(num, ce) \
-	((EG(active_op_array)->run_time_cache[(num)] == (ce)) ? \
-		EG(active_op_array)->run_time_cache[(num) + 1] : \
+	((EX(run_time_cache)[(num)] == (ce)) ? \
+		EX(run_time_cache)[(num) + 1] : \
 		NULL)
 
 #define CACHE_POLYMORPHIC_PTR(num, ce, ptr) do { \
-		EG(active_op_array)->run_time_cache[(num)] = (ce); \
-		EG(active_op_array)->run_time_cache[(num) + 1] = (ptr); \
+		EX(run_time_cache)[(num)] = (ce); \
+		EX(run_time_cache)[(num) + 1] = (ptr); \
+	} while (0)
+
+#define CACHED_PTR_EX(op_array, num) \
+	(op_array)->run_time_cache[(num)]
+
+#define CACHE_PTR_EX(op_array, num, ptr) do { \
+		(op_array)->run_time_cache[(num)] = (ptr); \
+	} while (0)
+
+#define CACHED_POLYMORPHIC_PTR_EX(op_array, num, ce) \
+	(((op_array)->run_time_cache[(num)] == (ce)) ? \
+		(op_array)->run_time_cache[(num) + 1] : \
+		NULL)
+
+#define CACHE_POLYMORPHIC_PTR_EX(op_array, num, ce, ptr) do { \
+		(op_array)->run_time_cache[(num)] = (ce); \
+		(op_array)->run_time_cache[(num) + 1] = (ptr); \
 	} while (0)
 
 END_EXTERN_C()
diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index 7cfd85d52a..03f763ea21 100644
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -26,7 +26,7 @@
 #include "zend_compile.h"
 #include "zend_execute.h"
 #include "zend_API.h"
-#include "zend_ptr_stack.h"
+#include "zend_stack.h"
 #include "zend_constants.h"
 #include "zend_extensions.h"
 #include "zend_exceptions.h"
@@ -39,10 +39,10 @@
 #endif
 
 ZEND_API void (*zend_execute_ex)(zend_execute_data *execute_data TSRMLS_DC);
-ZEND_API void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, zend_fcall_info *fci, int return_value_used TSRMLS_DC);
+ZEND_API void (*zend_execute_internal)(zend_execute_data *execute_data_ptr, zend_fcall_info *fci TSRMLS_DC);
 
 /* true globals */
-ZEND_API const zend_fcall_info empty_fcall_info = { 0, NULL, NULL, NULL, NULL, 0, NULL, NULL, 0 };
+ZEND_API const zend_fcall_info empty_fcall_info = { 0, NULL, {{0},0}, NULL, NULL, 0, NULL, NULL, 0 };
 ZEND_API const zend_fcall_info_cache empty_fcall_info_cache = { 0, NULL, NULL, NULL, NULL };
 
 #ifdef ZEND_WIN32
@@ -103,45 +103,46 @@ static void zend_extension_deactivator(zend_extension *extension TSRMLS_DC) /* {
 }
 /* }}} */
 
-static int clean_non_persistent_function(zend_function *function TSRMLS_DC) /* {{{ */
+static int clean_non_persistent_function(zval *zv TSRMLS_DC) /* {{{ */
 {
+	zend_function *function = Z_PTR_P(zv);
 	return (function->type == ZEND_INTERNAL_FUNCTION) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
 }
 /* }}} */
 
-static int clean_non_persistent_function_full(zend_function *function TSRMLS_DC) /* {{{ */
+static int clean_non_persistent_function_full(zval *zv TSRMLS_DC) /* {{{ */
 {
+	zend_function *function = Z_PTR_P(zv);
 	return (function->type == ZEND_INTERNAL_FUNCTION) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
 }
 /* }}} */
 
-static int clean_non_persistent_class(zend_class_entry **ce TSRMLS_DC) /* {{{ */
+static int clean_non_persistent_class(zval *zv TSRMLS_DC) /* {{{ */
 {
-	return ((*ce)->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
+	zend_class_entry *ce = Z_PTR_P(zv);
+	return (ce->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_STOP : ZEND_HASH_APPLY_REMOVE;
 }
 /* }}} */
 
-static int clean_non_persistent_class_full(zend_class_entry **ce TSRMLS_DC) /* {{{ */
+static int clean_non_persistent_class_full(zval *zv TSRMLS_DC) /* {{{ */
 {
-	return ((*ce)->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
+	zend_class_entry *ce = Z_PTR_P(zv);
+	return (ce->type == ZEND_INTERNAL_CLASS) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_REMOVE;
 }
 /* }}} */
 
 void init_executor(TSRMLS_D) /* {{{ */
 {
+	zval tmp;
 	zend_init_fpu(TSRMLS_C);
 
-	INIT_ZVAL(EG(uninitialized_zval));
+	ZVAL_NULL(&EG(uninitialized_zval));
 	/* trick to make uninitialized_zval never be modified, passed by ref, etc. */
-	Z_ADDREF(EG(uninitialized_zval));
-	INIT_ZVAL(EG(error_zval));
-	EG(uninitialized_zval_ptr)=&EG(uninitialized_zval);
-	EG(error_zval_ptr)=&EG(error_zval);
+	ZVAL_NULL(&EG(error_zval));
 /* destroys stack frame, therefore makes core dumps worthless */
 #if 0&&ZEND_DEBUG
 	original_sigsegv_handler = signal(SIGSEGV, zend_handle_sigsegv);
 #endif
-	EG(return_value_ptr_ptr) = NULL;
 
 	EG(symtable_cache_ptr) = EG(symtable_cache) - 1;
 	EG(symtable_cache_limit) = EG(symtable_cache) + SYMTABLE_CACHE_SIZE - 1;
@@ -156,25 +157,26 @@ void init_executor(TSRMLS_D) /* {{{ */
 	EG(error_handling) = EH_NORMAL;
 
 	zend_vm_stack_init(TSRMLS_C);
-	zend_vm_stack_push((void *) NULL TSRMLS_CC);
+	ZVAL_LONG(&tmp, 0);
+	zend_vm_stack_push(&tmp TSRMLS_CC);
 
-	zend_hash_init(&EG(symbol_table), 50, NULL, ZVAL_PTR_DTOR, 0);
+	zend_hash_init(&EG(symbol_table).ht, 64, NULL, ZVAL_PTR_DTOR, 0);
 	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;
 
-	zend_hash_init(&EG(included_files), 5, NULL, NULL, 0);
+	zend_hash_init(&EG(included_files), 8, NULL, NULL, 0);
 
 	EG(ticks_count) = 0;
 
-	EG(user_error_handler) = NULL;
+	ZVAL_UNDEF(&EG(user_error_handler));
 
 	EG(current_execute_data) = NULL;
 
 	zend_stack_init(&EG(user_error_handlers_error_reporting));
-	zend_ptr_stack_init(&EG(user_error_handlers));
-	zend_ptr_stack_init(&EG(user_exception_handlers));
+	zend_stack_init(&EG(user_error_handlers));
+	zend_stack_init(&EG(user_exception_handlers));
 
 	zend_objects_store_init(&EG(objects_store), 1024);
 
@@ -189,7 +191,7 @@ void init_executor(TSRMLS_D) /* {{{ */
 	EG(scope) = NULL;
 	EG(called_scope) = NULL;
 
-	EG(This) = NULL;
+	ZVAL_OBJ(&EG(This), NULL);
 
 	EG(active_op_array) = NULL;
 
@@ -198,9 +200,12 @@ void init_executor(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-static int zval_call_destructor(zval **zv TSRMLS_DC) /* {{{ */
+static int zval_call_destructor(zval *zv TSRMLS_DC) /* {{{ */
 {
-	if (Z_TYPE_PP(zv) == IS_OBJECT && Z_REFCOUNT_PP(zv) == 1) {
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+	}
+	if (Z_TYPE_P(zv) == IS_OBJECT && Z_REFCOUNT_P(zv) == 1) {
 		return ZEND_HASH_APPLY_REMOVE;
 	} else {
 		return ZEND_HASH_APPLY_KEEP;
@@ -208,14 +213,28 @@ static int zval_call_destructor(zval **zv TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
+static void zend_unclean_zval_ptr_dtor(zval *zv) /* {{{ */
+{
+	TSRMLS_FETCH();
+
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+	}
+	i_zval_ptr_dtor(zv ZEND_FILE_LINE_CC TSRMLS_CC);
+}
+/* }}} */
+
 void shutdown_destructors(TSRMLS_D) /* {{{ */
 {
+	if (CG(unclean_shutdown)) {
+		EG(symbol_table).ht.pDestructor = zend_unclean_zval_ptr_dtor;
+	}
 	zend_try {
 		int symbols;
 		do {
-			symbols = zend_hash_num_elements(&EG(symbol_table));
-			zend_hash_reverse_apply(&EG(symbol_table), (apply_func_t) zval_call_destructor TSRMLS_CC);
-		} while (symbols != zend_hash_num_elements(&EG(symbol_table)));
+			symbols = zend_hash_num_elements(&EG(symbol_table).ht);
+			zend_hash_reverse_apply(&EG(symbol_table).ht, (apply_func_t) zval_call_destructor TSRMLS_CC);
+		} while (symbols != zend_hash_num_elements(&EG(symbol_table).ht));
 		zend_objects_store_call_destructors(&EG(objects_store) TSRMLS_CC);
 	} zend_catch {
 		/* if we couldn't destruct cleanly, mark all objects as destructed anyway */
@@ -226,6 +245,9 @@ void shutdown_destructors(TSRMLS_D) /* {{{ */
 
 void shutdown_executor(TSRMLS_D) /* {{{ */
 {
+	zend_function *func;
+	zend_class_entry *ce;
+
 	zend_try {
 
 /* Removed because this can not be safely done, e.g. in this situation:
@@ -244,29 +266,33 @@ void shutdown_executor(TSRMLS_D) /* {{{ */
 		}
 */
 		zend_llist_apply(&zend_extensions, (llist_apply_func_t) zend_extension_deactivator TSRMLS_CC);
-		zend_hash_graceful_reverse_destroy(&EG(symbol_table));
+
+		if (CG(unclean_shutdown)) {
+			EG(symbol_table).ht.pDestructor = zend_unclean_zval_ptr_dtor;
+		}
+		zend_hash_graceful_reverse_destroy(&EG(symbol_table).ht);
 	} zend_end_try();
 
 	zend_try {
 		zval *zeh;
 		/* remove error handlers before destroying classes and functions,
 		 * so that if handler used some class, crash would not happen */
-		if (EG(user_error_handler)) {
-			zeh = EG(user_error_handler);
-			EG(user_error_handler) = NULL;
-			zval_ptr_dtor(&zeh);
+		if (Z_TYPE(EG(user_error_handler)) != IS_UNDEF) {
+			zeh = &EG(user_error_handler);
+			zval_ptr_dtor(zeh);
+			ZVAL_UNDEF(&EG(user_error_handler));
 		}
 
-		if (EG(user_exception_handler)) {
-			zeh = EG(user_exception_handler);
-			EG(user_exception_handler) = NULL;
-			zval_ptr_dtor(&zeh);
+		if (Z_TYPE(EG(user_exception_handler)) != IS_UNDEF) {
+			zeh = &EG(user_exception_handler);
+			zval_ptr_dtor(zeh);
+			ZVAL_UNDEF(&EG(user_exception_handler));
 		}
 
 		zend_stack_destroy(&EG(user_error_handlers_error_reporting));
 		zend_stack_init(&EG(user_error_handlers_error_reporting));
-		zend_ptr_stack_clean(&EG(user_error_handlers), ZVAL_DESTRUCTOR, 1);
-		zend_ptr_stack_clean(&EG(user_exception_handlers), ZVAL_DESTRUCTOR, 1);
+		zend_stack_clean(&EG(user_error_handlers), (void (*)(void *))ZVAL_DESTRUCTOR, 1);
+		zend_stack_clean(&EG(user_exception_handlers), (void (*)(void *))ZVAL_DESTRUCTOR, 1);
 	} zend_end_try();
 
 	zend_try {
@@ -280,31 +306,59 @@ void shutdown_executor(TSRMLS_D) /* {{{ */
 		 * Note that only run-time accessed data need to be cleaned up, pre-defined data can
 		 * not contain objects and thus are not probelmatic */
 		if (EG(full_tables_cleanup)) {
-			zend_hash_apply(EG(function_table), (apply_func_t) zend_cleanup_function_data_full TSRMLS_CC);
-			zend_hash_apply(EG(class_table), (apply_func_t) zend_cleanup_class_data TSRMLS_CC);
+			ZEND_HASH_FOREACH_PTR(EG(function_table), func) {
+				if (func->type == ZEND_USER_FUNCTION) {
+					zend_cleanup_op_array_data((zend_op_array *) func);
+				}
+			} ZEND_HASH_FOREACH_END();
+			ZEND_HASH_REVERSE_FOREACH_PTR(EG(class_table), ce) {
+				if (ce->type == ZEND_USER_CLASS) {
+					zend_cleanup_user_class_data(ce TSRMLS_CC);
+				} else {
+					zend_cleanup_internal_class_data(ce TSRMLS_CC);
+				}
+			} ZEND_HASH_FOREACH_END();
 		} else {
-			zend_hash_reverse_apply(EG(function_table), (apply_func_t) zend_cleanup_function_data TSRMLS_CC);
-			zend_hash_reverse_apply(EG(class_table), (apply_func_t) zend_cleanup_user_class_data TSRMLS_CC);
+			ZEND_HASH_REVERSE_FOREACH_PTR(EG(function_table), func) {
+				if (func->type != ZEND_USER_FUNCTION) {
+					break;
+				}
+				zend_cleanup_op_array_data((zend_op_array *) func);
+			} ZEND_HASH_FOREACH_END();
+			ZEND_HASH_REVERSE_FOREACH_PTR(EG(class_table), ce) {
+				if (ce->type != ZEND_USER_CLASS) {
+					break;
+				}
+				zend_cleanup_user_class_data(ce TSRMLS_CC);
+			} ZEND_HASH_FOREACH_END();
 			zend_cleanup_internal_classes(TSRMLS_C);
 		}
 	} zend_end_try();
 
 	zend_try {
+		zend_llist_destroy(&CG(open_files));
+	} zend_end_try();
+
+	zend_try {
+		zend_close_rsrc_list(&EG(regular_list) TSRMLS_CC);
+	} zend_end_try();
+
+	zend_try {
 		zend_objects_store_free_object_storage(&EG(objects_store) TSRMLS_CC);
 
 		zend_vm_stack_destroy(TSRMLS_C);
 
 		/* Destroy all op arrays */
 		if (EG(full_tables_cleanup)) {
-			zend_hash_reverse_apply(EG(function_table), (apply_func_t) clean_non_persistent_function_full TSRMLS_CC);
-			zend_hash_reverse_apply(EG(class_table), (apply_func_t) clean_non_persistent_class_full TSRMLS_CC);
+			zend_hash_reverse_apply(EG(function_table), clean_non_persistent_function_full TSRMLS_CC);
+			zend_hash_reverse_apply(EG(class_table), clean_non_persistent_class_full TSRMLS_CC);
 		} else {
-			zend_hash_reverse_apply(EG(function_table), (apply_func_t) clean_non_persistent_function TSRMLS_CC);
-			zend_hash_reverse_apply(EG(class_table), (apply_func_t) clean_non_persistent_class TSRMLS_CC);
+			zend_hash_reverse_apply(EG(function_table), clean_non_persistent_function TSRMLS_CC);
+			zend_hash_reverse_apply(EG(class_table), clean_non_persistent_class TSRMLS_CC);
 		}
 
 		while (EG(symtable_cache_ptr)>=EG(symtable_cache)) {
-			zend_hash_destroy(*EG(symtable_cache_ptr));
+			zend_hash_destroy(&(*EG(symtable_cache_ptr))->ht);
 			FREE_HASHTABLE(*EG(symtable_cache_ptr));
 			EG(symtable_cache_ptr)--;
 		}
@@ -322,8 +376,8 @@ void shutdown_executor(TSRMLS_D) /* {{{ */
 		zend_hash_destroy(&EG(included_files));
 
 		zend_stack_destroy(&EG(user_error_handlers_error_reporting));
-		zend_ptr_stack_destroy(&EG(user_error_handlers));
-		zend_ptr_stack_destroy(&EG(user_exception_handlers));
+		zend_stack_destroy(&EG(user_error_handlers));
+		zend_stack_destroy(&EG(user_exception_handlers));
 		zend_objects_store_destroy(&EG(objects_store));
 		if (EG(in_autoload)) {
 			zend_hash_destroy(EG(in_autoload));
@@ -355,7 +409,7 @@ ZEND_API const char *get_active_class_name(const char **space TSRMLS_DC) /* {{{
 			if (space) {
 				*space = ce ? "::" : "";
 			}
-			return ce ? ce->name : "";
+			return ce ? ce->name->val : "";
 		}
 		default:
 			if (space) {
@@ -373,17 +427,17 @@ ZEND_API const char *get_active_function_name(TSRMLS_D) /* {{{ */
 	}
 	switch (EG(current_execute_data)->function_state.function->type) {
 		case ZEND_USER_FUNCTION: {
-				const char *function_name = ((zend_op_array *) EG(current_execute_data)->function_state.function)->function_name;
+				zend_string *function_name = ((zend_op_array *) EG(current_execute_data)->function_state.function)->function_name;
 
 				if (function_name) {
-					return function_name;
+					return function_name->val;
 				} else {
 					return "main";
 				}
 			}
 			break;
 		case ZEND_INTERNAL_FUNCTION:
-			return ((zend_internal_function *) EG(current_execute_data)->function_state.function)->function_name;
+			return ((zend_internal_function *) EG(current_execute_data)->function_state.function)->function_name->val;
 			break;
 		default:
 			return NULL;
@@ -394,7 +448,7 @@ ZEND_API const char *get_active_function_name(TSRMLS_D) /* {{{ */
 ZEND_API const char *zend_get_executed_filename(TSRMLS_D) /* {{{ */
 {
 	if (EG(active_op_array)) {
-		return EG(active_op_array)->filename;
+		return EG(active_op_array)->filename->val;
 	} else {
 		return "[no active file]";
 	}
@@ -421,24 +475,20 @@ ZEND_API zend_bool zend_is_executing(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void _zval_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
 {
 	TSRMLS_FETCH();
-	i_zval_ptr_dtor(*zval_ptr ZEND_FILE_LINE_RELAY_CC TSRMLS_CC);
+	i_zval_ptr_dtor(zval_ptr ZEND_FILE_LINE_RELAY_CC TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API void _zval_internal_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API void _zval_internal_ptr_dtor(zval *zval_ptr ZEND_FILE_LINE_DC) /* {{{ */
 {
-#if DEBUG_ZEND>=2
-	printf("Reducing refcount for %x (%x): %d->%d\n", *zval_ptr, zval_ptr, Z_REFCOUNT_PP(zval_ptr), Z_REFCOUNT_PP(zval_ptr) - 1);
-#endif
-	Z_DELREF_PP(zval_ptr);
-	if (Z_REFCOUNT_PP(zval_ptr) == 0) {
-		zval_internal_dtor(*zval_ptr);
-		free(*zval_ptr);
-	} else if (Z_REFCOUNT_PP(zval_ptr) == 1) {
-		Z_UNSET_ISREF_PP(zval_ptr);
+	if (Z_REFCOUNTED_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);
+		}
 	}
 }
 /* }}} */
@@ -454,51 +504,49 @@ ZEND_API int zend_is_true(zval *op TSRMLS_DC) /* {{{ */
 #define IS_VISITED_CONSTANT			0x80
 #define IS_CONSTANT_VISITED(p)		(Z_TYPE_P(p) & IS_VISITED_CONSTANT)
 #define Z_REAL_TYPE_P(p)			(Z_TYPE_P(p) & ~IS_VISITED_CONSTANT)
-#define MARK_CONSTANT_VISITED(p)	Z_TYPE_P(p) |= IS_VISITED_CONSTANT
+#define MARK_CONSTANT_VISITED(p)	Z_TYPE_INFO_P(p) |= IS_VISITED_CONSTANT
 
-ZEND_API int zval_update_constant_ex(zval **pp, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_class_entry *scope TSRMLS_DC) /* {{{ */
 {
-	zval *p = *pp;
-	zval const_value;
+	zval *const_value, tmp;
 	char *colon;
 
 	if (IS_CONSTANT_VISITED(p)) {
 		zend_error(E_ERROR, "Cannot declare self-referencing constant '%s'", Z_STRVAL_P(p));
-	} else if ((Z_TYPE_P(p) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+	} else if (Z_TYPE_P(p) == IS_CONSTANT) {
 		int refcount;
-		zend_uchar is_ref;
-
-		SEPARATE_ZVAL_IF_NOT_REF(pp);
-		p = *pp;
 
+		SEPARATE_ZVAL_IF_NOT_REF(p);
 		MARK_CONSTANT_VISITED(p);
-
-		refcount = Z_REFCOUNT_P(p);
-		is_ref = Z_ISREF_P(p);
-
-		if (!zend_get_constant_ex(p->value.str.val, p->value.str.len, &const_value, scope, Z_REAL_TYPE_P(p) TSRMLS_CC)) {
+		refcount =  Z_REFCOUNTED_P(p) ? Z_REFCOUNT_P(p) : 1;
+		const_value = zend_get_constant_ex(Z_STR_P(p), scope, Z_CONST_FLAGS_P(p) TSRMLS_CC);
+		if (!const_value) {
 			char *actual = Z_STRVAL_P(p);
 
 			if ((colon = (char*)zend_memrchr(Z_STRVAL_P(p), ':', Z_STRLEN_P(p)))) {
+				int len;
+
 				zend_error(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(p));
-				Z_STRLEN_P(p) -= ((colon - Z_STRVAL_P(p)) + 1);
+				len = Z_STRLEN_P(p) - ((colon - Z_STRVAL_P(p)) + 1);
 				if (inline_change) {
-					colon = estrndup(colon, Z_STRLEN_P(p));
-					str_efree(Z_STRVAL_P(p));
-					Z_STRVAL_P(p) = colon;
+					zend_string *tmp = STR_INIT(colon + 1, len, 0);
+					STR_RELEASE(Z_STR_P(p));
+					Z_STR_P(p) = tmp;
 				} else {
-					Z_STRVAL_P(p) = colon + 1;
+					Z_STR_P(p) = STR_INIT(colon + 1, len, 0);
 				}
+				Z_TYPE_FLAGS_P(p) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
 			} else {
-				char *save = actual, *slash;
+				zend_string *save = Z_STR_P(p);
+				char *slash;
 				int actual_len = Z_STRLEN_P(p);
-				if ((Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) && (slash = (char *)zend_memrchr(actual, '\\', actual_len))) {
+				if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) && (slash = (char *)zend_memrchr(actual, '\\', actual_len))) {
 					actual = slash + 1;
 					actual_len -= (actual - Z_STRVAL_P(p));
 					if (inline_change) {
-						actual = estrndup(actual, actual_len);
-						Z_STRVAL_P(p) = actual;
-						Z_STRLEN_P(p) = actual_len;
+						zend_string *s = STR_INIT(actual, actual_len, 0);
+						Z_STR_P(p) = s;
+						Z_TYPE_FLAGS_P(p) = IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE;
 					}
 				}
 				if (actual[0] == '\\') {
@@ -510,94 +558,202 @@ ZEND_API int zval_update_constant_ex(zval **pp, zend_bool inline_change, zend_cl
 					}
 					--actual_len;
 				}
-				if ((Z_TYPE_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) {
-					int fix_save = 0;
-					if (save[0] == '\\') {
-						save++;
-						fix_save = 1;
-					}
-					zend_error(E_ERROR, "Undefined constant '%s'", save);
-					if (fix_save) {
-						save--;
+				if ((Z_CONST_FLAGS_P(p) & IS_CONSTANT_UNQUALIFIED) == 0) {
+					if (save->val[0] == '\\') {
+						zend_error(E_ERROR, "Undefined constant '%s'", save->val + 1);
+					} else {
+						zend_error(E_ERROR, "Undefined constant '%s'", save->val);
 					}
 					if (inline_change) {
-						str_efree(save);
+						STR_RELEASE(save);
 					}
 					save = NULL;
 				}
-				if (inline_change && save && save != actual) {
-					str_efree(save);
-				}
 				zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",  actual,  actual);
-				p->type = IS_STRING;
 				if (!inline_change) {
-					Z_STRVAL_P(p) = actual;
-					Z_STRLEN_P(p) = actual_len;
-					zval_copy_ctor(p);
+					ZVAL_STRINGL(p, actual, actual_len);
+				} else {
+					Z_TYPE_INFO_P(p) = IS_INTERNED(Z_STR_P(p)) ?
+						IS_INTERNED_STRING_EX : IS_STRING_EX;
+					if (save && save->val != actual) {
+						STR_RELEASE(save);
+					}
 				}
 			}
 		} else {
 			if (inline_change) {
-				str_efree(Z_STRVAL_P(p));
+				STR_RELEASE(Z_STR_P(p));
 			}
-			*p = const_value;
+//???!
+			ZVAL_COPY_VALUE(p, const_value);
+			if (Z_OPT_CONSTANT_P(p)) {
+				zval_update_constant_ex(p, 1, NULL TSRMLS_CC);
+			}
+			zval_opt_copy_ctor(p);
+		}
+
+		if (Z_REFCOUNTED_P(p)) Z_SET_REFCOUNT_P(p, refcount);
+	} else if (Z_TYPE_P(p) == IS_CONSTANT_ARRAY) {
+		zval *element, new_val;
+		zend_string *str_index;
+		ulong num_index;
+		int ret;
+
+		SEPARATE_ZVAL_IF_NOT_REF(p);
+
+		Z_TYPE_INFO_P(p) = IS_ARRAY_EX;
+		if (!inline_change) {
+			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, ZVAL_COPY_CTOR);
 		}
 
-		Z_SET_REFCOUNT_P(p, refcount);
-		Z_SET_ISREF_TO_P(p, is_ref);
+		/* First go over the array and see if there are any constant indices */
+		zend_hash_internal_pointer_reset(Z_ARRVAL_P(p));
+		while ((element = zend_hash_get_current_data(Z_ARRVAL_P(p))) != NULL) {
+			if (zend_hash_get_current_key(Z_ARRVAL_P(p), &str_index, &num_index, 0) != HASH_KEY_IS_STRING) {
+				zend_hash_move_forward(Z_ARRVAL_P(p));
+				continue;
+			}
+			if (!(GC_FLAGS(str_index) & (IS_STR_CONSTANT | IS_STR_AST))) {
+				zend_hash_move_forward(Z_ARRVAL_P(p));
+				continue;
+			}
+
+			if (GC_FLAGS(str_index) & IS_STR_AST) {
+				zend_ast_ref *ast = *(zend_ast_ref **)str_index->val;
+
+				zend_ast_evaluate(&tmp, ast->ast, scope TSRMLS_CC);
+				zend_ast_destroy(ast->ast);
+				efree(ast);
+				const_value = &tmp;
+			} else if (!(const_value = zend_get_constant_ex(str_index, scope, GC_FLAGS(str_index) & ~(IS_STR_PERSISTENT | IS_STR_INTERNED |IS_STR_PERMANENT) TSRMLS_CC))) {
+				char *actual, *str;
+				const char *save = str_index->val;
+				int len;
+
+				str = str_index->val;
+				len = str_index->len;
+				if ((colon = (char*)zend_memrchr(str, ':', len))) {
+					zend_error(E_ERROR, "Undefined class constant '%s'", str);
+					len -= ((colon - str) + 1);
+					str = colon;
+				} else {
+					if (GC_FLAGS(str_index) & IS_STR_CONSTANT_UNQUALIFIED) {
+						if ((actual = (char *)zend_memrchr(str, '\\', len))) {
+							actual++;
+							len -= (actual - str);
+							str = actual;
+						}
+					}
+					if (str[0] == '\\') {
+						++str;
+						--len;
+					}
+					if (save[0] == '\\') {
+						++save;
+					}
+					if (!(GC_FLAGS(str_index) & IS_STR_CONSTANT_UNQUALIFIED)) {
+						zend_error(E_ERROR, "Undefined constant '%s'", save);
+					}
+					zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'",	str, str);
+				}
+				if (str == str_index->val && len == str_index->len) {
+					ZVAL_STR(&tmp, STR_COPY(str_index));
+				} else {
+					ZVAL_STRINGL(&tmp, str, len);
+				}
+				const_value = &tmp;
+			} else {
+//???!
+				ZVAL_COPY_VALUE(&tmp, const_value);
+				if (Z_OPT_CONSTANT(tmp)) {
+					zval_update_constant_ex(&tmp, 1, NULL TSRMLS_CC);
+				}
+				zval_opt_copy_ctor(&tmp);
+				const_value = &tmp;
+			}
+
+			if (Z_REFCOUNTED_P(element) && Z_REFCOUNT_P(element) > 1) {
+				ZVAL_DUP(&new_val, element);
+				zval_ptr_dtor(element);
+				ZVAL_COPY_VALUE(element, &new_val);
+			}
+
+			switch (Z_TYPE_P(const_value)) {
+				case IS_STRING:
+					ret = zend_symtable_update_current_key_ex(Z_ARRVAL_P(p), Z_STR_P(const_value), HASH_UPDATE_KEY_IF_BEFORE);
+					break;
+				case IS_BOOL:
+				case IS_LONG:
+					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, Z_LVAL_P(const_value), HASH_UPDATE_KEY_IF_BEFORE);
+					break;
+				case IS_DOUBLE:
+					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, zend_dval_to_lval(Z_DVAL_P(const_value)), HASH_UPDATE_KEY_IF_BEFORE);
+					break;
+				case IS_NULL:
+					ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_STRING, STR_EMPTY_ALLOC(), 0, HASH_UPDATE_KEY_IF_BEFORE);
+					break;
+				default:
+					ret = SUCCESS;
+					break;
+			}
+			if (ret == SUCCESS) {
+				zend_hash_move_forward(Z_ARRVAL_P(p));
+			}
+			zval_dtor(const_value);
+		}
+		zend_hash_apply_with_argument(Z_ARRVAL_P(p), (apply_func_arg_t) zval_update_constant_inline_change, (void *) scope TSRMLS_CC);
+		zend_hash_internal_pointer_reset(Z_ARRVAL_P(p));
 	} else if (Z_TYPE_P(p) == IS_CONSTANT_AST) {
-		SEPARATE_ZVAL_IF_NOT_REF(pp);
-		p = *pp;
+		SEPARATE_ZVAL_IF_NOT_REF(p);
 
-		zend_ast_evaluate(&const_value, Z_AST_P(p), scope TSRMLS_CC);
+		zend_ast_evaluate(&tmp, Z_ASTVAL_P(p), scope TSRMLS_CC);
 		if (inline_change) {
-			zend_ast_destroy(Z_AST_P(p));
+			zend_ast_destroy(Z_ASTVAL_P(p));
+			efree(Z_AST_P(p));
 		}
-		ZVAL_COPY_VALUE(p, &const_value);
+		ZVAL_COPY_VALUE(p, &tmp);
 	}
 	return 0;
 }
 /* }}} */
 
-ZEND_API int zval_update_constant_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant_inline_change(zval *pp, zend_class_entry *scope TSRMLS_DC) /* {{{ */
 {
 	return zval_update_constant_ex(pp, 1, scope TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zval_update_constant_no_inline_change(zval **pp, zend_class_entry *scope TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant_no_inline_change(zval *pp, zend_class_entry *scope TSRMLS_DC) /* {{{ */
 {
 	return zval_update_constant_ex(pp, 0, scope TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zval_update_constant(zval **pp, zend_bool inline_change TSRMLS_DC) /* {{{ */
+ZEND_API int zval_update_constant(zval *pp, zend_bool inline_change TSRMLS_DC) /* {{{ */
 {
 	return zval_update_constant_ex(pp, inline_change, NULL TSRMLS_CC);
 }
 /* }}} */
 
-int call_user_function(HashTable *function_table, zval **object_pp, zval *function_name, zval *retval_ptr, zend_uint param_count, zval *params[] TSRMLS_DC) /* {{{ */
+int call_user_function(HashTable *function_table, zval *object, zval *function_name, zval *retval_ptr, zend_uint param_count, zval params[] TSRMLS_DC) /* {{{ */
 {
-	zval ***params_array;
+	zval *params_array;
 	zend_uint i;
 	int ex_retval;
-	zval *local_retval_ptr = NULL;
 
 	if (param_count) {
-		params_array = (zval ***) emalloc(sizeof(zval **)*param_count);
+		params_array = (zval *) emalloc(sizeof(zval) * param_count);
 		for (i=0; i<param_count; i++) {
-			params_array[i] = &params[i];
+			ZVAL_COPY_VALUE(&params_array[i], &params[i]);
 		}
 	} else {
 		params_array = NULL;
 	}
-	ex_retval = call_user_function_ex(function_table, object_pp, function_name, &local_retval_ptr, param_count, params_array, 1, NULL TSRMLS_CC);
-	if (local_retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*retval_ptr, local_retval_ptr);
-	} else {
-		INIT_ZVAL(*retval_ptr);
-	}
+	ZVAL_UNDEF(retval_ptr);
+	ex_retval = call_user_function_ex(function_table, object, function_name, retval_ptr, param_count, params_array, 1, NULL TSRMLS_CC);
 	if (params_array) {
 		efree(params_array);
 	}
@@ -605,15 +761,15 @@ int call_user_function(HashTable *function_table, zval **object_pp, zval *functi
 }
 /* }}} */
 
-int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *function_name, zval **retval_ptr_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;
 
 	fci.size = sizeof(fci);
 	fci.function_table = function_table;
-	fci.object_ptr = object_pp ? *object_pp : NULL;
-	fci.function_name = function_name;
-	fci.retval_ptr_ptr = retval_ptr_ptr;
+	fci.object = object ? Z_OBJ_P(object) : NULL;
+	ZVAL_COPY_VALUE(&fci.function_name, function_name);
+	fci.retval = retval_ptr;
 	fci.param_count = param_count;
 	fci.params = params;
 	fci.no_separation = (zend_bool) no_separation;
@@ -626,19 +782,16 @@ int call_user_function_ex(HashTable *function_table, zval **object_pp, zval *fun
 int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TSRMLS_DC) /* {{{ */
 {
 	zend_uint i;
-	zval **original_return_value;
-	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;
-	zend_class_entry *current_called_scope;
 	zend_class_entry *calling_scope = NULL;
 	zend_class_entry *called_scope = NULL;
-	zval *current_this;
 	zend_execute_data execute_data;
 	zend_fcall_info_cache fci_cache_local;
+	zval tmp;
 
-	*fci->retval_ptr_ptr = NULL;
+	ZVAL_UNDEF(fci->retval);
 
 	if (!EG(active)) {
 		return FAILURE; /* executor is already inactive */
@@ -659,9 +812,11 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 	/* Initialize execute_data */
 	if (EG(current_execute_data)) {
 		execute_data = *EG(current_execute_data);
+		EX(object) = Z_OBJ(EG(This));
+		EX(scope) = EG(scope);
+		EX(called_scope) = EG(called_scope);
 		EX(op_array) = NULL;
 		EX(opline) = NULL;
-		EX(object) = NULL;
 	} else {
 		/* This only happens when we're called outside any execute()'s
 		 * It shouldn't be strictly necessary to NULL execute_data out,
@@ -671,20 +826,20 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 	}
 
 	if (!fci_cache || !fci_cache->initialized) {
-		char *callable_name;
+		zend_string *callable_name;
 		char *error = NULL;
 
 		if (!fci_cache) {
 			fci_cache = &fci_cache_local;
 		}
 
-		if (!zend_is_callable_ex(fci->function_name, fci->object_ptr, IS_CALLABLE_CHECK_SILENT, &callable_name, NULL, fci_cache, &error TSRMLS_CC)) {
+		if (!zend_is_callable_ex(&fci->function_name, fci->object, IS_CALLABLE_CHECK_SILENT, &callable_name, fci_cache, &error TSRMLS_CC)) {
 			if (error) {
-				zend_error(E_WARNING, "Invalid callback %s, %s", callable_name, error);
+				zend_error(E_WARNING, "Invalid callback %s, %s", callable_name->val, error);
 				efree(error);
 			}
 			if (callable_name) {
-				efree(callable_name);
+				STR_RELEASE(callable_name);
 			}
 			return FAILURE;
 		} else if (error) {
@@ -695,28 +850,28 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 			zend_error(E_STRICT, "%s", error);
 			efree(error);
 		}
-		efree(callable_name);
+		STR_RELEASE(callable_name);
 	}
 
 	EX(function_state).function = fci_cache->function_handler;
 	calling_scope = fci_cache->calling_scope;
 	called_scope = fci_cache->called_scope;
-	fci->object_ptr = fci_cache->object_ptr;
-	EX(object) = fci->object_ptr;
-	if (fci->object_ptr && Z_TYPE_P(fci->object_ptr) == IS_OBJECT &&
-	    (!EG(objects_store).object_buckets || !EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(fci->object_ptr)].valid)) {
+	fci->object = fci_cache->object;
+	if (fci->object &&
+	    (!EG(objects_store).object_buckets ||
+	     !IS_OBJ_VALID(EG(objects_store).object_buckets[fci->object->handle]))) {
 		return FAILURE;
 	}
 
 	if (EX(function_state).function->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) {
 		if (EX(function_state).function->common.fn_flags & ZEND_ACC_ABSTRACT) {
-			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name, EX(function_state).function->common.function_name);
+			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EX(function_state).function->common.scope->name->val, EX(function_state).function->common.function_name->val);
 		}
 		if (EX(function_state).function->common.fn_flags & ZEND_ACC_DEPRECATED) {
  			zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
-				EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
+				EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name->val : "",
 				EX(function_state).function->common.scope ? "::" : "",
-				EX(function_state).function->common.function_name);
+				EX(function_state).function->common.function_name->val);
 		}
 	}
 
@@ -726,88 +881,63 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 		zval *param;
 
 		if (ARG_SHOULD_BE_SENT_BY_REF(EX(function_state).function, i + 1)) {
-			if (!PZVAL_IS_REF(*fci->params[i]) && Z_REFCOUNT_PP(fci->params[i]) > 1) {
-				zval *new_zval;
+			if (!Z_REFCOUNTED(fci->params[i]) ||
+			    (!Z_ISREF(fci->params[i]) && Z_REFCOUNT(fci->params[i]) > 1)) {
 
 				if (fci->no_separation &&
-				    !ARG_MAY_BE_SENT_BY_REF(EX(function_state).function, i + 1)) {
+					!ARG_MAY_BE_SENT_BY_REF(EX(function_state).function, i + 1)) {
 					if (i || UNEXPECTED(ZEND_VM_STACK_ELEMETS(EG(argument_stack)) == (EG(argument_stack)->top))) {
 						/* hack to clean up the stack */
-						zend_vm_stack_push((void *) (zend_uintptr_t)i TSRMLS_CC);
+						ZVAL_LONG(&tmp, i);
+						zend_vm_stack_push(&tmp TSRMLS_CC);
 						zend_vm_stack_clear_multiple(0 TSRMLS_CC);
 					}
 
 					zend_error(E_WARNING, "Parameter %d to %s%s%s() expected to be a reference, value given",
 						i+1,
-						EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name : "",
+						EX(function_state).function->common.scope ? EX(function_state).function->common.scope->name->val : "",
 						EX(function_state).function->common.scope ? "::" : "",
-						EX(function_state).function->common.function_name);
+						EX(function_state).function->common.function_name->val);
 					return FAILURE;
 				}
 
-				ALLOC_ZVAL(new_zval);
-				*new_zval = **fci->params[i];
-				zval_copy_ctor(new_zval);
-				Z_SET_REFCOUNT_P(new_zval, 1);
-				Z_DELREF_PP(fci->params[i]);
-				*fci->params[i] = new_zval;
+				if (Z_REFCOUNTED(fci->params[i])) {
+					Z_DELREF(fci->params[i]);
+				}
+				ZVAL_DUP(&tmp, &fci->params[i]);
+				ZVAL_NEW_REF(&fci->params[i], &tmp);
+				Z_ADDREF(fci->params[i]);
+			} else if (!Z_ISREF(fci->params[i])) {
+				ZVAL_NEW_REF(&fci->params[i], &fci->params[i]);
+				Z_ADDREF(fci->params[i]);
+			} else if (Z_REFCOUNTED(fci->params[i])) {
+				Z_ADDREF(fci->params[i]);
 			}
-			Z_ADDREF_PP(fci->params[i]);
-			Z_SET_ISREF_PP(fci->params[i]);
-			param = *fci->params[i];
-		} else if (PZVAL_IS_REF(*fci->params[i]) &&
+			param = &fci->params[i];
+		} else if (Z_ISREF(fci->params[i]) &&
 		           /* don't separate references for __call */
 		           (EX(function_state).function->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) == 0 ) {
-			ALLOC_ZVAL(param);
-			*param = **(fci->params[i]);
-			INIT_PZVAL(param);
-			zval_copy_ctor(param);
-		} else if (*fci->params[i] != &EG(uninitialized_zval)) {
-			Z_ADDREF_PP(fci->params[i]);
-			param = *fci->params[i];
+			param = &tmp;
+			ZVAL_DUP(param, Z_REFVAL(fci->params[i]));
 		} else {
-			ALLOC_ZVAL(param);
-			*param = **(fci->params[i]);
-			INIT_PZVAL(param);
+			param = &tmp;
+			ZVAL_COPY(param, &fci->params[i]);
 		}
 		zend_vm_stack_push(param TSRMLS_CC);
 	}
 
 	EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
-	zend_vm_stack_push((void*)(zend_uintptr_t)fci->param_count TSRMLS_CC);
+	ZVAL_LONG(&tmp, fci->param_count);
+	zend_vm_stack_push(&tmp TSRMLS_CC);
 
-	current_scope = EG(scope);
 	EG(scope) = calling_scope;
-
-	current_this = EG(This);
-
-	current_called_scope = EG(called_scope);
-	if (called_scope) {
-		EG(called_scope) = called_scope;
-	} else if (EX(function_state).function->type != ZEND_INTERNAL_FUNCTION) {
-		EG(called_scope) = NULL;
-	}
-
-	if (fci->object_ptr) {
-		if ((EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
-			EG(This) = NULL;
-		} else {
-			EG(This) = fci->object_ptr;
-
-			if (!PZVAL_IS_REF(EG(This))) {
-				Z_ADDREF_P(EG(This)); /* For $this pointer */
-			} else {
-				zval *this_ptr;
-
-				ALLOC_ZVAL(this_ptr);
-				*this_ptr = *EG(This);
-				INIT_PZVAL(this_ptr);
-				zval_copy_ctor(this_ptr);
-				EG(This) = this_ptr;
-			}
-		}
+	EG(called_scope) = called_scope;
+	if (!fci->object ||
+	    (EX(function_state).function->common.fn_flags & ZEND_ACC_STATIC)) {
+		Z_OBJ(EG(This)) = NULL;
 	} else {
-		EG(This) = NULL;
+		Z_OBJ(EG(This)) = fci->object;
+		Z_ADDREF(EG(This));
 	}
 
 	EX(prev_execute_data) = EG(current_execute_data);
@@ -822,36 +952,33 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 			EG(active_symbol_table) = NULL;
 		}
 
-		original_return_value = EG(return_value_ptr_ptr);
 		original_op_array = EG(active_op_array);
-		EG(return_value_ptr_ptr) = fci->retval_ptr_ptr;
 		EG(active_op_array) = (zend_op_array *) EX(function_state).function;
 		original_opline_ptr = EG(opline_ptr);
 
 		if (EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) {
-			*fci->retval_ptr_ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC);
+			zend_generator_create_zval(EG(active_op_array), fci->retval TSRMLS_CC);
 		} else {
-			zend_execute(EG(active_op_array) TSRMLS_CC);
+			zend_execute(EG(active_op_array), fci->retval TSRMLS_CC);
 		}
 
+		EG(active_op_array) = original_op_array;
+		EG(opline_ptr) = original_opline_ptr;
 		if (!fci->symbol_table && EG(active_symbol_table)) {
 			zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
 		}
 		EG(active_symbol_table) = calling_symbol_table;
-		EG(active_op_array) = original_op_array;
-		EG(return_value_ptr_ptr)=original_return_value;
-		EG(opline_ptr) = original_opline_ptr;
 	} else if (EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
 		int call_via_handler = (EX(function_state).function->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0;
-		ALLOC_INIT_ZVAL(*fci->retval_ptr_ptr);
+		ZVAL_NULL(fci->retval);
 		if (EX(function_state).function->common.scope) {
 			EG(scope) = EX(function_state).function->common.scope;
 		}
 		if (EXPECTED(zend_execute_internal == NULL)) {
 			/* saves one function call if zend_execute_internal is not used */
-			EX(function_state).function->internal_function.handler(fci->param_count, *fci->retval_ptr_ptr, fci->retval_ptr_ptr, fci->object_ptr, 1 TSRMLS_CC);
+			EX(function_state).function->internal_function.handler(fci->param_count, fci->retval TSRMLS_CC);
 		} else {
-			zend_execute_internal(&execute_data, fci, 1 TSRMLS_CC);
+			zend_execute_internal(&execute_data, fci TSRMLS_CC);
 		}
 		/*  We shouldn't fix bad extensions here,
 			because it can break proper ones (Bug #34045)
@@ -859,9 +986,9 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 		{
 			INIT_PZVAL(*fci->retval_ptr_ptr);
 		}*/
-		if (EG(exception) && fci->retval_ptr_ptr) {
-			zval_ptr_dtor(fci->retval_ptr_ptr);
-			*fci->retval_ptr_ptr = NULL;
+		if (EG(exception) && fci->retval) {
+			zval_ptr_dtor(fci->retval);
+			ZVAL_UNDEF(fci->retval);
 		}
 
 		if (call_via_handler) {
@@ -869,11 +996,11 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 			fci_cache->initialized = 0;
 		}
 	} else { /* ZEND_OVERLOADED_FUNCTION */
-		ALLOC_INIT_ZVAL(*fci->retval_ptr_ptr);
+		ZVAL_NULL(fci->retval);
 
 		/* Not sure what should be done here if it's a static method */
-		if (fci->object_ptr) {
-			Z_OBJ_HT_P(fci->object_ptr)->call_method(EX(function_state).function->common.function_name, fci->param_count, *fci->retval_ptr_ptr, fci->retval_ptr_ptr, fci->object_ptr, 1 TSRMLS_CC);
+		if (fci->object) {
+			fci->object->handlers->call_method(EX(function_state).function->common.function_name, fci->object, fci->param_count, fci->retval TSRMLS_CC);
 		} else {
 			zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
 		}
@@ -883,19 +1010,20 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 		}
 		efree(EX(function_state).function);
 
-		if (EG(exception) && fci->retval_ptr_ptr) {
-			zval_ptr_dtor(fci->retval_ptr_ptr);
-			*fci->retval_ptr_ptr = NULL;
+		if (EG(exception) && fci->retval) {
+			zval_ptr_dtor(fci->retval);
+			ZVAL_UNDEF(fci->retval);
 		}
 	}
 	zend_vm_stack_clear_multiple(0 TSRMLS_CC);
 
-	if (EG(This)) {
+	if (Z_OBJ(EG(This))) {
 		zval_ptr_dtor(&EG(This));
 	}
-	EG(called_scope) = current_called_scope;
-	EG(scope) = current_scope;
-	EG(This) = current_this;
+
+	Z_OBJ(EG(This)) = EX(object);
+	EG(scope) = EX(scope);
+	EG(called_scope) = EX(called_scope);
 	EG(current_execute_data) = EX(prev_execute_data);
 
 	if (EG(exception)) {
@@ -905,47 +1033,38 @@ int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci_cache TS
 }
 /* }}} */
 
-ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_literal *key, int use_autoload, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *zend_lookup_class_ex(zend_string *name, const zval *key, int use_autoload TSRMLS_DC) /* {{{ */
 {
-	zval **args[1];
-	zval autoload_function;
-	zval *class_name_ptr;
-	zval *retval_ptr = NULL;
-	int retval, lc_length;
-	char *lc_name;
-	char *lc_free;
+	zend_class_entry *ce = NULL;
+	zval args[1];
+	zval local_retval;
+	int retval;
+	zend_string *lc_name;
 	zend_fcall_info fcall_info;
 	zend_fcall_info_cache fcall_cache;
-	char dummy = 1;
-	ulong hash;
-	ALLOCA_FLAG(use_heap)
 
 	if (key) {
-		lc_name = Z_STRVAL(key->constant);
-		lc_length = Z_STRLEN(key->constant) + 1;
-		hash = key->hash_value;
+		lc_name = Z_STR_P(key);
 	} else {
-		if (name == NULL || !name_length) {
-			return FAILURE;
+		if (name == NULL || !name->len) {
+			return NULL;
 		}
 
-		lc_free = lc_name = do_alloca(name_length + 1, use_heap);
-		zend_str_tolower_copy(lc_name, name, name_length);
-		lc_length = name_length + 1;
-
-		if (lc_name[0] == '\\') {
-			lc_name += 1;
-			lc_length -= 1;
+		if (name->val[0] == '\\') {
+			lc_name = STR_ALLOC(name->len - 1, 0);
+			zend_str_tolower_copy(lc_name->val, name->val + 1, name->len - 1);
+		} else {
+			lc_name = STR_ALLOC(name->len, 0);
+			zend_str_tolower_copy(lc_name->val, name->val, name->len);
 		}
-
-		hash = zend_inline_hash_func(lc_name, lc_length);
 	}
 
-	if (zend_hash_quick_find(EG(class_table), lc_name, lc_length, hash, (void **) ce) == SUCCESS) {
+	ce = zend_hash_find_ptr(EG(class_table), lc_name);
+	if (ce) {
 		if (!key) {
-			free_alloca(lc_free, use_heap);
+			STR_FREE(lc_name);
 		}
-		return SUCCESS;
+		return ce;
 	}
 
 	/* The compiler is not-reentrant. Make sure we __autoload() only during run-time
@@ -953,86 +1072,92 @@ ZEND_API int zend_lookup_class_ex(const char *name, int name_length, const zend_
 	*/
 	if (!use_autoload || zend_is_compiling(TSRMLS_C)) {
 		if (!key) {
-			free_alloca(lc_free, use_heap);
+			STR_FREE(lc_name);
 		}
-		return FAILURE;
+		return NULL;
 	}
 
+	if (!EG(autoload_func)) {
+		zend_function *func = zend_hash_str_find_ptr(EG(function_table), ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1);
+		if (func) {
+			EG(autoload_func) = func;
+		} else {
+			if (!key) {
+				STR_FREE(lc_name);
+			}
+			return NULL;
+		}
+
+	}
+	
 	/* Verify class name before passing it to __autoload() */
-	if (strspn(name, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\") != name_length) {
+	if (strspn(name->val, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\") != name->len) {
 		if (!key) {
-			free_alloca(lc_free, use_heap);
+			STR_FREE(lc_name);
 		}
-		return FAILURE;
+		return NULL;
 	}
 	
 	if (EG(in_autoload) == NULL) {
 		ALLOC_HASHTABLE(EG(in_autoload));
-		zend_hash_init(EG(in_autoload), 0, NULL, NULL, 0);
+		zend_hash_init(EG(in_autoload), 8, NULL, NULL, 0);
 	}
 
-	if (zend_hash_quick_add(EG(in_autoload), lc_name, lc_length, hash, (void**)&dummy, sizeof(char), NULL) == FAILURE) {
+	if (zend_hash_add_empty_element(EG(in_autoload), lc_name) == NULL) {
 		if (!key) {
-			free_alloca(lc_free, use_heap);
+			STR_FREE(lc_name);
 		}
-		return FAILURE;
+		return NULL;
 	}
 
-	ZVAL_STRINGL(&autoload_function, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1, 0);
+	ZVAL_UNDEF(&local_retval);
 
-	ALLOC_ZVAL(class_name_ptr);
-	INIT_PZVAL(class_name_ptr);
-	if (name[0] == '\\') {
-		ZVAL_STRINGL(class_name_ptr, name+1, name_length-1, 1);
+	if (name->val[0] == '\\') {
+		ZVAL_STRINGL(&args[0], name->val + 1, name->len - 1);
 	} else {
-		ZVAL_STRINGL(class_name_ptr, name, name_length, 1);
+		ZVAL_STR(&args[0], STR_COPY(name));
 	}
 
-	args[0] = &class_name_ptr;
-
 	fcall_info.size = sizeof(fcall_info);
 	fcall_info.function_table = EG(function_table);
-	fcall_info.function_name = &autoload_function;
+	ZVAL_STR(&fcall_info.function_name, STR_COPY(EG(autoload_func)->common.function_name));
 	fcall_info.symbol_table = NULL;
-	fcall_info.retval_ptr_ptr = &retval_ptr;
+	fcall_info.retval = &local_retval;
 	fcall_info.param_count = 1;
 	fcall_info.params = args;
-	fcall_info.object_ptr = NULL;
+	fcall_info.object = NULL;
 	fcall_info.no_separation = 1;
 
-	fcall_cache.initialized = EG(autoload_func) ? 1 : 0;
+	fcall_cache.initialized = 1;
 	fcall_cache.function_handler = EG(autoload_func);
 	fcall_cache.calling_scope = NULL;
 	fcall_cache.called_scope = NULL;
-	fcall_cache.object_ptr = NULL;
+	fcall_cache.object = NULL;
 
 	zend_exception_save(TSRMLS_C);
 	retval = zend_call_function(&fcall_info, &fcall_cache TSRMLS_CC);
 	zend_exception_restore(TSRMLS_C);
 
-	EG(autoload_func) = fcall_cache.function_handler;
+	zval_ptr_dtor(&args[0]);
+	zval_dtor(&fcall_info.function_name);
 
-	zval_ptr_dtor(&class_name_ptr);
+	zend_hash_del(EG(in_autoload), lc_name);
 
-	zend_hash_quick_del(EG(in_autoload), lc_name, lc_length, hash);
-
-	if (retval_ptr) {
-		zval_ptr_dtor(&retval_ptr);
-	}
+	zval_ptr_dtor(&local_retval);
 
 	if (retval == SUCCESS) {
-		retval = zend_hash_quick_find(EG(class_table), lc_name, lc_length, hash, (void **) ce);
+		ce = zend_hash_find_ptr(EG(class_table), lc_name);
 	}
 	if (!key) {
-		free_alloca(lc_free, use_heap);
+		STR_FREE(lc_name);
 	}
-	return retval;
+	return ce;
 }
 /* }}} */
 
-ZEND_API int zend_lookup_class(const char *name, int name_length, zend_class_entry ***ce TSRMLS_DC) /* {{{ */
+ZEND_API zend_class_entry *zend_lookup_class(zend_string *name TSRMLS_DC) /* {{{ */
 {
-	return zend_lookup_class_ex(name, name_length, NULL, 1, ce TSRMLS_CC);
+	return zend_lookup_class_ex(name, NULL, 1 TSRMLS_CC);
 }
 /* }}} */
 
@@ -1045,17 +1170,14 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s
 	int retval;
 
 	if (retval_ptr) {
-		Z_STRLEN(pv) = str_len + sizeof("return ;") - 1;
-		Z_STRVAL(pv) = emalloc(Z_STRLEN(pv) + 1);
+		ZVAL_NEW_STR(&pv, STR_ALLOC(str_len + sizeof("return ;")-1, 1));
 		memcpy(Z_STRVAL(pv), "return ", sizeof("return ") - 1);
 		memcpy(Z_STRVAL(pv) + sizeof("return ") - 1, str, str_len);
 		Z_STRVAL(pv)[Z_STRLEN(pv) - 1] = ';';
 		Z_STRVAL(pv)[Z_STRLEN(pv)] = '\0';
 	} else {
-		Z_STRLEN(pv) = str_len;
-		Z_STRVAL(pv) = str;
+		ZVAL_STRINGL(&pv, str, str_len);
 	}
-	Z_TYPE(pv) = IS_STRING;
 
 	/*printf("Evaluating '%s'\n", pv.value.str.val);*/
 
@@ -1065,12 +1187,10 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s
 	CG(compiler_options) = original_compiler_options;
 
 	if (new_op_array) {
-		zval *local_retval_ptr=NULL;
-		zval **original_return_value_ptr_ptr = EG(return_value_ptr_ptr);
+		zval local_retval;
 		zend_op **original_opline_ptr = EG(opline_ptr);
 		int orig_interactive = CG(interactive);
 
-		EG(return_value_ptr_ptr) = &local_retval_ptr;
 		EG(active_op_array) = new_op_array;
 		EG(no_extensions)=1;
 		if (!EG(active_symbol_table)) {
@@ -1079,7 +1199,8 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s
 		CG(interactive) = 0;
 
 		zend_try {
-			zend_execute(new_op_array TSRMLS_CC);
+			ZVAL_UNDEF(&local_retval);
+			zend_execute(new_op_array, &local_retval TSRMLS_CC);
 		} zend_catch {
 			destroy_op_array(new_op_array TSRMLS_CC);
 			efree(new_op_array);
@@ -1087,15 +1208,15 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s
 		} zend_end_try();
 
 		CG(interactive) = orig_interactive;
-		if (local_retval_ptr) {
+		if (Z_TYPE(local_retval) != IS_UNDEF) {
 			if (retval_ptr) {
-				COPY_PZVAL_TO_ZVAL(*retval_ptr, local_retval_ptr);
+				ZVAL_COPY_VALUE(retval_ptr, &local_retval);
 			} else {
-				zval_ptr_dtor(&local_retval_ptr);
+				zval_ptr_dtor(&local_retval);
 			}
 		} else {
 			if (retval_ptr) {
-				INIT_ZVAL(*retval_ptr);
+				ZVAL_NULL(retval_ptr);
 			}
 		}
 
@@ -1104,14 +1225,11 @@ ZEND_API int zend_eval_stringl(char *str, int str_len, zval *retval_ptr, char *s
 		EG(active_op_array) = original_active_op_array;
 		destroy_op_array(new_op_array TSRMLS_CC);
 		efree(new_op_array);
-		EG(return_value_ptr_ptr) = original_return_value_ptr_ptr;
 		retval = SUCCESS;
 	} else {
 		retval = FAILURE;
 	}
-	if (retval_ptr) {
-		zval_dtor(&pv);
-	}
+	zval_dtor(&pv);
 	return retval;
 }
 /* }}} */
@@ -1169,10 +1287,10 @@ void execute_new_code(TSRMLS_D) /* {{{ */
 
 	while (opline<end) {
 		if (opline->op1_type == IS_CONST) {
-			opline->op1.zv = &CG(active_op_array)->literals[opline->op1.constant].constant;
+			opline->op1.zv = &CG(active_op_array)->literals[opline->op1.constant];
 		}
 		if (opline->op2_type == IS_CONST) {
-			opline->op2.zv = &CG(active_op_array)->literals[opline->op2.constant].constant;
+			opline->op2.zv = &CG(active_op_array)->literals[opline->op2.constant];
 		}
 		switch (opline->opcode) {
 			case ZEND_GOTO:
@@ -1198,11 +1316,10 @@ void execute_new_code(TSRMLS_D) /* {{{ */
 
 	zend_release_labels(1 TSRMLS_CC);
 
-	EG(return_value_ptr_ptr) = NULL;
 	EG(active_op_array) = CG(active_op_array);
 	orig_interactive = CG(interactive);
 	CG(interactive) = 0;
-	zend_execute(CG(active_op_array) TSRMLS_CC);
+	zend_execute(CG(active_op_array), NULL TSRMLS_CC);
 	CG(interactive) = orig_interactive;
 
 	if (EG(exception)) {
@@ -1427,9 +1544,9 @@ void zend_unset_timeout(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-zend_class_entry *zend_fetch_class(const char *class_name, uint class_name_len, int fetch_type TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_fetch_class(zend_string *class_name, int fetch_type TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry **pce;
+	zend_class_entry *ce;
 	int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;
 	int silent       = (fetch_type & ZEND_FETCH_CLASS_SILENT) != 0;
 
@@ -1456,7 +1573,7 @@ check_fetch_type:
 			}
 			return EG(called_scope);
 		case ZEND_FETCH_CLASS_AUTO: {
-				fetch_type = zend_get_class_fetch_type(class_name, class_name_len);
+				fetch_type = zend_get_class_fetch_type(class_name->val, class_name->len);
 				if (fetch_type!=ZEND_FETCH_CLASS_DEFAULT) {
 					goto check_fetch_type;
 				}
@@ -1464,44 +1581,44 @@ check_fetch_type:
 			break;
 	}
 
-	if (zend_lookup_class_ex(class_name, class_name_len, NULL, use_autoload, &pce TSRMLS_CC) == FAILURE) {
+	if ((ce = zend_lookup_class_ex(class_name, NULL, use_autoload TSRMLS_CC)) == NULL) {
 		if (use_autoload) {
 			if (!silent && !EG(exception)) {
 				if (fetch_type == ZEND_FETCH_CLASS_INTERFACE) {
-					zend_error(E_ERROR, "Interface '%s' not found", class_name);
+					zend_error(E_ERROR, "Interface '%s' not found", class_name->val);
 				} else if (fetch_type == ZEND_FETCH_CLASS_TRAIT) {
-                	zend_error(E_ERROR, "Trait '%s' not found", class_name);
+                	zend_error(E_ERROR, "Trait '%s' not found", class_name->val);
                 } else {
-					zend_error(E_ERROR, "Class '%s' not found", class_name);
+					zend_error(E_ERROR, "Class '%s' not found", class_name->val);
 				}
 			}
 		}
 		return NULL;
 	}
-	return *pce;
+	return ce;
 }
 /* }}} */
 
-zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_name_len, const zend_literal *key, int fetch_type TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_fetch_class_by_name(zend_string *class_name, const zval *key, int fetch_type TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry **pce;
+	zend_class_entry *ce;
 	int use_autoload = (fetch_type & ZEND_FETCH_CLASS_NO_AUTOLOAD) == 0;
 
-	if (zend_lookup_class_ex(class_name, class_name_len, key, use_autoload, &pce TSRMLS_CC) == FAILURE) {
+	if ((ce = zend_lookup_class_ex(class_name, key, use_autoload TSRMLS_CC)) == NULL) {
 		if (use_autoload) {
 			if ((fetch_type & ZEND_FETCH_CLASS_SILENT) == 0 && !EG(exception)) {
 				if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_INTERFACE) {
-					zend_error(E_ERROR, "Interface '%s' not found", class_name);
+					zend_error(E_ERROR, "Interface '%s' not found", class_name->val);
 				} else if ((fetch_type & ZEND_FETCH_CLASS_MASK) == ZEND_FETCH_CLASS_TRAIT) {
-					zend_error(E_ERROR, "Trait '%s' not found", class_name);
+					zend_error(E_ERROR, "Trait '%s' not found", class_name->val);
 				} else {
-					zend_error(E_ERROR, "Class '%s' not found", class_name);
+					zend_error(E_ERROR, "Class '%s' not found", class_name->val);
 				}
 			}
 		}
 		return NULL;
 	}
-	return *pce;
+	return ce;
 }
 /* }}} */
 
@@ -1510,7 +1627,7 @@ zend_class_entry *zend_fetch_class_by_name(const char *class_name, uint class_na
 #define DISPLAY_ABSTRACT_FN(idx) \
 	ai.afn[idx] ? ZEND_FN_SCOPE_NAME(ai.afn[idx]) : "", \
 	ai.afn[idx] ? "::" : "", \
-	ai.afn[idx] ? ai.afn[idx]->common.function_name : "", \
+	ai.afn[idx] ? ai.afn[idx]->common.function_name->val : "", \
 	ai.afn[idx] && ai.afn[idx + 1] ? ", " : (ai.afn[idx] && ai.cnt > MAX_ABSTRACT_INFO_CNT ? ", ..." : "")
 
 typedef struct _zend_abstract_info {
@@ -1519,8 +1636,10 @@ typedef struct _zend_abstract_info {
 	int ctor;
 } zend_abstract_info;
 
-static int zend_verify_abstract_class_function(zend_function *fn, zend_abstract_info *ai TSRMLS_DC) /* {{{ */
+static int zend_verify_abstract_class_function(zval *zv, zend_abstract_info *ai TSRMLS_DC) /* {{{ */
 {
+	zend_function *fn = Z_PTR_P(zv);
+
 	if (fn->common.fn_flags & ZEND_ACC_ABSTRACT) {
 		if (ai->cnt < MAX_ABSTRACT_INFO_CNT) {
 			ai->afn[ai->cnt] = fn;
@@ -1551,7 +1670,7 @@ void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 
 		if (ai.cnt) {
 			zend_error(E_ERROR, "Class %s contains %d abstract method%s and must therefore be declared abstract or implement the remaining methods (" MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT MAX_ABSTRACT_INFO_FMT ")",
-				ce->name, ai.cnt,
+				ce->name->val, ai.cnt,
 				ai.cnt > 1 ? "s" : "",
 				DISPLAY_ABSTRACT_FN(0),
 				DISPLAY_ABSTRACT_FN(1),
@@ -1562,72 +1681,9 @@ void zend_verify_abstract_class(zend_class_entry *ce TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC) /* {{{ */
-{
-	zend_execute_data *ex;
-	int i;
-
-	for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) {
-		if (ex->op_array && ex->symbol_table == symbol_table) {
-			for (i = 0; i < ex->op_array->last_var; i++) {
-				*EX_CV_NUM(ex, i) = NULL;
-			}
-		}
-	}
-}
-/* }}} */
-
-ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, int name_len, ulong hash_value TSRMLS_DC) /* {{{ */
-{
-	if (zend_hash_quick_del(ht, name, name_len, hash_value) == SUCCESS) {
-		name_len--;
-		while (ex && ex->symbol_table == ht) {
-			int i;
-
-			if (ex->op_array) {
-				for (i = 0; i < ex->op_array->last_var; i++) {
-					if (ex->op_array->vars[i].hash_value == hash_value &&
-						ex->op_array->vars[i].name_len == name_len &&
-						!memcmp(ex->op_array->vars[i].name, name, name_len)) {
-						*EX_CV_NUM(ex, i) = NULL;
-						break;
-					}
-				}
-			}
-			ex = ex->prev_execute_data;
-		}
-	}
-}
-/* }}} */
-
-ZEND_API int zend_delete_global_variable_ex(const char *name, int name_len, ulong hash_value TSRMLS_DC) /* {{{ */
+ZEND_API int zend_delete_global_variable(zend_string *name TSRMLS_DC) /* {{{ */
 {
-	zend_execute_data *ex;
-
-	if (zend_hash_quick_exists(&EG(symbol_table), name, name_len + 1, hash_value)) {
-		for (ex = EG(current_execute_data); ex; ex = ex->prev_execute_data) {
-			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].hash_value == hash_value &&
-						ex->op_array->vars[i].name_len == name_len &&
-						!memcmp(ex->op_array->vars[i].name, name, name_len)
-					) {
-						*EX_CV_NUM(ex, i) = NULL;
-						break;
-					}
-				}
-			}
-		}
-		return zend_hash_quick_del(&EG(symbol_table), name, name_len + 1, hash_value);
-	}
-	return FAILURE;
-}
-/* }}} */
-
-ZEND_API int zend_delete_global_variable(const char *name, int name_len TSRMLS_DC) /* {{{ */
-{
-	return zend_delete_global_variable_ex(name, name_len, zend_inline_hash_func(name, name_len + 1) TSRMLS_CC);
+    return zend_hash_del_ind(&EG(symbol_table).ht, name);
 }
 /* }}} */
 
@@ -1653,34 +1709,140 @@ 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));
+				GC_REFCOUNT(EG(active_symbol_table)) = 0;
+				GC_TYPE_INFO(EG(active_symbol_table)) = 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);
-
-			if (ex->op_array->this_var != -1 &&
-			    !*EX_CV_NUM(ex, ex->op_array->this_var) &&
-			    EG(This)) {
-			    *EX_CV_NUM(ex, ex->op_array->this_var) = (zval**)EX_CV_NUM(ex, ex->op_array->last_var + ex->op_array->this_var);
-				**EX_CV_NUM(ex, ex->op_array->this_var) = EG(This);
- 			}
 			for (i = 0; i < ex->op_array->last_var; i++) {
-				if (*EX_CV_NUM(ex, i)) {
-					zend_hash_quick_update(EG(active_symbol_table),
-						ex->op_array->vars[i].name,
-						ex->op_array->vars[i].name_len + 1,
-						ex->op_array->vars[i].hash_value,
-						(void**)*EX_CV_NUM(ex, i),
-						sizeof(zval*),
-						(void**)EX_CV_NUM(ex, i));
+				zval zv;
+					
+				ZVAL_INDIRECT(&zv, EX_VAR_NUM_2(ex, i));
+				zend_hash_update(&EG(active_symbol_table)->ht,
+					ex->op_array->vars[i], &zv);
+			}
+		}
+	}
+}
+/* }}} */
+
+ZEND_API void zend_attach_symbol_table(zend_execute_data *execute_data) /* {{{ */
+{
+	int i;
+	zend_op_array *op_array = execute_data->op_array;
+	HashTable *ht = &execute_data->symbol_table->ht;
+	
+	/* copy real values from symbol table into CV slots and create
+	   INDIRECT references to CV in symbol table  */
+	for (i = 0; i < op_array->last_var; i++) {
+		zval *zv = zend_hash_find(ht, op_array->vars[i]);
+
+		if (zv) {
+			if (Z_TYPE_P(zv) == IS_INDIRECT) {
+				zval *val = Z_INDIRECT_P(zv);
+				if (Z_TYPE_P(val) == IS_UNDEF) {
+					ZVAL_UNDEF(EX_VAR_NUM(i));
+				} else {
+					ZVAL_COPY_VALUE(EX_VAR_NUM(i), val);
 				}
+			} else {
+				ZVAL_COPY_VALUE(EX_VAR_NUM(i), zv);
 			}
+		} else {
+			ZVAL_UNDEF(EX_VAR_NUM(i));
+			zv = zend_hash_update(ht, op_array->vars[i], EX_VAR_NUM(i));
 		}
+		ZVAL_INDIRECT(zv, EX_VAR_NUM(i));
 	}
 }
 /* }}} */
 
+ZEND_API void zend_detach_symbol_table(zend_execute_data *execute_data) /* {{{ */
+{
+	int i;
+	zend_op_array *op_array = execute_data->op_array;
+	HashTable *ht = &execute_data->symbol_table->ht;
+	
+	/* copy real values from CV slots into symbol table */
+	for (i = 0; i < op_array->last_var; i++) {
+		if (Z_TYPE_P(EX_VAR_NUM(i)) == IS_UNDEF) {
+			zend_hash_del(ht, op_array->vars[i]);
+		} else {
+			zend_hash_update(ht, op_array->vars[i], EX_VAR_NUM(i));
+			ZVAL_UNDEF(EX_VAR_NUM(i));
+		}
+	}
+}
+/* }}} */
+
+ZEND_API int zend_set_local_var(zend_string *name, zval *value, int force TSRMLS_DC) /* {{{ */
+{
+	if (!EG(active_symbol_table)) {
+		int i;
+		zend_execute_data *execute_data = EG(current_execute_data);
+		zend_op_array *op_array = execute_data->op_array;
+		zend_ulong h = STR_HASH_VAL(name);
+
+		if (op_array) {
+			for (i = 0; i < op_array->last_var; i++) {
+				if (op_array->vars[i]->h == h &&
+				    op_array->vars[i]->len == name->len &&
+				    memcmp(op_array->vars[i]->val, name->val, name->len) == 0) {
+					ZVAL_COPY_VALUE(EX_VAR_NUM(i), value);
+					return SUCCESS;
+				}
+			}
+		}
+		if (force) {
+			zend_rebuild_symbol_table(TSRMLS_C);
+			if (EG(active_symbol_table)) {
+				zend_hash_update(&EG(active_symbol_table)->ht, name, value);
+			}
+		} else {
+			return FAILURE;
+		}
+	} else {
+		return (zend_hash_update_ind(&EG(active_symbol_table)->ht, name, value) != NULL) ? SUCCESS : FAILURE;
+	}
+	return SUCCESS;
+}
+/* }}} */
+
+ZEND_API int zend_set_local_var_str(const char *name, int len, zval *value, int force TSRMLS_DC) /* {{{ */
+{
+	if (!EG(active_symbol_table)) {
+		int i;
+		zend_execute_data *execute_data = EG(current_execute_data);
+		zend_op_array *op_array = execute_data->op_array;
+		zend_ulong h = zend_hash_func(name, len);
+
+		if (op_array) {
+			for (i = 0; i < op_array->last_var; i++) {
+				if (op_array->vars[i]->h == h &&
+				    op_array->vars[i]->len == len &&
+				    memcmp(op_array->vars[i]->val, name, len) == 0) {
+					ZVAL_COPY_VALUE(EX_VAR_NUM(i), value);
+					return SUCCESS;
+				}
+			}
+		}
+		if (force) {
+			zend_rebuild_symbol_table(TSRMLS_C);
+			if (EG(active_symbol_table)) {
+				zend_hash_str_update(&EG(active_symbol_table)->ht, name, len, value);
+			}
+		} else {
+			return FAILURE;
+		}
+	} else {
+		return (zend_hash_str_update_ind(&EG(active_symbol_table)->ht, name, len, value) != NULL) ? SUCCESS : FAILURE;
+	}
+	return SUCCESS;
+}
+/* }}} */
+
 /*
  * Local variables:
  * tab-width: 4
diff --git a/Zend/zend_gc.c b/Zend/zend_gc.c
index 76217e369d..7712ee41ed 100644
--- a/Zend/zend_gc.c
+++ b/Zend/zend_gc.c
@@ -22,7 +22,8 @@
 #include "zend.h"
 #include "zend_API.h"
 
-#define GC_ROOT_BUFFER_MAX_ENTRIES 10000
+/* one (0) is reserved */
+#define GC_ROOT_BUFFER_MAX_ENTRIES 10001
 
 #ifdef ZTS
 ZEND_API int gc_globals_id;
@@ -30,6 +31,18 @@ ZEND_API int gc_globals_id;
 ZEND_API zend_gc_globals gc_globals;
 #endif
 
+#define GC_REMOVE_FROM_ROOTS(current) \
+	gc_remove_from_roots((current) TSRMLS_CC)
+
+static zend_always_inline void gc_remove_from_roots(gc_root_buffer *root TSRMLS_DC)
+{
+	root->next->prev = root->prev;
+	root->prev->next = root->next;
+	root->prev = GC_G(unused);
+	GC_G(unused) = root;
+	GC_BENCH_DEC(root_buf_length);
+}
+
 static void root_buffer_dtor(zend_gc_globals *gc_globals TSRMLS_DC)
 {
 	if (gc_globals->buf) {
@@ -48,10 +61,11 @@ static void gc_globals_ctor_ex(zend_gc_globals *gc_globals TSRMLS_DC)
 	gc_globals->roots.next = &gc_globals->roots;
 	gc_globals->roots.prev = &gc_globals->roots;
 	gc_globals->unused = NULL;
-	gc_globals->zval_to_free = NULL;
-	gc_globals->free_list = NULL;
 	gc_globals->next_to_free = NULL;
 
+	gc_globals->to_free.next = &gc_globals->to_free;
+	gc_globals->to_free.prev = &gc_globals->to_free;
+
 	gc_globals->gc_runs = 0;
 	gc_globals->collected = 0;
 
@@ -59,13 +73,9 @@ static void gc_globals_ctor_ex(zend_gc_globals *gc_globals TSRMLS_DC)
 	gc_globals->root_buf_length = 0;
 	gc_globals->root_buf_peak = 0;
 	gc_globals->zval_possible_root = 0;
-	gc_globals->zobj_possible_root = 0;
 	gc_globals->zval_buffered = 0;
-	gc_globals->zobj_buffered = 0;
 	gc_globals->zval_remove_from_buffer = 0;
-	gc_globals->zobj_remove_from_buffer = 0;
 	gc_globals->zval_marked_grey = 0;
-	gc_globals->zobj_marked_grey = 0;
 #endif
 }
 
@@ -94,23 +104,20 @@ ZEND_API void gc_reset(TSRMLS_D)
 	GC_G(root_buf_length) = 0;
 	GC_G(root_buf_peak) = 0;
 	GC_G(zval_possible_root) = 0;
-	GC_G(zobj_possible_root) = 0;
 	GC_G(zval_buffered) = 0;
-	GC_G(zobj_buffered) = 0;
 	GC_G(zval_remove_from_buffer) = 0;
-	GC_G(zobj_remove_from_buffer) = 0;
 	GC_G(zval_marked_grey) = 0;
-	GC_G(zobj_marked_grey) = 0;
 #endif
 
 	GC_G(roots).next = &GC_G(roots);
 	GC_G(roots).prev = &GC_G(roots);
 
+	GC_G(to_free).next = &GC_G(to_free);
+	GC_G(to_free).prev = &GC_G(to_free);
+
 	if (GC_G(buf)) {
 		GC_G(unused) = NULL;
-		GC_G(first_unused) = GC_G(buf);
-
-		GC_G(zval_to_free) = NULL;
+		GC_G(first_unused) = GC_G(buf) + 1;
 	} else {
 		GC_G(unused) = NULL;
 		GC_G(first_unused) = NULL;
@@ -127,29 +134,14 @@ ZEND_API void gc_init(TSRMLS_D)
 	}
 }
 
-ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC)
+ZEND_API void gc_possible_root(zend_refcounted *ref TSRMLS_DC)
 {
-	if (UNEXPECTED(GC_G(free_list) != NULL &&
-	               GC_ZVAL_ADDRESS(zv) != NULL &&
-		           GC_ZVAL_GET_COLOR(zv) == GC_BLACK) &&
-		           (GC_ZVAL_ADDRESS(zv) < GC_G(buf) ||
-		            GC_ZVAL_ADDRESS(zv) >= GC_G(last_unused))) {
-		/* The given zval is a garbage that is going to be deleted by
-		 * currently running GC */
-		return;
-	}
-
-	if (zv->type == IS_OBJECT) {
-		GC_ZOBJ_CHECK_POSSIBLE_ROOT(zv);
-		return;
-	}
-
 	GC_BENCH_INC(zval_possible_root);
 
-	if (GC_ZVAL_GET_COLOR(zv) != GC_PURPLE) {
-		GC_ZVAL_SET_PURPLE(zv);
+	if (EXPECTED(GC_GET_COLOR(GC_INFO(ref)) == GC_BLACK)) {
+		GC_SET_PURPLE(GC_INFO(ref));
 
-		if (!GC_ZVAL_ADDRESS(zv)) {
+		if (!GC_ADDRESS(GC_INFO(ref))) {
 			gc_root_buffer *newRoot = GC_G(unused);
 
 			if (newRoot) {
@@ -159,17 +151,17 @@ ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC)
 				GC_G(first_unused)++;
 			} else {
 				if (!GC_G(gc_enabled)) {
-					GC_ZVAL_SET_BLACK(zv);
+					GC_SET_BLACK(GC_INFO(ref));
 					return;
 				}
-				zv->refcount__gc++;
+				GC_REFCOUNT(ref)++;
 				gc_collect_cycles(TSRMLS_C);
-				zv->refcount__gc--;
+				GC_REFCOUNT(ref)--;
 				newRoot = GC_G(unused);
 				if (!newRoot) {
 					return;
 				}
-				GC_ZVAL_SET_PURPLE(zv);
+				GC_SET_PURPLE(GC_INFO(ref));
 				GC_G(unused) = newRoot->prev;
 			}
 
@@ -178,10 +170,9 @@ ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC)
 			GC_G(roots).next->prev = newRoot;
 			GC_G(roots).next = newRoot;
 
-			GC_ZVAL_SET_ADDRESS(zv, newRoot);
+			GC_SET_ADDRESS(GC_INFO(ref), newRoot - GC_G(buf));
 
-			newRoot->handle = 0;
-			newRoot->u.pz = zv;
+			newRoot->ref = ref;
 
 			GC_BENCH_INC(zval_buffered);
 			GC_BENCH_INC(root_buf_length);
@@ -190,286 +181,187 @@ ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC)
 	}
 }
 
-ZEND_API void gc_zobj_possible_root(zval *zv TSRMLS_DC)
+ZEND_API void gc_remove_from_buffer(zend_refcounted *ref TSRMLS_DC)
 {
-	struct _store_object *obj;
-
-	if (UNEXPECTED(Z_OBJ_HT_P(zv)->get_gc == NULL ||
-	    EG(objects_store).object_buckets == NULL)) {
-		return;
-	}
-
-	GC_BENCH_INC(zobj_possible_root);
+	gc_root_buffer *root;
 
-	obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zv)].bucket.obj;
-	if (GC_GET_COLOR(obj->buffered) != GC_PURPLE) {
-		GC_SET_PURPLE(obj->buffered);
-		if (!GC_ADDRESS(obj->buffered)) {
-			gc_root_buffer *newRoot = GC_G(unused);
-
-			if (newRoot) {
-				GC_G(unused) = newRoot->prev;
-			} else if (GC_G(first_unused) != GC_G(last_unused)) {
-				newRoot = GC_G(first_unused);
-				GC_G(first_unused)++;
-			} else {
-				if (!GC_G(gc_enabled)) {
-					GC_ZVAL_SET_BLACK(zv);
-					return;
-				}
-				zv->refcount__gc++;
-				gc_collect_cycles(TSRMLS_C);
-				zv->refcount__gc--;
-				newRoot = GC_G(unused);
-				if (!newRoot) {
-					return;
-				}
-				obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zv)].bucket.obj;
-				GC_SET_PURPLE(obj->buffered);
-				GC_G(unused) = newRoot->prev;
-			}
-
-			newRoot->next = GC_G(roots).next;
-			newRoot->prev = &GC_G(roots);
-			GC_G(roots).next->prev = newRoot;
-			GC_G(roots).next = newRoot;
-
-			GC_SET_ADDRESS(obj->buffered, newRoot);
-
-			newRoot->handle = Z_OBJ_HANDLE_P(zv);
-			newRoot->u.handlers = Z_OBJ_HT_P(zv);
-
-			GC_BENCH_INC(zobj_buffered);
-			GC_BENCH_INC(root_buf_length);
-			GC_BENCH_PEAK(root_buf_peak, root_buf_length);
-		}
-	}
-}
-
-ZEND_API void gc_remove_zval_from_buffer(zval *zv TSRMLS_DC)
-{
-	gc_root_buffer* root_buffer = GC_ADDRESS(((zval_gc_info*)zv)->u.buffered);
-
-	if (UNEXPECTED(GC_G(free_list) != NULL &&
-		           GC_ZVAL_GET_COLOR(zv) == GC_BLACK) &&
-		           (GC_ZVAL_ADDRESS(zv) < GC_G(buf) ||
-		            GC_ZVAL_ADDRESS(zv) >= GC_G(last_unused))) {
+	if (UNEXPECTED(/*GC_ADDRESS(GC_INFO(ref)) &&*/
+	               GC_GET_COLOR(GC_INFO(ref)) == GC_BLACK &&
+		           GC_ADDRESS(GC_INFO(ref)) >= GC_G(last_unused) - GC_G(buf))) {
 		/* The given zval is a garbage that is going to be deleted by
 		 * currently running GC */
-		if (GC_G(next_to_free) == (zval_gc_info*)zv) {
-			GC_G(next_to_free) = ((zval_gc_info*)zv)->u.next;
-		}
 		return;
 	}
+
+	root = GC_G(buf) + GC_ADDRESS(GC_INFO(ref));
 	GC_BENCH_INC(zval_remove_from_buffer);
-	GC_REMOVE_FROM_BUFFER(root_buffer);
-	((zval_gc_info*)zv)->u.buffered = NULL;
+	GC_REMOVE_FROM_ROOTS(root);
+	GC_INFO(ref) = 0;
+
+	/* updete next root that is going to be freed */
+	if (GC_G(next_to_free) == root) {
+		GC_G(next_to_free) = root->next;
+	}
 }
 
-static void zval_scan_black(zval *pz TSRMLS_DC)
+static void gc_scan_black(zend_refcounted *ref TSRMLS_DC)
 {
+	HashTable *ht;
+	uint idx;
 	Bucket *p;
 
 tail_call:
-	p = NULL;
-	GC_ZVAL_SET_BLACK(pz);
+	ht = NULL;
+	GC_SET_BLACK(GC_INFO(ref));
 
-	if (Z_TYPE_P(pz) == IS_OBJECT && EG(objects_store).object_buckets) {
+	if (GC_TYPE(ref) == IS_OBJECT && EG(objects_store).object_buckets) {
 		zend_object_get_gc_t get_gc;
-		struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
+		zend_object *obj = (zend_object*)ref;
 
-		obj->refcount++;
-		if (GC_GET_COLOR(obj->buffered) != GC_BLACK) {
-			GC_SET_BLACK(obj->buffered);
-			if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-			             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-				int i, n;
-				zval **table;
-				HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
+		if (EXPECTED(IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle]) &&
+		             (get_gc = obj->handlers->get_gc) != NULL)) {
+			int i, n;
+			zval *table;
+			zval tmp;
+			HashTable *props;
 
-				while (n > 0 && !table[n-1]) n--;
-				for (i = 0; i < n; i++) {
-					if (table[i]) {
-						pz = table[i];
-						if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-							pz->refcount__gc++;
-						}
-						if (GC_ZVAL_GET_COLOR(pz) != GC_BLACK) {
-							if (!props && i == n - 1) {
-								goto tail_call;
-							} else {
-								zval_scan_black(pz TSRMLS_CC);
-							}
+			ZVAL_OBJ(&tmp, obj);
+			props = get_gc(&tmp, &table, &n TSRMLS_CC);
+			while (n > 0 && !Z_REFCOUNTED(table[n-1])) n--;
+			for (i = 0; i < n; i++) {
+				if (Z_REFCOUNTED(table[i])) {
+					ref = Z_COUNTED(table[i]);
+					if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+						GC_REFCOUNT(ref)++;
+					}
+					if (GC_GET_COLOR(GC_INFO(ref)) != GC_BLACK) {
+						if (!props && i == n - 1) {
+							goto tail_call;
+						} else {
+							gc_scan_black(ref TSRMLS_CC);
 						}
 					}
 				}
-				if (!props) {
-					return;
-				}
-				p = props->pListHead;
 			}
+			if (!props) {
+				return;
+			}
+			ht = props;
 		}
-	} else if (Z_TYPE_P(pz) == IS_ARRAY) {
-		if (Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-			p = Z_ARRVAL_P(pz)->pListHead;
-		}
-	}
-	while (p != NULL) {
-		pz = *(zval**)p->pData;
-		if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-			pz->refcount__gc++;
+	} else if (GC_TYPE(ref) == IS_ARRAY) {
+		if ((zend_array*)ref != &EG(symbol_table)) {
+			ht = &((zend_array*)ref)->ht;
 		}
-		if (GC_ZVAL_GET_COLOR(pz) != GC_BLACK) {
-			if (p->pListNext == NULL) {
+	} else if (GC_TYPE(ref) == IS_REFERENCE) {
+		if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
+			if (UNEXPECTED(!EG(objects_store).object_buckets) &&
+			    Z_TYPE(((zend_reference*)ref)->val) == IS_OBJECT) {
+				return;
+			}
+			ref = Z_COUNTED(((zend_reference*)ref)->val);
+			if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+				GC_REFCOUNT(ref)++;
+			}
+			if (GC_GET_COLOR(GC_INFO(ref)) != GC_BLACK) {
 				goto tail_call;
-			} else {
-				zval_scan_black(pz TSRMLS_CC);
 			}
 		}
-		p = p->pListNext;
+		return;
 	}
-}
-
-static void zobj_scan_black(struct _store_object *obj, zval *pz TSRMLS_DC)
-{
-	Bucket *p;
-	zend_object_get_gc_t get_gc;
-
-	GC_SET_BLACK(obj->buffered);
-	if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-	             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-		int i, n;
-		zval **table;
-		HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
-
-		for (i = 0; i < n; i++) {
-			if (table[i]) {
-				pz = table[i];
-				if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-					pz->refcount__gc++;
-				}
-				if (GC_ZVAL_GET_COLOR(pz) != GC_BLACK) {
-					zval_scan_black(pz TSRMLS_CC);
-				}
-			}
-		}
-		if (!props) {
-			return;
+	if (!ht) return;
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (!Z_REFCOUNTED(p->val)) continue;
+		ref = Z_COUNTED(p->val);
+		if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+			GC_REFCOUNT(ref)++;
 		}
-		p = props->pListHead;
-		while (p != NULL) {
-			pz = *(zval**)p->pData;
-			if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-				pz->refcount__gc++;
-			}
-			if (GC_ZVAL_GET_COLOR(pz) != GC_BLACK) {
-				zval_scan_black(pz TSRMLS_CC);
+		if (GC_GET_COLOR(GC_INFO(ref)) != GC_BLACK) {
+			if (idx == ht->nNumUsed-1) {
+				goto tail_call;
+			} else {
+				gc_scan_black(ref TSRMLS_CC);
 			}
-			p = p->pListNext;
 		}
 	}
 }
 
-static void zval_mark_grey(zval *pz TSRMLS_DC)
+static void gc_mark_grey(zend_refcounted *ref TSRMLS_DC)
 {
+    HashTable *ht;
+    uint idx;
 	Bucket *p;
 
 tail_call:
-	if (GC_ZVAL_GET_COLOR(pz) != GC_GREY) {
-		p = NULL;
+	if (GC_GET_COLOR(GC_INFO(ref)) != GC_GREY) {
+		ht = NULL;
 		GC_BENCH_INC(zval_marked_grey);
-		GC_ZVAL_SET_COLOR(pz, GC_GREY);
+		GC_SET_COLOR(GC_INFO(ref), GC_GREY);
 
-		if (Z_TYPE_P(pz) == IS_OBJECT && EG(objects_store).object_buckets) {
+		if (GC_TYPE(ref) == IS_OBJECT && EG(objects_store).object_buckets) {
 			zend_object_get_gc_t get_gc;
-			struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
-
-			obj->refcount--;
-			if (GC_GET_COLOR(obj->buffered) != GC_GREY) {
-				GC_BENCH_INC(zobj_marked_grey);
-				GC_SET_COLOR(obj->buffered, GC_GREY);
-				if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-				             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-					int i, n;
-					zval **table;
-					HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
+			zend_object *obj = (zend_object*)ref;
 
-					while (n > 0 && !table[n-1]) n--;
-					for (i = 0; i < n; i++) {
-						if (table[i]) {
-							pz = table[i];
-							if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-								pz->refcount__gc--;
-							}
-							if (!props && i == n - 1) {
-								goto tail_call;
-							} else {
-								zval_mark_grey(pz TSRMLS_CC);
-							}
+			if (EXPECTED(IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle]) &&
+		             (get_gc = obj->handlers->get_gc) != NULL)) {
+				int i, n;
+				zval *table;
+				zval tmp;
+
+				ZVAL_OBJ(&tmp, obj);
+				HashTable *props = get_gc(&tmp, &table, &n TSRMLS_CC);
+
+				while (n > 0 && !Z_REFCOUNTED(table[n-1])) n--;
+				for (i = 0; i < n; i++) {
+					if (Z_REFCOUNTED(table[i])) {
+						ref = Z_COUNTED(table[i]);
+						if (GC_TYPE(ref) != IS_ARRAY || ((zend_array*)ref) != &EG(symbol_table)) {
+							GC_REFCOUNT(ref)--;
+						}
+						if (!props && i == n - 1) {
+							goto tail_call;
+						} else {
+							gc_mark_grey(ref TSRMLS_CC);
 						}
 					}
-					if (!props) {
-						return;
-					}
-					p = props->pListHead;
 				}
+				if (!props) {
+					return;
+				}
+				ht = props;
 			}
-		} else if (Z_TYPE_P(pz) == IS_ARRAY) {
-			if (Z_ARRVAL_P(pz) == &EG(symbol_table)) {
-				GC_ZVAL_SET_BLACK(pz);
+		} else if (GC_TYPE(ref) == IS_ARRAY) {
+			if (((zend_array*)ref) == &EG(symbol_table)) {
+				GC_SET_BLACK(GC_INFO(ref));
 			} else {
-				p = Z_ARRVAL_P(pz)->pListHead;
-			}
-		}
-		while (p != NULL) {
-			pz = *(zval**)p->pData;
-			if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-				pz->refcount__gc--;
+				ht = &((zend_array*)ref)->ht;
 			}
-			if (p->pListNext == NULL) {
+		} else if (GC_TYPE(ref) == IS_REFERENCE) {
+			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
+				if (UNEXPECTED(!EG(objects_store).object_buckets) &&
+				    Z_TYPE(((zend_reference*)ref)->val) == IS_OBJECT) {
+					return;
+				}
+				ref = Z_COUNTED(((zend_reference*)ref)->val);
+				if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+					GC_REFCOUNT(ref)--;
+				}
 				goto tail_call;
-			} else {
-				zval_mark_grey(pz TSRMLS_CC);
 			}
-			p = p->pListNext;
+			return;
 		}
-	}
-}
-
-static void zobj_mark_grey(struct _store_object *obj, zval *pz TSRMLS_DC)
-{
-	Bucket *p;
-	zend_object_get_gc_t get_gc;
-
-	if (GC_GET_COLOR(obj->buffered) != GC_GREY) {
-		GC_BENCH_INC(zobj_marked_grey);
-		GC_SET_COLOR(obj->buffered, GC_GREY);
-		if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-		             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-			int i, n;
-			zval **table;
-			HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
-
-			for (i = 0; i < n; i++) {
-				if (table[i]) {
-					pz = table[i];
-					if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-						pz->refcount__gc--;
-					}
-					zval_mark_grey(pz TSRMLS_CC);
-				}
-			}
-			if (!props) {
-				return;
+		if (!ht) return;
+		for (idx = 0; idx < ht->nNumUsed; idx++) {
+			p = ht->arData + idx;
+			if (!Z_REFCOUNTED(p->val)) continue;
+			ref = Z_COUNTED(p->val);
+			if (GC_TYPE(ref) != IS_ARRAY || ((zend_array*)ref) != &EG(symbol_table)) {
+				GC_REFCOUNT(ref)--;
 			}
-			p = props->pListHead;
-			while (p != NULL) {
-				pz = *(zval**)p->pData;
-				if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-					pz->refcount__gc--;
-				}
-				zval_mark_grey(pz TSRMLS_CC);
-				p = p->pListNext;
+			if (idx == ht->nNumUsed-1) {
+				goto tail_call;
+			} else {
+				gc_mark_grey(ref TSRMLS_CC);
 			}
 		}
 	}
@@ -480,132 +372,82 @@ static void gc_mark_roots(TSRMLS_D)
 	gc_root_buffer *current = GC_G(roots).next;
 
 	while (current != &GC_G(roots)) {
-		if (current->handle) {
-			if (EG(objects_store).object_buckets) {
-				struct _store_object *obj = &EG(objects_store).object_buckets[current->handle].bucket.obj;
-
-				if (GC_GET_COLOR(obj->buffered) == GC_PURPLE) {
-					zval z;
-
-					INIT_PZVAL(&z);
-					Z_OBJ_HANDLE(z) = current->handle;
-					Z_OBJ_HT(z) = current->u.handlers;
-					zobj_mark_grey(obj, &z TSRMLS_CC);
-				} else {
-					GC_SET_ADDRESS(obj->buffered, NULL);
-					GC_REMOVE_FROM_BUFFER(current);
-				}
-			}
-		} else {
-			if (GC_ZVAL_GET_COLOR(current->u.pz) == GC_PURPLE) {
-				zval_mark_grey(current->u.pz TSRMLS_CC);
-			} else {
-				GC_ZVAL_SET_ADDRESS(current->u.pz, NULL);
-				GC_REMOVE_FROM_BUFFER(current);
-			}
+		if (GC_GET_COLOR(GC_INFO(current->ref)) == GC_PURPLE) {
+			gc_mark_grey(current->ref TSRMLS_CC);
 		}
 		current = current->next;
 	}
 }
 
-static void zval_scan(zval *pz TSRMLS_DC)
+static void gc_scan(zend_refcounted *ref TSRMLS_DC)
 {
+    HashTable *ht;
+    uint idx;
 	Bucket *p;
 
 tail_call:	
-	if (GC_ZVAL_GET_COLOR(pz) == GC_GREY) {
-		p = NULL;
-		if (pz->refcount__gc > 0) {
-			zval_scan_black(pz TSRMLS_CC);
+	if (GC_GET_COLOR(GC_INFO(ref)) == GC_GREY) {
+		ht = NULL;
+		if (GC_REFCOUNT(ref) > 0) {
+			gc_scan_black(ref TSRMLS_CC);
 		} else {
-			GC_ZVAL_SET_COLOR(pz, GC_WHITE);
-			if (Z_TYPE_P(pz) == IS_OBJECT && EG(objects_store).object_buckets) {
+			GC_SET_COLOR(GC_INFO(ref), GC_WHITE);
+			if (GC_TYPE(ref) == IS_OBJECT && EG(objects_store).object_buckets) {
 				zend_object_get_gc_t get_gc;
-				struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
-
-				if (GC_GET_COLOR(obj->buffered) == GC_GREY) {
-					if (obj->refcount > 0) {
-						zobj_scan_black(obj, pz TSRMLS_CC);
-					} else {
-						GC_SET_COLOR(obj->buffered, GC_WHITE);
-						if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-						             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-							int i, n;
-							zval **table;
-							HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
-
-							while (n > 0 && !table[n-1]) n--;
-							for (i = 0; i < n; i++) {
-								if (table[i]) {
-									pz = table[i];
-									if (!props && i == n - 1) {
-										goto tail_call;
-									} else {
-										zval_scan(pz TSRMLS_CC);
-									}
-								}
-							}
-							if (!props) {
-								return;
+				zend_object *obj = (zend_object*)ref;
+
+				if (EXPECTED(IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle]) &&
+				             (get_gc = obj->handlers->get_gc) != NULL)) {
+					int i, n;
+					zval *table;
+					zval tmp;
+					HashTable *props;
+					
+					ZVAL_OBJ(&tmp, obj);
+					props = get_gc(&tmp, &table, &n TSRMLS_CC);
+					while (n > 0 && !Z_REFCOUNTED(table[n-1])) n--;
+					for (i = 0; i < n; i++) {
+						if (Z_REFCOUNTED(table[i])) {
+							ref = Z_COUNTED(table[i]);
+							if (!props && i == n - 1) {
+								goto tail_call;
+							} else {
+								gc_scan(ref TSRMLS_CC);
 							}
-							p = props->pListHead;
 						}
 					}
+					if (!props) {
+						return;
+					}
+					ht = props;
 				}
-			} else if (Z_TYPE_P(pz) == IS_ARRAY) {
-				if (Z_ARRVAL_P(pz) == &EG(symbol_table)) {
-					GC_ZVAL_SET_BLACK(pz);
+			} else if (GC_TYPE(ref) == IS_ARRAY) {
+				if ((zend_array*)ref == &EG(symbol_table)) {
+					GC_SET_BLACK(GC_INFO(ref));
 				} else {
-					p = Z_ARRVAL_P(pz)->pListHead;
+					ht = &((zend_array*)ref)->ht;
+				}
+			} else if (GC_TYPE(ref) == IS_REFERENCE) {
+				if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
+					if (UNEXPECTED(!EG(objects_store).object_buckets) &&
+					    Z_TYPE(((zend_reference*)ref)->val) == IS_OBJECT) {
+						return;
+					}
+					ref = Z_COUNTED(((zend_reference*)ref)->val);
+					goto tail_call;
 				}
+				return;
 			}
 		}
-		while (p != NULL) {
-			if (p->pListNext == NULL) {
-				pz = *(zval**)p->pData;
+		if (!ht) return;
+		for (idx = 0; idx < ht->nNumUsed; idx++) {
+			p = ht->arData + idx;
+			if (!Z_REFCOUNTED(p->val)) continue;
+			ref = Z_COUNTED(p->val);
+			if (idx == ht->nNumUsed-1) {
 				goto tail_call;
 			} else {
-				zval_scan(*(zval**)p->pData TSRMLS_CC);
-			}
-			p = p->pListNext;
-		}
-	}
-}
-
-static void zobj_scan(zval *pz TSRMLS_DC)
-{
-	Bucket *p;
-	zend_object_get_gc_t get_gc;
-
-	if (EG(objects_store).object_buckets) {
-		struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
-
-		if (GC_GET_COLOR(obj->buffered) == GC_GREY) {
-			if (obj->refcount > 0) {
-				zobj_scan_black(obj, pz TSRMLS_CC);
-			} else {
-				GC_SET_COLOR(obj->buffered, GC_WHITE);
-				if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-				             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-					int i, n;
-					zval **table;
-					HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
-
-					for (i = 0; i < n; i++) {
-						if (table[i]) {
-							pz = table[i];
-							zval_scan(pz TSRMLS_CC);
-                    	}
-					}
-					if (!props) {
-						return;
-					}
-					p = props->pListHead;
-					while (p != NULL) {
-						zval_scan(*(zval**)p->pData TSRMLS_CC);
-						p = p->pListNext;
-					}
-				}
+				gc_scan(ref TSRMLS_CC);
 			}
 		}
 	}
@@ -616,243 +458,255 @@ static void gc_scan_roots(TSRMLS_D)
 	gc_root_buffer *current = GC_G(roots).next;
 
 	while (current != &GC_G(roots)) {
-		if (current->handle) {
-			zval z;
-
-			INIT_PZVAL(&z);
-			Z_OBJ_HANDLE(z) = current->handle;
-			Z_OBJ_HT(z) = current->u.handlers;
-			zobj_scan(&z TSRMLS_CC);
-		} else {
-			zval_scan(current->u.pz TSRMLS_CC);
-		}
+		gc_scan(current->ref TSRMLS_CC);
 		current = current->next;
 	}
 }
 
-static void zval_collect_white(zval *pz TSRMLS_DC)
+static int gc_collect_white(zend_refcounted *ref TSRMLS_DC)
 {
+	int count = 0;
+	HashTable *ht;
+	uint idx;
 	Bucket *p;
 
 tail_call:
-	if (((zval_gc_info*)(pz))->u.buffered == (gc_root_buffer*)GC_WHITE) {
-		p = NULL;
-		GC_ZVAL_SET_BLACK(pz);
+	if (GC_INFO(ref) == GC_WHITE) {
+		ht = NULL;
+		GC_SET_BLACK(GC_INFO(ref));
 
-		if (Z_TYPE_P(pz) == IS_OBJECT && EG(objects_store).object_buckets) {
-			zend_object_get_gc_t get_gc;
-			struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
-
-			if (obj->buffered == (gc_root_buffer*)GC_WHITE) {
-				/* PURPLE instead of BLACK to prevent buffering in nested gc calls */
-				GC_SET_PURPLE(obj->buffered);
-
-				if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-				             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-					int i, n;
-					zval **table, *zv;
-					HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
+		/* don't count references for compatibilty ??? */
+		if (GC_TYPE(ref) != IS_REFERENCE) {
+			count++;
+		}
 
-					if (!props) {
-						/* restore refcount and put into list to free */
-						pz->refcount__gc++;
-						((zval_gc_info*)pz)->u.next = GC_G(zval_to_free);
-						GC_G(zval_to_free) = (zval_gc_info*)pz;
-					}
+		if (GC_TYPE(ref) == IS_OBJECT && EG(objects_store).object_buckets) {
+			zend_object_get_gc_t get_gc;
+			zend_object *obj = (zend_object*)ref;
 
-					while (n > 0 && !table[n-1]) n--;
-					for (i = 0; i < n; i++) {
-						if (table[i]) {
-							zv = table[i];
-							if (Z_TYPE_P(zv) != IS_ARRAY || Z_ARRVAL_P(zv) != &EG(symbol_table)) {
-								zv->refcount__gc++;
-							}
-							if (!props && i == n - 1) {
-								pz = zv;
-								goto tail_call;
-							} else {
-								zval_collect_white(zv TSRMLS_CC);
-							}
+			if (EXPECTED(IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle]) &&
+			             (get_gc = obj->handlers->get_gc) != NULL)) {
+				int i, n;
+				zval *table;
+				zval tmp;
+				HashTable *props;
+				
+				ZVAL_OBJ(&tmp, obj);
+				props = get_gc(&tmp, &table, &n TSRMLS_CC);
+				while (n > 0 && !Z_REFCOUNTED(table[n-1])) {
+					/* count non-refcounted for compatibilty ??? */
+					if (Z_TYPE(table[n-1]) != IS_UNDEF) {
+						count++;
+					}					
+					n--;
+				}
+				for (i = 0; i < n; i++) {
+					if (Z_REFCOUNTED(table[i])) {
+						ref = Z_COUNTED(table[i]);
+						if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+							GC_REFCOUNT(ref)++;
 						}
-					}
-					if (!props) {
-						return;
-					}
-					p = props->pListHead;
+						if (!props && i == n - 1) {
+							goto tail_call;
+						} else {
+							count += gc_collect_white(ref TSRMLS_CC);
+						}
+					/* count non-refcounted for compatibilty ??? */
+					} else if (Z_TYPE(table[i]) != IS_UNDEF) {
+						count++;
+					}					
+				}
+				if (!props) {
+					return count;
 				}
+				ht = props;
 			}
-		} else {
-			if (Z_TYPE_P(pz) == IS_ARRAY) {
-				p = Z_ARRVAL_P(pz)->pListHead;
+		} else if (GC_TYPE(ref) == IS_ARRAY) {
+			ht = &((zend_array*)ref)->ht;
+		} else if (GC_TYPE(ref) == IS_REFERENCE) {
+			if (Z_REFCOUNTED(((zend_reference*)ref)->val)) {
+				if (UNEXPECTED(!EG(objects_store).object_buckets) &&
+				    Z_TYPE(((zend_reference*)ref)->val) == IS_OBJECT) {
+					return count;
+				}
+				ref = Z_COUNTED(((zend_reference*)ref)->val);
+				if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+					GC_REFCOUNT(ref)++;
+				}
+				goto tail_call;
 			}
+			return count;
 		}
 
-		/* restore refcount and put into list to free */
-		pz->refcount__gc++;
-		((zval_gc_info*)pz)->u.next = GC_G(zval_to_free);
-		GC_G(zval_to_free) = (zval_gc_info*)pz;
-
-		while (p != NULL) {
-			pz = *(zval**)p->pData;
-			if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-				pz->refcount__gc++;
+		if (!ht) return count;
+		for (idx = 0; idx < ht->nNumUsed; idx++) {
+			p = ht->arData + idx;
+			if (!Z_REFCOUNTED(p->val)) {
+				/* count non-refcounted for compatibilty ??? */
+				if (Z_TYPE(p->val) != IS_UNDEF && Z_TYPE(p->val) != IS_INDIRECT) {
+					count++;
+				}
+				continue;
 			}
-			if (p->pListNext == NULL) {
+			ref = Z_COUNTED(p->val);
+			if (GC_TYPE(ref) != IS_ARRAY || (zend_array*)ref != &EG(symbol_table)) {
+				GC_REFCOUNT(ref)++;
+			}
+			if (idx == ht->nNumUsed-1) {
 				goto tail_call;
 			} else {
-				zval_collect_white(pz TSRMLS_CC);
-			}
-			p = p->pListNext;
-		}
-	}
-}
-
-static void zobj_collect_white(zval *pz TSRMLS_DC)
-{
-	Bucket *p;
-
-	if (EG(objects_store).object_buckets) {
-		zend_object_get_gc_t get_gc;
-		struct _store_object *obj = &EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].bucket.obj;
-
-		if (obj->buffered == (gc_root_buffer*)GC_WHITE) {
-			/* PURPLE instead of BLACK to prevent buffering in nested gc calls */
-			GC_SET_PURPLE(obj->buffered);
-
-			if (EXPECTED(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(pz)].valid &&
-			             (get_gc = Z_OBJ_HANDLER_P(pz, get_gc)) != NULL)) {
-				int i, n;
-				zval **table;
-				HashTable *props = get_gc(pz, &table, &n TSRMLS_CC);
-
-				for (i = 0; i < n; i++) {
-					if (table[i]) {
-						pz = table[i];
-						if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-							pz->refcount__gc++;
-						}
-						zval_collect_white(pz TSRMLS_CC);
-					}
-				}
-				if (!props) {
-					return;
-				}
-				p = props->pListHead;
-				while (p != NULL) {
-					pz = *(zval**)p->pData;
-					if (Z_TYPE_P(pz) != IS_ARRAY || Z_ARRVAL_P(pz) != &EG(symbol_table)) {
-						pz->refcount__gc++;
-					}
-					zval_collect_white(pz TSRMLS_CC);
-					p = p->pListNext;
-				}
+				count += gc_collect_white(ref TSRMLS_CC);
 			}
 		}
 	}
+	return count;
 }
 
-static void gc_collect_roots(TSRMLS_D)
+static int gc_collect_roots(TSRMLS_D)
 {
+	int count = 0;
 	gc_root_buffer *current = GC_G(roots).next;
 
 	while (current != &GC_G(roots)) {
-		if (current->handle) {
-			if (EG(objects_store).object_buckets) {
-				struct _store_object *obj = &EG(objects_store).object_buckets[current->handle].bucket.obj;
-				zval z;
-
-				GC_SET_ADDRESS(obj->buffered, NULL);
-				INIT_PZVAL(&z);
-				Z_OBJ_HANDLE(z) = current->handle;
-				Z_OBJ_HT(z) = current->u.handlers;
-				zobj_collect_white(&z TSRMLS_CC);
-			}
+		GC_SET_ADDRESS(GC_INFO(current->ref), 0);
+		if (GC_INFO(current->ref) == GC_WHITE) {
+			count += gc_collect_white(current->ref TSRMLS_CC);
+			GC_SET_ADDRESS(GC_INFO(current->ref), current - GC_G(buf));
 		} else {
-			GC_ZVAL_SET_ADDRESS(current->u.pz, NULL);
-			zval_collect_white(current->u.pz TSRMLS_CC);
+			GC_REMOVE_FROM_ROOTS(current);
 		}
-
-		GC_REMOVE_FROM_BUFFER(current);
 		current = current->next;
 	}
-}
+	/* relink remaining roots into list to free */
+	if (GC_G(roots).next != &GC_G(roots)) {
+		if (GC_G(to_free).next == &GC_G(to_free)) {
+			/* move roots into list to free */
+			GC_G(to_free).next = GC_G(roots).next;
+			GC_G(to_free).prev = GC_G(roots).prev;
+			GC_G(to_free).next->prev = &GC_G(to_free);
+			GC_G(to_free).prev->next = &GC_G(to_free);
+		} else {
+			/* add roots into list to free */
+			GC_G(to_free).prev->next = GC_G(roots).next;
+			GC_G(roots).next->prev = GC_G(to_free).prev;
+			GC_G(roots).prev->next = &GC_G(to_free);
+			GC_G(to_free).prev = GC_G(roots).prev;
+		}
 
-#define FREE_LIST_END ((zval_gc_info*)(~(zend_uintptr_t)GC_COLOR))
+		GC_G(roots).next = &GC_G(roots);
+		GC_G(roots).prev = &GC_G(roots);
+	}
+	return count;
+}
 
 ZEND_API int gc_collect_cycles(TSRMLS_D)
 {
 	int count = 0;
 
 	if (GC_G(roots).next != &GC_G(roots)) {
-		zval_gc_info *p, *q, *orig_free_list, *orig_next_to_free;
+		gc_root_buffer *current, *orig_next_to_free;
+		zend_refcounted *p;
+		gc_root_buffer to_free;
 
 		if (GC_G(gc_active)) {
 			return 0;
 		}
 		GC_G(gc_runs)++;
-		GC_G(zval_to_free) = FREE_LIST_END;
 		GC_G(gc_active) = 1;
 		gc_mark_roots(TSRMLS_C);
 		gc_scan_roots(TSRMLS_C);
-		gc_collect_roots(TSRMLS_C);
+		count = gc_collect_roots(TSRMLS_C);
+		GC_G(gc_active) = 0;
+
+		if (GC_G(to_free).next == &GC_G(to_free)) {
+			/* nothing to free */
+			return 0;
+		}
+
+		/* Copy global to_free list into local list */
+		to_free.next = GC_G(to_free).next;
+		to_free.prev = GC_G(to_free).prev;
+		to_free.next->prev = &to_free;
+		to_free.prev->next = &to_free;
+
+		/* Free global list */
+		GC_G(to_free).next = &GC_G(to_free);
+		GC_G(to_free).prev = &GC_G(to_free);
 
-		orig_free_list = GC_G(free_list);
 		orig_next_to_free = GC_G(next_to_free);
-		p = GC_G(free_list) = GC_G(zval_to_free);
-		GC_G(zval_to_free) = NULL;
-		GC_G(gc_active) = 0;
 
 		/* First call destructors */
-		while (p != FREE_LIST_END) {
-			if (Z_TYPE(p->z) == IS_OBJECT) {
+		current = to_free.next;
+		while (current != &to_free) {
+			p = current->ref;
+			GC_G(next_to_free) = current->next;
+			if (GC_TYPE(p) == IS_OBJECT) {
+				zend_object *obj = (zend_object*)p;
+
 				if (EG(objects_store).object_buckets &&
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].valid &&
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount <= 0 &&
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.dtor &&
-					!EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].destructor_called) {
-
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].destructor_called = 1;
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount++;
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.dtor(EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.object, Z_OBJ_HANDLE(p->z) TSRMLS_CC);
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount--;
+				    IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle]) &&
+					!(GC_FLAGS(obj) & IS_OBJ_DESTRUCTOR_CALLED)) {
+
+					GC_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
+					if (obj->handlers->dtor_obj) {
+						GC_REFCOUNT(obj)++;
+						obj->handlers->dtor_obj(obj TSRMLS_CC);
+						GC_REFCOUNT(obj)--;
+					}
 				}
 			}
-			count++;
-			p = p->u.next;
+			current = GC_G(next_to_free);
 		}
 
 		/* Destroy zvals */
-		p = GC_G(free_list);
-		while (p != FREE_LIST_END) {
-			GC_G(next_to_free) = p->u.next;
-			if (Z_TYPE(p->z) == IS_OBJECT) {
+		current = to_free.next;
+		while (current != &to_free) {
+			p = current->ref;
+			GC_G(next_to_free) = current->next;
+			if (GC_TYPE(p) == IS_OBJECT) {
+				zend_object *obj = (zend_object*)p;
+
 				if (EG(objects_store).object_buckets &&
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].valid &&
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount <= 0) {
-					EG(objects_store).object_buckets[Z_OBJ_HANDLE(p->z)].bucket.obj.refcount = 1;
-					Z_TYPE(p->z) = IS_NULL;
-					zend_objects_store_del_ref_by_handle_ex(Z_OBJ_HANDLE(p->z), Z_OBJ_HT(p->z) TSRMLS_CC);
+				    IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle]) &&
+					!(GC_FLAGS(obj) & IS_OBJ_FREE_CALLED)) {
+
+					GC_FLAGS(obj) |= IS_OBJ_FREE_CALLED;
+					if (obj->handlers->free_obj) {
+						GC_REFCOUNT(obj)++;
+						obj->handlers->free_obj(obj TSRMLS_CC);
+						GC_REFCOUNT(obj)--;
+					}
 				}
-			} else if (Z_TYPE(p->z) == IS_ARRAY) {
-				Z_TYPE(p->z) = IS_NULL;
-				zend_hash_destroy(Z_ARRVAL(p->z));
-				FREE_HASHTABLE(Z_ARRVAL(p->z));
-			} else {
-				zval_dtor(&p->z);
-				Z_TYPE(p->z) = IS_NULL;
+			} else if (GC_TYPE(p) == IS_ARRAY) {
+				zend_array *arr = (zend_array*)p;
+
+				GC_TYPE(arr) = IS_NULL;
+				zend_hash_destroy(&arr->ht);
 			}
-			p = GC_G(next_to_free);
+			current = GC_G(next_to_free);
 		}
 
-		/* Free zvals */
-		p = GC_G(free_list);
-		while (p != FREE_LIST_END) {
-			q = p->u.next;
-			FREE_ZVAL_EX(&p->z);
-			p = q;
+		/* Free objects */
+		current = to_free.next;
+		while (current != &to_free) {
+			p = current->ref;
+			GC_G(next_to_free) = current->next;
+			if (GC_TYPE(p) == IS_OBJECT) {
+				zend_object *obj = (zend_object*)p;
+
+				if (EG(objects_store).object_buckets &&
+				    IS_OBJ_VALID(EG(objects_store).object_buckets[obj->handle])) {
+
+					zend_objects_store_free(obj TSRMLS_CC);
+				}
+			} else {
+				GC_REMOVE_FROM_BUFFER(p);
+				efree(p);
+			}
+			current = GC_G(next_to_free);
 		}
+
 		GC_G(collected) += count;
-		GC_G(free_list) = orig_free_list;
 		GC_G(next_to_free) = orig_next_to_free;
 	}
 
diff --git a/Zend/zend_gc.h b/Zend/zend_gc.h
index ac5f6350a2..d060fae9dd 100644
--- a/Zend/zend_gc.h
+++ b/Zend/zend_gc.h
@@ -40,62 +40,45 @@
 # define GC_BENCH_PEAK(peak, counter)
 #endif
 
-#define GC_COLOR  0x03
+#define GC_COLOR  0xc000
 
-#define GC_BLACK  0x00
-#define GC_WHITE  0x01
-#define GC_GREY   0x02
-#define GC_PURPLE 0x03
+#define GC_BLACK  0x0000
+#define GC_WHITE  0x8000
+#define GC_GREY   0x4000
+#define GC_PURPLE 0xc000
 
 #define GC_ADDRESS(v) \
-	((gc_root_buffer*)(((zend_uintptr_t)(v)) & ~GC_COLOR))
+	((v) & ~GC_COLOR)
 #define GC_SET_ADDRESS(v, a) \
-	(v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & GC_COLOR) | ((zend_uintptr_t)(a))))
+	do {(v) = ((v) & GC_COLOR) | (a);} while (0)
 #define GC_GET_COLOR(v) \
 	(((zend_uintptr_t)(v)) & GC_COLOR)
 #define GC_SET_COLOR(v, c) \
-	(v) = ((gc_root_buffer*)((((zend_uintptr_t)(v)) & ~GC_COLOR) | (c)))
+	do {(v) = ((v) & ~GC_COLOR) | (c);} while (0)
 #define GC_SET_BLACK(v) \
-	(v) = ((gc_root_buffer*)(((zend_uintptr_t)(v)) & ~GC_COLOR))
+	do {(v) = (v) & ~GC_COLOR;} while (0)
 #define GC_SET_PURPLE(v) \
-	(v) = ((gc_root_buffer*)(((zend_uintptr_t)(v)) | GC_PURPLE))
+	do {(v) = (v) | GC_COLOR;} while (0)
 
-#define GC_ZVAL_INIT(z) \
-	((zval_gc_info*)(z))->u.buffered = NULL
 #define GC_ZVAL_ADDRESS(v) \
-	GC_ADDRESS(((zval_gc_info*)(v))->u.buffered)
+	GC_ADDRESS(Z_GC_INFO_P(v))
 #define GC_ZVAL_SET_ADDRESS(v, a) \
-	GC_SET_ADDRESS(((zval_gc_info*)(v))->u.buffered, (a))
+	GC_SET_ADDRESS(Z_GC_INFO_P(v), (a))
 #define GC_ZVAL_GET_COLOR(v) \
-	GC_GET_COLOR(((zval_gc_info*)(v))->u.buffered)
+	GC_GET_COLOR(Z_GC_INFO_P(v))
 #define GC_ZVAL_SET_COLOR(v, c) \
-	GC_SET_COLOR(((zval_gc_info*)(v))->u.buffered, (c))
+	GC_SET_COLOR(Z_GC_INFO_P(v), (c))
 #define GC_ZVAL_SET_BLACK(v) \
-	GC_SET_BLACK(((zval_gc_info*)(v))->u.buffered)
+	GC_SET_BLACK(Z_GC_INFO_P(v))
 #define GC_ZVAL_SET_PURPLE(v) \
-	GC_SET_PURPLE(((zval_gc_info*)(v))->u.buffered)
-
-#define GC_OBJ_INIT(z) \
-	(z)->buffered = NULL
+	GC_SET_PURPLE(Z_GC_INFO_P(v))
 
 typedef struct _gc_root_buffer {
 	struct _gc_root_buffer   *prev;		/* double-linked list               */
 	struct _gc_root_buffer   *next;
-	zend_object_handle        handle;	/* must be 0 for zval               */
-	union {
-		zval                 *pz;
-		const zend_object_handlers *handlers;
-	} u;
+	zend_refcounted          *ref;
 } gc_root_buffer;
 
-typedef struct _zval_gc_info {
-	zval z;
-	union {
-		gc_root_buffer       *buffered;
-		struct _zval_gc_info *next;
-	} u;
-} zval_gc_info;
-
 typedef struct _zend_gc_globals {
 	zend_bool         gc_enabled;
 	zend_bool         gc_active;
@@ -106,9 +89,8 @@ typedef struct _zend_gc_globals {
 	gc_root_buffer   *first_unused;		/* pointer to first unused buffer   */
 	gc_root_buffer   *last_unused;		/* pointer to last unused buffer    */
 
-	zval_gc_info     *zval_to_free;		/* temporary list of zvals to free */
-	zval_gc_info     *free_list;
-	zval_gc_info     *next_to_free;
+	gc_root_buffer    to_free;			/* list to free                     */
+	gc_root_buffer   *next_to_free;
 
 	zend_uint gc_runs;
 	zend_uint collected;
@@ -117,13 +99,9 @@ typedef struct _zend_gc_globals {
 	zend_uint root_buf_length;
 	zend_uint root_buf_peak;
 	zend_uint zval_possible_root;
-	zend_uint zobj_possible_root;
 	zend_uint zval_buffered;
-	zend_uint zobj_buffered;
 	zend_uint zval_remove_from_buffer;
-	zend_uint zobj_remove_from_buffer;
 	zend_uint zval_marked_grey;
-	zend_uint zobj_marked_grey;
 #endif
 
 } zend_gc_globals;
@@ -140,9 +118,8 @@ extern ZEND_API zend_gc_globals gc_globals;
 
 BEGIN_EXTERN_C()
 ZEND_API int  gc_collect_cycles(TSRMLS_D);
-ZEND_API void gc_zval_possible_root(zval *zv TSRMLS_DC);
-ZEND_API void gc_zobj_possible_root(zval *zv TSRMLS_DC);
-ZEND_API void gc_remove_zval_from_buffer(zval *zv TSRMLS_DC);
+ZEND_API void gc_possible_root(zend_refcounted *ref TSRMLS_DC);
+ZEND_API void gc_remove_from_buffer(zend_refcounted *ref TSRMLS_DC);
 ZEND_API void gc_globals_ctor(TSRMLS_D);
 ZEND_API void gc_globals_dtor(TSRMLS_D);
 ZEND_API void gc_init(TSRMLS_D);
@@ -150,90 +127,23 @@ ZEND_API void gc_reset(TSRMLS_D);
 END_EXTERN_C()
 
 #define GC_ZVAL_CHECK_POSSIBLE_ROOT(z) \
-	gc_zval_check_possible_root((z) TSRMLS_CC)
-
-#define GC_REMOVE_FROM_BUFFER(current) \
-	gc_remove_from_buffer((current) TSRMLS_CC)
+	gc_check_possible_root((z) TSRMLS_CC)
 
-#define GC_REMOVE_ZVAL_FROM_BUFFER(z)					\
-	if (GC_ADDRESS(((zval_gc_info*)z)->u.buffered)) {	\
-		gc_remove_zval_from_buffer(z TSRMLS_CC);		\
-	}
-
-#define GC_ZOBJ_CHECK_POSSIBLE_ROOT(zobject)									\
-	do {																		\
-		if (EXPECTED(EG(objects_store).object_buckets != NULL) &&				\
-		    EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zobject)].valid) {	\
-			gc_zobj_possible_root(zobject TSRMLS_CC);							\
-		}																		\
+#define GC_REMOVE_FROM_BUFFER(p) do { \
+		zend_refcounted *_p = (zend_refcounted*)(p); \
+		if (GC_ADDRESS(GC_INFO(_p))) { \
+			gc_remove_from_buffer(_p TSRMLS_CC); \
+		} \
 	} while (0)
 
-#define GC_REMOVE_ZOBJ_FROM_BUFFER(obj)									\
-	do {																\
-		if (GC_ADDRESS((obj)->buffered) && !GC_G(gc_active)) {			\
-			GC_BENCH_INC(zobj_remove_from_buffer);						\
-			GC_REMOVE_FROM_BUFFER(GC_ADDRESS((obj)->buffered));			\
-			(obj)->buffered = NULL;										\
-		}																\
-	} while (0)
-
-static zend_always_inline void gc_zval_check_possible_root(zval *z TSRMLS_DC)
+static zend_always_inline void gc_check_possible_root(zval *z TSRMLS_DC)
 {
-	if (z->type == IS_ARRAY || z->type == IS_OBJECT) {
-		gc_zval_possible_root(z TSRMLS_CC);
+	ZVAL_DEREF(z);
+	if (Z_COLLECTABLE_P(z) && UNEXPECTED(!Z_GC_INFO_P(z))) {
+		gc_possible_root(Z_COUNTED_P(z) TSRMLS_CC);
 	}
 }
 
-static zend_always_inline void gc_remove_from_buffer(gc_root_buffer *root TSRMLS_DC)
-{
-	root->next->prev = root->prev;
-	root->prev->next = root->next;
-	root->prev = GC_G(unused);
-	GC_G(unused) = root;
-	GC_BENCH_DEC(root_buf_length);
-}
-
-#define ALLOC_PERMANENT_ZVAL(z)							\
-	do {												\
-		(z) = (zval*)malloc(sizeof(zval_gc_info));		\
-		GC_ZVAL_INIT(z);								\
-	} while (0)
-
-/* The following macros override macros from zend_alloc.h */
-#undef  ALLOC_ZVAL
-#define ALLOC_ZVAL(z) 									\
-	do {												\
-		(z) = (zval*)emalloc(sizeof(zval_gc_info));		\
-		GC_ZVAL_INIT(z);								\
-	} while (0)
-
-#undef  FREE_ZVAL
-#define FREE_ZVAL(z) 									\
-	do {												\
-	    GC_REMOVE_ZVAL_FROM_BUFFER(z);					\
-		efree(z);										\
-	} while (0)
-
-#undef  ALLOC_ZVAL_REL
-#define ALLOC_ZVAL_REL(z)								\
-	do {												\
-		(z) = (zval*)emalloc_rel(sizeof(zval_gc_info));	\
-		GC_ZVAL_INIT(z);								\
-	} while (0)
-
-#undef  FREE_ZVAL_REL
-#define FREE_ZVAL_REL(z)								\
-	do {												\
-	    GC_REMOVE_ZVAL_FROM_BUFFER(z);					\
-		efree_rel(z);									\
-	} while (0)
-
-#define FREE_ZVAL_EX(z)									\
-	efree(z)
-
-#define FREE_ZVAL_REL_EX(z)								\
-	efree_rel(z)
-
 #endif /* ZEND_GC_H */
 
 /*
diff --git a/Zend/zend_generators.c b/Zend/zend_generators.c
index 7d7c330710..0f19e84041 100644
--- a/Zend/zend_generators.c
+++ b/Zend/zend_generators.c
@@ -27,7 +27,7 @@
 ZEND_API zend_class_entry *zend_ce_generator;
 static zend_object_handlers zend_generator_handlers;
 
-static zend_object_value zend_generator_create(zend_class_entry *class_type TSRMLS_DC);
+static zend_object *zend_generator_create(zend_class_entry *class_type TSRMLS_DC);
 
 static void zend_generator_cleanup_unfinished_execution(zend_generator *generator TSRMLS_DC) /* {{{ */
 {
@@ -35,7 +35,7 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 	zend_op_array *op_array = execute_data->op_array;
 
 	if (generator->send_target) {
-		Z_DELREF_PP(generator->send_target);
+		if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
 		generator->send_target = NULL;
 	}
 
@@ -60,14 +60,14 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 				switch (brk_opline->opcode) {
 					case ZEND_SWITCH_FREE:
 						{
-							temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
-							zval_ptr_dtor(&var->var.ptr);
+							zval *var = EX_VAR_2(execute_data, brk_opline->op1.var);
+							zval_ptr_dtor(var);
 						}
 						break;
 					case ZEND_FREE:
 						{
-							temp_variable *var = EX_TMP_VAR(execute_data, brk_opline->op1.var);
-							zval_dtor(&var->tmp_var);
+							zval *var = EX_VAR_2(execute_data, brk_opline->op1.var);
+							zval_dtor(var);
 						}
 						break;
 				}
@@ -77,11 +77,11 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 
 	/* Clear any backed up stack arguments */
 	{
-		void **ptr = generator->stack->top - 1;
-		void **end = zend_vm_stack_frame_base(execute_data);
+		zval *ptr = generator->stack->top - 1;
+		zval *end = zend_vm_stack_frame_base(execute_data);
 
 		for (; ptr >= end; --ptr) {
-			zval_ptr_dtor((zval **) ptr);
+			zval_ptr_dtor((zval*) ptr);
 		}
 	}
 
@@ -89,7 +89,7 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 	 * method calls those objects need to be freed */
 	while (execute_data->call >= execute_data->call_slots) {
 		if (execute_data->call->object) {
-			zval_ptr_dtor(&execute_data->call->object);
+			OBJ_RELEASE(execute_data->call->object);
 		}
 		execute_data->call--;
 	}
@@ -98,14 +98,14 @@ static void zend_generator_cleanup_unfinished_execution(zend_generator *generato
 
 ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished_execution TSRMLS_DC) /* {{{ */
 {
-	if (generator->value) {
+	if (Z_TYPE(generator->value) != IS_UNDEF) {
 		zval_ptr_dtor(&generator->value);
-		generator->value = NULL;
+		ZVAL_UNDEF(&generator->value);
 	}
 
-	if (generator->key) {
+	if (Z_TYPE(generator->key) != IS_UNDEF) {
 		zval_ptr_dtor(&generator->key);
-		generator->key = NULL;
+		ZVAL_UNDEF(&generator->key);
 	}
 
 	if (generator->execute_data) {
@@ -118,8 +118,8 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 			zend_clean_and_cache_symbol_table(execute_data->symbol_table TSRMLS_CC);
 		}
 
-		if (execute_data->current_this) {
-			zval_ptr_dtor(&execute_data->current_this);
+		if (execute_data->object) {
+			OBJ_RELEASE(execute_data->object);
 		}
 
 		/* A fatal error / die occurred during the generator execution. Trying to clean
@@ -133,11 +133,11 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 		 * generator (for func_get_args) so those have to be freed too. */
 		{
 			zend_execute_data *prev_execute_data = execute_data->prev_execute_data;
-			void **arguments = prev_execute_data->function_state.arguments;
+			zval *arguments = prev_execute_data->function_state.arguments;
 
 			if (arguments) {
-				int arguments_count = (int) (zend_uintptr_t) *arguments;
-				zval **arguments_start = (zval **) (arguments - arguments_count);
+				int arguments_count = Z_LVAL_P(arguments);
+				zval *arguments_start = arguments - arguments_count;
 				int i;
 
 				for (i = 0; i < arguments_count; ++i) {
@@ -164,8 +164,9 @@ ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished
 }
 /* }}} */
 
-static void zend_generator_dtor_storage(zend_generator *generator, zend_object_handle handle TSRMLS_DC) /* {{{ */
+static void zend_generator_dtor_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
+	zend_generator *generator = (zend_generator*) object;
 	zend_execute_data *ex = generator->execute_data;
 	zend_uint op_num, finally_op_num;
 	int i;
@@ -203,19 +204,23 @@ static void zend_generator_dtor_storage(zend_generator *generator, zend_object_h
 }
 /* }}} */
 
-static void zend_generator_free_storage(zend_generator *generator TSRMLS_DC) /* {{{ */
+static void zend_generator_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
+	zend_generator *generator = (zend_generator*) object;
+
 	zend_generator_close(generator, 0 TSRMLS_CC);
 
 	zend_object_std_dtor(&generator->std TSRMLS_CC);
-	efree(generator);
+
+	if (generator->iterator) {
+		zend_iterator_dtor(generator->iterator TSRMLS_CC);
+	}
 }
 /* }}} */
 
-static zend_object_value zend_generator_create(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *zend_generator_create(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
 	zend_generator *generator;
-	zend_object_value object;
 
 	generator = emalloc(sizeof(zend_generator));
 	memset(generator, 0, sizeof(zend_generator));
@@ -224,37 +229,30 @@ static zend_object_value zend_generator_create(zend_class_entry *class_type TSRM
 	generator->largest_used_integer_key = -1;
 
 	zend_object_std_init(&generator->std, class_type TSRMLS_CC);
+	generator->std.handlers = &zend_generator_handlers;
 
-	object.handle = zend_objects_store_put(generator,
-		(zend_objects_store_dtor_t)          zend_generator_dtor_storage,
-		(zend_objects_free_object_storage_t) zend_generator_free_storage,
-		NULL TSRMLS_CC
-	);
-	object.handlers = &zend_generator_handlers;
-
-	return object;
+	return (zend_object*)generator;
 }
 /* }}} */
 
-static void copy_closure_static_var(zval **var TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
+static void copy_closure_static_var(zval *var TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
 {
 	HashTable *target = va_arg(args, HashTable *);
 
 	SEPARATE_ZVAL_TO_MAKE_IS_REF(var);
-	Z_ADDREF_PP(var);
-	zend_hash_quick_update(target, key->arKey, key->nKeyLength, key->h, var, sizeof(zval *), NULL);
+	Z_ADDREF_P(var);
+	zend_hash_update(target, key->key, var);
 }
 /* }}} */
 
 /* Requires globals EG(scope), EG(current_scope), EG(This),
  * EG(active_symbol_table) and EG(current_execute_data). */
-ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC) /* {{{ */
+ZEND_API void zend_generator_create_zval(zend_op_array *op_array, zval *return_value TSRMLS_DC) /* {{{ */
 {
-	zval *return_value;
 	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);
 
@@ -289,35 +287,30 @@ ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC) /*
 	opline_ptr = EG(opline_ptr);
 	current_symbol_table = EG(active_symbol_table);
 	EG(active_symbol_table) = NULL;
-	execute_data = zend_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC);
+	execute_data = zend_create_execute_data_from_op_array(op_array, return_value, VM_FRAME_TOP_FUNCTION TSRMLS_CC);
 	EG(active_symbol_table) = current_symbol_table;
 	EG(current_execute_data) = current_execute_data;
 	EG(opline_ptr) = opline_ptr;
 
-	ALLOC_INIT_ZVAL(return_value);
 	object_init_ex(return_value, zend_ce_generator);
 
-	if (EG(This)) {
-		Z_ADDREF_P(EG(This));
+	if (Z_OBJ(EG(This))) {
+		Z_ADDREF(EG(This));
 	}
 
-	/* Back up executor globals. */
-	execute_data->current_scope = EG(scope);
-	execute_data->current_called_scope = EG(called_scope);
-	execute_data->symbol_table = EG(active_symbol_table);
-	execute_data->current_this = EG(This);
-
 	/* Save execution context in generator object. */
-	generator = (zend_generator *) zend_object_store_get_object(return_value TSRMLS_CC);
+	execute_data->prev_execute_data->object = Z_OBJ_P(return_value);
+	generator = (zend_generator *) Z_OBJ_P(return_value);
 	generator->execute_data = execute_data;
 	generator->stack = EG(argument_stack);
 	EG(argument_stack) = current_stack;
 
-	return return_value;
+	/* EX(return_value) keeps pointer to zend_object (not a real zval) */
+	execute_data->return_value = (zval*)generator;
 }
 /* }}} */
 
-static zend_function *zend_generator_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+static zend_function *zend_generator_get_constructor(zend_object *object TSRMLS_DC) /* {{{ */
 {
 	zend_error(E_RECOVERABLE_ERROR, "The \"Generator\" class is reserved for internal use and cannot be manually instantiated");
 
@@ -341,28 +334,25 @@ ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{
 
 	{
 		/* Backup executor globals */
-		zval **original_return_value_ptr_ptr = EG(return_value_ptr_ptr);
 		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);
-		zval *original_This = EG(This);
+		zend_array *original_active_symbol_table = EG(active_symbol_table);
+		zend_object *original_This;
 		zend_class_entry *original_scope = EG(scope);
 		zend_class_entry *original_called_scope = EG(called_scope);
 		zend_vm_stack original_stack = EG(argument_stack);
 
-		/* We (mis)use the return_value_ptr_ptr to provide the generator object
-		 * to the executor, so YIELD will be able to set the yielded value */
-		EG(return_value_ptr_ptr) = (zval **) generator;
+		original_This = Z_OBJ(EG(This));
 
 		/* Set executor globals */
 		EG(current_execute_data) = generator->execute_data;
 		EG(opline_ptr) = &generator->execute_data->opline;
 		EG(active_op_array) = generator->execute_data->op_array;
 		EG(active_symbol_table) = generator->execute_data->symbol_table;
-		EG(This) = generator->execute_data->current_this;
-		EG(scope) = generator->execute_data->current_scope;
-		EG(called_scope) = generator->execute_data->current_called_scope;
+		Z_OBJ(EG(This)) = generator->execute_data->object;
+		EG(scope) = generator->execute_data->scope;
+		EG(called_scope) = generator->execute_data->called_scope;
 		EG(argument_stack) = generator->stack;
 
 		/* We want the backtrace to look as if the generator function was
@@ -379,12 +369,11 @@ ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{
 		generator->flags &= ~ZEND_GENERATOR_CURRENTLY_RUNNING;
 
 		/* Restore executor globals */
-		EG(return_value_ptr_ptr) = original_return_value_ptr_ptr;
 		EG(current_execute_data) = original_execute_data;
 		EG(opline_ptr) = original_opline_ptr;
 		EG(active_op_array) = original_active_op_array;
 		EG(active_symbol_table) = original_active_symbol_table;
-		EG(This) = original_This;
+		Z_OBJ(EG(This)) = original_This;
 		EG(scope) = original_scope;
 		EG(called_scope) = original_called_scope;
 		EG(argument_stack) = original_stack;
@@ -400,7 +389,7 @@ ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC) /* {{{
 
 static void zend_generator_ensure_initialized(zend_generator *generator TSRMLS_DC) /* {{{ */
 {
-	if (generator->execute_data && !generator->value) {
+	if (generator->execute_data && Z_TYPE(generator->value) == IS_UNDEF) {
 		zend_generator_resume(generator TSRMLS_CC);
 		generator->flags |= ZEND_GENERATOR_AT_FIRST_YIELD;
 	}
@@ -427,7 +416,7 @@ ZEND_METHOD(Generator, rewind)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_rewind(generator TSRMLS_CC);
 }
@@ -443,11 +432,11 @@ ZEND_METHOD(Generator, valid)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	RETURN_BOOL(generator->value != NULL);
+	RETURN_BOOL(Z_TYPE(generator->value) != IS_UNDEF);
 }
 /* }}} */
 
@@ -461,12 +450,12 @@ ZEND_METHOD(Generator, current)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->value) {
-		RETURN_ZVAL_FAST(generator->value);
+	if (Z_TYPE(generator->value) != IS_UNDEF) {
+		RETURN_ZVAL_FAST(&generator->value);
 	}
 }
 /* }}} */
@@ -481,12 +470,12 @@ ZEND_METHOD(Generator, key)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->key) {
-		RETURN_ZVAL_FAST(generator->key);
+	if (Z_TYPE(generator->key) != IS_UNDEF) {
+		RETURN_ZVAL_FAST(&generator->key);
 	}
 }
 /* }}} */
@@ -501,7 +490,7 @@ ZEND_METHOD(Generator, next)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
@@ -520,7 +509,7 @@ ZEND_METHOD(Generator, send)
 		return;
 	}
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC); 
 
@@ -531,15 +520,14 @@ ZEND_METHOD(Generator, send)
 
 	/* Put sent value in the target VAR slot, if it is used */
 	if (generator->send_target) {
-		Z_DELREF_PP(generator->send_target);
-		Z_ADDREF_P(value);
-		*generator->send_target = value;
+		if (Z_REFCOUNTED_P(generator->send_target)) Z_DELREF_P(generator->send_target);
+		ZVAL_COPY(generator->send_target, value);
 	}
 
 	zend_generator_resume(generator TSRMLS_CC);
 
-	if (generator->value) {
-		RETURN_ZVAL_FAST(generator->value);
+	if (Z_TYPE(generator->value) != IS_UNDEF) {
+		RETURN_ZVAL_FAST(&generator->value);
 	}
 }
 /* }}} */
@@ -548,17 +536,16 @@ ZEND_METHOD(Generator, send)
  * Throws an exception into the generator */
 ZEND_METHOD(Generator, throw)
 {
-	zval *exception, *exception_copy;
+	zval *exception, exception_copy;
 	zend_generator *generator;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &exception) == FAILURE) {
 		return;
 	}
 
-	ALLOC_ZVAL(exception_copy);
-	MAKE_COPY_ZVAL(&exception, exception_copy);
+	ZVAL_DUP(&exception_copy, exception);
 
-	generator = (zend_generator *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	generator = (zend_generator *) Z_OBJ_P(getThis());
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC); 
 
@@ -567,19 +554,19 @@ ZEND_METHOD(Generator, throw)
 		zend_execute_data *current_execute_data = EG(current_execute_data);
 		EG(current_execute_data) = generator->execute_data;
 
-		zend_throw_exception_object(exception_copy TSRMLS_CC);
+		zend_throw_exception_object(&exception_copy TSRMLS_CC);
 
 		EG(current_execute_data) = current_execute_data;
 
 		zend_generator_resume(generator TSRMLS_CC);
 
-		if (generator->value) {
-			RETURN_ZVAL_FAST(generator->value);
+		if (Z_TYPE(generator->value) != IS_UNDEF) {
+			RETURN_ZVAL_FAST(&generator->value);
 		}
 	} else {
 		/* If the generator is already closed throw the exception in the
 		 * current context */
-		zend_throw_exception_object(exception_copy TSRMLS_CC);
+		zend_throw_exception_object(&exception_copy TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -604,44 +591,41 @@ ZEND_METHOD(Generator, __wakeup)
 
 static void zend_generator_iterator_dtor(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zval *object = ((zend_generator_iterator *) iterator)->object;
-
-	zval_ptr_dtor(&object);
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
+	generator->iterator = NULL;
+	zval_ptr_dtor(&iterator->data);
+	zend_iterator_dtor(iterator TSRMLS_CC);
 }
 /* }}} */
 
 static int zend_generator_iterator_valid(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	return generator->value != NULL ? SUCCESS : FAILURE;
+	return Z_TYPE(generator->value) != IS_UNDEF ? SUCCESS : FAILURE;
 }
 /* }}} */
 
-static void zend_generator_iterator_get_data(zend_object_iterator *iterator, zval ***data TSRMLS_DC) /* {{{ */
+static zval *zend_generator_iterator_get_data(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->value) {
-		*data = &generator->value;
-	} else {
-		*data = NULL;
-	}
+	return &generator->value;
 }
 /* }}} */
 
 static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval *key TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
-	if (generator->key) {
-		ZVAL_ZVAL(key, generator->key, 1, 0);
+	if (Z_TYPE(generator->key) != IS_UNDEF) {
+		ZVAL_ZVAL(key, &generator->key, 1, 0);
 	} else {
 		ZVAL_NULL(key);
 	}
@@ -650,7 +634,7 @@ static void zend_generator_iterator_get_key(zend_object_iterator *iterator, zval
 
 static void zend_generator_iterator_move_forward(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_ensure_initialized(generator TSRMLS_CC);
 
@@ -660,7 +644,7 @@ static void zend_generator_iterator_move_forward(zend_object_iterator *iterator
 
 static void zend_generator_iterator_rewind(zend_object_iterator *iterator TSRMLS_DC) /* {{{ */
 {
-	zend_generator *generator = (zend_generator *) iterator->data;
+	zend_generator *generator = (zend_generator*)Z_OBJ(iterator->data);
 
 	zend_generator_rewind(generator TSRMLS_CC);
 }
@@ -677,10 +661,8 @@ static zend_object_iterator_funcs zend_generator_iterator_functions = {
 
 zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
-	zend_generator_iterator *iterator;
-	zend_generator *generator;
-
-	generator = (zend_generator *) zend_object_store_get_object(object TSRMLS_CC);
+	zend_object_iterator *iterator;
+	zend_generator *generator = (zend_generator*)Z_OBJ_P(object);
 
 	if (!generator->execute_data) {
 		zend_throw_exception(NULL, "Cannot traverse an already closed generator", 0 TSRMLS_CC);
@@ -692,16 +674,14 @@ zend_object_iterator *zend_generator_get_iterator(zend_class_entry *ce, zval *ob
 		return NULL;
 	}
 
-	iterator = &generator->iterator;
-	iterator->intern.funcs = &zend_generator_iterator_functions;
-	iterator->intern.data = (void *) generator;
+	iterator = generator->iterator = emalloc(sizeof(zend_object_iterator));
+	
+	zend_iterator_init(iterator TSRMLS_CC);
 
-	/* We have to keep a reference to the generator object zval around,
-	 * otherwise the generator may be destroyed during iteration. */
-	Z_ADDREF_P(object);
-	iterator->object = object;
+	iterator->funcs = &zend_generator_iterator_functions;
+	ZVAL_COPY(&iterator->data, object);
 
-	return (zend_object_iterator *) iterator;
+	return iterator;
 }
 /* }}} */
 
@@ -745,8 +725,10 @@ void zend_register_generator_ce(TSRMLS_D) /* {{{ */
 	zend_ce_generator->iterator_funcs.funcs = &zend_generator_iterator_functions;
 
 	memcpy(&zend_generator_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-	zend_generator_handlers.get_constructor = zend_generator_get_constructor;
+	zend_generator_handlers.free_obj = zend_generator_free_storage;
+	zend_generator_handlers.dtor_obj = zend_generator_dtor_storage;
 	zend_generator_handlers.clone_obj = NULL;
+	zend_generator_handlers.get_constructor = zend_generator_get_constructor;
 }
 /* }}} */
 
diff --git a/Zend/zend_generators.h b/Zend/zend_generators.h
index 2373a1a7c8..999ead4b6e 100644
--- a/Zend/zend_generators.h
+++ b/Zend/zend_generators.h
@@ -25,18 +25,10 @@ BEGIN_EXTERN_C()
 
 extern ZEND_API zend_class_entry *zend_ce_generator;
 
-typedef struct _zend_generator_iterator {
-	zend_object_iterator intern;
-
-	/* The generator object zval has to be stored, because the iterator is
-	 * holding a ref to it, which has to be dtored. */
-	zval *object;
-} zend_generator_iterator;
-
 typedef struct _zend_generator {
 	zend_object std;
 
-	zend_generator_iterator iterator;
+	zend_object_iterator *iterator;
 
 	/* The suspended execution context. */
 	zend_execute_data *execute_data;
@@ -45,11 +37,11 @@ typedef struct _zend_generator {
 	zend_vm_stack stack;
 
 	/* Current value */
-	zval *value;
+	zval value;
 	/* Current key */
-	zval *key;
+	zval key;
 	/* Variable to put sent value into */
-	zval **send_target;
+	zval *send_target;
 	/* Largest used integer key for auto-incrementing keys */
 	long largest_used_integer_key;
 
@@ -62,7 +54,7 @@ static const zend_uchar ZEND_GENERATOR_FORCED_CLOSE      = 0x2;
 static const zend_uchar ZEND_GENERATOR_AT_FIRST_YIELD    = 0x4;
 
 void zend_register_generator_ce(TSRMLS_D);
-ZEND_API zval *zend_generator_create_zval(zend_op_array *op_array TSRMLS_DC);
+ZEND_API void zend_generator_create_zval(zend_op_array *op_array, zval *return_value TSRMLS_DC);
 ZEND_API void zend_generator_close(zend_generator *generator, zend_bool finished_execution TSRMLS_DC);
 ZEND_API void zend_generator_resume(zend_generator *generator TSRMLS_DC);
 
diff --git a/Zend/zend_globals.h b/Zend/zend_globals.h
index 31dd9af619..2a29e337de 100644
--- a/Zend/zend_globals.h
+++ b/Zend/zend_globals.h
@@ -85,7 +85,7 @@ struct _zend_compiler_globals {
 
 	zend_stack function_call_stack;
 
-	char *compiled_filename;
+	zend_string *compiled_filename;
 
 	int zend_lineno;
 
@@ -124,12 +124,11 @@ struct _zend_compiler_globals {
 
 	zend_uint access_type;
 
-	char *doc_comment;
-	zend_uint doc_comment_len;
+	zend_string *doc_comment;
 
 	zend_uint compiler_options; /* set of ZEND_COMPILE_* constants */
 
-	zval      *current_namespace;
+	zval       current_namespace;
 	HashTable *current_import;
 	HashTable *current_import_function;
 	HashTable *current_import_const;
@@ -141,14 +140,8 @@ struct _zend_compiler_globals {
 	zend_compiler_context context;
 	zend_stack context_stack;
 
-	/* interned strings */
-	char *interned_strings_start;
-	char *interned_strings_end;
-	char *interned_strings_top;
-	char *interned_strings_snapshot_top;
-#ifndef ZTS
-	char *interned_empty_string;
-#endif
+	zend_string *empty_string;
+	zend_string *one_char_string[256];
 
 	HashTable interned_strings;
 
@@ -159,30 +152,25 @@ struct _zend_compiler_globals {
 	zend_bool encoding_declared;
 
 #ifdef ZTS
-	zval ***static_members_table;
+	zval **static_members_table;
 	int last_static_member;
 #endif
 };
 
 
 struct _zend_executor_globals {
-	zval **return_value_ptr_ptr;
-
 	zval uninitialized_zval;
-	zval *uninitialized_zval_ptr;
-
 	zval error_zval;
-	zval *error_zval_ptr;
 
 	/* 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;
-	HashTable symbol_table;		/* main symbol table */
+	zend_array *active_symbol_table;
+	zend_array symbol_table;		/* main symbol table */
 
 	HashTable included_files;	/* files already included */
 
@@ -201,7 +189,7 @@ struct _zend_executor_globals {
 	zend_class_entry *scope;
 	zend_class_entry *called_scope; /* Scope of the calling class */
 
-	zval *This;
+	zval This;
 
 	long precision;
 
@@ -226,11 +214,11 @@ struct _zend_executor_globals {
 	zend_vm_stack argument_stack;
 
 	int user_error_handler_error_reporting;
-	zval *user_error_handler;
-	zval *user_exception_handler;
+	zval user_error_handler;
+	zval user_exception_handler;
 	zend_stack user_error_handlers_error_reporting;
-	zend_ptr_stack user_error_handlers;
-	zend_ptr_stack user_exception_handlers;
+	zend_stack user_error_handlers;
+	zend_stack user_exception_handlers;
 
 	zend_error_handling_t  error_handling;
 	zend_class_entry      *exception_class;
@@ -245,7 +233,7 @@ struct _zend_executor_globals {
 	zend_ini_entry *error_reporting_ini_entry;	                
 
 	zend_objects_store objects_store;
-	zval *exception, *prev_exception;
+	zend_object *exception, *prev_exception;
 	zend_op *opline_before_exception;
 	zend_op exception_op[3];
 
@@ -313,6 +301,9 @@ struct _zend_php_scanner_globals {
 	zend_encoding_filter input_filter;
 	zend_encoding_filter output_filter;
 	const zend_encoding *script_encoding;
+
+	/* initial string length after scanning to first variable */
+	int scanned_string_len;
 };
 
 #endif /* ZEND_GLOBALS_H */
diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index 309631338a..bc882dd8db 100644
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -22,45 +22,21 @@
 #include "zend.h"
 #include "zend_globals.h"
 
-#define CONNECT_TO_BUCKET_DLLIST(element, list_head)		\
-	(element)->pNext = (list_head);							\
-	(element)->pLast = NULL;								\
-	if ((element)->pNext) {									\
-		(element)->pNext->pLast = (element);				\
-	}
-
-#define CONNECT_TO_GLOBAL_DLLIST_EX(element, ht, last, next)\
-	(element)->pListLast = (last);							\
-	(element)->pListNext = (next);							\
-	if ((last) != NULL) {									\
-		(last)->pListNext = (element);						\
-	} else {												\
-		(ht)->pListHead = (element);						\
-	}														\
-	if ((next) != NULL) {									\
-		(next)->pListLast = (element);						\
-	} else {												\
-		(ht)->pListTail = (element);						\
-	}														\
-
-#define CONNECT_TO_GLOBAL_DLLIST(element, ht)									\
-	CONNECT_TO_GLOBAL_DLLIST_EX(element, ht, (ht)->pListTail, (Bucket *) NULL);	\
-	if ((ht)->pInternalPointer == NULL) {										\
-		(ht)->pInternalPointer = (element);										\
-	}
-
 #if ZEND_DEBUG
-#define HT_OK				0
-#define HT_IS_DESTROYING	1
-#define HT_DESTROYED		2
-#define HT_CLEANING			3
+/*
+#define HASH_MASK_CONSISTENCY	0x60
+*/
+#define HT_OK					0x00
+#define HT_IS_DESTROYING		0x20
+#define HT_DESTROYED			0x40
+#define HT_CLEANING				0x60
 
 static void _zend_is_inconsistent(const HashTable *ht, const char *file, int line)
 {
-	if (ht->inconsistent==HT_OK) {
+	if ((ht->u.flags & HASH_MASK_CONSISTENCY) == HT_OK) {
 		return;
 	}
-	switch (ht->inconsistent) {
+	switch ((ht->u.flags & HASH_MASK_CONSISTENCY)) {
 		case HT_IS_DESTROYING:
 			zend_output_debug_string(1, "%s(%d) : ht=%p is being destroyed", file, line, ht);
 			break;
@@ -77,122 +53,51 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, int lin
 	zend_bailout();
 }
 #define IS_CONSISTENT(a) _zend_is_inconsistent(a, __FILE__, __LINE__);
-#define SET_INCONSISTENT(n) ht->inconsistent = n;
+#define SET_INCONSISTENT(n) do { \
+		(ht)->u.flags |= n; \
+	} while (0)
 #else
 #define IS_CONSISTENT(a)
 #define SET_INCONSISTENT(n)
 #endif
 
 #define HASH_PROTECT_RECURSION(ht)														\
-	if ((ht)->bApplyProtection) {														\
-		if ((ht)->nApplyCount++ >= 3) {													\
-			zend_error(E_ERROR, "Nesting level too deep - recursive dependency?");		\
+	if ((ht)->u.flags & HASH_FLAG_APPLY_PROTECTION) {									\
+		if ((ht)->u.flags >= (3 << 8)) {												\
+			zend_error_noreturn(E_ERROR, "Nesting level too deep - recursive dependency?");\
 		}																				\
+		(ht)->u.flags += (1 << 8);														\
 	}
 
-
 #define HASH_UNPROTECT_RECURSION(ht)													\
-	if ((ht)->bApplyProtection) {														\
-		(ht)->nApplyCount--;															\
+	if ((ht)->u.flags & HASH_FLAG_APPLY_PROTECTION) {									\
+		(ht)->u.flags -= (1 << 8);														\
 	}
 
-
 #define ZEND_HASH_IF_FULL_DO_RESIZE(ht)				\
-	if ((ht)->nNumOfElements > (ht)->nTableSize) {	\
+	if ((ht)->nNumUsed >= (ht)->nTableSize) {		\
 		zend_hash_do_resize(ht);					\
 	}
 
 static void zend_hash_do_resize(HashTable *ht);
 
-ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength)
-{
-	return zend_inline_hash_func(arKey, nKeyLength);
-}
-
-
-#define UPDATE_DATA(ht, p, pData, nDataSize)											\
-	if (nDataSize == sizeof(void*)) {													\
-		if ((p)->pData != &(p)->pDataPtr) {												\
-			pefree_rel((p)->pData, (ht)->persistent);									\
-		}																				\
-		memcpy(&(p)->pDataPtr, pData, sizeof(void *));									\
-		(p)->pData = &(p)->pDataPtr;													\
-	} else {																			\
-		if ((p)->pData == &(p)->pDataPtr) {												\
-			(p)->pData = (void *) pemalloc_rel(nDataSize, (ht)->persistent);			\
-			(p)->pDataPtr=NULL;															\
-		} else {																		\
-			(p)->pData = (void *) perealloc_rel((p)->pData, nDataSize, (ht)->persistent);	\
-			/* (p)->pDataPtr is already NULL so no need to initialize it */				\
-		}																				\
-		memcpy((p)->pData, pData, nDataSize);											\
-	}
-
-#define INIT_DATA(ht, p, _pData, nDataSize);								\
-	if (nDataSize == sizeof(void*)) {									\
-		memcpy(&(p)->pDataPtr, (_pData), sizeof(void *));					\
-		(p)->pData = &(p)->pDataPtr;									\
-	} else {															\
-		(p)->pData = (void *) pemalloc_rel(nDataSize, (ht)->persistent);\
-		memcpy((p)->pData, (_pData), nDataSize);							\
-		(p)->pDataPtr=NULL;												\
-	}
-
-#define CHECK_INIT(ht) do {												\
-	if (UNEXPECTED((ht)->nTableMask == 0)) {								\
-		(ht)->arBuckets = (Bucket **) pecalloc((ht)->nTableSize, sizeof(Bucket *), (ht)->persistent);	\
+#define CHECK_INIT(ht, packed) do {												\
+	if (UNEXPECTED((ht)->nTableMask == 0)) {							\
+		if (packed) { \
+			(ht)->arData = (Bucket *) safe_pemalloc((ht)->nTableSize, sizeof(Bucket), 0, (ht)->u.flags & HASH_FLAG_PERSISTENT);	\
+			(ht)->u.flags |= HASH_FLAG_PACKED; \
+		} else { \
+			(ht)->arData = (Bucket *) safe_pemalloc((ht)->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, (ht)->u.flags & HASH_FLAG_PERSISTENT);	\
+			(ht)->arHash = (zend_uint*)((ht)->arData + (ht)->nTableSize);	\
+			memset((ht)->arHash, INVALID_IDX, (ht)->nTableSize * sizeof(zend_uint));	\
+		} \
 		(ht)->nTableMask = (ht)->nTableSize - 1;						\
 	}																	\
 } while (0)
  
-static const Bucket *uninitialized_bucket = NULL;
-
-static zend_always_inline void i_zend_hash_bucket_delete(HashTable *ht, Bucket *p)
-{
-#ifdef ZEND_SIGNALS
-	TSRMLS_FETCH();
-#endif
-
-	HANDLE_BLOCK_INTERRUPTIONS();
-	if (p->pLast) {
-		p->pLast->pNext = p->pNext;
-	} else {
-		ht->arBuckets[p->h & ht->nTableMask] = p->pNext;
-	}
-	if (p->pNext) {
-		p->pNext->pLast = p->pLast;
-	}
-	if (p->pListLast != NULL) {
-		p->pListLast->pListNext = p->pListNext;
-	} else { 
-		/* Deleting the head of the list */
-		ht->pListHead = p->pListNext;
-	}
-	if (p->pListNext != NULL) {
-		p->pListNext->pListLast = p->pListLast;
-	} else {
-		/* Deleting the tail of the list */
-		ht->pListTail = p->pListLast;
-	}
-	if (ht->pInternalPointer == p) {
-		ht->pInternalPointer = p->pListNext;
-	}
-	ht->nNumOfElements--;
-	if (ht->pDestructor) {
-		ht->pDestructor(p->pData);
-	}
-	if (p->pData != &p->pDataPtr) {
-		pefree(p->pData, ht->persistent);
-	}
-	pefree(p, ht->persistent);
-	HANDLE_UNBLOCK_INTERRUPTIONS();
-}
-
-static void zend_hash_bucket_delete(HashTable *ht, Bucket *p) {
-	i_zend_hash_bucket_delete(ht, p);
-}
+static const zend_uint uninitialized_bucket = {INVALID_IDX};
 
-ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
+ZEND_API void _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
 {
 	uint i = 3;
 
@@ -209,105 +114,141 @@ ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor,
 	}
 
 	ht->nTableMask = 0;	/* 0 means that ht->arBuckets is uninitialized */
-	ht->pDestructor = pDestructor;
-	ht->arBuckets = (Bucket**)&uninitialized_bucket;
-	ht->pListHead = NULL;
-	ht->pListTail = NULL;
+	ht->nNumUsed = 0;
 	ht->nNumOfElements = 0;
 	ht->nNextFreeElement = 0;
-	ht->pInternalPointer = NULL;
-	ht->persistent = persistent;
-	ht->nApplyCount = 0;
-	ht->bApplyProtection = 1;
-	return SUCCESS;
+	ht->arData = NULL;
+	ht->arHash = (zend_uint*)&uninitialized_bucket;
+	ht->pDestructor = pDestructor;
+	ht->nInternalPointer = INVALID_IDX;
+	if (persistent) {
+		ht->u.flags = HASH_FLAG_PERSISTENT | HASH_FLAG_APPLY_PROTECTION;
+	} else {
+		ht->u.flags = HASH_FLAG_APPLY_PROTECTION;
+	}
 }
 
+static void zend_hash_packed_grow(HashTable *ht)
+{
+	HANDLE_BLOCK_INTERRUPTIONS();
+	ht->arData = (Bucket *) safe_perealloc(ht->arData, (ht->nTableSize << 1), sizeof(Bucket), 0, ht->u.flags & HASH_FLAG_PERSISTENT);
+	ht->nTableSize = (ht->nTableSize << 1);
+	ht->nTableMask = ht->nTableSize - 1;
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+}
 
-ZEND_API int _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
+ZEND_API void zend_hash_real_init(HashTable *ht, int packed)
 {
-	int retval = _zend_hash_init(ht, nSize, pDestructor, persistent ZEND_FILE_LINE_CC);
+	IS_CONSISTENT(ht);
 
-	ht->bApplyProtection = bApplyProtection;
-	return retval;
+	CHECK_INIT(ht, packed);
 }
 
+ZEND_API void zend_hash_packed_to_hash(HashTable *ht)
+{
+	HANDLE_BLOCK_INTERRUPTIONS();
+	ht->u.flags &= ~HASH_FLAG_PACKED;
+	ht->arData = (Bucket *) safe_perealloc(ht->arData, ht->nTableSize, sizeof(Bucket) + sizeof(zend_uint), 0, ht->u.flags & HASH_FLAG_PERSISTENT);
+	ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize);
+	zend_hash_rehash(ht);
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+}
 
-ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProtection)
+ZEND_API void zend_hash_to_packed(HashTable *ht)
 {
-	ht->bApplyProtection = bApplyProtection;
+	HANDLE_BLOCK_INTERRUPTIONS();
+	ht->u.flags |= HASH_FLAG_PACKED;
+	ht->arData = erealloc(ht->arData, ht->nTableSize * sizeof(Bucket));
+	ht->arHash = (zend_uint*)&uninitialized_bucket;
+	HANDLE_UNBLOCK_INTERRUPTIONS();
 }
 
+ZEND_API void _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
+{
+	_zend_hash_init(ht, nSize, pDestructor, persistent ZEND_FILE_LINE_CC);
+	if (!bApplyProtection) {
+		ht->u.flags &= ~HASH_FLAG_APPLY_PROTECTION;
+	}
+}
 
 
-ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProtection)
+{
+	if (bApplyProtection) {
+		ht->u.flags |= HASH_FLAG_APPLY_PROTECTION;
+	} else {
+		ht->u.flags &= ~HASH_FLAG_APPLY_PROTECTION;
+	}
+}
+
+static zend_always_inline Bucket *zend_hash_find_bucket(const HashTable *ht, zend_string *key)
 {
 	ulong h;
 	uint nIndex;
+	uint idx;
 	Bucket *p;
-#ifdef ZEND_SIGNALS
-	TSRMLS_FETCH();
-#endif
 
-	IS_CONSISTENT(ht);
-
-	ZEND_ASSERT(nKeyLength != 0);
+	h = STR_HASH_VAL(key);
+	nIndex = h & ht->nTableMask;
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if ((p->key == key) || /* check for the the same interned string */
+			(p->h == h &&
+			 p->key &&
+			 p->key->len == key->len &&
+			 memcmp(p->key->val, key->val, key->len) == 0)) {
+			return p;
+		}
+		idx = Z_NEXT(p->val);
+	}
+	return NULL;
+}
 
-	CHECK_INIT(ht);
+static zend_always_inline Bucket *zend_hash_str_find_bucket(const HashTable *ht, const char *str, int len, ulong h)
+{
+	uint nIndex;
+	uint idx;
+	Bucket *p;
 
-	h = zend_inline_hash_func(arKey, nKeyLength);
 	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if (p->arKey == arKey ||
-			((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
-				if (flag & HASH_ADD) {
-					return FAILURE;
-				}
-				ZEND_ASSERT(p->pData != pData);
-				HANDLE_BLOCK_INTERRUPTIONS();
-				if (ht->pDestructor) {
-					ht->pDestructor(p->pData);
-				}
-				UPDATE_DATA(ht, p, pData, nDataSize);
-				if (pDest) {
-					*pDest = p->pData;
-				}
-				HANDLE_UNBLOCK_INTERRUPTIONS();
-				return SUCCESS;
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if ((p->h == h) 
+			 && p->key
+			 && (p->key->len == len)
+			 && !memcmp(p->key->val, str, len)) {
+			return p;
 		}
-		p = p->pNext;
-	}
-	
-	if (IS_INTERNED(arKey)) {
-		p = (Bucket *) pemalloc(sizeof(Bucket), ht->persistent);
-		p->arKey = arKey;
-	} else {
-		p = (Bucket *) pemalloc(sizeof(Bucket) + nKeyLength, ht->persistent);
-		p->arKey = (const char*)(p + 1);
-		memcpy((char*)p->arKey, arKey, nKeyLength);
-	}
-	p->nKeyLength = nKeyLength;
-	INIT_DATA(ht, p, pData, nDataSize);
-	p->h = h;
-	CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
-	if (pDest) {
-		*pDest = p->pData;
+		idx = Z_NEXT(p->val);
 	}
+	return NULL;
+}
 
-	HANDLE_BLOCK_INTERRUPTIONS();
-	CONNECT_TO_GLOBAL_DLLIST(p, ht);
-	ht->arBuckets[nIndex] = p;
-	HANDLE_UNBLOCK_INTERRUPTIONS();
+static zend_always_inline Bucket *zend_hash_index_find_bucket(const HashTable *ht, ulong h)
+{
+	uint nIndex;
+	uint idx;
+	Bucket *p;
 
-	ht->nNumOfElements++;
-	ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
-	return SUCCESS;
+	nIndex = h & ht->nTableMask;
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if (p->h == h && !p->key) {
+			return p;
+		}
+		idx = Z_NEXT(p->val);
+	}
+	return NULL;
 }
 
-ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API zval *_zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC)
 {
+	ulong h;
 	uint nIndex;
+	uint idx;
 	Bucket *p;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
@@ -315,145 +256,223 @@ ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, ui
 
 	IS_CONSISTENT(ht);
 
-	ZEND_ASSERT(nKeyLength != 0);
-
-	CHECK_INIT(ht);
-	nIndex = h & ht->nTableMask;
-	
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if (p->arKey == arKey ||
-			((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
-				if (flag & HASH_ADD) {
-					return FAILURE;
-				}
-				ZEND_ASSERT(p->pData != pData);
-				HANDLE_BLOCK_INTERRUPTIONS();
-				if (ht->pDestructor) {
-					ht->pDestructor(p->pData);
-				}
-				UPDATE_DATA(ht, p, pData, nDataSize);
-				if (pDest) {
-					*pDest = p->pData;
-				}
-				HANDLE_UNBLOCK_INTERRUPTIONS();
-				return SUCCESS;
-		}
-		p = p->pNext;
-	}
-	
-	if (IS_INTERNED(arKey)) {
-		p = (Bucket *) pemalloc(sizeof(Bucket), ht->persistent);
-		p->arKey = arKey;
-	} else {
-		p = (Bucket *) pemalloc(sizeof(Bucket) + nKeyLength, ht->persistent);
-		p->arKey = (const char*)(p + 1);
-		memcpy((char*)p->arKey, arKey, nKeyLength);
+	CHECK_INIT(ht, 0);
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		zend_hash_packed_to_hash(ht);
 	}
 
-	p->nKeyLength = nKeyLength;
-	INIT_DATA(ht, p, pData, nDataSize);
-	p->h = h;
-	
-	CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
+	h = STR_HASH_VAL(key);
+	p = zend_hash_find_bucket(ht, key);
+
+	if (p) {
+		zval *data;
 
-	if (pDest) {
-		*pDest = p->pData;
+		if (flag & HASH_ADD) {
+			return NULL;
+		}
+		ZEND_ASSERT(&p->val != pData);
+		data = &p->val;
+		if ((flag & HASH_UPDATE_INDIRECT) && Z_TYPE_P(data) == IS_INDIRECT) {
+			data = Z_INDIRECT_P(data);
+		}
+		HANDLE_BLOCK_INTERRUPTIONS();
+		if (ht->pDestructor) {
+			ht->pDestructor(data);
+		}
+		ZVAL_COPY_VALUE(data, pData);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		return data;
 	}
+	
+	ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
 
 	HANDLE_BLOCK_INTERRUPTIONS();
-	ht->arBuckets[nIndex] = p;
-	CONNECT_TO_GLOBAL_DLLIST(p, ht);
+	idx = ht->nNumUsed++;
+	ht->nNumOfElements++;
+	if (ht->nInternalPointer == INVALID_IDX) {
+		ht->nInternalPointer = idx;
+	}
+	p = ht->arData + idx; 
+	p->h = h;
+	p->key = key;
+	STR_ADDREF(key);
+	ZVAL_COPY_VALUE(&p->val, pData);
+	nIndex = h & ht->nTableMask;
+	Z_NEXT(p->val) = ht->arHash[nIndex];
+	ht->arHash[nIndex] = idx;
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 
-	ht->nNumOfElements++;
-	ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
-	return SUCCESS;
+	return &p->val;
+}
+
+ZEND_API zval *_zend_hash_str_add_or_update(HashTable *ht, const char *str, int len, zval *pData, int flag ZEND_FILE_LINE_DC)
+{
+	zend_string *key = STR_INIT(str, len, ht->u.flags & HASH_FLAG_PERSISTENT);
+	zval *ret = _zend_hash_add_or_update(ht, key, pData, flag ZEND_FILE_LINE_CC);
+	STR_RELEASE(key);
+	return ret;
 }
 
+ZEND_API zval *zend_hash_index_add_empty_element(HashTable *ht, ulong h)
+{
+	
+	zval dummy;
 
-ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint nKeyLength)
+	ZVAL_NULL(&dummy);
+	return zend_hash_index_add(ht, h, &dummy);
+}
+
+ZEND_API zval *zend_hash_add_empty_element(HashTable *ht, zend_string *key)
 {
-	void *dummy = (void *) 1;
+	
+	zval dummy;
 
-	return zend_hash_add(ht, arKey, nKeyLength, &dummy, sizeof(void *), NULL);
+	ZVAL_NULL(&dummy);
+	return zend_hash_add(ht, key, &dummy);
 }
 
+ZEND_API zval *zend_hash_str_add_empty_element(HashTable *ht, const char *str, int len)
+{
+	
+	zval dummy;
+
+	ZVAL_NULL(&dummy);
+	return zend_hash_str_add(ht, str, len, &dummy);
+}
 
-ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC)
 {
 	uint nIndex;
+	uint idx;
 	Bucket *p;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
 #endif
 
 	IS_CONSISTENT(ht);
-	CHECK_INIT(ht);
 
 	if (flag & HASH_NEXT_INSERT) {
 		h = ht->nNextFreeElement;
 	}
-	nIndex = h & ht->nTableMask;
+	CHECK_INIT(ht, h >= 0 && h < ht->nTableSize);
 
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if ((p->nKeyLength == 0) && (p->h == h)) {
-			if (flag & HASH_NEXT_INSERT || flag & HASH_ADD) {
-				return FAILURE;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		if (EXPECTED(h >= 0))  {
+			if (h < ht->nNumUsed) {
+				p = ht->arData + h;
+				if (Z_TYPE(p->val) != IS_UNDEF) {
+					if (flag & (HASH_NEXT_INSERT | HASH_ADD)) {
+						return NULL;
+					}
+					if (ht->pDestructor) {
+						ht->pDestructor(&p->val);
+					}
+					ZVAL_COPY_VALUE(&p->val, pData);
+					if ((long)h >= (long)ht->nNextFreeElement) {
+						ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
+					}
+					return &p->val;
+				} else { /* we have to keep the order :( */
+				    goto convert_to_hash;
+				}
+			} else if (EXPECTED(h < ht->nTableSize)) {
+				p = ht->arData + h;
+			} else if (h < ht->nTableSize * 2 &&
+			           ht->nTableSize - ht->nNumOfElements < ht->nTableSize / 2) {
+				zend_hash_packed_grow(ht);
+				p = ht->arData + h;
+			} else {
+			    goto convert_to_hash;
 			}
-			ZEND_ASSERT(p->pData != pData);
 			HANDLE_BLOCK_INTERRUPTIONS();
-			if (ht->pDestructor) {
-				ht->pDestructor(p->pData);
+			/* incremental initialization of empty Buckets */
+			if (h >= ht->nNumUsed) {
+				Bucket *q = ht->arData + ht->nNumUsed;
+				while (q != p) {
+					ZVAL_UNDEF(&q->val);
+					q++;
+				}
+				ht->nNumUsed = h + 1;
 			}
-			UPDATE_DATA(ht, p, pData, nDataSize);
-			HANDLE_UNBLOCK_INTERRUPTIONS();
-			if (pDest) {
-				*pDest = p->pData;
+			ht->nNumOfElements++;
+			if (ht->nInternalPointer == INVALID_IDX) {
+				ht->nInternalPointer = h;
 			}
-			return SUCCESS;
+			if ((long)h >= (long)ht->nNextFreeElement) {
+				ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
+			}
+			p->h = h;
+			p->key = NULL;
+			ZVAL_COPY_VALUE(&p->val, pData);
+			Z_NEXT(p->val) = INVALID_IDX;
+
+			HANDLE_UNBLOCK_INTERRUPTIONS();
+
+			return &p->val;
+		} else {
+convert_to_hash:
+			zend_hash_packed_to_hash(ht);
 		}
-		p = p->pNext;
 	}
-	p = (Bucket *) pemalloc_rel(sizeof(Bucket), ht->persistent);
-	p->arKey = NULL;
-	p->nKeyLength = 0; /* Numeric indices are marked by making the nKeyLength == 0 */
-	p->h = h;
-	INIT_DATA(ht, p, pData, nDataSize);
-	if (pDest) {
-		*pDest = p->pData;
+
+	p = zend_hash_index_find_bucket(ht, h);
+	if (p) {
+		if (flag & (HASH_NEXT_INSERT | HASH_ADD)) {
+			return NULL;
+		}
+		ZEND_ASSERT(&p->val != pData);
+		HANDLE_BLOCK_INTERRUPTIONS();
+		if (ht->pDestructor) {
+			ht->pDestructor(&p->val);
+		}
+		ZVAL_COPY_VALUE(&p->val, pData);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+		if ((long)h >= (long)ht->nNextFreeElement) {
+			ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
+		}
+		return &p->val;
 	}
 
-	CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
+	ZEND_HASH_IF_FULL_DO_RESIZE(ht);		/* If the Hash table is full, resize it */
 
 	HANDLE_BLOCK_INTERRUPTIONS();
-	ht->arBuckets[nIndex] = p;
-	CONNECT_TO_GLOBAL_DLLIST(p, ht);
-	HANDLE_UNBLOCK_INTERRUPTIONS();
-
+	idx = ht->nNumUsed++;
+	ht->nNumOfElements++;
+	if (ht->nInternalPointer == INVALID_IDX) {
+		ht->nInternalPointer = idx;
+	}
 	if ((long)h >= (long)ht->nNextFreeElement) {
 		ht->nNextFreeElement = h < LONG_MAX ? h + 1 : LONG_MAX;
 	}
-	ht->nNumOfElements++;
-	ZEND_HASH_IF_FULL_DO_RESIZE(ht);
-	return SUCCESS;
+	p = ht->arData + idx;
+	p->h = h;
+	p->key = NULL;
+	nIndex = h & ht->nTableMask;
+	ZVAL_COPY_VALUE(&p->val, pData);
+	Z_NEXT(p->val) = ht->arHash[nIndex];
+	ht->arHash[nIndex] = idx;
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+
+	return &p->val;
 }
 
 
 static void zend_hash_do_resize(HashTable *ht)
 {
-	Bucket **t;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
 #endif
 
 	IS_CONSISTENT(ht);
 
-	if ((ht->nTableSize << 1) > 0) {	/* Let's double the table size */
-		t = (Bucket **) perealloc(ht->arBuckets, (ht->nTableSize << 1) * sizeof(Bucket *), ht->persistent);
+	if (ht->nNumUsed < ht->nNumOfElements) {
+		HANDLE_BLOCK_INTERRUPTIONS();
+		zend_hash_rehash(ht);
+		HANDLE_UNBLOCK_INTERRUPTIONS();
+	} else if ((ht->nTableSize << 1) > 0) {	/* Let's double the table size */
 		HANDLE_BLOCK_INTERRUPTIONS();
-		ht->arBuckets = t;
+		ht->arData = (Bucket *) safe_perealloc(ht->arData, (ht->nTableSize << 1), sizeof(Bucket) + sizeof(zend_uint), 0, ht->u.flags & HASH_FLAG_PERSISTENT);
+		ht->arHash = (zend_uint*)(ht->arData + (ht->nTableSize << 1));
 		ht->nTableSize = (ht->nTableSize << 1);
 		ht->nTableMask = ht->nTableSize - 1;
 		zend_hash_rehash(ht);
@@ -464,95 +483,328 @@ static void zend_hash_do_resize(HashTable *ht)
 ZEND_API int zend_hash_rehash(HashTable *ht)
 {
 	Bucket *p;
-	uint nIndex;
+	uint nIndex, i, j;
 
 	IS_CONSISTENT(ht);
+	memset(ht->arHash, INVALID_IDX, ht->nTableSize * sizeof(zend_uint));
+
 	if (UNEXPECTED(ht->nNumOfElements == 0)) {
 		return SUCCESS;
 	}
 
-	memset(ht->arBuckets, 0, ht->nTableSize * sizeof(Bucket *));
-	for (p = ht->pListHead; p != NULL; p = p->pListNext) {
-		nIndex = p->h & ht->nTableMask;
-		CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
-		ht->arBuckets[nIndex] = p;
+	for (i = 0, j = 0; i < ht->nNumUsed; i++) {
+		p = ht->arData + i;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (i != j) {
+			ht->arData[j] = ht->arData[i];
+			if (ht->nInternalPointer == i) {
+				ht->nInternalPointer = j;
+			}
+		}
+		nIndex = ht->arData[j].h & ht->nTableMask;
+		Z_NEXT(ht->arData[j].val) = ht->arHash[nIndex];
+		ht->arHash[nIndex] = j;
+		j++;
 	}
+	ht->nNumUsed = j;
 	return SUCCESS;
 }
 
-ZEND_API void zend_hash_reindex(HashTable *ht, zend_bool only_integer_keys) {
-	Bucket *p;
+static zend_always_inline void _zend_hash_del_el_ex(HashTable *ht, uint idx, Bucket *p, Bucket *prev)
+{
+	if (!(ht->u.flags & HASH_FLAG_PACKED)) {
+		if (prev) {
+			Z_NEXT(prev->val) = Z_NEXT(p->val);
+		} else {
+			ht->arHash[p->h & ht->nTableMask] = Z_NEXT(p->val);
+		}
+	}
+	if (ht->nNumUsed - 1 == idx) {
+		do {
+			ht->nNumUsed--;
+		} while (ht->nNumUsed > 0 && (Z_TYPE(ht->arData[ht->nNumUsed-1].val) == IS_UNDEF));
+	}
+	ht->nNumOfElements--;
+	if (ht->nInternalPointer == idx) {
+		while (1) {
+			idx++;
+			if (idx >= ht->nNumUsed) {
+				ht->nInternalPointer = INVALID_IDX;
+				break;
+			} else if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
+				ht->nInternalPointer = idx;
+				break;
+			}
+		}
+	}
+	if (p->key) {
+		STR_RELEASE(p->key);
+	}
+	if (ht->pDestructor) {
+		zval tmp;
+		ZVAL_COPY_VALUE(&tmp, &p->val);
+		ZVAL_UNDEF(&p->val);
+		ht->pDestructor(&tmp);
+	} else {
+		ZVAL_UNDEF(&p->val);
+	}
+}
+
+static zend_always_inline void _zend_hash_del_el(HashTable *ht, uint idx, Bucket *p)
+{
 	uint nIndex;
-	ulong offset = 0;
+	Bucket *prev = NULL;
+
+	if (!(ht->u.flags & HASH_FLAG_PACKED)) {
+		nIndex = p->h & ht->nTableMask;
+		idx = ht->arHash[nIndex];
+		if (p != ht->arData + idx) {
+			prev = ht->arData + idx;
+			while (ht->arData + Z_NEXT(prev->val) != p) {
+				idx = Z_NEXT(prev->val);
+				prev = ht->arData + idx;
+			}
+			idx = Z_NEXT(prev->val);
+	 	}
+	}
+
+	_zend_hash_del_el_ex(ht, idx, p, prev);
+}
+
+ZEND_API int zend_hash_del(HashTable *ht, zend_string *key)
+{
+	ulong h;
+	uint nIndex;
+	uint idx;
+	Bucket *p;
+	Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
 
 	IS_CONSISTENT(ht);
-	if (UNEXPECTED(ht->nNumOfElements == 0)) {
-		return;
+
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		return FAILURE;
 	}
 
-	memset(ht->arBuckets, 0, ht->nTableSize * sizeof(Bucket *));
-	for (p = ht->pListHead; p != NULL; p = p->pListNext) {
-		if (!only_integer_keys || p->nKeyLength == 0) {
-			p->h = offset++;
-			p->nKeyLength = 0;
+	h = STR_HASH_VAL(key);
+	nIndex = h & ht->nTableMask;
+
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if ((p->key == key) ||
+			(p->h == h &&
+		     p->key &&
+		     p->key->len == key->len &&
+		     memcmp(p->key->val, key->val, key->len) == 0)) {
+			HANDLE_BLOCK_INTERRUPTIONS();
+			_zend_hash_del_el_ex(ht, idx, p, prev);
+			HANDLE_UNBLOCK_INTERRUPTIONS();
+			return SUCCESS;
 		}
+		prev = p;
+		idx = Z_NEXT(p->val);
+	}
+	return FAILURE;
+}
 
-		nIndex = p->h & ht->nTableMask;
-		CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[nIndex]);
-		ht->arBuckets[nIndex] = p;
+ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key)
+{
+	ulong h;
+	uint nIndex;
+	uint idx;
+	Bucket *p;
+	Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
+
+	IS_CONSISTENT(ht);
+
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		return FAILURE;
 	}
-	ht->nNextFreeElement = offset;
+
+	h = STR_HASH_VAL(key);
+	nIndex = h & ht->nTableMask;
+
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if ((p->key == key) ||
+			(p->h == h &&
+		     p->key &&
+		     p->key->len == key->len &&
+		     memcmp(p->key->val, key->val, key->len) == 0)) {
+			if (Z_TYPE(p->val) == IS_INDIRECT) {
+				zval *data = Z_INDIRECT(p->val);
+
+				if (Z_TYPE_P(data) == IS_UNDEF) {
+					return FAILURE;
+				} else {
+					if (ht->pDestructor) {
+						ht->pDestructor(data);
+					}
+					ZVAL_UNDEF(data);
+				}
+			} else {
+				HANDLE_BLOCK_INTERRUPTIONS();
+				_zend_hash_del_el_ex(ht, idx, p, prev);
+				HANDLE_UNBLOCK_INTERRUPTIONS();
+			}
+			return SUCCESS;
+		}
+		prev = p;
+		idx = Z_NEXT(p->val);
+	}
+	return FAILURE;
 }
 
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag)
+ZEND_API int zend_hash_str_del(HashTable *ht, const char *str, int len)
 {
+	ulong h;
 	uint nIndex;
+	uint idx;
 	Bucket *p;
+	Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
 
 	IS_CONSISTENT(ht);
 
-	if (flag == HASH_DEL_KEY) {
-		h = zend_inline_hash_func(arKey, nKeyLength);
+	h = zend_inline_hash_func(str, len);
+	nIndex = h & ht->nTableMask;
+
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if ((p->h == h) 
+			 && p->key
+			 && (p->key->len == len)
+			 && !memcmp(p->key->val, str, len)) {
+			if (Z_TYPE(p->val) == IS_INDIRECT) {
+				zval *data = Z_INDIRECT(p->val);
+
+				if (Z_TYPE_P(data) == IS_UNDEF) {
+					return FAILURE;
+				} else {
+					if (ht->pDestructor) {
+						ht->pDestructor(data);
+					}
+					ZVAL_UNDEF(data);
+				}
+			} else {
+				HANDLE_BLOCK_INTERRUPTIONS();
+				_zend_hash_del_el_ex(ht, idx, p, prev);
+				HANDLE_UNBLOCK_INTERRUPTIONS();
+			}
+			return SUCCESS;
+		}
+		prev = p;
+		idx = Z_NEXT(p->val);
 	}
+	return FAILURE;
+}
+
+ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *str, int len)
+{
+	ulong h;
+	uint nIndex;
+	uint idx;
+	Bucket *p;
+	Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
+
+	IS_CONSISTENT(ht);
+
+	h = zend_inline_hash_func(str, len);
 	nIndex = h & ht->nTableMask;
 
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
 		if ((p->h == h) 
-			 && (p->nKeyLength == nKeyLength)
-			 && ((p->nKeyLength == 0) /* Numeric index (short circuits the memcmp() check) */
-				 || !memcmp(p->arKey, arKey, nKeyLength))) { /* String index */
-			i_zend_hash_bucket_delete(ht, p);
+			 && p->key
+			 && (p->key->len == len)
+			 && !memcmp(p->key->val, str, len)) {
+			HANDLE_BLOCK_INTERRUPTIONS();
+			_zend_hash_del_el_ex(ht, idx, p, prev);
+			HANDLE_UNBLOCK_INTERRUPTIONS();
 			return SUCCESS;
 		}
-		p = p->pNext;
+		prev = p;
+		idx = Z_NEXT(p->val);
 	}
 	return FAILURE;
 }
 
+ZEND_API int zend_hash_index_del(HashTable *ht, ulong h)
+{
+	uint nIndex;
+	uint idx;
+	Bucket *p;
+	Bucket *prev = NULL;
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
+
+	IS_CONSISTENT(ht);
+
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		if (h >=0 && h < ht->nNumUsed) {
+			p = ht->arData + h;
+			if (Z_TYPE(p->val) != IS_UNDEF) {
+				HANDLE_BLOCK_INTERRUPTIONS();
+				_zend_hash_del_el_ex(ht, h, p, NULL);
+				HANDLE_UNBLOCK_INTERRUPTIONS();
+				return SUCCESS;
+			}
+		}
+		return FAILURE;
+	}
+	nIndex = h & ht->nTableMask;
+
+	idx = ht->arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if ((p->h == h) && (p->key == NULL)) {
+			HANDLE_BLOCK_INTERRUPTIONS();
+			_zend_hash_del_el_ex(ht, idx, p, prev);
+			HANDLE_UNBLOCK_INTERRUPTIONS();
+			return SUCCESS;
+		}
+		prev = p;
+		idx = Z_NEXT(p->val);
+	}
+	return FAILURE;
+}
 
 ZEND_API void zend_hash_destroy(HashTable *ht)
 {
-	Bucket *p, *q;
+	uint idx;
+	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
 	SET_INCONSISTENT(HT_IS_DESTROYING);
 
-	p = ht->pListHead;
-	while (p != NULL) {
-		q = p;
-		p = p->pListNext;
+	for (idx = 0 ; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 		if (ht->pDestructor) {
-			ht->pDestructor(q->pData);
+			ht->pDestructor(&p->val);
 		}
-		if (q->pData != &q->pDataPtr) {
-			pefree(q->pData, ht->persistent);
+		if (p->key) {
+			STR_RELEASE(p->key);
 		}
-		pefree(q, ht->persistent);
 	}
 	if (ht->nTableMask) {
-		pefree(ht->arBuckets, ht->persistent);
+		pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT);
 	}
 
 	SET_INCONSISTENT(HT_DESTROYED);
@@ -561,44 +813,63 @@ ZEND_API void zend_hash_destroy(HashTable *ht)
 
 ZEND_API void zend_hash_clean(HashTable *ht)
 {
-	Bucket *p, *q;
+	uint idx;
+	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
-	p = ht->pListHead;
-
-	if (ht->nTableMask) {
-		memset(ht->arBuckets, 0, ht->nTableSize*sizeof(Bucket *));
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (ht->pDestructor) {
+			ht->pDestructor(&p->val);
+		}
+		if (p->key) {
+			STR_RELEASE(p->key);
+		}
 	}
-	ht->pListHead = NULL;
-	ht->pListTail = NULL;
+	ht->nNumUsed = 0;
 	ht->nNumOfElements = 0;
 	ht->nNextFreeElement = 0;
-	ht->pInternalPointer = NULL;
-
-	while (p != NULL) {
-		q = p;
-		p = p->pListNext;
-		if (ht->pDestructor) {
-			ht->pDestructor(q->pData);
-		}
-		if (q->pData != &q->pDataPtr) {
-			pefree(q->pData, ht->persistent);
+	ht->nInternalPointer = INVALID_IDX;
+	if (ht->nTableMask) {
+		if (!(ht->u.flags & HASH_FLAG_PACKED)) {
+			memset(ht->arHash, INVALID_IDX, ht->nTableSize * sizeof(zend_uint));	
 		}
-		pefree(q, ht->persistent);
 	}
 }
 
+/* This function is used by the various apply() functions.
+ * It deletes the passed bucket, and returns the address of the
+ * next bucket.  The hash *may* be altered during that time, the
+ * returned value will still be valid.
+ */
+static void zend_hash_apply_deleter(HashTable *ht, uint idx, Bucket *p)
+{
+#ifdef ZEND_SIGNALS
+	TSRMLS_FETCH();
+#endif
+
+	HANDLE_BLOCK_INTERRUPTIONS();
+	_zend_hash_del_el(ht, idx, p);
+	HANDLE_UNBLOCK_INTERRUPTIONS();
+}
+
+
 ZEND_API void zend_hash_graceful_destroy(HashTable *ht)
 {
+	uint idx;
+	Bucket *p;
+
 	IS_CONSISTENT(ht);
 
-	while (ht->pListHead != NULL) {
-		zend_hash_bucket_delete(ht, ht->pListHead);
+	for (idx = 0; idx < ht->nNumUsed; idx++) {		
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		zend_hash_apply_deleter(ht, idx, p);
 	}
-
 	if (ht->nTableMask) {
-		pefree(ht->arBuckets, ht->persistent);
+		pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT);
 	}
 
 	SET_INCONSISTENT(HT_DESTROYED);
@@ -606,14 +877,21 @@ ZEND_API void zend_hash_graceful_destroy(HashTable *ht)
 
 ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht)
 {
+	uint idx;
+	Bucket *p;
+
 	IS_CONSISTENT(ht);
 
-	while (ht->pListTail != NULL) {
-		zend_hash_bucket_delete(ht, ht->pListTail);
+	idx = ht->nNumUsed;
+	while (idx > 0) {
+		idx--;
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		zend_hash_apply_deleter(ht, idx, p);
 	}
 
 	if (ht->nTableMask) {
-		pefree(ht->arBuckets, ht->persistent);
+		pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT);
 	}
 
 	SET_INCONSISTENT(HT_DESTROYED);
@@ -630,21 +908,22 @@ ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht)
 
 ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
 {
+	uint idx;
 	Bucket *p;
+	int result;
 
 	IS_CONSISTENT(ht);
 
 	HASH_PROTECT_RECURSION(ht);
-	p = ht->pListHead;
-	while (p != NULL) {
-		int result = apply_func(p->pData TSRMLS_CC);
-
-		Bucket *p_next = p->pListNext;
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		
+		result = apply_func(&p->val TSRMLS_CC);
+		
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			zend_hash_bucket_delete(ht, p);
+			zend_hash_apply_deleter(ht, idx, p);
 		}
-		p = p_next;
-
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
@@ -655,21 +934,22 @@ ZEND_API void zend_hash_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
 
 ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t apply_func, void *argument TSRMLS_DC)
 {
+    uint idx;
 	Bucket *p;
+	int result;
 
 	IS_CONSISTENT(ht);
 
 	HASH_PROTECT_RECURSION(ht);
-	p = ht->pListHead;
-	while (p != NULL) {
-		int result = apply_func(p->pData, argument TSRMLS_CC);
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+
+		result = apply_func(&p->val, argument TSRMLS_CC);
 		
-		Bucket *p_next = p->pListNext;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			zend_hash_bucket_delete(ht, p);
+			zend_hash_apply_deleter(ht, idx, p);
 		}
-		p = p_next;
-
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
@@ -680,31 +960,28 @@ ZEND_API void zend_hash_apply_with_argument(HashTable *ht, apply_func_arg_t appl
 
 ZEND_API void zend_hash_apply_with_arguments(HashTable *ht TSRMLS_DC, apply_func_args_t apply_func, int num_args, ...)
 {
+	uint idx;
 	Bucket *p;
 	va_list args;
 	zend_hash_key hash_key;
+	int result;
 
 	IS_CONSISTENT(ht);
 
 	HASH_PROTECT_RECURSION(ht);
 
-	p = ht->pListHead;
-	while (p != NULL) {
-		int result;
-		Bucket *p_next;
-
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 		va_start(args, num_args);
-		hash_key.arKey = p->arKey;
-		hash_key.nKeyLength = p->nKeyLength;
 		hash_key.h = p->h;
-		result = apply_func(p->pData TSRMLS_CC, num_args, args, &hash_key);
+		hash_key.key = p->key;
+
+		result = apply_func(&p->val TSRMLS_CC, num_args, args, &hash_key);
 
-		p_next = p->pListNext;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			zend_hash_bucket_delete(ht, p);
+			zend_hash_apply_deleter(ht, idx, p);
 		}
-		p = p_next;
-
 		if (result & ZEND_HASH_APPLY_STOP) {
 			va_end(args);
 			break;
@@ -718,21 +995,24 @@ ZEND_API void zend_hash_apply_with_arguments(HashTable *ht TSRMLS_DC, apply_func
 
 ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSRMLS_DC)
 {
+	uint idx;
 	Bucket *p;
+	int result;
 
 	IS_CONSISTENT(ht);
 
 	HASH_PROTECT_RECURSION(ht);
-	p = ht->pListTail;
-	while (p != NULL) {
-		int result = apply_func(p->pData TSRMLS_CC);
+	idx = ht->nNumUsed;
+	while (idx > 0) {
+		idx--;
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		
+		result = apply_func(&p->val TSRMLS_CC);
 
-		Bucket *p_last = p->pListLast;
 		if (result & ZEND_HASH_APPLY_REMOVE) {
-			zend_hash_bucket_delete(ht, p);
+			zend_hash_apply_deleter(ht, idx, p);
 		}
-		p = p_last;
-
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
@@ -741,92 +1021,124 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
 }
 
 
-ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size)
+ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor)
 {
+    uint idx;
 	Bucket *p;
-	void *new_entry;
+	zval *new_entry, *data;
 	zend_bool setTargetPointer;
 
 	IS_CONSISTENT(source);
 	IS_CONSISTENT(target);
 
-	setTargetPointer = !target->pInternalPointer;
-	p = source->pListHead;
-	while (p) {
-		if (setTargetPointer && source->pInternalPointer == p) {
-			target->pInternalPointer = NULL;
+	setTargetPointer = (target->nInternalPointer == INVALID_IDX);
+	for (idx = 0; idx < source->nNumUsed; idx++) {		
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+
+		if (setTargetPointer && source->nInternalPointer == idx) {
+			target->nInternalPointer = INVALID_IDX;
+		}
+		/* INDIRECT element may point to UNDEF-ined slots */
+		data = &p->val;
+		if (Z_TYPE_P(data) == IS_INDIRECT) {
+			data = Z_INDIRECT_P(data);
+			if (Z_TYPE_P(data) == IS_UNDEF) {
+				continue;
+			}
 		}
-		if (p->nKeyLength) {
-			zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &new_entry);
+		if (p->key) {
+			new_entry = zend_hash_update(target, p->key, data);
 		} else {
-			zend_hash_index_update(target, p->h, p->pData, size, &new_entry);
+			new_entry = zend_hash_index_update(target, p->h, data);
 		}
 		if (pCopyConstructor) {
 			pCopyConstructor(new_entry);
 		}
-		p = p->pListNext;
 	}
-	if (!target->pInternalPointer) {
-		target->pInternalPointer = target->pListHead;
+	if (target->nInternalPointer == INVALID_IDX && target->nNumOfElements > 0) {
+		idx = 0;
+		while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
+			idx++;
+		}
+		target->nInternalPointer = idx;
 	}
 }
 
 
-ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC)
+ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, int overwrite ZEND_FILE_LINE_DC)
 {
+    uint idx;
 	Bucket *p;
-	void *t;
+	zval *t;
 	int mode = (overwrite?HASH_UPDATE:HASH_ADD);
 
 	IS_CONSISTENT(source);
 	IS_CONSISTENT(target);
 
-	p = source->pListHead;
-	while (p) {
-		if (p->nKeyLength>0) {
-			if (_zend_hash_quick_add_or_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t, mode ZEND_FILE_LINE_RELAY_CC)==SUCCESS && pCopyConstructor) {
+	for (idx = 0; idx < source->nNumUsed; idx++) {
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key) {
+			t = _zend_hash_add_or_update(target, p->key, &p->val, mode ZEND_FILE_LINE_RELAY_CC);
+			if (t && pCopyConstructor) {
 				pCopyConstructor(t);
 			}
 		} else {
-			if ((mode==HASH_UPDATE || !zend_hash_index_exists(target, p->h)) && zend_hash_index_update(target, p->h, p->pData, size, &t)==SUCCESS && pCopyConstructor) {
-				pCopyConstructor(t);
+			if ((mode==HASH_UPDATE || !zend_hash_index_exists(target, p->h))) {
+			 	t = zend_hash_index_update(target, p->h, &p->val);
+			 	if (t && pCopyConstructor) {
+					pCopyConstructor(t);
+				}
 			}
 		}
-		p = p->pListNext;
 	}
-	target->pInternalPointer = target->pListHead;
+	if (target->nNumOfElements > 0) {
+		idx = 0;
+		while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
+			idx++;
+		}
+		target->nInternalPointer = idx;
+	}
 }
 
 
-static zend_bool zend_hash_replace_checker_wrapper(HashTable *target, void *source_data, Bucket *p, void *pParam, merge_checker_func_t merge_checker_func)
+static zend_bool zend_hash_replace_checker_wrapper(HashTable *target, zval *source_data, Bucket *p, void *pParam, merge_checker_func_t merge_checker_func)
 {
 	zend_hash_key hash_key;
 
-	hash_key.arKey = p->arKey;
-	hash_key.nKeyLength = p->nKeyLength;
 	hash_key.h = p->h;
+	hash_key.key = p->key;
 	return merge_checker_func(target, source_data, &hash_key, pParam);
 }
 
 
-ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)
+ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam)
 {
+	uint idx;
 	Bucket *p;
-	void *t;
+	zval *t;
 
 	IS_CONSISTENT(source);
 	IS_CONSISTENT(target);
 
-	p = source->pListHead;
-	while (p) {
-		if (zend_hash_replace_checker_wrapper(target, p->pData, p, pParam, pMergeSource)) {
-			if (zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t)==SUCCESS && pCopyConstructor) {
+	for (idx = 0; idx < source->nNumUsed; idx++) {
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (zend_hash_replace_checker_wrapper(target, &p->val, p, pParam, pMergeSource)) {
+			t = zend_hash_update(target, p->key, &p->val);
+			if (t && pCopyConstructor) {
 				pCopyConstructor(t);
 			}
 		}
-		p = p->pListNext;
 	}
-	target->pInternalPointer = target->pListHead;
+	if (target->nNumOfElements > 0) {
+		idx = 0;
+		while (Z_TYPE(target->arData[idx].val) == IS_UNDEF) {
+			idx++;
+		}
+		target->nInternalPointer = idx;
+	}
 }
 
 
@@ -834,139 +1146,104 @@ ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor
  * data is returned in pData. The reason is that there's no reason
  * someone using the hash table might not want to have NULL data
  */
-ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
+ZEND_API zval *zend_hash_find(const HashTable *ht, zend_string *key)
 {
-	ulong h;
-	uint nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
-	h = zend_inline_hash_func(arKey, nKeyLength);
-	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if (p->arKey == arKey ||
-			((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
-				*pData = p->pData;
-				return SUCCESS;
-		}
-		p = p->pNext;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		return NULL;
 	}
-	return FAILURE;
-}
 
+	p = zend_hash_find_bucket(ht, key);
+	return p ? &p->val : NULL;
+}
 
-ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData)
+ZEND_API zval *zend_hash_str_find(const HashTable *ht, const char *str, int len)
 {
-	uint nIndex;
+	ulong h;
 	Bucket *p;
 
-	ZEND_ASSERT(nKeyLength != 0);
-
 	IS_CONSISTENT(ht);
 
-	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if (p->arKey == arKey ||
-			((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
-				*pData = p->pData;
-				return SUCCESS;
-		}
-		p = p->pNext;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		return NULL;
 	}
-	return FAILURE;
-}
 
+	h = zend_inline_hash_func(str, len);
+	p = zend_hash_str_find_bucket(ht, str, len, h);
+	return p ? &p->val : NULL;
+}
 
-ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength)
+ZEND_API int zend_hash_exists(const HashTable *ht, zend_string *key)
 {
-	ulong h;
-	uint nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
-	h = zend_inline_hash_func(arKey, nKeyLength);
-	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if (p->arKey == arKey ||
-			((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
-				return 1;
-		}
-		p = p->pNext;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		return 0;
 	}
-	return 0;
-}
 
+	p = zend_hash_find_bucket(ht, key);
+	return p ? 1 : 0;
+}
 
-ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h)
+ZEND_API int zend_hash_str_exists(const HashTable *ht, const char *str, int len)
 {
-	uint nIndex;
+	ulong h;
 	Bucket *p;
 
-	ZEND_ASSERT(nKeyLength != 0);
-
 	IS_CONSISTENT(ht);
 
-	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if (p->arKey == arKey ||
-			((p->h == h) && (p->nKeyLength == nKeyLength) && !memcmp(p->arKey, arKey, nKeyLength))) {
-				return 1;
-		}
-		p = p->pNext;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		return 0;
 	}
-	return 0;
 
+	h = zend_inline_hash_func(str, len);
+	p = zend_hash_str_find_bucket(ht, str, len, h);
+	return p ? 1 : 0;
 }
 
-
-ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)
+ZEND_API zval *zend_hash_index_find(const HashTable *ht, ulong h)
 {
-	uint nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
-	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if ((p->h == h) && (p->nKeyLength == 0)) {
-			*pData = p->pData;
-			return SUCCESS;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		if (h >= 0 && h < ht->nNumUsed) {
+			p = ht->arData + h;
+			if (Z_TYPE(p->val) != IS_UNDEF) {
+				return &p->val;
+			}
 		}
-		p = p->pNext;
+		return NULL;
 	}
-	return FAILURE;
+
+	p = zend_hash_index_find_bucket(ht, h);
+	return p ? &p->val : NULL;
 }
 
 
 ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h)
 {
-	uint nIndex;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
 
-	nIndex = h & ht->nTableMask;
-
-	p = ht->arBuckets[nIndex];
-	while (p != NULL) {
-		if ((p->h == h) && (p->nKeyLength == 0)) {
-			return 1;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		if (h >= 0 && h < ht->nNumUsed) {
+			if (Z_TYPE(ht->arData[h].val) != IS_UNDEF) {
+				return 1;
+			}
 		}
-		p = p->pNext;
+		return 0;
 	}
-	return 0;
+
+	p = zend_hash_index_find_bucket(ht, h);
+	return p ? 1 : 0;
 }
 
 
@@ -980,9 +1257,10 @@ ZEND_API int zend_hash_num_elements(const HashTable *ht)
 
 ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr)
 {
-	ptr->pos = ht->pInternalPointer;
-	if (ht->pInternalPointer) {
-		ptr->h = ht->pInternalPointer->h;
+	ptr->pos = ht->nInternalPointer;
+	ptr->ht = (HashTable*)ht;
+	if (ht->nInternalPointer != INVALID_IDX) {
+		ptr->h = ht->arData[ht->nInternalPointer].h;
 		return 1;
 	} else {
 		ptr->h = 0;
@@ -992,19 +1270,36 @@ ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr)
 
 ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr)
 {
-	if (ptr->pos == NULL) {
-		ht->pInternalPointer = NULL;
-	} else if (ht->pInternalPointer != ptr->pos) {
-		Bucket *p;
+	uint idx;
 
+	if (ptr->pos == INVALID_IDX) {
+		ht->nInternalPointer = INVALID_IDX;
+	} else if (ptr->ht != ht) {
 		IS_CONSISTENT(ht);
-		p = ht->arBuckets[ptr->h & ht->nTableMask];
-		while (p != NULL) {
-			if (p == ptr->pos) {
-				ht->pInternalPointer = p;
+		for (idx = 0; idx < ht->nNumUsed; idx++) {
+			if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
+				ht->nInternalPointer = idx;
+				return 0;
+			}
+		}
+		idx = INVALID_IDX;
+		return 0;
+	} else if (ht->nInternalPointer != ptr->pos) {
+		IS_CONSISTENT(ht);
+		if (ht->u.flags & HASH_FLAG_PACKED) {
+			if (Z_TYPE(ht->arData[ptr->h].val) != IS_UNDEF) {
+				ht->nInternalPointer = ptr->h;
 				return 1;
 			}
-			p = p->pNext;
+		} else {
+			idx = ht->arHash[ptr->h & ht->nTableMask];
+			while (idx != INVALID_IDX) {
+				if (idx == ptr->pos) {
+					ht->nInternalPointer = idx;
+					return 1;
+				}
+				idx = Z_NEXT(ht->arData[idx].val);
+			}
 		}
 		return 0;
 	}
@@ -1013,12 +1308,16 @@ ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr)
 
 ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos)
 {
+    uint idx;
+	
 	IS_CONSISTENT(ht);
-
-	if (pos)
-		*pos = ht->pListHead;
-	else
-		ht->pInternalPointer = ht->pListHead;
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
+			*pos = idx;
+			return;
+		}
+	}
+	*pos = INVALID_IDX;
 }
 
 
@@ -1027,60 +1326,81 @@ ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *p
  */
 ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos)
 {
+	uint idx;
+	
 	IS_CONSISTENT(ht);
 
-	if (pos)
-		*pos = ht->pListTail;
-	else
-		ht->pInternalPointer = ht->pListTail;
+	idx = ht->nNumUsed;
+	while (idx > 0) {
+		idx--;
+		if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
+			*pos = idx;
+			return;
+		}
+	}
+	*pos = INVALID_IDX;
 }
 
 
 ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos)
 {
-	HashPosition *current = pos ? pos : &ht->pInternalPointer;
+	uint idx = *pos;
 
 	IS_CONSISTENT(ht);
 
-	if (*current) {
-		*current = (*current)->pListNext;
-		return SUCCESS;
-	} else
-		return FAILURE;
+	if (idx != INVALID_IDX) {
+		while (1) {
+			idx++;
+			if (idx >= ht->nNumUsed) {
+				*pos = INVALID_IDX;
+				return SUCCESS;
+			}
+			if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
+				*pos = idx;
+				return SUCCESS;
+			}
+		}
+	} else {
+ 		return FAILURE;
+	}
 }
 
 ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos)
 {
-	HashPosition *current = pos ? pos : &ht->pInternalPointer;
+	uint idx = *pos;
 
 	IS_CONSISTENT(ht);
 
-	if (*current) {
-		*current = (*current)->pListLast;
-		return SUCCESS;
-	} else
-		return FAILURE;
+	if (idx != INVALID_IDX) {
+		while (idx > 0) {
+			idx--;
+			if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) {
+				*pos = idx;
+				return SUCCESS;
+			}
+		}
+		*pos = INVALID_IDX;
+ 		return SUCCESS;
+	} else {
+ 		return FAILURE;
+	}
 }
 
 
 /* This function should be made binary safe  */
-ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, uint *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos)
+ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, ulong *num_index, zend_bool duplicate, HashPosition *pos)
 {
+	uint idx = *pos;
 	Bucket *p;
 
-	p = pos ? (*pos) : ht->pInternalPointer;
-
 	IS_CONSISTENT(ht);
-
-	if (p) {
-		if (p->nKeyLength) {
+	if (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if (p->key) {
 			if (duplicate) {
-				*str_index = estrndup(p->arKey, p->nKeyLength - 1);
+				*str_index = STR_COPY(p->key);
 			} else {
-				*str_index = (char*)p->arKey;
-			}
-			if (str_length) {
-				*str_length = p->nKeyLength;
+				*str_index = p->key;
 			}
 			return HASH_KEY_IS_STRING;
 		} else {
@@ -1091,35 +1411,34 @@ ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index,
 	return HASH_KEY_NON_EXISTENT;
 }
 
-ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos) {
+ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos)
+{
+	uint idx = *pos;
 	Bucket *p;
 
 	IS_CONSISTENT(ht);
-
-	p = pos ? (*pos) : ht->pInternalPointer;
-
-	if (!p) {
-		Z_TYPE_P(key) = IS_NULL;
-	} else if (p->nKeyLength) {
-		Z_TYPE_P(key) = IS_STRING;
-		Z_STRVAL_P(key) = IS_INTERNED(p->arKey) ? (char*)p->arKey : estrndup(p->arKey, p->nKeyLength - 1);
-		Z_STRLEN_P(key) = p->nKeyLength - 1;
+	if (idx == INVALID_IDX) {
+		ZVAL_NULL(key);
 	} else {
-		Z_TYPE_P(key) = IS_LONG;
-		Z_LVAL_P(key) = p->h;
+		p = ht->arData + idx;
+		if (p->key) {
+			ZVAL_STR(key, p->key);
+			STR_ADDREF(p->key);
+		} else {
+			ZVAL_LONG(key, p->h);
+		}
 	}
 }
 
 ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos)
 {
+    uint idx = *pos;
 	Bucket *p;
 
-	p = pos ? (*pos) : ht->pInternalPointer;
-
 	IS_CONSISTENT(ht);
-
-	if (p) {
-		if (p->nKeyLength) {
+	if (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		if (p->key) {
 			return HASH_KEY_IS_STRING;
 		} else {
 			return HASH_KEY_IS_LONG;
@@ -1129,158 +1448,118 @@ ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos)
 }
 
 
-ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos)
+ZEND_API zval *zend_hash_get_current_data_ex(HashTable *ht, HashPosition *pos)
 {
+	uint idx = *pos;
 	Bucket *p;
 
-	p = pos ? (*pos) : ht->pInternalPointer;
-
 	IS_CONSISTENT(ht);
-
-	if (p) {
-		*pData = p->pData;
-		return SUCCESS;
+	if (idx != INVALID_IDX) {
+		p = ht->arData + idx;
+		return &p->val;
 	} else {
-		return FAILURE;
+		return NULL;
 	}
 }
 
 /* This function changes key of current element without changing elements'
  * order. If element with target key already exists, it will be deleted first.
  */
-ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, int mode, HashPosition *pos)
+ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, zend_string *str_index, ulong num_index, int mode)
 {
+	uint idx1 = ht->nInternalPointer;
+	uint idx2;
 	Bucket *p, *q;
 	ulong h;
 #ifdef ZEND_SIGNALS
 	TSRMLS_FETCH();
 #endif
 
-	p = pos ? (*pos) : ht->pInternalPointer;
-
 	IS_CONSISTENT(ht);
-
-	if (p) {
+	if (idx1 != INVALID_IDX) {
+		p = ht->arData + idx1;
 		if (key_type == HASH_KEY_IS_LONG) {
-			str_length = 0;
-			if (!p->nKeyLength && p->h == num_index) {
+			if (p->h == num_index && p->key == NULL) {
 				return SUCCESS;
 			}
 
-			q = ht->arBuckets[num_index & ht->nTableMask];
-			while (q != NULL) {
-				if (!q->nKeyLength && q->h == num_index) {
+			idx2 = ht->arHash[num_index & ht->nTableMask];
+			while (idx2 != INVALID_IDX) {
+				q = ht->arData + idx2;
+				if (q->h == num_index && q->key == NULL) {
 					break;
 				}
-				q = q->pNext;
+				idx2 = Z_NEXT(q->val);
 			}
 		} else if (key_type == HASH_KEY_IS_STRING) {
-			if (IS_INTERNED(str_index)) {
-				h = INTERNED_HASH(str_index);
-			} else {
-				h = zend_inline_hash_func(str_index, str_length);
-			}
-
-			if (p->arKey == str_index ||
-			    (p->nKeyLength == str_length &&
-			     p->h == h &&
-			     memcmp(p->arKey, str_index, str_length) == 0)) {
+			h = STR_HASH_VAL(str_index);
+			if (p->key == str_index ||
+			    (p->h == h &&
+			     p->key &&
+			     p->key->len == str_index->len &&
+			     memcmp(p->key->val, str_index->val, str_index->len) == 0)) {
 				return SUCCESS;
 			}
 
-			q = ht->arBuckets[h & ht->nTableMask];
-
-			while (q != NULL) {
-				if (q->arKey == str_index ||
-				    (q->h == h && q->nKeyLength == str_length &&
-				     memcmp(q->arKey, str_index, str_length) == 0)) {
+			idx2 = ht->arHash[h & ht->nTableMask];
+			while (idx2 != INVALID_IDX) {
+				q = ht->arData + idx2;
+				if (q->key == str_index ||
+				    (q->h == h && q->key && q->key->len == str_index->len &&
+				     memcmp(q->key->val, str_index->val, str_index->len) == 0)) {
 					break;
 				}
-				q = q->pNext;
+				idx2 = Z_NEXT(q->val);
 			}
 		} else {
 			return FAILURE;
 		}
 
-		if (q) {
+		HANDLE_BLOCK_INTERRUPTIONS();
+
+		if (idx2 != INVALID_IDX) {
+			/* we have another bucket with the key equal to new one */
 			if (mode != HASH_UPDATE_KEY_ANYWAY) {
-				Bucket *r = p->pListLast;
-				int found = HASH_UPDATE_KEY_IF_BEFORE;
+				int found = (idx1 < idx2) ? HASH_UPDATE_KEY_IF_BEFORE : HASH_UPDATE_KEY_IF_AFTER;
 
-				while (r) {
-					if (r == q) {
-						found = HASH_UPDATE_KEY_IF_AFTER;
-						break;
-					}
-					r = r->pListLast;
-				}
 				if (mode & found) {
 					/* delete current bucket */
-					zend_hash_bucket_delete(ht, p);
+					_zend_hash_del_el(ht, idx1, p);
+					HANDLE_UNBLOCK_INTERRUPTIONS();
 					return FAILURE;
 				}
 			}
-
 			/* delete another bucket with the same key */
-			zend_hash_bucket_delete(ht, q);
-		}
-
-		HANDLE_BLOCK_INTERRUPTIONS();
-
-		if (p->pNext) {
-			p->pNext->pLast = p->pLast;
-		}
-		if (p->pLast) {
-			p->pLast->pNext = p->pNext;
-		} else {
-			ht->arBuckets[p->h & ht->nTableMask] = p->pNext;
-		}
-
-		if ((IS_INTERNED(p->arKey) != IS_INTERNED(str_index)) ||
-		    (!IS_INTERNED(p->arKey) && p->nKeyLength != str_length)) {
-			Bucket *q;
-
-			if (IS_INTERNED(str_index)) {
-				q = (Bucket *) pemalloc(sizeof(Bucket), ht->persistent);
-			} else {
-				q = (Bucket *) pemalloc(sizeof(Bucket) + str_length, ht->persistent);
-			}
-
-			q->nKeyLength = str_length;
-			if (p->pData == &p->pDataPtr) {
-				q->pData = &q->pDataPtr;
-			} else {
-				q->pData = p->pData;
-			}
-			q->pDataPtr = p->pDataPtr;
-
-			CONNECT_TO_GLOBAL_DLLIST_EX(q, ht, p->pListLast, p->pListNext);
-			if (ht->pInternalPointer == p) {
-				ht->pInternalPointer = q;
-			}
-
-			if (pos) {
-				*pos = q;
-			}
-			pefree(p, ht->persistent);
-			p = q;
+			_zend_hash_del_el(ht, idx2, q);
 		}
 
+		/* remove old key from hash */
+		if (ht->arHash[p->h & ht->nTableMask] == idx1) {
+			ht->arHash[p->h & ht->nTableMask] = Z_NEXT(p->val);
+ 		} else {
+			uint idx3 = ht->arHash[p->h & ht->nTableMask];
+			while (Z_NEXT(ht->arData[idx3].val) != idx1) {
+				idx3 = Z_NEXT(ht->arData[idx3].val);
+			} 
+			Z_NEXT(ht->arData[idx3].val) = Z_NEXT(p->val);
+ 		}
+
+		/* update key */
+ 		if (p->key) {
+ 			STR_RELEASE(p->key);
+ 		}
 		if (key_type == HASH_KEY_IS_LONG) {
 			p->h = num_index;
+			p->key = NULL;
 		} else {
 			p->h = h;
-			p->nKeyLength = str_length;
-			if (IS_INTERNED(str_index)) {
-				p->arKey = str_index;
-			} else {
-				p->arKey = (const char*)(p+1);
-				memcpy((char*)p->arKey, str_index, str_length);
-			}
+			p->key = str_index;
+			STR_ADDREF(str_index);
 		}
 
-		CONNECT_TO_BUCKET_DLLIST(p, ht->arBuckets[p->h & ht->nTableMask]);
-		ht->arBuckets[p->h & ht->nTableMask] = p;
+		/* insert new key into hash */
+		Z_NEXT(p->val) = ht->arHash[p->h & ht->nTableMask];
+		ht->arHash[p->h & ht->nTableMask] = idx1;
 		HANDLE_UNBLOCK_INTERRUPTIONS();
 
 		return SUCCESS;
@@ -1289,132 +1568,76 @@ ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const
 	}
 }
 
-/* Performs an in-place splice operation on a hashtable:
- * The elements between offset and offset+length are removed and the elements in list[list_count]
- * are inserted in their place. The removed elements can be optionally collected into a hashtable.
- * This operation reindexes the hashtable, i.e. integer keys will be zero-based and sequential,
- * while string keys stay intact. The same applies to the elements inserted into the removed HT. */
-ZEND_API void _zend_hash_splice(HashTable *ht, uint nDataSize, copy_ctor_func_t pCopyConstructor, uint offset, uint length, void **list, uint list_count, HashTable *removed ZEND_FILE_LINE_DC) /* {{{ */
+ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func,
+							compare_func_t compar, int renumber TSRMLS_DC)
 {
-	int pos;
 	Bucket *p;
+	int i, j;
 
 	IS_CONSISTENT(ht);
-	CHECK_INIT(ht);
-
-	/* Skip all elements until offset */
-	for (pos = 0, p = ht->pListHead; pos < offset && p; pos++, p = p->pListNext);
-
-	while (pos < offset + length && p) {
-		/* Copy removed element into HT, if it was specified */
-		if (removed != NULL) {
-			void *new_entry;
 
-			if (p->nKeyLength == 0) {
-				zend_hash_next_index_insert(removed, p->pData, sizeof(zval *), &new_entry);
-			} else {
-				zend_hash_quick_update(removed, p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval *), &new_entry);
-			}
+	if (!(ht->nNumOfElements>1) && !(renumber && ht->nNumOfElements>0)) { /* Doesn't require sorting */
+		return SUCCESS;
+	}
 
-			if (pCopyConstructor) {
-				pCopyConstructor(new_entry);
+	if (ht->nNumUsed == ht->nNumOfElements) {
+		i = ht->nNumUsed;
+	} else {
+		for (j = 0, i = 0; j < ht->nNumUsed; j++) {
+			p = ht->arData + j;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			if (i != j) {
+				ht->arData[i] = *p;
 			}
+			i++;
 		}
-
-		/* Remove element */
-		{
-			Bucket *p_next = p->pListNext;	
-			zend_hash_bucket_delete(ht, p);
-			p = p_next;
-		}
-
-		pos++;
 	}
 
-	if (list != NULL) {
-		int i;
-		for (i = 0; i < list_count; i++) {
-			/* Add new element only to the global linked list, not the bucket list.
-			 * Also use key 0 for everything, as we'll reindex the hashtable anyways. */
-			Bucket *q = pemalloc_rel(sizeof(Bucket), ht->persistent);
-			q->arKey = NULL;
-			q->nKeyLength = 0;
-			q->h = 0;
-			INIT_DATA(ht, q, list[i], nDataSize);
-
-			CONNECT_TO_GLOBAL_DLLIST_EX(q, ht, p ? p->pListLast : ht->pListTail, p);
+	(*sort_func)((void *) ht->arData, i, sizeof(Bucket), compar TSRMLS_CC);
 
-			ht->nNumOfElements++;
+	HANDLE_BLOCK_INTERRUPTIONS();
+	ht->nNumUsed = i;
+	ht->nInternalPointer = 0;
 
-			if (pCopyConstructor) {
-				pCopyConstructor(q->pData);
+	if (renumber) {
+		for (j = 0; j < i; j++) {
+			p = ht->arData + j;
+			p->h = j;
+			if (p->key) {
+				STR_RELEASE(p->key);
+				p->key = NULL;
 			}
 		}
-
-		ZEND_HASH_IF_FULL_DO_RESIZE(ht);
 	}
-
-	zend_hash_reindex(ht, 1);
-}
-/* }}} */
-
-ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func,
-							compare_func_t compar, int renumber TSRMLS_DC)
-{
-	Bucket **arTmp;
-	Bucket *p;
-	int i, j;
-
-	IS_CONSISTENT(ht);
-
-	if (!(ht->nNumOfElements>1) && !(renumber && ht->nNumOfElements>0)) { /* Doesn't require sorting */
-		return SUCCESS;
-	}
-	arTmp = (Bucket **) pemalloc(ht->nNumOfElements * sizeof(Bucket *), ht->persistent);
-	p = ht->pListHead;
-	i = 0;
-	while (p) {
-		arTmp[i] = p;
-		p = p->pListNext;
-		i++;
+	if (renumber) {
+		ht->nNextFreeElement = i;
 	}
-
-	(*sort_func)((void *) arTmp, i, sizeof(Bucket *), compar TSRMLS_CC);
-
-	HANDLE_BLOCK_INTERRUPTIONS();
-	ht->pListHead = arTmp[0];
-	ht->pListTail = NULL;
-	ht->pInternalPointer = ht->pListHead;
-
-	arTmp[0]->pListLast = NULL;
-	if (i > 1) {
-		arTmp[0]->pListNext = arTmp[1];
-		for (j = 1; j < i-1; j++) {
-			arTmp[j]->pListLast = arTmp[j-1];
-			arTmp[j]->pListNext = arTmp[j+1];
-		}
-		arTmp[j]->pListLast = arTmp[j-1];
-		arTmp[j]->pListNext = NULL;
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		if (!renumber) {
+			zend_hash_packed_to_hash(ht);
+		}
 	} else {
-		arTmp[0]->pListNext = NULL;
+		if (renumber) {
+			ht->u.flags |= HASH_FLAG_PACKED;
+			ht->arData = erealloc(ht->arData, ht->nTableSize * sizeof(Bucket));
+			ht->arHash = (zend_uint*)&uninitialized_bucket;
+		} else {
+			zend_hash_rehash(ht);
+		}
 	}
-	ht->pListTail = arTmp[i-1];
 
-	pefree(arTmp, ht->persistent);
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 
-	if (renumber) {
-		zend_hash_reindex(ht, 0);
-	}
 	return SUCCESS;
 }
 
 
 ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC)
 {
+	uint idx1, idx2;
 	Bucket *p1, *p2 = NULL;
 	int result;
-	void *pData2;
+	zval *pData1, *pData2;
 
 	IS_CONSISTENT(ht1);
 	IS_CONSISTENT(ht2);
@@ -1429,64 +1652,83 @@ ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t co
 		return result;
 	}
 
-	p1 = ht1->pListHead;
-	if (ordered) {
-		p2 = ht2->pListHead;
-	}
+	for (idx1 = 0, idx2 = 0; idx1 < ht1->nNumUsed; idx1++) {
+		p1 = ht1->arData + idx1;
+		if (Z_TYPE(p1->val) == IS_UNDEF) continue;
 
-	while (p1) {
-		if (ordered && !p2) {
-			HASH_UNPROTECT_RECURSION(ht1); 
-			HASH_UNPROTECT_RECURSION(ht2); 
-			return 1; /* That's not supposed to happen */
-		}
 		if (ordered) {
-			if (p1->nKeyLength==0 && p2->nKeyLength==0) { /* numeric indices */
+			while (1) {
+				p2 = ht2->arData + idx2;
+				if (idx2 == ht2->nNumUsed) {
+					HASH_UNPROTECT_RECURSION(ht1); 
+					HASH_UNPROTECT_RECURSION(ht2); 
+					return 1; /* That's not supposed to happen */
+				}
+				if (Z_TYPE(p2->val) != IS_UNDEF) break;
+				idx2++;
+			}						
+			if (p1->key == NULL && p2->key == NULL) { /* numeric indices */
 				result = p1->h - p2->h;
-				if (result!=0) {
+				if (result != 0) {
 					HASH_UNPROTECT_RECURSION(ht1); 
 					HASH_UNPROTECT_RECURSION(ht2); 
 					return result;
 				}
 			} else { /* string indices */
-				result = p1->nKeyLength - p2->nKeyLength;
-				if (result!=0) {
+				result = (p1->key ? p1->key->len : 0) - (p2->key ? p2->key->len : 0);
+				if (result != 0) {
 					HASH_UNPROTECT_RECURSION(ht1); 
 					HASH_UNPROTECT_RECURSION(ht2); 
 					return result;
 				}
-				result = memcmp(p1->arKey, p2->arKey, p1->nKeyLength);
-				if (result!=0) {
+				result = memcmp(p1->key->val, p2->key->val, p1->key->len);
+				if (result != 0) {
 					HASH_UNPROTECT_RECURSION(ht1); 
 					HASH_UNPROTECT_RECURSION(ht2); 
 					return result;
 				}
 			}
-			pData2 = p2->pData;
+			pData2 = &p2->val;
 		} else {
-			if (p1->nKeyLength==0) { /* numeric index */
-				if (zend_hash_index_find(ht2, p1->h, &pData2)==FAILURE) {
+			if (p1->key == NULL) { /* numeric index */
+				pData2 = zend_hash_index_find(ht2, p1->h);
+				if (pData2 == NULL) {
 					HASH_UNPROTECT_RECURSION(ht1); 
 					HASH_UNPROTECT_RECURSION(ht2); 
 					return 1;
 				}
 			} else { /* string index */
-				if (zend_hash_quick_find(ht2, p1->arKey, p1->nKeyLength, p1->h, &pData2)==FAILURE) {
+				pData2 = zend_hash_find(ht2, p1->key);
+				if (pData2 == NULL) {
 					HASH_UNPROTECT_RECURSION(ht1); 
 					HASH_UNPROTECT_RECURSION(ht2); 
 					return 1;
 				}
 			}
 		}
-		result = compar(p1->pData, pData2 TSRMLS_CC);
-		if (result!=0) {
+		pData1 = &p1->val;
+		if (Z_TYPE_P(pData1) == IS_INDIRECT) {
+			pData1 = Z_INDIRECT_P(pData1);
+		}
+		if (Z_TYPE_P(pData2) == IS_INDIRECT) {
+			pData2 = Z_INDIRECT_P(pData2);
+		}
+		if (Z_TYPE_P(pData1) == IS_UNDEF) {
+			if (Z_TYPE_P(pData2) != IS_UNDEF) {
+				return -1;
+			}
+		} else if (Z_TYPE_P(pData2) == IS_UNDEF) {
+			return 1;
+		} else {
+			result = compar(pData1, pData2 TSRMLS_CC);
+		}
+		if (result != 0) {
 			HASH_UNPROTECT_RECURSION(ht1); 
 			HASH_UNPROTECT_RECURSION(ht2); 
 			return result;
 		}
-		p1 = p1->pListNext;
 		if (ordered) {
-			p2 = p2->pListNext;
+			idx2++;
 		}
 	}
 	
@@ -1496,31 +1738,41 @@ ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t co
 }
 
 
-ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC)
+ZEND_API zval *zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag TSRMLS_DC)
 {
+	uint idx;
 	Bucket *p, *res;
 
 	IS_CONSISTENT(ht);
 
 	if (ht->nNumOfElements == 0 ) {
-		*pData=NULL;
-		return FAILURE;
+		return NULL;
 	}
 
-	res = p = ht->pListHead;
-	while ((p = p->pListNext)) {
+	idx = 0;
+	while (1) {
+		if (idx == ht->nNumUsed) {
+			return NULL;
+		}
+		if (Z_TYPE(ht->arData[idx].val) != IS_UNDEF) break;
+		idx++;
+	}
+	res = ht->arData + idx;
+	for (; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		
 		if (flag) {
-			if (compar(&res, &p TSRMLS_CC) < 0) { /* max */
+			if (compar(res, p TSRMLS_CC) < 0) { /* max */
 				res = p;
 			}
 		} else {
-			if (compar(&res, &p TSRMLS_CC) > 0) { /* min */
+			if (compar(res, p TSRMLS_CC) > 0) { /* min */
 				res = p;
 			}
 		}
 	}
-	*pData = res->pData;
-	return SUCCESS;
+	return &res->val;
 }
 
 ZEND_API ulong zend_hash_next_free_element(const HashTable *ht)
@@ -1531,44 +1783,6 @@ ZEND_API ulong zend_hash_next_free_element(const HashTable *ht)
 
 }
 
-
-#if ZEND_DEBUG
-void zend_hash_display_pListTail(const HashTable *ht)
-{
-	Bucket *p;
-
-	p = ht->pListTail;
-	while (p != NULL) {
-		zend_output_debug_string(0, "pListTail has key %s\n", p->arKey);
-		p = p->pListLast;
-	}
-}
-
-void zend_hash_display(const HashTable *ht)
-{
-	Bucket *p;
-	uint i;
-
-	if (UNEXPECTED(ht->nNumOfElements == 0)) {
-		zend_output_debug_string(0, "The hash is empty");
-		return;
-	}
-	for (i = 0; i < ht->nTableSize; i++) {
-		p = ht->arBuckets[i];
-		while (p != NULL) {
-			zend_output_debug_string(0, "%s <==> 0x%lX\n", p->arKey, p->h);
-			p = p->pNext;
-		}
-	}
-
-	p = ht->pListTail;
-	while (p != NULL) {
-		zend_output_debug_string(0, "%s <==> 0x%lX\n", p->arKey, p->h);
-		p = p->pListLast;
-	}
-}
-#endif
-
 /*
  * Local variables:
  * tab-width: 4
diff --git a/Zend/zend_hash.h b/Zend/zend_hash.h
index 03f83dfb18..3db7abdf11 100644
--- a/Zend/zend_hash.h
+++ b/Zend/zend_hash.h
@@ -30,109 +30,83 @@
 #define HASH_KEY_NON_EXISTENT 3
 #define HASH_KEY_NON_EXISTANT HASH_KEY_NON_EXISTENT /* Keeping old define (with typo) for backward compatibility */
 
-#define HASH_UPDATE 		(1<<0)
-#define HASH_ADD			(1<<1)
-#define HASH_NEXT_INSERT	(1<<2)
-
-#define HASH_DEL_KEY 0
-#define HASH_DEL_INDEX 1
-#define HASH_DEL_KEY_QUICK 2
+#define HASH_UPDATE 			(1<<0)
+#define HASH_ADD				(1<<1)
+#define HASH_NEXT_INSERT		(1<<2)
+#define HASH_UPDATE_INDIRECT	(1<<3)
 
 #define HASH_UPDATE_KEY_IF_NONE    0
 #define HASH_UPDATE_KEY_IF_BEFORE  1
 #define HASH_UPDATE_KEY_IF_AFTER   2
 #define HASH_UPDATE_KEY_ANYWAY     3
 
-typedef ulong (*hash_func_t)(const char *arKey, uint nKeyLength);
-typedef int  (*compare_func_t)(const void *, const void * TSRMLS_DC);
-typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t TSRMLS_DC);
-typedef void (*dtor_func_t)(void *pDest);
-typedef void (*copy_ctor_func_t)(void *pElement);
-typedef void (*copy_ctor_param_func_t)(void *pElement, void *pParam);
-
-struct _hashtable;
-
-typedef struct bucket {
-	ulong h;						/* Used for numeric indexing */
-	uint nKeyLength;
-	void *pData;
-	void *pDataPtr;
-	struct bucket *pListNext;
-	struct bucket *pListLast;
-	struct bucket *pNext;
-	struct bucket *pLast;
-	const char *arKey;
-} Bucket;
-
-typedef struct _hashtable {
-	uint nTableSize;
-	uint nTableMask;
-	uint nNumOfElements;
-	ulong nNextFreeElement;
-	Bucket *pInternalPointer;	/* Used for element traversal */
-	Bucket *pListHead;
-	Bucket *pListTail;
-	Bucket **arBuckets;
-	dtor_func_t pDestructor;
-	zend_bool persistent;
-	unsigned char nApplyCount;
-	zend_bool bApplyProtection;
-#if ZEND_DEBUG
-	int inconsistent;
-#endif
-} HashTable;
+#define INVALID_IDX ((uint)-1)
 
+#define HASH_FLAG_PERSISTENT       (1<<0)
+#define HASH_FLAG_APPLY_PROTECTION (1<<1)
+#define HASH_FLAG_PACKED           (1<<2)
+
+#define HASH_MASK_CONSISTENCY      0x60
 
 typedef struct _zend_hash_key {
-	const char *arKey;
-	uint nKeyLength;
-	ulong h;
+	ulong        h;
+	zend_string *key;
 } zend_hash_key;
 
+typedef zend_bool (*merge_checker_func_t)(HashTable *target_ht, zval *source_data, zend_hash_key *hash_key, void *pParam);
 
-typedef zend_bool (*merge_checker_func_t)(HashTable *target_ht, void *source_data, zend_hash_key *hash_key, void *pParam);
-
-typedef Bucket* HashPosition;
+typedef uint HashPosition;
 
 BEGIN_EXTERN_C()
 
 /* startup/shutdown */
-ZEND_API int _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC);
-ZEND_API int _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC);
+ZEND_API void _zend_hash_init(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC);
+ZEND_API void _zend_hash_init_ex(HashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC);
 ZEND_API void zend_hash_destroy(HashTable *ht);
 ZEND_API void zend_hash_clean(HashTable *ht);
 #define zend_hash_init(ht, nSize, pHashFunction, pDestructor, persistent)						_zend_hash_init((ht), (nSize), (pDestructor), (persistent) ZEND_FILE_LINE_CC)
 #define zend_hash_init_ex(ht, nSize, pHashFunction, pDestructor, persistent, bApplyProtection)		_zend_hash_init_ex((ht), (nSize), (pDestructor), (persistent), (bApplyProtection) ZEND_FILE_LINE_CC)
 
-/* additions/updates/changes */
-ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
-#define zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-		_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
-#define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-		_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
-
-ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
-#define zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-		_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
-#define zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-		_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
-
-ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
-#define zend_hash_index_update(ht, h, pData, nDataSize, pDest) \
-		_zend_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
-#define zend_hash_next_index_insert(ht, pData, nDataSize, pDest) \
-		_zend_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
-
-ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, uint nKeyLength);
+ZEND_API void zend_hash_real_init(HashTable *ht, int packed);
+ZEND_API void zend_hash_packed_to_hash(HashTable *ht);
+ZEND_API void zend_hash_to_packed(HashTable *ht);
 
+/* additions/updates/changes */
+ZEND_API zval *_zend_hash_add_or_update(HashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC);
+#define zend_hash_update(ht, key, pData) \
+		_zend_hash_add_or_update(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_hash_update_ind(ht, key, pData) \
+		_zend_hash_add_or_update(ht, key, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_CC)
+#define zend_hash_add(ht, key, pData) \
+		_zend_hash_add_or_update(ht, key, pData, HASH_ADD ZEND_FILE_LINE_CC)
+
+ZEND_API zval *_zend_hash_str_add_or_update(HashTable *ht, const char *key, int len, zval *pData, int flag ZEND_FILE_LINE_DC);
+#define zend_hash_str_update(ht, key, len, pData) \
+		_zend_hash_str_add_or_update(ht, key, len, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_hash_str_update_ind(ht, key, len, pData) \
+		_zend_hash_str_add_or_update(ht, key, len, pData, HASH_UPDATE | HASH_UPDATE_INDIRECT ZEND_FILE_LINE_CC)
+#define zend_hash_str_add(ht, key, len, pData) \
+		_zend_hash_str_add_or_update(ht, key, len, pData, HASH_ADD ZEND_FILE_LINE_CC)
+
+ZEND_API zval *_zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC);
+#define zend_hash_index_add(ht, h, pData) \
+		_zend_hash_index_update_or_next_insert(ht, h, pData, HASH_ADD ZEND_FILE_LINE_CC)
+#define zend_hash_index_update(ht, h, pData) \
+		_zend_hash_index_update_or_next_insert(ht, h, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_hash_next_index_insert(ht, pData) \
+		_zend_hash_index_update_or_next_insert(ht, 0, pData, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
+
+ZEND_API zval *zend_hash_index_add_empty_element(HashTable *ht, ulong h);
+ZEND_API zval *zend_hash_add_empty_element(HashTable *ht, zend_string *key);
+ZEND_API zval *zend_hash_str_add_empty_element(HashTable *ht, const char *key, int len);
 
 #define ZEND_HASH_APPLY_KEEP				0
 #define ZEND_HASH_APPLY_REMOVE				1<<0
 #define ZEND_HASH_APPLY_STOP				1<<1
 
-typedef int (*apply_func_t)(void *pDest TSRMLS_DC);
-typedef int (*apply_func_arg_t)(void *pDest, void *argument TSRMLS_DC);
-typedef int (*apply_func_args_t)(void *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key);
+typedef int (*apply_func_t)(zval *pDest TSRMLS_DC);
+typedef int (*apply_func_arg_t)(zval *pDest, void *argument TSRMLS_DC);
+typedef int (*apply_func_args_t)(zval *pDest TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key);
 
 ZEND_API void zend_hash_graceful_destroy(HashTable *ht);
 ZEND_API void zend_hash_graceful_reverse_destroy(HashTable *ht);
@@ -150,24 +124,20 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
 
 
 /* Deletes */
-ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, uint nKeyLength, ulong h, int flag);
-#define zend_hash_del(ht, arKey, nKeyLength) \
-		zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY)
-#define zend_hash_quick_del(ht, arKey, nKeyLength, h) \
-		zend_hash_del_key_or_index(ht, arKey, nKeyLength, h, HASH_DEL_KEY_QUICK)
-#define zend_hash_index_del(ht, h) \
-		zend_hash_del_key_or_index(ht, NULL, 0, h, HASH_DEL_INDEX)
-#define zend_get_hash_value \
-		zend_hash_func
+ZEND_API int zend_hash_del(HashTable *ht, zend_string *key);
+ZEND_API int zend_hash_del_ind(HashTable *ht, zend_string *key);
+ZEND_API int zend_hash_str_del(HashTable *ht, const char *key, int len);
+ZEND_API int zend_hash_str_del_ind(HashTable *ht, const char *key, int len);
+ZEND_API int zend_hash_index_del(HashTable *ht, ulong h);
 
 /* Data retreival */
-ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h, void **pData);
-ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData);
+ZEND_API zval *zend_hash_find(const HashTable *ht, zend_string *key);
+ZEND_API zval *zend_hash_str_find(const HashTable *ht, const char *key, int len);
+ZEND_API zval *zend_hash_index_find(const HashTable *ht, ulong h);
 
 /* Misc */
-ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, uint nKeyLength);
-ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, uint nKeyLength, ulong h);
+ZEND_API int zend_hash_exists(const HashTable *ht, zend_string *key);
+ZEND_API int zend_hash_str_exists(const HashTable *ht, const char *str, int len);
 ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h);
 ZEND_API ulong zend_hash_next_free_element(const HashTable *ht);
 
@@ -176,16 +146,17 @@ ZEND_API ulong zend_hash_next_free_element(const HashTable *ht);
 	(zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS)
 ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
 ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, uint *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos);
+ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, zend_string **str_index, ulong *num_index, zend_bool duplicate, HashPosition *pos);
 ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos);
 ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
+ZEND_API zval *zend_hash_get_current_data_ex(HashTable *ht, HashPosition *pos);
 ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
 ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
-ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, uint str_length, ulong num_index, int mode, HashPosition *pos);
+ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, zend_string *str_index, ulong num_index, int mode);
 
 typedef struct _HashPointer {
 	HashPosition pos;
+	HashTable *ht;
 	ulong h;
 } HashPointer;
 
@@ -193,110 +164,40 @@ ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr);
 ZEND_API int zend_hash_set_pointer(HashTable *ht, const HashPointer *ptr);
 
 #define zend_hash_has_more_elements(ht) \
-	zend_hash_has_more_elements_ex(ht, NULL)
+	zend_hash_has_more_elements_ex(ht, &(ht)->nInternalPointer)
 #define zend_hash_move_forward(ht) \
-	zend_hash_move_forward_ex(ht, NULL)
+	zend_hash_move_forward_ex(ht, &(ht)->nInternalPointer)
 #define zend_hash_move_backwards(ht) \
-	zend_hash_move_backwards_ex(ht, NULL)
+	zend_hash_move_backwards_ex(ht, &(ht)->nInternalPointer)
 #define zend_hash_get_current_key(ht, str_index, num_index, duplicate) \
-	zend_hash_get_current_key_ex(ht, str_index, NULL, num_index, duplicate, NULL)
+	zend_hash_get_current_key_ex(ht, str_index, num_index, duplicate, &(ht)->nInternalPointer)
 #define zend_hash_get_current_key_zval(ht, key) \
-	zend_hash_get_current_key_zval_ex(ht, key, NULL)
+	zend_hash_get_current_key_zval_ex(ht, key, &(ht)->nInternalPointer)
 #define zend_hash_get_current_key_type(ht) \
-	zend_hash_get_current_key_type_ex(ht, NULL)
-#define zend_hash_get_current_data(ht, pData) \
-	zend_hash_get_current_data_ex(ht, pData, NULL)
+	zend_hash_get_current_key_type_ex(ht, &(ht)->nInternalPointer)
+#define zend_hash_get_current_data(ht) \
+	zend_hash_get_current_data_ex(ht, &(ht)->nInternalPointer)
 #define zend_hash_internal_pointer_reset(ht) \
-	zend_hash_internal_pointer_reset_ex(ht, NULL)
+	zend_hash_internal_pointer_reset_ex(ht, &(ht)->nInternalPointer)
 #define zend_hash_internal_pointer_end(ht) \
-	zend_hash_internal_pointer_end_ex(ht, NULL)
+	zend_hash_internal_pointer_end_ex(ht, &(ht)->nInternalPointer)
 #define zend_hash_update_current_key(ht, key_type, str_index, str_length, num_index) \
-	zend_hash_update_current_key_ex(ht, key_type, str_index, str_length, num_index, HASH_UPDATE_KEY_ANYWAY, NULL)
+	zend_hash_update_current_key_ex(ht, key_type, str_index, str_length, num_index, HASH_UPDATE_KEY_ANYWAY)
 
 /* Copying, merging and sorting */
-ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
-ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite ZEND_FILE_LINE_DC);
-ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam);
+ZEND_API void zend_hash_copy(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor);
+ZEND_API void _zend_hash_merge(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, int overwrite ZEND_FILE_LINE_DC);
+ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam);
 ZEND_API int zend_hash_sort(HashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber TSRMLS_DC);
 ZEND_API int zend_hash_compare(HashTable *ht1, HashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC);
-ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC);
+ZEND_API zval *zend_hash_minmax(const HashTable *ht, compare_func_t compar, int flag TSRMLS_DC);
 
-#define zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite)					\
-	_zend_hash_merge(target, source, pCopyConstructor, tmp, size, overwrite ZEND_FILE_LINE_CC)
+#define zend_hash_merge(target, source, pCopyConstructor, overwrite)					\
+	_zend_hash_merge(target, source, pCopyConstructor, overwrite ZEND_FILE_LINE_CC)
 
 ZEND_API int zend_hash_num_elements(const HashTable *ht);
 
 ZEND_API int zend_hash_rehash(HashTable *ht);
-ZEND_API void zend_hash_reindex(HashTable *ht, zend_bool only_integer_keys);
-
-ZEND_API void _zend_hash_splice(HashTable *ht, uint nDataSize, copy_ctor_func_t pCopyConstructor, uint offset, uint length, void **list, uint list_count, HashTable *removed ZEND_FILE_LINE_DC);
-#define zend_hash_splice(ht, nDataSize, pCopyConstructor, offset, length, list, list_count, removed) \
-	_zend_hash_splice(ht, nDataSize, pCopyConstructor, offset, length, list, list_count, removed ZEND_FILE_LINE_CC)
-
-/*
- * DJBX33A (Daniel J. Bernstein, Times 33 with Addition)
- *
- * This is Daniel J. Bernstein's popular `times 33' hash function as
- * posted by him years ago on comp.lang.c. It basically uses a function
- * like ``hash(i) = hash(i-1) * 33 + str[i]''. This is one of the best
- * known hash functions for strings. Because it is both computed very
- * fast and distributes very well.
- *
- * The magic of number 33, i.e. why it works better than many other
- * constants, prime or not, has never been adequately explained by
- * anyone. So I try an explanation: if one experimentally tests all
- * multipliers between 1 and 256 (as RSE did now) one detects that even
- * numbers are not useable at all. The remaining 128 odd numbers
- * (except for the number 1) work more or less all equally well. They
- * all distribute in an acceptable way and this way fill a hash table
- * with an average percent of approx. 86%. 
- *
- * If one compares the Chi^2 values of the variants, the number 33 not
- * even has the best value. But the number 33 and a few other equally
- * good numbers like 17, 31, 63, 127 and 129 have nevertheless a great
- * advantage to the remaining numbers in the large set of possible
- * multipliers: their multiply operation can be replaced by a faster
- * operation based on just one shift plus either a single addition
- * or subtraction operation. And because a hash function has to both
- * distribute good _and_ has to be very fast to compute, those few
- * numbers should be preferred and seems to be the reason why Daniel J.
- * Bernstein also preferred it.
- *
- *
- *                  -- Ralf S. Engelschall <rse@engelschall.com>
- */
-
-static inline ulong zend_inline_hash_func(const char *arKey, uint nKeyLength)
-{
-	register ulong hash = 5381;
-
-	/* variant with the hash unrolled eight times */
-	for (; nKeyLength >= 8; nKeyLength -= 8) {
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-		hash = ((hash << 5) + hash) + *arKey++;
-	}
-	switch (nKeyLength) {
-		case 7: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
-		case 6: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
-		case 5: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
-		case 4: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
-		case 3: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
-		case 2: hash = ((hash << 5) + hash) + *arKey++; /* fallthrough... */
-		case 1: hash = ((hash << 5) + hash) + *arKey++; break;
-		case 0: break;
-EMPTY_SWITCH_DEFAULT_CASE()
-	}
-	return hash;
-}
-
-
-ZEND_API ulong zend_hash_func(const char *arKey, uint nKeyLength);
 
 #if ZEND_DEBUG
 /* debug */
@@ -307,7 +208,7 @@ void zend_hash_display(const HashTable *ht);
 END_EXTERN_C()
 
 #define ZEND_INIT_SYMTABLE(ht)								\
-	ZEND_INIT_SYMTABLE_EX(ht, 2, 0)
+	ZEND_INIT_SYMTABLE_EX(ht, 8, 0)
 
 #define ZEND_INIT_SYMTABLE_EX(ht, n, persistent)			\
 	zend_hash_init(ht, n, NULL, ZVAL_PTR_DTOR, persistent)
@@ -353,41 +254,391 @@ END_EXTERN_C()
 	ZEND_HANDLE_NUMERIC_EX(key, length, idx, return func);					\
 } while (0)
 
-static inline int zend_symtable_update(HashTable *ht, const char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest)					\
+
+static inline zval *zend_hash_find_ind(const HashTable *ht, zend_string *key)
+{
+	zval *zv;
+
+	zv = zend_hash_find(ht, key);
+	return (zv && Z_TYPE_P(zv) == IS_INDIRECT) ? Z_INDIRECT_P(zv) : zv;
+}
+
+
+static inline int zend_hash_exists_ind(const HashTable *ht, zend_string *key)
+{
+	zval *zv;
+
+	zv = zend_hash_find(ht, key);
+	return zv && (Z_TYPE_P(zv) != IS_INDIRECT ||
+			Z_TYPE_P(Z_INDIRECT_P(zv)) != IS_UNDEF);
+}
+
+
+static inline zval *zend_hash_str_find_ind(const HashTable *ht, const char *str, int len)
+{
+	zval *zv;
+
+	zv = zend_hash_str_find(ht, str, len);
+	return (zv && Z_TYPE_P(zv) == IS_INDIRECT) ? Z_INDIRECT_P(zv) : zv;
+}
+
+
+static inline zval *zend_symtable_update(HashTable *ht, zend_string *key, zval *pData)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_update(ht, idx, pData));
+	return zend_hash_update(ht, key, pData);
+}
+
+
+static inline zval *zend_symtable_update_ind(HashTable *ht, zend_string *key, zval *pData)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_update(ht, idx, pData));
+	return zend_hash_update_ind(ht, key, pData);
+}
+
+
+static inline int zend_symtable_del(HashTable *ht, zend_string *key)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_del(ht, idx));
+	return zend_hash_del(ht, key);
+}
+
+
+static inline int zend_symtable_del_ind(HashTable *ht, zend_string *key)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_del(ht, idx));
+	return zend_hash_del_ind(ht, key);
+}
+
+
+static inline zval *zend_symtable_find(const HashTable *ht, zend_string *key)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_find(ht, idx));
+	return zend_hash_find(ht, key);
+}
+
+
+static inline zval *zend_symtable_find_ind(const HashTable *ht, zend_string *key)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_find(ht, idx));
+	return zend_hash_find_ind(ht, key);
+}
+
+
+static inline int zend_symtable_exists(HashTable *ht, zend_string *key)
+{
+	ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_index_exists(ht, idx));
+	return zend_hash_exists(ht, key);
+}
+
+
+static inline zval *zend_symtable_str_update(HashTable *ht, const char *str, int len, zval *pData)
+{
+	ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_update(ht, idx, pData));
+	return zend_hash_str_update(ht, str, len, pData);
+}
+
+
+static inline zval *zend_symtable_str_update_ind(HashTable *ht, const char *str, int len, zval *pData)
 {
-	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update(ht, idx, pData, nDataSize, pDest));
-	return zend_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest);
+	ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_update(ht, idx, pData));
+	return zend_hash_str_update_ind(ht, str, len, pData);
 }
 
 
-static inline int zend_symtable_del(HashTable *ht, const char *arKey, uint nKeyLength)
+static inline int zend_symtable_str_del(HashTable *ht, const char *str, int len)
 {
-	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_del(ht, idx));
-	return zend_hash_del(ht, arKey, nKeyLength);
+	ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_del(ht, idx));
+	return zend_hash_str_del(ht, str, len);
 }
 
 
-static inline int zend_symtable_find(HashTable *ht, const char *arKey, uint nKeyLength, void **pData)
+static inline int zend_symtable_str_del_ind(HashTable *ht, const char *str, int len)
 {
-	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
-	return zend_hash_find(ht, arKey, nKeyLength, pData);
+	ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_del(ht, idx));
+	return zend_hash_str_del_ind(ht, str, len);
 }
 
 
-static inline int zend_symtable_exists(HashTable *ht, const char *arKey, uint nKeyLength)
+static inline zval *zend_symtable_str_find(HashTable *ht, const char *str, int len)
 {
-	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
-	return zend_hash_exists(ht, arKey, nKeyLength);
+	ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_find(ht, idx));
+	return zend_hash_str_find(ht, str, len);
 }
 
-static inline int zend_symtable_update_current_key_ex(HashTable *ht, const char *arKey, uint nKeyLength, int mode, HashPosition *pos)
+
+static inline int zend_symtable_str_exists(HashTable *ht, const char *str, int len)
+{
+	ZEND_HANDLE_NUMERIC(str, len+1, zend_hash_index_exists(ht, idx));
+	return zend_hash_str_exists(ht, str, len);
+}
+
+static inline int zend_symtable_update_current_key_ex(HashTable *ht, zend_string *key, int mode)
+{
+ZEND_HANDLE_NUMERIC(key->val, key->len+1, zend_hash_update_current_key_ex(ht, HASH_KEY_IS_LONG, NULL, idx, mode));
+	return zend_hash_update_current_key_ex(ht, HASH_KEY_IS_STRING, key, 0, mode);
+}
+
+static inline void *zend_hash_add_ptr(HashTable *ht, zend_string *key, void *pData)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, pData);
+	zv = zend_hash_add(ht, key, &tmp);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_str_add_ptr(HashTable *ht, const char *str, int len, void *pData)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, pData);
+	zv = zend_hash_str_add(ht, str, len, &tmp);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_update_ptr(HashTable *ht, zend_string *key, void *pData)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, pData);
+	zv = zend_hash_update(ht, key, &tmp);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_str_update_ptr(HashTable *ht, const char *str, int len, void *pData)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, pData);
+	zv = zend_hash_str_update(ht, str, len, &tmp);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_add_mem(HashTable *ht, zend_string *key, void *pData, size_t size)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, NULL);
+	if ((zv = zend_hash_add(ht, key, &tmp))) {
+		Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT);
+		memcpy(Z_PTR_P(zv), pData, size);
+		return Z_PTR_P(zv);
+	}
+	return NULL;
+}
+
+static inline void *zend_hash_str_add_mem(HashTable *ht, const char *str, int len, void *pData, size_t size)
 {
-	ZEND_HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_update_current_key_ex(ht, HASH_KEY_IS_LONG, NULL, 0, idx, mode, pos));
-	return zend_hash_update_current_key_ex(ht, HASH_KEY_IS_STRING, arKey, nKeyLength, 0, mode, pos);
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, NULL);
+	if ((zv = zend_hash_str_add(ht, str, len, &tmp))) {
+		Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT);
+		memcpy(Z_PTR_P(zv), pData, size);
+		return Z_PTR_P(zv);
+	}
+	return NULL;
+}
+
+static inline void *zend_hash_update_mem(HashTable *ht, zend_string *key, void *pData, size_t size)
+{
+	void *p;
+
+	p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT);
+	memcpy(p, pData, size);
+	return zend_hash_update_ptr(ht, key, p);
+}
+
+static inline void *zend_hash_str_update_mem(HashTable *ht, const char *str, int len, void *pData, size_t size)
+{
+	void *p;
+
+	p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT);
+	memcpy(p, pData, size);
+	return zend_hash_str_update_ptr(ht, str, len, p);
+}
+
+static inline void *zend_hash_index_update_ptr(HashTable *ht, ulong h, void *pData)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, pData);
+	zv = zend_hash_index_update(ht, h, &tmp);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_next_index_insert_ptr(HashTable *ht, void *pData)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, pData);
+	zv = zend_hash_next_index_insert(ht, &tmp);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_index_update_mem(HashTable *ht, ulong h, void *pData, size_t size)
+{
+	void *p;
+
+	p = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT);
+	memcpy(p, pData, size);
+	return zend_hash_index_update_ptr(ht, h, p);
+}
+
+static inline void *zend_hash_next_index_insert_mem(HashTable *ht, void *pData, size_t size)
+{
+	zval tmp, *zv;
+
+	ZVAL_PTR(&tmp, NULL);
+	if ((zv = zend_hash_next_index_insert(ht, &tmp))) {
+		Z_PTR_P(zv) = pemalloc(size, ht->u.flags & HASH_FLAG_PERSISTENT);
+		memcpy(Z_PTR_P(zv), pData, size);
+		return Z_PTR_P(zv);
+	}
+	return NULL;
+}
+
+static inline void *zend_hash_find_ptr(const HashTable *ht, zend_string *key)
+{
+	zval *zv;
+
+	zv = zend_hash_find(ht, key);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_str_find_ptr(const HashTable *ht, const char *str, int len)
+{
+	zval *zv;
+
+	zv = zend_hash_str_find(ht, str, len);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_index_find_ptr(const HashTable *ht, ulong h)
+{
+	zval *zv;
+
+	zv = zend_hash_index_find(ht, h);
+	return zv ? Z_PTR_P(zv) : NULL;
+}
+
+static inline void *zend_hash_get_current_data_ptr_ex(HashTable *ht, HashPosition *pos)
+{
+	zval *zv;
+
+	zv = zend_hash_get_current_data_ex(ht, pos);
+	return zv ? Z_PTR_P(zv) : NULL;
 }
-#define zend_symtable_update_current_key(ht,arKey,nKeyLength,mode) \
-	zend_symtable_update_current_key_ex(ht, arKey, nKeyLength, mode, NULL)
 
+#define zend_hash_get_current_data_ptr(ht) \
+	zend_hash_get_current_data_ptr_ex(ht, &(ht)->nInternalPointer)
+
+#define ZEND_HASH_FOREACH(_ht, indirect) do { \
+		uint _idx; \
+		for (_idx = 0; _idx < (_ht)->nNumUsed; _idx++) { \
+			Bucket *_p = (_ht)->arData + _idx; \
+			zval *_z = &_p->val; \
+			if (indirect && Z_TYPE_P(_z) == IS_INDIRECT) { \
+				_z = Z_INDIRECT_P(_z); \
+			} \
+			if (Z_TYPE_P(_z) == IS_UNDEF) continue;
+
+#define ZEND_HASH_REVERSE_FOREACH(_ht, indirect) do { \
+		uint _idx; \
+		for (_idx = (_ht)->nNumUsed; _idx > 0; _idx--) { \
+			Bucket *_p = (_ht)->arData + _idx - 1; \
+			zval *_z = &_p->val; \
+			if (indirect && Z_TYPE_P(_z) == IS_INDIRECT) { \
+				_z = Z_INDIRECT_P(_z); \
+			} \
+			if (Z_TYPE_P(_z) == IS_UNDEF) continue;
+
+#define ZEND_HASH_FOREACH_END() \
+		} \
+	} while (0)
+	
+#define ZEND_HASH_FOREACH_VAL(ht, _val) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_val = _z;
+
+#define ZEND_HASH_FOREACH_VAL_IND(ht, _val) \
+	ZEND_HASH_FOREACH(ht, 1); \
+	_val = _z;
+
+#define ZEND_HASH_FOREACH_PTR(ht, _ptr) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_ptr = Z_PTR_P(_z);
+
+#define ZEND_HASH_FOREACH_NUM_KEY(ht, _h) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_h = _p->h;
+
+#define ZEND_HASH_FOREACH_STR_KEY(ht, _key) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_key = _p->key;
+		
+#define ZEND_HASH_FOREACH_KEY(ht, _h, _key) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_h = _p->h; \
+	_key = _p->key;
+		
+#define ZEND_HASH_FOREACH_STR_KEY_VAL(ht, _key, _val) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_key = _p->key; \
+	_val = _z;
+
+#define ZEND_HASH_FOREACH_KEY_VAL(ht, _h, _key, _val) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_h = _p->h; \
+	_key = _p->key; \
+	_val = _z;
+
+#define ZEND_HASH_FOREACH_STR_KEY_VAL_IND(ht, _key, _val) \
+	ZEND_HASH_FOREACH(ht, 1); \
+	_key = _p->key; \
+	_val = _z;
+
+#define ZEND_HASH_FOREACH_KEY_VAL_IND(ht, _h, _key, _val) \
+	ZEND_HASH_FOREACH(ht, 1); \
+	_h = _p->h; \
+	_key = _p->key; \
+	_val = _z;
+
+#define ZEND_HASH_FOREACH_STR_KEY_PTR(ht, _key, _ptr) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_key = _p->key; \
+	_ptr = Z_PTR_P(_z);
+
+#define ZEND_HASH_FOREACH_KEY_PTR(ht, _h, _key, _ptr) \
+	ZEND_HASH_FOREACH(ht, 0); \
+	_h = _p->h; \
+	_key = _p->key; \
+	_ptr = Z_PTR_P(_z);
+
+#define ZEND_HASH_REVERSE_FOREACH_VAL(ht, _val) \
+	ZEND_HASH_REVERSE_FOREACH(ht, 0); \
+	_val = _z;
+
+#define ZEND_HASH_REVERSE_FOREACH_PTR(ht, _ptr) \
+	ZEND_HASH_REVERSE_FOREACH(ht, 0); \
+	_ptr = Z_PTR_P(_z);
+
+#define ZEND_HASH_REVERSE_FOREACH_VAL_IND(ht, _val) \
+	ZEND_HASH_REVERSE_FOREACH(ht, 1); \
+	_val = _z;
+
+#define ZEND_HASH_REVERSE_FOREACH_KEY_VAL(ht, _h, _key, _val) \
+	ZEND_HASH_REVERSE_FOREACH(ht, 0); \
+	_h = _p->h; \
+	_key = _p->key; \
+	_val = _z;
+
+#define ZEND_HASH_REVERSE_FOREACH_KEY_VAL_IND(ht, _h, _key, _val) \
+	ZEND_HASH_REVERSE_FOREACH(ht, 1); \
+	_h = _p->h; \
+	_key = _p->key; \
+	_val = _z;
 
 #endif							/* ZEND_HASH_H */
 
diff --git a/Zend/zend_highlight.c b/Zend/zend_highlight.c
index 68f2b7b72d..50a1edce38 100644
--- a/Zend/zend_highlight.c
+++ b/Zend/zend_highlight.c
@@ -92,7 +92,7 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 	zend_printf("<code>");
 	zend_printf("<span style=\"color: %s\">\n", last_color);
 	/* highlight stuff coming back from zendlex() */
-	token.type = 0;
+	ZVAL_UNDEF(&token);
 	while ((token_type=lex_scan(&token TSRMLS_CC))) {
 		switch (token_type) {
 			case T_INLINE_HTML:
@@ -116,11 +116,11 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				break;
 			case T_WHITESPACE:
 				zend_html_puts((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng) TSRMLS_CC);  /* no color needed */
-				token.type = 0;
+				ZVAL_UNDEF(&token);
 				continue;
 				break;
 			default:
-				if (token.type == 0) {
+				if (Z_TYPE(token) == IS_UNDEF) {
 					next_color = syntax_highlighter_ini->highlight_keyword;
 				} else {
 					next_color = syntax_highlighter_ini->highlight_default;
@@ -140,7 +140,7 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 
 		zend_html_puts((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng) TSRMLS_CC);
 
-		if (token.type == IS_STRING) {
+		if (Z_TYPE(token) == IS_STRING) {
 			switch (token_type) {
 				case T_OPEN_TAG:
 				case T_OPEN_TAG_WITH_ECHO:
@@ -150,11 +150,11 @@ ZEND_API void zend_highlight(zend_syntax_highlighter_ini *syntax_highlighter_ini
 				case T_DOC_COMMENT:
 					break;
 				default:
-					efree(token.value.str.val);
+					STR_RELEASE(Z_STR(token));
 					break;
 			}
 		}
-		token.type = 0;
+		ZVAL_UNDEF(&token);
 	}
 
 	if (last_color != syntax_highlighter_ini->highlight_html) {
@@ -170,7 +170,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 	int token_type;
 	int prev_space = 0;
 
-	token.type = 0;
+	ZVAL_UNDEF(&token);
 	while ((token_type=lex_scan(&token TSRMLS_CC))) {
 		switch (token_type) {
 			case T_WHITESPACE:
@@ -181,7 +181,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 						/* lack of break; is intentional */
 			case T_COMMENT:
 			case T_DOC_COMMENT:
-				token.type = 0;
+				ZVAL_UNDEF(&token);
 				continue;
 			
 			case T_END_HEREDOC:
@@ -192,7 +192,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 				}
 				zend_write("\n", sizeof("\n") - 1);
 				prev_space = 1;
-				token.type = 0;
+				ZVAL_UNDEF(&token);
 				continue;
 
 			default:
@@ -200,7 +200,7 @@ ZEND_API void zend_strip(TSRMLS_D)
 				break;
 		}
 
-		if (token.type == IS_STRING) {
+		if (Z_TYPE(token) == IS_STRING) {
 			switch (token_type) {
 				case T_OPEN_TAG:
 				case T_OPEN_TAG_WITH_ECHO:
@@ -211,11 +211,12 @@ ZEND_API void zend_strip(TSRMLS_D)
 					break;
 
 				default:
-					STR_FREE(token.value.str.val);
+					STR_RELEASE(Z_STR(token));
 					break;
 			}
 		}
-		prev_space = token.type = 0;
+		prev_space = 0;
+		ZVAL_UNDEF(&token);
 	}
 }
 
diff --git a/Zend/zend_indent.c b/Zend/zend_indent.c
index 38ce669083..05254a30bc 100644
--- a/Zend/zend_indent.c
+++ b/Zend/zend_indent.c
@@ -59,14 +59,14 @@ ZEND_API void zend_indent(TSRMLS_D)
 	memset(emit_whitespace, 0, sizeof(int)*256);
 
 	/* highlight stuff coming back from zendlex() */
-	token.type = 0;
+	ZVAL_UNDEF(&token);
 	while ((token_type=lex_scan(&token TSRMLS_CC))) {
 		switch (token_type) {
 			case T_INLINE_HTML:
 				zend_write((char*)LANG_SCNG(yy_text), LANG_SCNG(yy_leng));
 				break;
 			case T_WHITESPACE: {
-					token.type = 0;
+					ZVAL_UNDEF(&token);
 					/* eat whitespace, emit newlines */
 					for (i=0; i<LANG_SCNG(yy_leng); i++) {
 						emit_whitespace[(unsigned char) LANG_SCNG(yy_text)[i]]++;
@@ -78,7 +78,7 @@ ZEND_API void zend_indent(TSRMLS_D)
 				in_string = !in_string;
 				/* break missing intentionally */
 			default:
-				if (token.type==0) {
+				if (Z_TYPE(token) == IS_UNDEF) {
 					/* keyword */
 					switch (token_type) {
 						case ',':
@@ -131,18 +131,18 @@ dflt_printout:
 				}
 				break;
 		}
-		if (token.type == IS_STRING) {
+		if (Z_TYPE(token) == IS_STRING) {
 			switch (token_type) {
 			case T_OPEN_TAG:
 			case T_CLOSE_TAG:
 			case T_WHITESPACE:
 				break;
 			default:
-				efree(token.value.str.val);
+				STR_RELEASE(Z_STR(token));
 				break;
 			}
 		}
-		token.type = 0;
+		ZVAL_UNDEF(&token);
 	}
 }
 
diff --git a/Zend/zend_ini.c b/Zend/zend_ini.c
index f286ccd157..883a6bf84b 100644
--- a/Zend/zend_ini.c
+++ b/Zend/zend_ini.c
@@ -83,6 +83,12 @@ static int zend_restore_ini_entry_wrapper(zend_ini_entry **ini_entry TSRMLS_DC)
 }
 /* }}} */
 
+static void _free_ptr(zval *zv) /* {{{ */
+{
+	free(Z_PTR_P(zv));
+}
+/* }}} */
+
 /*
  * Startup / shutdown
  */
@@ -93,9 +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) {
-		return FAILURE;
-	}
+	zend_hash_init_ex(registered_zend_ini_directives, 128, NULL, _free_ptr, 1, 0);
 	return SUCCESS;
 }
 /* }}} */
@@ -131,15 +135,11 @@ ZEND_API int zend_ini_deactivate(TSRMLS_D) /* {{{ */
 #ifdef ZTS
 ZEND_API int zend_copy_ini_directives(TSRMLS_D) /* {{{ */
 {
-	zend_ini_entry ini_entry;
-
 	EG(modified_ini_directives) = NULL;
 	EG(error_reporting_ini_entry) = NULL;
 	EG(ini_directives) = (HashTable *) malloc(sizeof(HashTable));
-	if (zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, NULL, 1, 0) == FAILURE) {
-		return FAILURE;
-	}
-	zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, NULL, &ini_entry, sizeof(zend_ini_entry));
+	zend_hash_init_ex(EG(ini_directives), registered_zend_ini_directives->nNumOfElements, NULL, NULL, 1, 0);
+	zend_hash_copy(EG(ini_directives), registered_zend_ini_directives, NULL);
 	return SUCCESS;
 }
 /* }}} */
@@ -150,17 +150,17 @@ static int ini_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
 	const Bucket *f;
 	const Bucket *s;
 
-	f = *((const Bucket **) a);
-	s = *((const Bucket **) b);
+	f = (const Bucket *) a;
+	s = (const Bucket *) b;
 
-	if (f->nKeyLength == 0 && s->nKeyLength == 0) { /* both numeric */
-		return ZEND_NORMALIZE_BOOL(f->nKeyLength - s->nKeyLength);
-	} else if (f->nKeyLength == 0) { /* f is numeric, s is not */
+	if (!f->key && !s->key) { /* both numeric */
+		return ZEND_NORMALIZE_BOOL(f->h - s->h);
+	} else if (!f->key) { /* f is numeric, s is not */
 		return -1;
-	} else if (s->nKeyLength == 0) { /* s is numeric, f is not */
+	} else if (!s->key) { /* s is numeric, f is not */
 		return 1;
 	} else { /* both strings */
-		return zend_binary_strcasecmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength);
+		return zend_binary_strcasecmp(f->key->val, f->key->len, s->key->val, s->key->len);
 	}
 }
 /* }}} */
@@ -198,7 +198,7 @@ ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int modu
 
 	while (p->name) {
 		config_directive_success = 0;
-		if (zend_hash_add(directives, p->name, p->name_length, (void*)p, sizeof(zend_ini_entry), (void **) &hashed_ini_entry) == FAILURE) {
+		if ((hashed_ini_entry = zend_hash_str_add_mem(directives, p->name, p->name_length, (void*)p, sizeof(zend_ini_entry))) == NULL) {
 			zend_unregister_ini_entries(module_number TSRMLS_CC);
 			return FAILURE;
 		}
@@ -244,22 +244,22 @@ ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC) /* {{{ */
 /* }}} */
 #endif
 
-ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage) /* {{{ */
+ZEND_API int zend_alter_ini_entry(zend_string *name, char *new_value, uint new_value_length, int modify_type, int stage) /* {{{ */
 {
 	TSRMLS_FETCH();
 
-	return zend_alter_ini_entry_ex(name, name_length, new_value, new_value_length, modify_type, stage, 0 TSRMLS_CC);
+	return zend_alter_ini_entry_ex(name, new_value, new_value_length, modify_type, stage, 0 TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
+ZEND_API int zend_alter_ini_entry_ex(zend_string *name, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	char *duplicate;
 	zend_bool modifiable;
 	zend_bool modified;
 
-	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == FAILURE) {
+	if ((ini_entry = zend_hash_find_ptr(EG(ini_directives), name)) == NULL) {
 		return FAILURE;
 	}
 
@@ -285,7 +285,7 @@ ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_val
 		ini_entry->orig_value_length = ini_entry->value_length;
 		ini_entry->orig_modifiable = modifiable;
 		ini_entry->modified = 1;
-		zend_hash_add(EG(modified_ini_directives), name, name_length, &ini_entry, sizeof(zend_ini_entry*), NULL);
+		zend_hash_add_ptr(EG(modified_ini_directives), name, ini_entry);
 	}
 
 	duplicate = estrndup(new_value, new_value_length);
@@ -306,19 +306,19 @@ ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_val
 }
 /* }}} */
 
-ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage) /* {{{ */
+ZEND_API int zend_restore_ini_entry(zend_string *name, int stage) /* {{{ */
 {
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
 
-	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == FAILURE ||
+	if ((ini_entry = zend_hash_find_ptr(EG(ini_directives), name)) == NULL ||
 		(stage == ZEND_INI_STAGE_RUNTIME && (ini_entry->modifiable & ZEND_INI_USER) == 0)) {
 		return FAILURE;
 	}
 
 	if (EG(modified_ini_directives)) {
 		if (zend_restore_ini_entry_cb(ini_entry, stage TSRMLS_CC) == 0) {
-			zend_hash_del(EG(modified_ini_directives), name, name_length);
+			zend_hash_del(EG(modified_ini_directives), name);
 		} else {
 			return FAILURE;
 		}
@@ -332,7 +332,8 @@ ZEND_API int zend_ini_register_displayer(char *name, uint name_length, void (*di
 {
 	zend_ini_entry *ini_entry;
 
-	if (zend_hash_find(registered_zend_ini_directives, name, name_length, (void **) &ini_entry) == FAILURE) {
+	ini_entry = zend_hash_str_find_ptr(registered_zend_ini_directives, name, name_length);	
+	if (ini_entry == NULL) {
 		return FAILURE;
 	}
 
@@ -350,7 +351,8 @@ ZEND_API long zend_ini_long(char *name, uint name_length, int orig) /* {{{ */
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
 
-	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
+	ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
+	if (ini_entry) {
 		if (orig && ini_entry->modified) {
 			return (ini_entry->orig_value ? strtol(ini_entry->orig_value, NULL, 0) : 0);
 		} else {
@@ -367,7 +369,8 @@ ZEND_API double zend_ini_double(char *name, uint name_length, int orig) /* {{{ *
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
 
-	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
+	ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
+	if (ini_entry) {
 		if (orig && ini_entry->modified) {
 			return (double) (ini_entry->orig_value ? zend_strtod(ini_entry->orig_value, NULL) : 0.0);
 		} else {
@@ -384,7 +387,8 @@ ZEND_API char *zend_ini_string_ex(char *name, uint name_length, int orig, zend_b
 	zend_ini_entry *ini_entry;
 	TSRMLS_FETCH();
 
-	if (zend_hash_find(EG(ini_directives), name, name_length, (void **) &ini_entry) == SUCCESS) {
+	ini_entry = zend_hash_str_find_ptr(EG(ini_directives), name, name_length);
+	if (ini_entry) {
 		if (exists) {
 			*exists = 1;
 		}
diff --git a/Zend/zend_ini.h b/Zend/zend_ini.h
index 0fe4c3161f..0a0c1137e1 100644
--- a/Zend/zend_ini.h
+++ b/Zend/zend_ini.h
@@ -27,53 +27,23 @@
 
 #define ZEND_INI_ALL (ZEND_INI_USER|ZEND_INI_PERDIR|ZEND_INI_SYSTEM)
 
-#ifndef XtOffsetOf
-# if defined(CRAY) || (defined(__ARMCC_VERSION) && !defined(LINUX))
-# ifdef __STDC__
-# define XtOffset(p_type, field) _Offsetof(p_type, field)
-# else
-# ifdef CRAY2
-# define XtOffset(p_type, field) \
-    (sizeof(int)*((unsigned int)&(((p_type)NULL)->field)))
-
-# else /* !CRAY2 */
-
-# define XtOffset(p_type, field) ((unsigned int)&(((p_type)NULL)->field))
-
-# endif /* !CRAY2 */
-# endif /* __STDC__ */
-# else /* ! (CRAY || __arm) */
-
-# define XtOffset(p_type, field) \
-    ((long) (((char *) (&(((p_type)NULL)->field))) - ((char *) NULL)))
-
-# endif /* !CRAY */
-
-# ifdef offsetof
-# define XtOffsetOf(s_type, field) offsetof(s_type, field)
-# else
-# define XtOffsetOf(s_type, field) XtOffset(s_type*, field)
-# endif
-
-#endif
-
 #define ZEND_INI_MH(name) int name(zend_ini_entry *entry, char *new_value, uint new_value_length, void *mh_arg1, void *mh_arg2, void *mh_arg3, int stage TSRMLS_DC)
 #define ZEND_INI_DISP(name) void name(zend_ini_entry *ini_entry, int type)
 
 struct _zend_ini_entry {
 	int module_number;
 	int modifiable;
-	char *name;
+	char *name;					// TODO: convert into zend_string ???
 	uint name_length;
 	ZEND_INI_MH((*on_modify));
 	void *mh_arg1;
 	void *mh_arg2;
 	void *mh_arg3;
 
-	char *value;
+	char *value;				// TODO: convert into zend_string ???
 	uint value_length;
 
-	char *orig_value;
+	char *orig_value;			// TODO: convert into zend_string ???
 	uint orig_value_length;
 	int orig_modifiable;
 	int modified;
@@ -94,9 +64,9 @@ ZEND_API void zend_ini_sort_entries(TSRMLS_D);
 ZEND_API int zend_register_ini_entries(const zend_ini_entry *ini_entry, int module_number TSRMLS_DC);
 ZEND_API void zend_unregister_ini_entries(int module_number TSRMLS_DC);
 ZEND_API void zend_ini_refresh_caches(int stage TSRMLS_DC);
-ZEND_API int zend_alter_ini_entry(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage);
-ZEND_API int zend_alter_ini_entry_ex(char *name, uint name_length, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC);
-ZEND_API int zend_restore_ini_entry(char *name, uint name_length, int stage);
+ZEND_API int zend_alter_ini_entry(zend_string *name, char *new_value, uint new_value_length, int modify_type, int stage);
+ZEND_API int zend_alter_ini_entry_ex(zend_string *name, char *new_value, uint new_value_length, int modify_type, int stage, int force_change TSRMLS_DC);
+ZEND_API int zend_restore_ini_entry(zend_string *name, int stage);
 ZEND_API void display_ini_entries(zend_module_entry *module);
 
 ZEND_API long zend_ini_long(char *name, uint name_length, int orig);
@@ -115,7 +85,7 @@ END_EXTERN_C()
 #define ZEND_INI_END()		{ 0, 0, NULL, 0, NULL, NULL, NULL, NULL, NULL, 0, NULL, 0, 0, 0, NULL } };
 
 #define ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, arg1, arg2, arg3, displayer) \
-	{ 0, modifiable, name, sizeof(name), on_modify, arg1, arg2, arg3, default_value, sizeof(default_value)-1, NULL, 0, 0, 0, displayer },
+	{ 0, modifiable, name, sizeof(name)-1, on_modify, arg1, arg2, arg3, default_value, sizeof(default_value)-1, NULL, 0, 0, 0, displayer },
 
 #define ZEND_INI_ENTRY3(name, default_value, modifiable, on_modify, arg1, arg2, arg3) \
 	ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, arg1, arg2, arg3, NULL)
@@ -154,21 +124,21 @@ END_EXTERN_C()
 	ZEND_INI_ENTRY3_EX(name, default_value, modifiable, on_modify, (void *) XtOffsetOf(struct_type, property_name), (void *) &struct_ptr, NULL, zend_ini_boolean_displayer_cb)
 #endif
 
-#define INI_INT(name) zend_ini_long((name), sizeof(name), 0)
-#define INI_FLT(name) zend_ini_double((name), sizeof(name), 0)
-#define INI_STR(name) zend_ini_string_ex((name), sizeof(name), 0, NULL)
+#define INI_INT(name) zend_ini_long((name), sizeof(name)-1, 0)
+#define INI_FLT(name) zend_ini_double((name), sizeof(name)-1, 0)
+#define INI_STR(name) zend_ini_string_ex((name), sizeof(name)-1, 0, NULL)
 #define INI_BOOL(name) ((zend_bool) INI_INT(name))
 
-#define INI_ORIG_INT(name)	zend_ini_long((name), sizeof(name), 1)
-#define INI_ORIG_FLT(name)	zend_ini_double((name), sizeof(name), 1)
-#define INI_ORIG_STR(name)	zend_ini_string((name), sizeof(name), 1)
+#define INI_ORIG_INT(name)	zend_ini_long((name), sizeof(name)-1, 1)
+#define INI_ORIG_FLT(name)	zend_ini_double((name), sizeof(name)-1, 1)
+#define INI_ORIG_STR(name)	zend_ini_string((name), sizeof(name)-1, 1)
 #define INI_ORIG_BOOL(name) ((zend_bool) INI_ORIG_INT(name))
 
 #define REGISTER_INI_ENTRIES() zend_register_ini_entries(ini_entries, module_number TSRMLS_CC)
 #define UNREGISTER_INI_ENTRIES() zend_unregister_ini_entries(module_number TSRMLS_CC)
 #define DISPLAY_INI_ENTRIES() display_ini_entries(zend_module)
 
-#define REGISTER_INI_DISPLAYER(name, displayer) zend_ini_register_displayer((name), sizeof(name), displayer)
+#define REGISTER_INI_DISPLAYER(name, displayer) zend_ini_register_displayer((name), sizeof(name)-1, displayer)
 #define REGISTER_INI_BOOLEAN(name) REGISTER_INI_DISPLAYER(name, zend_ini_boolean_displayer_cb)
 
 /* Standard message handlers */
diff --git a/Zend/zend_ini_parser.y b/Zend/zend_ini_parser.y
index 3823efd413..eaf451a3a1 100644
--- a/Zend/zend_ini_parser.y
+++ b/Zend/zend_ini_parser.y
@@ -49,13 +49,14 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
 {
 	int i_result;
 	int i_op1, i_op2;
+	int str_len;
 	char str_result[MAX_LENGTH_OF_LONG];
 
 	i_op1 = atoi(Z_STRVAL_P(op1));
-	free(Z_STRVAL_P(op1));
+	STR_FREE(Z_STR_P(op1));
 	if (op2) {
 		i_op2 = atoi(Z_STRVAL_P(op2));
-		free(Z_STRVAL_P(op2));
+		STR_FREE(Z_STR_P(op2));
 	} else {
 		i_op2 = 0;
 	}
@@ -81,11 +82,8 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
 			break;
 	}
 
-	Z_STRLEN_P(result) = zend_sprintf(str_result, "%d", i_result);
-	Z_STRVAL_P(result) = (char *) malloc(Z_STRLEN_P(result)+1);
-	memcpy(Z_STRVAL_P(result), str_result, Z_STRLEN_P(result));
-	Z_STRVAL_P(result)[Z_STRLEN_P(result)] = 0;
-	Z_TYPE_P(result) = IS_STRING;
+	str_len = zend_sprintf(str_result, "%d", i_result);
+	ZVAL_PSTRINGL(result, str_result, str_len);
 }
 /* }}} */
 
@@ -93,10 +91,7 @@ static void zend_ini_do_op(char type, zval *result, zval *op1, zval *op2)
 */
 static void zend_ini_init_string(zval *result)
 {
-	Z_STRVAL_P(result) = malloc(1);
-	Z_STRVAL_P(result)[0] = 0;
-	Z_STRLEN_P(result) = 0;
-	Z_TYPE_P(result) = IS_STRING;
+	ZVAL_EMPTY_PSTRING(result);
 }
 /* }}} */
 
@@ -104,13 +99,12 @@ 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);
 
-	Z_STRVAL_P(result) = (char *) realloc(Z_STRVAL_P(op1), length+1);
-	memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+	ZVAL_NEW_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;
-	Z_STRLEN_P(result) = length;
-	Z_TYPE_P(result) = IS_STRING;
 }
 /* }}} */
 
@@ -118,18 +112,25 @@ static void zend_ini_add_string(zval *result, zval *op1, zval *op2)
 */
 static void zend_ini_get_constant(zval *result, zval *name TSRMLS_DC)
 {
-	zval z_constant;
+	zval *c, tmp;
 
 	/* If name contains ':' it is not a constant. Bug #26893. */
 	if (!memchr(Z_STRVAL_P(name), ':', Z_STRLEN_P(name))
-		   	&& zend_get_constant(Z_STRVAL_P(name), Z_STRLEN_P(name), &z_constant TSRMLS_CC)) {
-		/* z_constant is emalloc()'d */
-		convert_to_string(&z_constant);
-		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(z_constant), Z_STRLEN(z_constant));
-		Z_STRLEN_P(result) = Z_STRLEN(z_constant);
-		Z_TYPE_P(result) = Z_TYPE(z_constant);
-		zval_dtor(&z_constant);
-		free(Z_STRVAL_P(name));
+		   	&& (c = zend_get_constant(Z_STR_P(name) TSRMLS_CC)) != 0) {
+		if (Z_TYPE_P(c) != IS_STRING) {
+			ZVAL_COPY_VALUE(&tmp, c);
+			if (Z_OPT_CONSTANT(tmp)) {
+				zval_update_constant_ex(&tmp, 1, NULL TSRMLS_CC);
+			}
+			zval_opt_copy_ctor(&tmp);
+			convert_to_string(&tmp);
+			c = &tmp;
+		}
+		ZVAL_PSTRINGL(result, Z_STRVAL_P(c), Z_STRLEN_P(c));
+		if (c == &tmp) {
+			zval_dtor(&tmp);
+		}
+		STR_FREE(Z_STR_P(name));
 	} else {
 		*result = *name;
 	}
@@ -144,14 +145,12 @@ static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
 	char *envvar;
 
 	/* Fetch configuration option value */
-	if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name)+1, &curval) == SUCCESS) {
-		Z_STRVAL_P(result) = zend_strndup(Z_STRVAL(curval), Z_STRLEN(curval));
-		Z_STRLEN_P(result) = Z_STRLEN(curval);
+	if (zend_get_configuration_directive(Z_STRVAL_P(name), Z_STRLEN_P(name), &curval) == SUCCESS) {
+		ZVAL_PSTRINGL(result, Z_STRVAL(curval), Z_STRLEN(curval));
 	/* ..or if not found, try ENV */
 	} else if ((envvar = zend_getenv(Z_STRVAL_P(name), Z_STRLEN_P(name) TSRMLS_CC)) != NULL ||
 			   (envvar = getenv(Z_STRVAL_P(name))) != NULL) {
-		Z_STRVAL_P(result) = strdup(envvar);
-		Z_STRLEN_P(result) = strlen(envvar);
+		ZVAL_PSTRING(result, envvar);
 	} else {
 		zend_ini_init_string(result);
 	}
@@ -160,7 +159,7 @@ static void zend_ini_get_var(zval *result, zval *name TSRMLS_DC)
 
 /* {{{ ini_error()
 */
-static void ini_error(char *msg)
+static void ini_error(const char *msg)
 {
 	char *error_buf;
 	int error_buf_len;
@@ -283,26 +282,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);
-			free(Z_STRVAL($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);
-			free(Z_STRVAL($1));
-			free(Z_STRVAL($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);
-			free(Z_STRVAL($1));
-			free(Z_STRVAL($2));
-			free(Z_STRVAL($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); free(Z_STRVAL($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
 ;
 
@@ -324,8 +323,8 @@ option_offset:
 ;
 
 encapsed_list:
-		encapsed_list cfg_var_ref		{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	encapsed_list TC_QUOTED_STRING	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
+		encapsed_list cfg_var_ref		{ zend_ini_add_string(&$$, &$1, &$2); STR_FREE(Z_STR($2)); }
+	|	encapsed_list TC_QUOTED_STRING	{ zend_ini_add_string(&$$, &$1, &$2); STR_FREE(Z_STR($2)); }
 	|	/* empty */						{ zend_ini_init_string(&$$); }
 ;
 
@@ -333,18 +332,18 @@ var_string_list_section:
 		cfg_var_ref						{ $$ = $1; }
 	|	constant_literal				{ $$ = $1; }
 	|	'"' encapsed_list '"'			{ $$ = $2; }
-	|	var_string_list_section cfg_var_ref 	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list_section constant_literal	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list_section '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); free(Z_STRVAL($3)); }
+	|	var_string_list_section cfg_var_ref 	{ zend_ini_add_string(&$$, &$1, &$2); STR_FREE(Z_STR($2)); }
+	|	var_string_list_section constant_literal	{ zend_ini_add_string(&$$, &$1, &$2); STR_FREE(Z_STR($2)); }
+	|	var_string_list_section '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); STR_FREE(Z_STR($3)); }
 ;
 
 var_string_list:
 		cfg_var_ref						{ $$ = $1; }
 	|	constant_string					{ $$ = $1; }
 	|	'"' encapsed_list '"'			{ $$ = $2; }
-	|	var_string_list cfg_var_ref 	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list constant_string	{ zend_ini_add_string(&$$, &$1, &$2); free(Z_STRVAL($2)); }
-	|	var_string_list '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); free(Z_STRVAL($3)); }
+	|	var_string_list cfg_var_ref 	{ zend_ini_add_string(&$$, &$1, &$2); STR_FREE(Z_STR($2)); }
+	|	var_string_list constant_string	{ zend_ini_add_string(&$$, &$1, &$2); STR_FREE(Z_STR($2)); }
+	|	var_string_list '"' encapsed_list '"'  { zend_ini_add_string(&$$, &$1, &$3); STR_FREE(Z_STR($3)); }
 ;
 
 expr:
@@ -358,7 +357,7 @@ expr:
 ;
 
 cfg_var_ref:
-		TC_DOLLAR_CURLY TC_VARNAME '}'	{ zend_ini_get_var(&$$, &$2 TSRMLS_CC); free(Z_STRVAL($2)); }
+		TC_DOLLAR_CURLY TC_VARNAME '}'	{ zend_ini_get_var(&$$, &$2 TSRMLS_CC); STR_FREE(Z_STR($2)); }
 ;
 
 constant_literal:
diff --git a/Zend/zend_ini_scanner.c b/Zend/zend_ini_scanner.c
index c73f3cedda..311788fbbf 100644
--- a/Zend/zend_ini_scanner.c
+++ b/Zend/zend_ini_scanner.c
@@ -1,4663 +1,4661 @@
-/* Generated by re2c 0.13.5 */

-#line 1 "Zend/zend_ini_scanner.l"

-/*

-   +----------------------------------------------------------------------+

-   | Zend Engine                                                          |

-   +----------------------------------------------------------------------+

-   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |

-   +----------------------------------------------------------------------+

-   | This source file is subject to version 2.00 of the Zend license,     |

-   | that is bundled with this package in the file LICENSE, and is        |

-   | available through the world-wide-web at the following url:           |

-   | http://www.zend.com/license/2_00.txt.                                |

-   | If you did not receive a copy of the Zend license and are unable to  |

-   | obtain it through the world-wide-web, please send a note to          |

-   | license@zend.com so we can mail you a copy immediately.              |

-   +----------------------------------------------------------------------+

-   | Authors: Zeev Suraski <zeev@zend.com>                                |

-   |          Jani Taskinen <jani@php.net>                                |

-   |          Marcus Boerger <helly@php.net>                              |

-   |          Nuno Lopes <nlopess@php.net>                                |

-   |          Scott MacVicar <scottmac@php.net>                           |

-   +----------------------------------------------------------------------+

-*/

-

-/* $Id$ */

-

-#include <errno.h>

-#include "zend.h"

-#include "zend_globals.h"

-#include <zend_ini_parser.h>

-#include "zend_ini_scanner.h"

-

-#if 0

-# define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)

-#else

-# define YYDEBUG(s, c)

-#endif

-

-#include "zend_ini_scanner_defs.h"

-

-#define YYCTYPE   unsigned char

-/* allow the scanner to read one null byte after the end of the string (from ZEND_MMAP_AHEAD)

- * so that if will be able to terminate to match the current token (e.g. non-enclosed string) */

-#define YYFILL(n) { if (YYCURSOR > YYLIMIT) return 0; }

-#define YYCURSOR  SCNG(yy_cursor)

-#define YYLIMIT   SCNG(yy_limit)

-#define YYMARKER  SCNG(yy_marker)

-

-#define YYGETCONDITION()  SCNG(yy_state)

-#define YYSETCONDITION(s) SCNG(yy_state) = s

-

-#define STATE(name)  yyc##name

-

-/* emulate flex constructs */

-#define BEGIN(state) YYSETCONDITION(STATE(state))

-#define YYSTATE      YYGETCONDITION()

-#define yytext       ((char*)SCNG(yy_text))

-#define yyleng       SCNG(yy_leng)

-#define yyless(x)    do {	YYCURSOR = (unsigned char*)yytext + x; \

-							yyleng   = (unsigned int)x; } while(0)

-

-/* #define yymore()     goto yymore_restart */

-

-/* perform sanity check. If this message is triggered you should

-   increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */

-#define YYMAXFILL 6

-#if ZEND_MMAP_AHEAD < (YYMAXFILL + 1)

-# error ZEND_MMAP_AHEAD should be greater than YYMAXFILL

-#endif

-

-

-/* How it works (for the core ini directives):

- * ===========================================

- *

- * 1. Scanner scans file for tokens and passes them to parser.

- * 2. Parser parses the tokens and passes the name/value pairs to the callback

- *    function which stores them in the configuration hash table.

- * 3. Later REGISTER_INI_ENTRIES() is called which triggers the actual

- *    registering of ini entries and uses zend_get_configuration_directive()

- *    to fetch the previously stored name/value pair from configuration hash table

- *    and registers the static ini entries which match the name to the value

- *    into EG(ini_directives) hash table.

- * 4. PATH section entries are used per-request from down to top, each overriding

- *    previous if one exists. zend_alter_ini_entry() is called for each entry.

- *    Settings in PATH section are ZEND_INI_SYSTEM accessible and thus mimics the

- *    php_admin_* directives used within Apache httpd.conf when PHP is compiled as

- *    module for Apache.

- * 5. User defined ini files (like .htaccess for apache) are parsed for each request and

- *    stored in separate hash defined by SAPI.

- */

-

-/* TODO: (ordered by importance :-)

- * ===============================================================================

- *

- *  - Separate constant lookup totally from plain strings (using CONSTANT pattern)

- *  - Add #if .. #else .. #endif and ==, !=, <, > , <=, >= operators

- *  - Add #include "some.ini"

- *  - Allow variables to refer to options also when using parse_ini_file()

- *

- */

-

-/* Globals Macros */

-#define SCNG	INI_SCNG

-#ifdef ZTS

-ZEND_API ts_rsrc_id ini_scanner_globals_id;

-#else

-ZEND_API zend_ini_scanner_globals ini_scanner_globals;

-#endif

-

-/* Eat leading whitespace */

-#define EAT_LEADING_WHITESPACE()                     \

-	while (yytext[0]) {                              \

-		if (yytext[0] == ' ' || yytext[0] == '\t') { \

-			SCNG(yy_text)++;                         \

-			yyleng--;                                \

-		} else {                                     \

-			break;                                   \

-		}                                            \

-	}

-

-/* Eat trailing whitespace + extra char */

-#define EAT_TRAILING_WHITESPACE_EX(ch)              \

-	while (yyleng > 0 && (                          \

-		(ch != 'X' && yytext[yyleng - 1] ==  ch) || \

-		yytext[yyleng - 1] == '\n' ||               \

-		yytext[yyleng - 1] == '\r' ||               \

-		yytext[yyleng - 1] == '\t' ||               \

-		yytext[yyleng - 1] == ' ')                  \

-	) {                                             \

-		yyleng--;                                   \

-	}

-

-/* Eat trailing whitespace */

-#define EAT_TRAILING_WHITESPACE()	EAT_TRAILING_WHITESPACE_EX('X')

-

-#define zend_ini_copy_value(retval, str, len) {  \

-	Z_STRVAL_P(retval) = zend_strndup(str, len); \

-	Z_STRLEN_P(retval) = len;                    \

-	Z_TYPE_P(retval) = IS_STRING;                \

-}

-

-#define RETURN_TOKEN(type, str, len) {           \

-	zend_ini_copy_value(ini_lval, str, len);     \

-	return type;                                 \

-}

-

-static void _yy_push_state(int new_state TSRMLS_DC)

-{

-	zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));

-	YYSETCONDITION(new_state);

-}

-

-#define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)

-

-static void yy_pop_state(TSRMLS_D)

-{

-	int *stack_state;

-	zend_stack_top(&SCNG(state_stack), (void **) &stack_state);

-	YYSETCONDITION(*stack_state);

-	zend_stack_del_top(&SCNG(state_stack));

-}

-

-static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)

-{

-	YYCURSOR = (YYCTYPE*)str;

-	SCNG(yy_start) = YYCURSOR;

-	YYLIMIT  = YYCURSOR + len;

-}

-

-#define ini_filename SCNG(filename)

-

-/* {{{ init_ini_scanner()

-*/

-static int init_ini_scanner(int scanner_mode, zend_file_handle *fh TSRMLS_DC)

-{

-	/* Sanity check */

-	if (scanner_mode != ZEND_INI_SCANNER_NORMAL && scanner_mode != ZEND_INI_SCANNER_RAW) {

-		zend_error(E_WARNING, "Invalid scanner mode");

-		return FAILURE;

-	}

-

-	SCNG(lineno) = 1;

-	SCNG(scanner_mode) = scanner_mode;

-	SCNG(yy_in) = fh;

-

-	if (fh != NULL) {

-		ini_filename = zend_strndup(fh->filename, strlen(fh->filename));

-	} else {

-		ini_filename = NULL;

-	}

-

-	zend_stack_init(&SCNG(state_stack));

-	BEGIN(INITIAL);

-

-	return SUCCESS;

-}

-/* }}} */

-

-/* {{{ shutdown_ini_scanner()

-*/

-void shutdown_ini_scanner(TSRMLS_D)

-{

-	zend_stack_destroy(&SCNG(state_stack));

-	if (ini_filename) {

-		free(ini_filename);

-	}

-}

-/* }}} */

-

-/* {{{ zend_ini_scanner_get_lineno()

-*/

-int zend_ini_scanner_get_lineno(TSRMLS_D)

-{

-	return SCNG(lineno);

-}

-/* }}} */

-

-/* {{{ zend_ini_scanner_get_filename()

-*/

-char *zend_ini_scanner_get_filename(TSRMLS_D)

-{

-	return ini_filename ? ini_filename : "Unknown";

-}

-/* }}} */

-

-/* {{{ zend_ini_open_file_for_scanning()

-*/

-int zend_ini_open_file_for_scanning(zend_file_handle *fh, int scanner_mode TSRMLS_DC)

-{

-	char *buf;

-	size_t size;

-

-	if (zend_stream_fixup(fh, &buf, &size TSRMLS_CC) == FAILURE) {

-		return FAILURE;

-	}

-

-	if (init_ini_scanner(scanner_mode, fh TSRMLS_CC) == FAILURE) {

-		zend_file_handle_dtor(fh TSRMLS_CC);

-		return FAILURE;

-	}

-

-	yy_scan_buffer(buf, size TSRMLS_CC);

-

-	return SUCCESS;

-}

-/* }}} */

-

-/* {{{ zend_ini_prepare_string_for_scanning()

-*/

-int zend_ini_prepare_string_for_scanning(char *str, int scanner_mode TSRMLS_DC)

-{

-	int len = strlen(str);

-

-	if (init_ini_scanner(scanner_mode, NULL TSRMLS_CC) == FAILURE) {

-		return FAILURE;

-	}

-

-	yy_scan_buffer(str, len TSRMLS_CC);

-

-	return SUCCESS;

-}

-/* }}} */

-

-/* {{{ zend_ini_escape_string()

- */

-static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_type TSRMLS_DC)

-{

-	register char *s, *t;

-	char *end;

-

-	zend_ini_copy_value(lval, str, len);

-

-	/* convert escape sequences */

-	s = t = Z_STRVAL_P(lval);

-	end = s + Z_STRLEN_P(lval);

-

-	while (s < end) {

-		if (*s == '\\') {

-			s++;

-			if (s >= end) {

-				*t++ = '\\';

-				continue;

-			}

-			switch (*s) {

-				case '"':

-					if (*s != quote_type) {

-						*t++ = '\\';

-						*t++ = *s;

-						break;

-					}

-				case '\\':

-				case '$':

-					*t++ = *s;

-					Z_STRLEN_P(lval)--;

-					break;

-				default:

-					*t++ = '\\';

-					*t++ = *s;

-					break;

-			}

-		} else {

-			*t++ = *s;

-		}

-		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {

-			SCNG(lineno)++;

-		}

-		s++;

-	}

-	*t = 0;

-}

-/* }}} */

-

-int ini_lex(zval *ini_lval TSRMLS_DC)

-{

-restart:

-	SCNG(yy_text) = YYCURSOR;

-

-/* yymore_restart: */

-	/* detect EOF */

-	if (YYCURSOR >= YYLIMIT) {

-		if (YYSTATE == STATE(ST_VALUE) || YYSTATE == STATE(ST_RAW)) {

-			BEGIN(INITIAL);

-			return END_OF_LINE;

-		}

-		return 0;

-	}

-

-	/* Eat any UTF-8 BOM we find in the first 3 bytes */

-	if (YYCURSOR == SCNG(yy_start) && YYCURSOR + 3 < YYLIMIT) {

-		if (memcmp(YYCURSOR, "\xef\xbb\xbf", 3) == 0) {

-			YYCURSOR += 3;

-			goto restart;

-		}

-	}

-

-#line 337 "Zend/zend_ini_scanner.c"

-{

-	YYCTYPE yych;

-	unsigned int yyaccept = 0;

-	if (YYGETCONDITION() < 4) {

-		if (YYGETCONDITION() < 2) {

-			if (YYGETCONDITION() < 1) {

-				goto yyc_INITIAL;

-			} else {

-				goto yyc_ST_OFFSET;

-			}

-		} else {

-			if (YYGETCONDITION() < 3) {

-				goto yyc_ST_SECTION_VALUE;

-			} else {

-				goto yyc_ST_VALUE;

-			}

-		}

-	} else {

-		if (YYGETCONDITION() < 6) {

-			if (YYGETCONDITION() < 5) {

-				goto yyc_ST_SECTION_RAW;

-			} else {

-				goto yyc_ST_DOUBLE_QUOTES;

-			}

-		} else {

-			if (YYGETCONDITION() < 7) {

-				goto yyc_ST_VARNAME;

-			} else {

-				goto yyc_ST_RAW;

-			}

-		}

-	}

-/* *********************************** */

-yyc_INITIAL:

-	{

-		static const unsigned char yybm[] = {

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 160,   0, 144, 144,   0, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			240, 128, 128, 144, 128, 144, 128, 144, 

-			128, 128, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 128, 144, 128, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 128, 144, 144, 128, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 128, 128, 128, 128, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-			144, 144, 144, 144, 144, 144, 144, 144, 

-		};

-

-		YYDEBUG(0, *YYCURSOR);

-		YYFILL(5);

-		yych = *YYCURSOR;

-		YYDEBUG(-1, yych);

-		switch (yych) {

-		case '\t':	goto yy4;

-		case '\n':	goto yy6;

-		case '\r':	goto yy8;

-		case ' ':	goto yy9;

-		case '!':

-		case '"':

-		case '$':

-		case '&':

-		case '(':

-		case ')':

-		case '^':

-		case '{':

-		case '|':

-		case '}':

-		case '~':	goto yy10;

-		case '#':	goto yy12;

-		case '%':

-		case '\'':

-		case '*':

-		case '+':

-		case ',':

-		case '-':

-		case '.':

-		case '/':

-		case ':':

-		case '<':

-		case '>':

-		case '?':

-		case '@':

-		case ']':	goto yy13;

-		case ';':	goto yy14;

-		case '=':	goto yy16;

-		case 'F':

-		case 'f':	goto yy18;

-		case 'N':

-		case 'n':	goto yy19;

-		case 'O':

-		case 'o':	goto yy20;

-		case 'T':

-		case 't':	goto yy21;

-		case 'Y':

-		case 'y':	goto yy22;

-		case '[':	goto yy23;

-		default:	goto yy2;

-		}

-yy2:

-		YYDEBUG(2, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy26;

-yy3:

-		YYDEBUG(3, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 429 "Zend/zend_ini_scanner.l"

-		{ /* Get option name */

-	/* Eat leading whitespace */

-	EAT_LEADING_WHITESPACE();

-

-	/* Eat trailing whitespace */

-	EAT_TRAILING_WHITESPACE();

-

-	RETURN_TOKEN(TC_LABEL, yytext, yyleng);

-}

-#line 476 "Zend/zend_ini_scanner.c"

-yy4:

-		YYDEBUG(4, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy68;

-yy5:

-		YYDEBUG(5, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 575 "Zend/zend_ini_scanner.l"

-		{

-	/* eat whitespace */

-	goto restart;

-}

-#line 490 "Zend/zend_ini_scanner.c"

-yy6:

-		YYDEBUG(6, *YYCURSOR);

-		++YYCURSOR;

-yy7:

-		YYDEBUG(7, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 580 "Zend/zend_ini_scanner.l"

-		{

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 502 "Zend/zend_ini_scanner.c"

-yy8:

-		YYDEBUG(8, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy71;

-		goto yy7;

-yy9:

-		YYDEBUG(9, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= ' ') {

-			if (yych <= '\n') {

-				if (yych <= 0x08) goto yy26;

-				if (yych <= '\t') goto yy67;

-				goto yy71;

-			} else {

-				if (yych == '\r') goto yy72;

-				if (yych <= 0x1F) goto yy26;

-				goto yy69;

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych == '#') goto yy58;

-				goto yy26;

-			} else {

-				if (yych <= ';') goto yy53;

-				if (yych == '=') goto yy51;

-				goto yy26;

-			}

-		}

-yy10:

-		YYDEBUG(10, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(11, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 503 "Zend/zend_ini_scanner.l"

-		{ /* Disallow these chars outside option values */

-	return yytext[0];

-}

-#line 541 "Zend/zend_ini_scanner.c"

-yy12:

-		YYDEBUG(12, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy59;

-yy13:

-		YYDEBUG(13, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy26;

-yy14:

-		YYDEBUG(14, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy54;

-		YYDEBUG(15, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 603 "Zend/zend_ini_scanner.l"

-		{

-	return 0;

-}

-#line 562 "Zend/zend_ini_scanner.c"

-yy16:

-		YYDEBUG(16, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy52;

-yy17:

-		YYDEBUG(17, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 439 "Zend/zend_ini_scanner.l"

-		{ /* Start option value */

-	if (SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW) {

-		yy_push_state(ST_RAW TSRMLS_CC);

-	} else {

-		yy_push_state(ST_VALUE TSRMLS_CC);

-	}

-	return '=';

-}

-#line 580 "Zend/zend_ini_scanner.c"

-yy18:

-		YYDEBUG(18, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy48;

-		if (yych == 'a') goto yy48;

-		goto yy26;

-yy19:

-		YYDEBUG(19, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'U') {

-			if (yych == 'O') goto yy44;

-			if (yych <= 'T') goto yy26;

-			goto yy45;

-		} else {

-			if (yych <= 'o') {

-				if (yych <= 'n') goto yy26;

-				goto yy44;

-			} else {

-				if (yych == 'u') goto yy45;

-				goto yy26;

-			}

-		}

-yy20:

-		YYDEBUG(20, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'N') {

-			if (yych == 'F') goto yy38;

-			if (yych <= 'M') goto yy26;

-			goto yy31;

-		} else {

-			if (yych <= 'f') {

-				if (yych <= 'e') goto yy26;

-				goto yy38;

-			} else {

-				if (yych == 'n') goto yy31;

-				goto yy26;

-			}

-		}

-yy21:

-		YYDEBUG(21, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy36;

-		if (yych == 'r') goto yy36;

-		goto yy26;

-yy22:

-		YYDEBUG(22, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy27;

-		if (yych == 'e') goto yy27;

-		goto yy26;

-yy23:

-		YYDEBUG(23, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(24, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 358 "Zend/zend_ini_scanner.l"

-		{ /* Section start */

-	/* Enter section data lookup state */

-	if (SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW) {

-		yy_push_state(ST_SECTION_RAW TSRMLS_CC);

-	} else {

-		yy_push_state(ST_SECTION_VALUE TSRMLS_CC);

-	}

-	return TC_SECTION;

-}

-#line 646 "Zend/zend_ini_scanner.c"

-yy25:

-		YYDEBUG(25, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy26:

-		YYDEBUG(26, *YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy25;

-		}

-		if (yych == '[') goto yy28;

-		goto yy3;

-yy27:

-		YYDEBUG(27, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy31;

-		if (yych == 's') goto yy31;

-		goto yy26;

-yy28:

-		YYDEBUG(28, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(29, *YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy28;

-		}

-		YYDEBUG(30, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 383 "Zend/zend_ini_scanner.l"

-		{ /* Start of option with offset */

-	/* Eat leading whitespace */

-	EAT_LEADING_WHITESPACE();

-	

-	/* Eat trailing whitespace and [ */

-	EAT_TRAILING_WHITESPACE_EX('[');

-

-	/* Enter offset lookup state */

-	yy_push_state(ST_OFFSET TSRMLS_CC);

-

-	RETURN_TOKEN(TC_OFFSET, yytext, yyleng);

-}

-#line 689 "Zend/zend_ini_scanner.c"

-yy31:

-		YYDEBUG(31, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(32, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy31;

-		}

-		if (yych <= '\'') {

-			if (yych <= ' ') {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy25;

-					if (yych <= '\t') goto yy34;

-				} else {

-					if (yych != '\r') goto yy25;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych == '#') goto yy25;

-				} else {

-					if (yych != '&') goto yy25;

-				}

-			}

-		} else {

-			if (yych <= 'Z') {

-				if (yych <= ';') {

-					if (yych <= ')') goto yy33;

-					if (yych <= ':') goto yy25;

-				} else {

-					if (yych != '=') goto yy25;

-				}

-			} else {

-				if (yych <= '^') {

-					if (yych <= '[') goto yy28;

-					if (yych <= ']') goto yy25;

-				} else {

-					if (yych <= 'z') goto yy25;

-					if (yych >= 0x7F) goto yy25;

-				}

-			}

-		}

-yy33:

-		YYDEBUG(33, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 421 "Zend/zend_ini_scanner.l"

-		{ /* TRUE value (when used outside option value/offset this causes parse error!) */

-	RETURN_TOKEN(BOOL_TRUE, "1", 1);

-}

-#line 739 "Zend/zend_ini_scanner.c"

-yy34:

-		YYDEBUG(34, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(35, *YYCURSOR);

-		if (yych == '\t') goto yy34;

-		if (yych == ' ') goto yy34;

-		goto yy33;

-yy36:

-		YYDEBUG(36, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy37;

-		if (yych != 'u') goto yy26;

-yy37:

-		YYDEBUG(37, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy31;

-		if (yych == 'e') goto yy31;

-		goto yy26;

-yy38:

-		YYDEBUG(38, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'F') goto yy39;

-		if (yych != 'f') goto yy26;

-yy39:

-		YYDEBUG(39, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(40, *YYCURSOR);

-		if (yych <= '&') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy25;

-					if (yych <= '\t') goto yy42;

-				} else {

-					if (yych != '\r') goto yy25;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= ' ') goto yy39;

-					if (yych >= '#') goto yy25;

-				} else {

-					if (yych == '%') goto yy25;

-				}

-			}

-		} else {

-			if (yych <= '=') {

-				if (yych <= ':') {

-					if (yych <= '\'') goto yy25;

-					if (yych >= '*') goto yy25;

-				} else {

-					if (yych == '<') goto yy25;

-				}

-			} else {

-				if (yych <= ']') {

-					if (yych == '[') goto yy28;

-					goto yy25;

-				} else {

-					if (yych <= '^') goto yy41;

-					if (yych <= 'z') goto yy25;

-					if (yych >= 0x7F) goto yy25;

-				}

-			}

-		}

-yy41:

-		YYDEBUG(41, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 425 "Zend/zend_ini_scanner.l"

-		{ /* FALSE value (when used outside option value/offset this causes parse error!)*/

-	RETURN_TOKEN(BOOL_FALSE, "", 0);

-}

-#line 813 "Zend/zend_ini_scanner.c"

-yy42:

-		YYDEBUG(42, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(43, *YYCURSOR);

-		if (yych == '\t') goto yy42;

-		if (yych == ' ') goto yy42;

-		goto yy41;

-yy44:

-		YYDEBUG(44, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '\'') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy26;

-					if (yych <= '\t') goto yy42;

-					goto yy41;

-				} else {

-					if (yych == '\r') goto yy41;

-					goto yy26;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= ' ') goto yy39;

-					if (yych <= '"') goto yy41;

-					goto yy26;

-				} else {

-					if (yych == '%') goto yy26;

-					if (yych <= '&') goto yy41;

-					goto yy26;

-				}

-			}

-		} else {

-			if (yych <= 'N') {

-				if (yych <= ';') {

-					if (yych <= ')') goto yy41;

-					if (yych <= ':') goto yy26;

-					goto yy41;

-				} else {

-					if (yych == '=') goto yy41;

-					if (yych <= 'M') goto yy26;

-					goto yy47;

-				}

-			} else {

-				if (yych <= 'm') {

-					if (yych == '^') goto yy41;

-					goto yy26;

-				} else {

-					if (yych <= 'n') goto yy47;

-					if (yych <= 'z') goto yy26;

-					if (yych <= '~') goto yy41;

-					goto yy26;

-				}

-			}

-		}

-yy45:

-		YYDEBUG(45, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy46;

-		if (yych != 'l') goto yy26;

-yy46:

-		YYDEBUG(46, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy39;

-		if (yych == 'l') goto yy39;

-		goto yy26;

-yy47:

-		YYDEBUG(47, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy39;

-		if (yych == 'e') goto yy39;

-		goto yy26;

-yy48:

-		YYDEBUG(48, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy49;

-		if (yych != 'l') goto yy26;

-yy49:

-		YYDEBUG(49, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy50;

-		if (yych != 's') goto yy26;

-yy50:

-		YYDEBUG(50, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy39;

-		if (yych == 'e') goto yy39;

-		goto yy26;

-yy51:

-		YYDEBUG(51, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy52:

-		YYDEBUG(52, *YYCURSOR);

-		if (yych == '\t') goto yy51;

-		if (yych == ' ') goto yy51;

-		goto yy17;

-yy53:

-		YYDEBUG(53, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy54:

-		YYDEBUG(54, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy53;

-		}

-		if (yych >= '\r') goto yy57;

-yy55:

-		YYDEBUG(55, *YYCURSOR);

-		++YYCURSOR;

-yy56:

-		YYDEBUG(56, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 585 "Zend/zend_ini_scanner.l"

-		{ /* Comment */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 936 "Zend/zend_ini_scanner.c"

-yy57:

-		YYDEBUG(57, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy55;

-		goto yy56;

-yy58:

-		YYDEBUG(58, *YYCURSOR);

-		yyaccept = 1;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy59:

-		YYDEBUG(59, *YYCURSOR);

-		if (yych <= '\'') {

-			if (yych <= ' ') {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy58;

-					if (yych >= '\n') goto yy64;

-				} else {

-					if (yych == '\r') goto yy66;

-					goto yy58;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych == '#') goto yy58;

-				} else {

-					if (yych != '&') goto yy58;

-				}

-			}

-		} else {

-			if (yych <= 'Z') {

-				if (yych <= ';') {

-					if (yych <= ')') goto yy60;

-					if (yych <= ':') goto yy58;

-				} else {

-					if (yych != '=') goto yy58;

-				}

-			} else {

-				if (yych <= '^') {

-					if (yych <= '[') goto yy62;

-					if (yych <= ']') goto yy58;

-				} else {

-					if (yych <= 'z') goto yy58;

-					if (yych >= 0x7F) goto yy58;

-				}

-			}

-		}

-yy60:

-		YYDEBUG(60, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-		YYDEBUG(61, *YYCURSOR);

-		if (yych == '\n') goto yy64;

-		if (yych == '\r') goto yy66;

-		goto yy60;

-yy62:

-		YYDEBUG(62, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-		YYDEBUG(63, *YYCURSOR);

-		if (yych <= '\f') {

-			if (yych <= 0x08) goto yy60;

-			if (yych <= '\t') goto yy62;

-			if (yych >= '\v') goto yy60;

-		} else {

-			if (yych <= '\r') goto yy66;

-			if (yych == ' ') goto yy62;

-			goto yy60;

-		}

-yy64:

-		YYDEBUG(64, *YYCURSOR);

-		++YYCURSOR;

-yy65:

-		YYDEBUG(65, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 591 "Zend/zend_ini_scanner.l"

-		{ /* #Comment */

-	zend_error(E_DEPRECATED, "Comments starting with '#' are deprecated in %s on line %d", zend_ini_scanner_get_filename(TSRMLS_C), SCNG(lineno));

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 1022 "Zend/zend_ini_scanner.c"

-yy66:

-		YYDEBUG(66, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy64;

-		goto yy65;

-yy67:

-		YYDEBUG(67, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy68:

-		YYDEBUG(68, *YYCURSOR);

-		if (yych <= ' ') {

-			if (yych <= '\n') {

-				if (yych <= 0x08) goto yy5;

-				if (yych <= '\t') goto yy67;

-				goto yy71;

-			} else {

-				if (yych == '\r') goto yy72;

-				if (yych <= 0x1F) goto yy5;

-				goto yy67;

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych == '#') goto yy60;

-				goto yy5;

-			} else {

-				if (yych <= ';') goto yy53;

-				if (yych == '=') goto yy51;

-				goto yy5;

-			}

-		}

-yy69:

-		YYDEBUG(69, *YYCURSOR);

-		yyaccept = 1;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-		YYDEBUG(70, *YYCURSOR);

-		if (yych <= '&') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy25;

-					if (yych <= '\t') goto yy67;

-				} else {

-					if (yych == '\r') goto yy72;

-					goto yy25;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= ' ') goto yy69;

-					if (yych <= '"') goto yy3;

-					goto yy58;

-				} else {

-					if (yych == '%') goto yy25;

-					goto yy3;

-				}

-			}

-		} else {

-			if (yych <= '=') {

-				if (yych <= ':') {

-					if (yych <= '\'') goto yy25;

-					if (yych <= ')') goto yy3;

-					goto yy25;

-				} else {

-					if (yych <= ';') goto yy53;

-					if (yych <= '<') goto yy25;

-					goto yy51;

-				}

-			} else {

-				if (yych <= ']') {

-					if (yych == '[') goto yy28;

-					goto yy25;

-				} else {

-					if (yych <= '^') goto yy3;

-					if (yych <= 'z') goto yy25;

-					if (yych <= '~') goto yy3;

-					goto yy25;

-				}

-			}

-		}

-yy71:

-		YYDEBUG(71, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy7;

-yy72:

-		YYDEBUG(72, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '\n') goto yy71;

-		goto yy7;

-	}

-/* *********************************** */

-yyc_ST_DOUBLE_QUOTES:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0, 128,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-		};

-		YYDEBUG(73, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych == '"') goto yy77;

-		if (yych == '$') goto yy79;

-		YYDEBUG(75, *YYCURSOR);

-		++YYCURSOR;

-yy76:

-		YYDEBUG(76, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 535 "Zend/zend_ini_scanner.l"

-		{ /* Escape double quoted string contents */

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-	

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '"':

-				if (YYCURSOR < YYLIMIT && YYCURSOR[-2] == '\\' && *YYCURSOR != '\r' && *YYCURSOR != '\n') {

-					continue;

-				}

-				break;

-			case '$':

-				if (*YYCURSOR == '{') {

-					break;

-				}

-				continue;

-			case '\\':

-				if (YYCURSOR < YYLIMIT && *YYCURSOR != '"') {

-					YYCURSOR++;

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-		

-		YYCURSOR--;

-		break;

-	}

-

-	yyleng = YYCURSOR - SCNG(yy_text);

-	

-	zend_ini_escape_string(ini_lval, yytext, yyleng, '"' TSRMLS_CC);

-	return TC_QUOTED_STRING;

-}

-#line 1198 "Zend/zend_ini_scanner.c"

-yy77:

-		YYDEBUG(77, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy83;

-yy78:

-		YYDEBUG(78, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 530 "Zend/zend_ini_scanner.l"

-		{ /* Double quoted '"' string ends */

-	yy_pop_state(TSRMLS_C);

-	return '"';

-}

-#line 1212 "Zend/zend_ini_scanner.c"

-yy79:

-		YYDEBUG(79, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '{') goto yy76;

-		YYDEBUG(80, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(81, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 401 "Zend/zend_ini_scanner.l"

-		{ /* Variable start */

-	yy_push_state(ST_VARNAME TSRMLS_CC);

-	return TC_DOLLAR_CURLY;

-}

-#line 1226 "Zend/zend_ini_scanner.c"

-yy82:

-		YYDEBUG(82, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy83:

-		YYDEBUG(83, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy82;

-		}

-		goto yy78;

-	}

-/* *********************************** */

-yyc_ST_OFFSET:

-	{

-		static const unsigned char yybm[] = {

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66, 194,  64,  66,  66,  64,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			194,  66,  64,  66,  68,  66,  66,   0, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			114, 114, 114, 114, 114, 114, 114, 114, 

-			114, 114,  66,  64,  66,  66,  66,  66, 

-			 66,  82,  82,  82,  82,  82,  82,  82, 

-			 82,  82,  82,  82,  82,  82,  82,  82, 

-			 82,  82,  82,  82,  82,  82,  82,  82, 

-			 82,  82,  82,  66,  72,  64,  66,  82, 

-			 66,  82,  82,  82,  82,  82,  82,  82, 

-			 82,  82,  82,  82,  82,  82,  82,  82, 

-			 82,  82,  82,  82,  82,  82,  82,  82, 

-			 82,  82,  82,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-			 66,  66,  66,  66,  66,  66,  66,  66, 

-		};

-		YYDEBUG(84, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych <= '-') {

-			if (yych <= ' ') {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy86;

-					if (yych <= '\t') goto yy88;

-					goto yy89;

-				} else {

-					if (yych == '\r') goto yy89;

-					if (yych >= ' ') goto yy88;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych == '"') goto yy91;

-					if (yych >= '$') goto yy93;

-				} else {

-					if (yych == '\'') goto yy94;

-					if (yych >= '-') goto yy95;

-				}

-			}

-		} else {

-			if (yych <= 'Z') {

-				if (yych <= '9') {

-					if (yych <= '.') goto yy96;

-					if (yych >= '0') goto yy97;

-				} else {

-					if (yych == ';') goto yy89;

-					if (yych >= 'A') goto yy99;

-				}

-			} else {

-				if (yych <= '^') {

-					if (yych <= '[') goto yy86;

-					if (yych <= '\\') goto yy101;

-					if (yych <= ']') goto yy102;

-				} else {

-					if (yych == '`') goto yy86;

-					if (yych <= 'z') goto yy99;

-				}

-			}

-		}

-yy86:

-		YYDEBUG(86, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy105;

-yy87:

-		YYDEBUG(87, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 521 "Zend/zend_ini_scanner.l"

-		{ /* Get rest as section/offset value */

-	RETURN_TOKEN(TC_STRING, yytext, yyleng);

-}

-#line 1330 "Zend/zend_ini_scanner.c"

-yy88:

-		YYDEBUG(88, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy131;

-		}

-		if (yych == '"') goto yy133;

-		if (yych == ']') goto yy134;

-		goto yy105;

-yy89:

-		YYDEBUG(89, *YYCURSOR);

-		++YYCURSOR;

-yy90:

-		YYDEBUG(90, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 603 "Zend/zend_ini_scanner.l"

-		{

-	return 0;

-}

-#line 1351 "Zend/zend_ini_scanner.c"

-yy91:

-		YYDEBUG(91, *YYCURSOR);

-		++YYCURSOR;

-yy92:

-		YYDEBUG(92, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 525 "Zend/zend_ini_scanner.l"

-		{ /* Double quoted '"' string start */

-	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);

-	return '"';

-}

-#line 1363 "Zend/zend_ini_scanner.c"

-yy93:

-		YYDEBUG(93, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '\\') {

-			if (yych <= 0x00) goto yy90;

-			if (yych <= '[') goto yy104;

-			goto yy109;

-		} else {

-			if (yych == '{') goto yy129;

-			goto yy104;

-		}

-yy94:

-		YYDEBUG(94, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy125;

-		}

-		goto yy90;

-yy95:

-		YYDEBUG(95, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') goto yy105;

-		if (yych <= '9') goto yy123;

-		goto yy105;

-yy96:

-		YYDEBUG(96, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') goto yy105;

-		if (yych <= '9') goto yy121;

-		goto yy105;

-yy97:

-		YYDEBUG(97, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '\'') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy98;

-				if (yych <= '\f') goto yy105;

-			} else {

-				if (yych == '"') goto yy98;

-				if (yych <= '&') goto yy105;

-			}

-		} else {

-			if (yych <= '9') {

-				if (yych == '.') goto yy117;

-				if (yych <= '/') goto yy105;

-				goto yy119;

-			} else {

-				if (yych <= ';') {

-					if (yych <= ':') goto yy105;

-				} else {

-					if (yych != ']') goto yy105;

-				}

-			}

-		}

-yy98:

-		YYDEBUG(98, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 499 "Zend/zend_ini_scanner.l"

-		{ /* Get number option value as string */

-	RETURN_TOKEN(TC_NUMBER, yytext, yyleng);

-}

-#line 1429 "Zend/zend_ini_scanner.c"

-yy99:

-		YYDEBUG(99, *YYCURSOR);

-		yyaccept = 3;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy115;

-		}

-		if (yych <= '"') {

-			if (yych <= '\f') {

-				if (yych != '\n') goto yy105;

-			} else {

-				if (yych <= '\r') goto yy100;

-				if (yych <= '!') goto yy105;

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych != '\'') goto yy105;

-			} else {

-				if (yych <= ';') goto yy100;

-				if (yych != ']') goto yy105;

-			}

-		}

-yy100:

-		YYDEBUG(100, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 495 "Zend/zend_ini_scanner.l"

-		{ /* Get constant option value */

-	RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);

-}

-#line 1459 "Zend/zend_ini_scanner.c"

-yy101:

-		YYDEBUG(101, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy104;

-yy102:

-		YYDEBUG(102, *YYCURSOR);

-		++YYCURSOR;

-yy103:

-		YYDEBUG(103, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 396 "Zend/zend_ini_scanner.l"

-		{ /* End of section or an option offset */

-	BEGIN(INITIAL);

-	return ']';

-}

-#line 1475 "Zend/zend_ini_scanner.c"

-yy104:

-		YYDEBUG(104, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy105:

-		YYDEBUG(105, *YYCURSOR);

-		if (yybm[0+yych] & 2) {

-			goto yy104;

-		}

-		if (yych == '$') goto yy107;

-		if (yych != '\\') goto yy87;

-yy106:

-		YYDEBUG(106, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		goto yy104;

-yy107:

-		YYDEBUG(107, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yych <= '\\') {

-			if (yych <= 0x00) goto yy108;

-			if (yych <= '[') goto yy104;

-			goto yy109;

-		} else {

-			if (yych != '{') goto yy104;

-		}

-yy108:

-		YYDEBUG(108, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		if (yyaccept <= 1) {

-			if (yyaccept <= 0) {

-				goto yy87;

-			} else {

-				goto yy90;

-			}

-		} else {

-			if (yyaccept <= 2) {

-				goto yy98;

-			} else {

-				goto yy100;

-			}

-		}

-yy109:

-		YYDEBUG(109, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yybm[0+yych] & 4) {

-			goto yy110;

-		}

-		if (yych == '\\') goto yy112;

-		goto yy104;

-yy110:

-		YYDEBUG(110, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(111, *YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy110;

-		}

-		if (yych == '\\') goto yy114;

-		goto yy104;

-yy112:

-		YYDEBUG(112, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(113, *YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy110;

-		}

-		if (yych == '\\') goto yy112;

-		goto yy104;

-yy114:

-		YYDEBUG(114, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yybm[0+yych] & 4) {

-			goto yy110;

-		}

-		if (yych == '\\') goto yy112;

-		goto yy104;

-yy115:

-		YYDEBUG(115, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(116, *YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy115;

-		}

-		if (yych <= '$') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy100;

-				if (yych <= '\f') goto yy104;

-				goto yy100;

-			} else {

-				if (yych == '"') goto yy100;

-				if (yych <= '#') goto yy104;

-				goto yy107;

-			}

-		} else {

-			if (yych <= ';') {

-				if (yych == '\'') goto yy100;

-				if (yych <= ':') goto yy104;

-				goto yy100;

-			} else {

-				if (yych <= '[') goto yy104;

-				if (yych <= '\\') goto yy106;

-				if (yych <= ']') goto yy100;

-				goto yy104;

-			}

-		}

-yy117:

-		YYDEBUG(117, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(118, *YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy117;

-		}

-		if (yych <= '$') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy98;

-				if (yych <= '\f') goto yy104;

-				goto yy98;

-			} else {

-				if (yych == '"') goto yy98;

-				if (yych <= '#') goto yy104;

-				goto yy107;

-			}

-		} else {

-			if (yych <= ';') {

-				if (yych == '\'') goto yy98;

-				if (yych <= ':') goto yy104;

-				goto yy98;

-			} else {

-				if (yych <= '[') goto yy104;

-				if (yych <= '\\') goto yy106;

-				if (yych <= ']') goto yy98;

-				goto yy104;

-			}

-		}

-yy119:

-		YYDEBUG(119, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(120, *YYCURSOR);

-		if (yych <= '\'') {

-			if (yych <= '!') {

-				if (yych <= '\n') {

-					if (yych <= '\t') goto yy104;

-					goto yy98;

-				} else {

-					if (yych == '\r') goto yy98;

-					goto yy104;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= '"') goto yy98;

-					goto yy104;

-				} else {

-					if (yych <= '$') goto yy107;

-					if (yych <= '&') goto yy104;

-					goto yy98;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '.') {

-					if (yych <= '-') goto yy104;

-					goto yy117;

-				} else {

-					if (yych <= '/') goto yy104;

-					if (yych <= '9') goto yy119;

-					goto yy104;

-				}

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy98;

-					goto yy104;

-				} else {

-					if (yych <= '\\') goto yy106;

-					if (yych <= ']') goto yy98;

-					goto yy104;

-				}

-			}

-		}

-yy121:

-		YYDEBUG(121, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(122, *YYCURSOR);

-		if (yych <= '&') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy98;

-				if (yych <= '\f') goto yy104;

-				goto yy98;

-			} else {

-				if (yych <= '"') {

-					if (yych <= '!') goto yy104;

-					goto yy98;

-				} else {

-					if (yych == '$') goto yy107;

-					goto yy104;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '\'') goto yy98;

-				if (yych <= '/') goto yy104;

-				if (yych <= '9') goto yy121;

-				goto yy104;

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy98;

-					goto yy104;

-				} else {

-					if (yych <= '\\') goto yy106;

-					if (yych <= ']') goto yy98;

-					goto yy104;

-				}

-			}

-		}

-yy123:

-		YYDEBUG(123, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(124, *YYCURSOR);

-		if (yych <= '&') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy98;

-				if (yych <= '\f') goto yy104;

-				goto yy98;

-			} else {

-				if (yych <= '"') {

-					if (yych <= '!') goto yy104;

-					goto yy98;

-				} else {

-					if (yych == '$') goto yy107;

-					goto yy104;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '\'') goto yy98;

-				if (yych <= '/') goto yy104;

-				if (yych <= '9') goto yy123;

-				goto yy104;

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy98;

-					goto yy104;

-				} else {

-					if (yych <= '\\') goto yy106;

-					if (yych <= ']') goto yy98;

-					goto yy104;

-				}

-			}

-		}

-yy125:

-		YYDEBUG(125, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(126, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy125;

-		}

-		YYDEBUG(127, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(128, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 368 "Zend/zend_ini_scanner.l"

-		{ /* Raw string */

-	/* Eat leading and trailing single quotes */

-	if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {

-		SCNG(yy_text)++;

-		yyleng = yyleng - 2;

-	}

-	RETURN_TOKEN(TC_RAW, yytext, yyleng);

-}

-#line 1774 "Zend/zend_ini_scanner.c"

-yy129:

-		YYDEBUG(129, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(130, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 401 "Zend/zend_ini_scanner.l"

-		{ /* Variable start */

-	yy_push_state(ST_VARNAME TSRMLS_CC);

-	return TC_DOLLAR_CURLY;

-}

-#line 1785 "Zend/zend_ini_scanner.c"

-yy131:

-		YYDEBUG(131, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(132, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy131;

-		}

-		if (yych <= '$') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy87;

-				if (yych <= '\f') goto yy104;

-				goto yy87;

-			} else {

-				if (yych == '"') goto yy133;

-				if (yych <= '#') goto yy104;

-				goto yy107;

-			}

-		} else {

-			if (yych <= ';') {

-				if (yych == '\'') goto yy87;

-				if (yych <= ':') goto yy104;

-				goto yy87;

-			} else {

-				if (yych <= '[') goto yy104;

-				if (yych <= '\\') goto yy106;

-				if (yych <= ']') goto yy134;

-				goto yy104;

-			}

-		}

-yy133:

-		YYDEBUG(133, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy92;

-yy134:

-		YYDEBUG(134, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy103;

-	}

-/* *********************************** */

-yyc_ST_RAW:

-	{

-		static const unsigned char yybm[] = {

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64, 192,   0,  64,  64,   0,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			192,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-		};

-		YYDEBUG(135, *YYCURSOR);

-		YYFILL(3);

-		yych = *YYCURSOR;

-		if (yych <= '\f') {

-			if (yych <= 0x08) {

-				if (yych >= 0x01) goto yy139;

-			} else {

-				if (yych <= '\t') goto yy141;

-				if (yych <= '\n') goto yy142;

-				goto yy139;

-			}

-		} else {

-			if (yych <= ' ') {

-				if (yych <= '\r') goto yy144;

-				if (yych <= 0x1F) goto yy139;

-				goto yy141;

-			} else {

-				if (yych == ';') goto yy145;

-				goto yy139;

-			}

-		}

-		YYDEBUG(137, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(138, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 598 "Zend/zend_ini_scanner.l"

-		{ /* End of option value (if EOF is reached before EOL */

-	BEGIN(INITIAL);

-	return END_OF_LINE;

-}

-#line 1895 "Zend/zend_ini_scanner.c"

-yy139:

-		YYDEBUG(139, *YYCURSOR);

-		++YYCURSOR;

-yy140:

-		YYDEBUG(140, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 448 "Zend/zend_ini_scanner.l"

-		{ /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */

-	char *sc = NULL;

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR) {

-			case '\n':

-			case '\r':

-				goto end_raw_value_chars;

-				break;

-			case ';':

-				if (sc == NULL) {

-					sc = YYCURSOR;

-				}

-				/* no break */

-			default:

-				YYCURSOR++;

-				break;

-		}

-	}

-end_raw_value_chars:

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	/* Eat trailing semicolons */

-	while (yytext[yyleng - 1] == ';') {

-		yyleng--;

-	}

-

-	/* Eat leading and trailing double quotes */

-	if (yytext[0] == '"' && yytext[yyleng - 1] == '"') {

-		SCNG(yy_text)++;

-		yyleng = yyleng - 2;

-	} else if (sc) {

-		YYCURSOR = sc;

-		yyleng = YYCURSOR - SCNG(yy_text);

-	}

-	RETURN_TOKEN(TC_RAW, yytext, yyleng);

-}

-#line 1939 "Zend/zend_ini_scanner.c"

-yy141:

-		YYDEBUG(141, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '\r') {

-			if (yych <= 0x08) goto yy140;

-			if (yych <= '\n') goto yy153;

-			if (yych <= '\f') goto yy140;

-			goto yy153;

-		} else {

-			if (yych <= ' ') {

-				if (yych <= 0x1F) goto yy140;

-				goto yy153;

-			} else {

-				if (yych == ';') goto yy153;

-				goto yy140;

-			}

-		}

-yy142:

-		YYDEBUG(142, *YYCURSOR);

-		++YYCURSOR;

-yy143:

-		YYDEBUG(143, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 489 "Zend/zend_ini_scanner.l"

-		{ /* End of option value */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 1970 "Zend/zend_ini_scanner.c"

-yy144:

-		YYDEBUG(144, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy151;

-		goto yy143;

-yy145:

-		YYDEBUG(145, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy147;

-yy146:

-		YYDEBUG(146, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy147:

-		YYDEBUG(147, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy146;

-		}

-		if (yych >= '\r') goto yy150;

-yy148:

-		YYDEBUG(148, *YYCURSOR);

-		++YYCURSOR;

-yy149:

-		YYDEBUG(149, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 585 "Zend/zend_ini_scanner.l"

-		{ /* Comment */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 2004 "Zend/zend_ini_scanner.c"

-yy150:

-		YYDEBUG(150, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy148;

-		goto yy149;

-yy151:

-		YYDEBUG(151, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy143;

-yy152:

-		YYDEBUG(152, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy153:

-		YYDEBUG(153, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy152;

-		}

-		if (yych <= '\f') {

-			if (yych == '\n') goto yy151;

-		} else {

-			if (yych <= '\r') goto yy155;

-			if (yych == ';') goto yy146;

-		}

-		YYDEBUG(154, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 575 "Zend/zend_ini_scanner.l"

-		{

-	/* eat whitespace */

-	goto restart;

-}

-#line 2038 "Zend/zend_ini_scanner.c"

-yy155:

-		YYDEBUG(155, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '\n') goto yy151;

-		goto yy143;

-	}

-/* *********************************** */

-yyc_ST_SECTION_RAW:

-	{

-		static const unsigned char yybm[] = {

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 192,   0, 128, 128,   0, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			192, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128,   0, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-		};

-		YYDEBUG(156, *YYCURSOR);

-		YYFILL(3);

-		yych = *YYCURSOR;

-		if (yych <= '\f') {

-			if (yych == '\n') goto yy160;

-		} else {

-			if (yych <= '\r') goto yy160;

-			if (yych == ']') goto yy162;

-		}

-		YYDEBUG(158, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy169;

-yy159:

-		YYDEBUG(159, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 485 "Zend/zend_ini_scanner.l"

-		{ /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */

-	RETURN_TOKEN(TC_RAW, yytext, yyleng);

-}

-#line 2102 "Zend/zend_ini_scanner.c"

-yy160:

-		YYDEBUG(160, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(161, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 603 "Zend/zend_ini_scanner.l"

-		{

-	return 0;

-}

-#line 2112 "Zend/zend_ini_scanner.c"

-yy162:

-		YYDEBUG(162, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy165;

-yy163:

-		YYDEBUG(163, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 377 "Zend/zend_ini_scanner.l"

-		{ /* End of section */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return ']';

-}

-#line 2127 "Zend/zend_ini_scanner.c"

-yy164:

-		YYDEBUG(164, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy165:

-		YYDEBUG(165, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy164;

-		}

-		if (yych == '\n') goto yy166;

-		if (yych == '\r') goto yy167;

-		goto yy163;

-yy166:

-		YYDEBUG(166, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy163;

-yy167:

-		YYDEBUG(167, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy166;

-		goto yy163;

-yy168:

-		YYDEBUG(168, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy169:

-		YYDEBUG(169, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy168;

-		}

-		goto yy159;

-	}

-/* *********************************** */

-yyc_ST_SECTION_VALUE:

-	{

-		static const unsigned char yybm[] = {

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 134, 128, 132, 132, 128, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			134, 132, 128, 132, 136, 132, 132,   0, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			228, 228, 228, 228, 228, 228, 228, 228, 

-			228, 228, 132, 128, 132, 132, 132, 132, 

-			132, 164, 164, 164, 164, 164, 164, 164, 

-			164, 164, 164, 164, 164, 164, 164, 164, 

-			164, 164, 164, 164, 164, 164, 164, 164, 

-			164, 164, 164, 132, 144, 128, 132, 164, 

-			132, 164, 164, 164, 164, 164, 164, 164, 

-			164, 164, 164, 164, 164, 164, 164, 164, 

-			164, 164, 164, 164, 164, 164, 164, 164, 

-			164, 164, 164, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-			132, 132, 132, 132, 132, 132, 132, 132, 

-		};

-		YYDEBUG(170, *YYCURSOR);

-		YYFILL(3);

-		yych = *YYCURSOR;

-		if (yych <= '-') {

-			if (yych <= ' ') {

-				if (yych <= '\n') {

-					if (yych <= 0x08) goto yy172;

-					if (yych <= '\t') goto yy174;

-					goto yy175;

-				} else {

-					if (yych == '\r') goto yy175;

-					if (yych >= ' ') goto yy174;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych == '"') goto yy177;

-					if (yych >= '$') goto yy179;

-				} else {

-					if (yych == '\'') goto yy180;

-					if (yych >= '-') goto yy181;

-				}

-			}

-		} else {

-			if (yych <= 'Z') {

-				if (yych <= '9') {

-					if (yych <= '.') goto yy182;

-					if (yych >= '0') goto yy183;

-				} else {

-					if (yych == ';') goto yy175;

-					if (yych >= 'A') goto yy185;

-				}

-			} else {

-				if (yych <= '^') {

-					if (yych <= '[') goto yy172;

-					if (yych <= '\\') goto yy187;

-					if (yych <= ']') goto yy188;

-				} else {

-					if (yych == '`') goto yy172;

-					if (yych <= 'z') goto yy185;

-				}

-			}

-		}

-yy172:

-		YYDEBUG(172, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy195;

-yy173:

-		YYDEBUG(173, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 521 "Zend/zend_ini_scanner.l"

-		{ /* Get rest as section/offset value */

-	RETURN_TOKEN(TC_STRING, yytext, yyleng);

-}

-#line 2253 "Zend/zend_ini_scanner.c"

-yy174:

-		YYDEBUG(174, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy221;

-			goto yy195;

-		} else {

-			if (yych <= ' ') goto yy221;

-			if (yych == '"') goto yy223;

-			goto yy195;

-		}

-yy175:

-		YYDEBUG(175, *YYCURSOR);

-		++YYCURSOR;

-yy176:

-		YYDEBUG(176, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 603 "Zend/zend_ini_scanner.l"

-		{

-	return 0;

-}

-#line 2276 "Zend/zend_ini_scanner.c"

-yy177:

-		YYDEBUG(177, *YYCURSOR);

-		++YYCURSOR;

-yy178:

-		YYDEBUG(178, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 525 "Zend/zend_ini_scanner.l"

-		{ /* Double quoted '"' string start */

-	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);

-	return '"';

-}

-#line 2288 "Zend/zend_ini_scanner.c"

-yy179:

-		YYDEBUG(179, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '\\') {

-			if (yych <= 0x00) goto yy176;

-			if (yych <= '[') goto yy194;

-			goto yy199;

-		} else {

-			if (yych == '{') goto yy219;

-			goto yy194;

-		}

-yy180:

-		YYDEBUG(180, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy215;

-		}

-		goto yy176;

-yy181:

-		YYDEBUG(181, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') goto yy195;

-		if (yych <= '9') goto yy213;

-		goto yy195;

-yy182:

-		YYDEBUG(182, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') goto yy195;

-		if (yych <= '9') goto yy211;

-		goto yy195;

-yy183:

-		YYDEBUG(183, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '\'') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy184;

-				if (yych <= '\f') goto yy195;

-			} else {

-				if (yych == '"') goto yy184;

-				if (yych <= '&') goto yy195;

-			}

-		} else {

-			if (yych <= '9') {

-				if (yych == '.') goto yy207;

-				if (yych <= '/') goto yy195;

-				goto yy209;

-			} else {

-				if (yych <= ';') {

-					if (yych <= ':') goto yy195;

-				} else {

-					if (yych != ']') goto yy195;

-				}

-			}

-		}

-yy184:

-		YYDEBUG(184, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 499 "Zend/zend_ini_scanner.l"

-		{ /* Get number option value as string */

-	RETURN_TOKEN(TC_NUMBER, yytext, yyleng);

-}

-#line 2354 "Zend/zend_ini_scanner.c"

-yy185:

-		YYDEBUG(185, *YYCURSOR);

-		yyaccept = 3;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy205;

-		}

-		if (yych <= '"') {

-			if (yych <= '\f') {

-				if (yych != '\n') goto yy195;

-			} else {

-				if (yych <= '\r') goto yy186;

-				if (yych <= '!') goto yy195;

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych != '\'') goto yy195;

-			} else {

-				if (yych <= ';') goto yy186;

-				if (yych != ']') goto yy195;

-			}

-		}

-yy186:

-		YYDEBUG(186, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 495 "Zend/zend_ini_scanner.l"

-		{ /* Get constant option value */

-	RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);

-}

-#line 2384 "Zend/zend_ini_scanner.c"

-yy187:

-		YYDEBUG(187, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy194;

-yy188:

-		YYDEBUG(188, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy191;

-yy189:

-		YYDEBUG(189, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 377 "Zend/zend_ini_scanner.l"

-		{ /* End of section */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return ']';

-}

-#line 2403 "Zend/zend_ini_scanner.c"

-yy190:

-		YYDEBUG(190, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy191:

-		YYDEBUG(191, *YYCURSOR);

-		if (yybm[0+yych] & 2) {

-			goto yy190;

-		}

-		if (yych == '\n') goto yy192;

-		if (yych == '\r') goto yy193;

-		goto yy189;

-yy192:

-		YYDEBUG(192, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy189;

-yy193:

-		YYDEBUG(193, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy192;

-		goto yy189;

-yy194:

-		YYDEBUG(194, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy195:

-		YYDEBUG(195, *YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy194;

-		}

-		if (yych == '$') goto yy197;

-		if (yych != '\\') goto yy173;

-yy196:

-		YYDEBUG(196, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		goto yy194;

-yy197:

-		YYDEBUG(197, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yych <= '\\') {

-			if (yych <= 0x00) goto yy198;

-			if (yych <= '[') goto yy194;

-			goto yy199;

-		} else {

-			if (yych != '{') goto yy194;

-		}

-yy198:

-		YYDEBUG(198, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		if (yyaccept <= 1) {

-			if (yyaccept <= 0) {

-				goto yy173;

-			} else {

-				goto yy176;

-			}

-		} else {

-			if (yyaccept <= 2) {

-				goto yy184;

-			} else {

-				goto yy186;

-			}

-		}

-yy199:

-		YYDEBUG(199, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yybm[0+yych] & 8) {

-			goto yy200;

-		}

-		if (yych == '\\') goto yy202;

-		goto yy194;

-yy200:

-		YYDEBUG(200, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(201, *YYCURSOR);

-		if (yybm[0+yych] & 8) {

-			goto yy200;

-		}

-		if (yych == '\\') goto yy204;

-		goto yy194;

-yy202:

-		YYDEBUG(202, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(203, *YYCURSOR);

-		if (yybm[0+yych] & 8) {

-			goto yy200;

-		}

-		if (yych == '\\') goto yy202;

-		goto yy194;

-yy204:

-		YYDEBUG(204, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yybm[0+yych] & 8) {

-			goto yy200;

-		}

-		if (yych == '\\') goto yy202;

-		goto yy194;

-yy205:

-		YYDEBUG(205, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(206, *YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy205;

-		}

-		if (yych <= '$') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy186;

-				if (yych <= '\f') goto yy194;

-				goto yy186;

-			} else {

-				if (yych == '"') goto yy186;

-				if (yych <= '#') goto yy194;

-				goto yy197;

-			}

-		} else {

-			if (yych <= ';') {

-				if (yych == '\'') goto yy186;

-				if (yych <= ':') goto yy194;

-				goto yy186;

-			} else {

-				if (yych <= '[') goto yy194;

-				if (yych <= '\\') goto yy196;

-				if (yych <= ']') goto yy186;

-				goto yy194;

-			}

-		}

-yy207:

-		YYDEBUG(207, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(208, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy207;

-		}

-		if (yych <= '$') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy184;

-				if (yych <= '\f') goto yy194;

-				goto yy184;

-			} else {

-				if (yych == '"') goto yy184;

-				if (yych <= '#') goto yy194;

-				goto yy197;

-			}

-		} else {

-			if (yych <= ';') {

-				if (yych == '\'') goto yy184;

-				if (yych <= ':') goto yy194;

-				goto yy184;

-			} else {

-				if (yych <= '[') goto yy194;

-				if (yych <= '\\') goto yy196;

-				if (yych <= ']') goto yy184;

-				goto yy194;

-			}

-		}

-yy209:

-		YYDEBUG(209, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(210, *YYCURSOR);

-		if (yych <= '\'') {

-			if (yych <= '!') {

-				if (yych <= '\n') {

-					if (yych <= '\t') goto yy194;

-					goto yy184;

-				} else {

-					if (yych == '\r') goto yy184;

-					goto yy194;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= '"') goto yy184;

-					goto yy194;

-				} else {

-					if (yych <= '$') goto yy197;

-					if (yych <= '&') goto yy194;

-					goto yy184;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '.') {

-					if (yych <= '-') goto yy194;

-					goto yy207;

-				} else {

-					if (yych <= '/') goto yy194;

-					if (yych <= '9') goto yy209;

-					goto yy194;

-				}

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy184;

-					goto yy194;

-				} else {

-					if (yych <= '\\') goto yy196;

-					if (yych <= ']') goto yy184;

-					goto yy194;

-				}

-			}

-		}

-yy211:

-		YYDEBUG(211, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(212, *YYCURSOR);

-		if (yych <= '&') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy184;

-				if (yych <= '\f') goto yy194;

-				goto yy184;

-			} else {

-				if (yych <= '"') {

-					if (yych <= '!') goto yy194;

-					goto yy184;

-				} else {

-					if (yych == '$') goto yy197;

-					goto yy194;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '\'') goto yy184;

-				if (yych <= '/') goto yy194;

-				if (yych <= '9') goto yy211;

-				goto yy194;

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy184;

-					goto yy194;

-				} else {

-					if (yych <= '\\') goto yy196;

-					if (yych <= ']') goto yy184;

-					goto yy194;

-				}

-			}

-		}

-yy213:

-		YYDEBUG(213, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(214, *YYCURSOR);

-		if (yych <= '&') {

-			if (yych <= '\r') {

-				if (yych == '\n') goto yy184;

-				if (yych <= '\f') goto yy194;

-				goto yy184;

-			} else {

-				if (yych <= '"') {

-					if (yych <= '!') goto yy194;

-					goto yy184;

-				} else {

-					if (yych == '$') goto yy197;

-					goto yy194;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '\'') goto yy184;

-				if (yych <= '/') goto yy194;

-				if (yych <= '9') goto yy213;

-				goto yy194;

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy184;

-					goto yy194;

-				} else {

-					if (yych <= '\\') goto yy196;

-					if (yych <= ']') goto yy184;

-					goto yy194;

-				}

-			}

-		}

-yy215:

-		YYDEBUG(215, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(216, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy215;

-		}

-		YYDEBUG(217, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(218, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 368 "Zend/zend_ini_scanner.l"

-		{ /* Raw string */

-	/* Eat leading and trailing single quotes */

-	if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {

-		SCNG(yy_text)++;

-		yyleng = yyleng - 2;

-	}

-	RETURN_TOKEN(TC_RAW, yytext, yyleng);

-}

-#line 2724 "Zend/zend_ini_scanner.c"

-yy219:

-		YYDEBUG(219, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(220, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 401 "Zend/zend_ini_scanner.l"

-		{ /* Variable start */

-	yy_push_state(ST_VARNAME TSRMLS_CC);

-	return TC_DOLLAR_CURLY;

-}

-#line 2735 "Zend/zend_ini_scanner.c"

-yy221:

-		YYDEBUG(221, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(222, *YYCURSOR);

-		if (yych <= '"') {

-			if (yych <= '\f') {

-				if (yych <= 0x08) goto yy194;

-				if (yych <= '\t') goto yy221;

-				if (yych <= '\n') goto yy173;

-				goto yy194;

-			} else {

-				if (yych <= 0x1F) {

-					if (yych <= '\r') goto yy173;

-					goto yy194;

-				} else {

-					if (yych <= ' ') goto yy221;

-					if (yych <= '!') goto yy194;

-				}

-			}

-		} else {

-			if (yych <= ':') {

-				if (yych <= '$') {

-					if (yych <= '#') goto yy194;

-					goto yy197;

-				} else {

-					if (yych == '\'') goto yy173;

-					goto yy194;

-				}

-			} else {

-				if (yych <= '[') {

-					if (yych <= ';') goto yy173;

-					goto yy194;

-				} else {

-					if (yych <= '\\') goto yy196;

-					if (yych <= ']') goto yy173;

-					goto yy194;

-				}

-			}

-		}

-yy223:

-		YYDEBUG(223, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy178;

-	}

-/* *********************************** */

-yyc_ST_VALUE:

-	{

-		static const unsigned char yybm[] = {

-			160, 162, 162, 162, 162, 162, 162, 162, 

-			162, 176, 128, 162, 162, 128, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			176, 160, 160, 162, 168, 162, 160,  32, 

-			160, 160, 162, 162, 162, 162, 162, 162, 

-			230, 230, 230, 230, 230, 230, 230, 230, 

-			230, 230, 162, 160, 162, 160, 162, 162, 

-			162, 166, 166, 166, 166, 166, 166, 166, 

-			166, 166, 166, 166, 166, 166, 166, 166, 

-			166, 166, 166, 166, 166, 166, 166, 166, 

-			166, 166, 166, 162, 162, 162, 160, 166, 

-			162, 166, 166, 166, 166, 166, 166, 166, 

-			166, 166, 166, 166, 166, 166, 166, 166, 

-			166, 166, 166, 166, 166, 166, 166, 166, 

-			166, 166, 166, 162, 160, 162, 160, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-			162, 162, 162, 162, 162, 162, 162, 162, 

-		};

-		YYDEBUG(224, *YYCURSOR);

-		YYFILL(6);

-		yych = *YYCURSOR;

-		YYDEBUG(-1, yych);

-		switch (yych) {

-		case 0x00:	goto yy226;

-		case '\t':

-		case ' ':	goto yy230;

-		case '\n':	goto yy232;

-		case '\r':	goto yy234;

-		case '!':

-		case '&':

-		case '(':

-		case ')':

-		case '^':

-		case '|':

-		case '~':	goto yy235;

-		case '"':	goto yy237;

-		case '$':	goto yy239;

-		case '\'':	goto yy240;

-		case '-':	goto yy241;

-		case '.':	goto yy242;

-		case '0':

-		case '1':

-		case '2':

-		case '3':

-		case '4':

-		case '5':

-		case '6':

-		case '7':

-		case '8':

-		case '9':	goto yy243;

-		case ';':	goto yy245;

-		case '=':	goto yy246;

-		case 'A':

-		case 'B':

-		case 'C':

-		case 'D':

-		case 'E':

-		case 'G':

-		case 'H':

-		case 'I':

-		case 'J':

-		case 'K':

-		case 'L':

-		case 'M':

-		case 'P':

-		case 'Q':

-		case 'R':

-		case 'S':

-		case 'U':

-		case 'V':

-		case 'W':

-		case 'X':

-		case 'Z':

-		case '_':

-		case 'a':

-		case 'b':

-		case 'c':

-		case 'd':

-		case 'e':

-		case 'g':

-		case 'h':

-		case 'i':

-		case 'j':

-		case 'k':

-		case 'l':

-		case 'm':

-		case 'p':

-		case 'q':

-		case 'r':

-		case 's':

-		case 'u':

-		case 'v':

-		case 'w':

-		case 'x':

-		case 'z':	goto yy248;

-		case 'F':

-		case 'f':	goto yy250;

-		case 'N':

-		case 'n':	goto yy251;

-		case 'O':

-		case 'o':	goto yy252;

-		case 'T':

-		case 't':	goto yy253;

-		case 'Y':

-		case 'y':	goto yy254;

-		default:	goto yy228;

-		}

-yy226:

-		YYDEBUG(226, *YYCURSOR);

-		++YYCURSOR;

-yy227:

-		YYDEBUG(227, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 598 "Zend/zend_ini_scanner.l"

-		{ /* End of option value (if EOF is reached before EOL */

-	BEGIN(INITIAL);

-	return END_OF_LINE;

-}

-#line 2921 "Zend/zend_ini_scanner.c"

-yy228:

-		YYDEBUG(228, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy256;

-yy229:

-		YYDEBUG(229, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 517 "Zend/zend_ini_scanner.l"

-		{ /* Get everything else as option/offset value */

-	RETURN_TOKEN(TC_STRING, yytext, yyleng);

-}

-#line 2934 "Zend/zend_ini_scanner.c"

-yy230:

-		YYDEBUG(230, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy306;

-yy231:

-		YYDEBUG(231, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 571 "Zend/zend_ini_scanner.l"

-		{

-	RETURN_TOKEN(TC_WHITESPACE, yytext, yyleng);

-}

-#line 2947 "Zend/zend_ini_scanner.c"

-yy232:

-		YYDEBUG(232, *YYCURSOR);

-		++YYCURSOR;

-yy233:

-		YYDEBUG(233, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 489 "Zend/zend_ini_scanner.l"

-		{ /* End of option value */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 2960 "Zend/zend_ini_scanner.c"

-yy234:

-		YYDEBUG(234, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy304;

-		goto yy233;

-yy235:

-		YYDEBUG(235, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy303;

-yy236:

-		YYDEBUG(236, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 507 "Zend/zend_ini_scanner.l"

-		{ /* Boolean operators */

-	return yytext[0];

-}

-#line 2978 "Zend/zend_ini_scanner.c"

-yy237:

-		YYDEBUG(237, *YYCURSOR);

-		++YYCURSOR;

-yy238:

-		YYDEBUG(238, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 525 "Zend/zend_ini_scanner.l"

-		{ /* Double quoted '"' string start */

-	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);

-	return '"';

-}

-#line 2990 "Zend/zend_ini_scanner.c"

-yy239:

-		YYDEBUG(239, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '\\') {

-			if (yych <= 0x00) goto yy227;

-			if (yych <= '[') goto yy255;

-			goto yy262;

-		} else {

-			if (yych == '{') goto yy300;

-			goto yy255;

-		}

-yy240:

-		YYDEBUG(240, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy296;

-		}

-		goto yy227;

-yy241:

-		YYDEBUG(241, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') goto yy256;

-		if (yych <= '9') goto yy294;

-		goto yy256;

-yy242:

-		YYDEBUG(242, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') goto yy256;

-		if (yych <= '9') goto yy292;

-		goto yy256;

-yy243:

-		YYDEBUG(243, *YYCURSOR);

-		yyaccept = 3;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy244;

-					if (yych <= 0x08) goto yy256;

-				} else {

-					if (yych != '\r') goto yy256;

-				}

-			} else {

-				if (yych <= ')') {

-					if (yych <= '"') goto yy244;

-					if (yych <= '%') goto yy256;

-				} else {

-					if (yych == '.') goto yy288;

-					goto yy256;

-				}

-			}

-		} else {

-			if (yych <= ']') {

-				if (yych <= ';') {

-					if (yych <= '9') goto yy290;

-					if (yych <= ':') goto yy256;

-				} else {

-					if (yych != '=') goto yy256;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '^') goto yy244;

-					if (yych <= '{') goto yy256;

-				} else {

-					if (yych != '~') goto yy256;

-				}

-			}

-		}

-yy244:

-		YYDEBUG(244, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 499 "Zend/zend_ini_scanner.l"

-		{ /* Get number option value as string */

-	RETURN_TOKEN(TC_NUMBER, yytext, yyleng);

-}

-#line 3069 "Zend/zend_ini_scanner.c"

-yy245:

-		YYDEBUG(245, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		goto yy284;

-yy246:

-		YYDEBUG(246, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(247, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 511 "Zend/zend_ini_scanner.l"

-		{ /* Make = used in option value to trigger error */

-	yyless(0);

-	BEGIN(INITIAL);

-	return END_OF_LINE;

-}

-#line 3086 "Zend/zend_ini_scanner.c"

-yy248:

-		YYDEBUG(248, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy257;

-		}

-		if (yych <= ':') {

-			if (yych <= '\r') {

-				if (yych <= 0x08) {

-					if (yych >= 0x01) goto yy256;

-				} else {

-					if (yych <= '\n') goto yy249;

-					if (yych <= '\f') goto yy256;

-				}

-			} else {

-				if (yych <= '"') {

-					if (yych <= 0x1F) goto yy256;

-				} else {

-					if (yych <= '%') goto yy256;

-					if (yych >= '*') goto yy256;

-				}

-			}

-		} else {

-			if (yych <= '^') {

-				if (yych <= '<') {

-					if (yych >= '<') goto yy256;

-				} else {

-					if (yych <= '=') goto yy249;

-					if (yych <= ']') goto yy256;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '{') goto yy256;

-				} else {

-					if (yych != '~') goto yy256;

-				}

-			}

-		}

-yy249:

-		YYDEBUG(249, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 495 "Zend/zend_ini_scanner.l"

-		{ /* Get constant option value */

-	RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);

-}

-#line 3133 "Zend/zend_ini_scanner.c"

-yy250:

-		YYDEBUG(250, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '<') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '/') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					goto yy256;

-				} else {

-					if (yych <= '9') goto yy257;

-					if (yych == ';') goto yy249;

-					goto yy256;

-				}

-			}

-		} else {

-			if (yych <= '_') {

-				if (yych <= 'A') {

-					if (yych <= '=') goto yy249;

-					if (yych <= '@') goto yy256;

-					goto yy280;

-				} else {

-					if (yych <= 'Z') goto yy257;

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					goto yy257;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych <= '`') goto yy256;

-					if (yych <= 'a') goto yy280;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy251:

-		YYDEBUG(251, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 'N') {

-			if (yych <= '%') {

-				if (yych <= '\f') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					if (yych <= '\n') goto yy249;

-					goto yy256;

-				} else {

-					if (yych <= '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					if (yych <= '"') goto yy249;

-					goto yy256;

-				}

-			} else {

-				if (yych <= ':') {

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					if (yych <= '9') goto yy257;

-					goto yy256;

-				} else {

-					if (yych <= '<') {

-						if (yych <= ';') goto yy249;

-						goto yy256;

-					} else {

-						if (yych <= '=') goto yy249;

-						if (yych <= '@') goto yy256;

-						goto yy257;

-					}

-				}

-			}

-		} else {

-			if (yych <= 'n') {

-				if (yych <= 'Z') {

-					if (yych <= 'O') goto yy276;

-					if (yych == 'U') goto yy277;

-					goto yy257;

-				} else {

-					if (yych <= '^') {

-						if (yych <= ']') goto yy256;

-						goto yy249;

-					} else {

-						if (yych == '`') goto yy256;

-						goto yy257;

-					}

-				}

-			} else {

-				if (yych <= 'z') {

-					if (yych <= 'o') goto yy276;

-					if (yych == 'u') goto yy277;

-					goto yy257;

-				} else {

-					if (yych <= '|') {

-						if (yych <= '{') goto yy256;

-						goto yy249;

-					} else {

-						if (yych == '~') goto yy249;

-						goto yy256;

-					}

-				}

-			}

-		}

-yy252:

-		YYDEBUG(252, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 'E') {

-			if (yych <= '%') {

-				if (yych <= '\f') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					if (yych <= '\n') goto yy249;

-					goto yy256;

-				} else {

-					if (yych <= '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					if (yych <= '"') goto yy249;

-					goto yy256;

-				}

-			} else {

-				if (yych <= ':') {

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					if (yych <= '9') goto yy257;

-					goto yy256;

-				} else {

-					if (yych <= '<') {

-						if (yych <= ';') goto yy249;

-						goto yy256;

-					} else {

-						if (yych <= '=') goto yy249;

-						if (yych <= '@') goto yy256;

-						goto yy257;

-					}

-				}

-			}

-		} else {

-			if (yych <= 'e') {

-				if (yych <= 'Z') {

-					if (yych <= 'F') goto yy271;

-					if (yych == 'N') goto yy265;

-					goto yy257;

-				} else {

-					if (yych <= '^') {

-						if (yych <= ']') goto yy256;

-						goto yy249;

-					} else {

-						if (yych == '`') goto yy256;

-						goto yy257;

-					}

-				}

-			} else {

-				if (yych <= 'z') {

-					if (yych <= 'f') goto yy271;

-					if (yych == 'n') goto yy265;

-					goto yy257;

-				} else {

-					if (yych <= '|') {

-						if (yych <= '{') goto yy256;

-						goto yy249;

-					} else {

-						if (yych == '~') goto yy249;

-						goto yy256;

-					}

-				}

-			}

-		}

-yy253:

-		YYDEBUG(253, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'R') goto yy269;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'r') goto yy269;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy254:

-		YYDEBUG(254, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'E') goto yy259;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'e') goto yy259;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy255:

-		YYDEBUG(255, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy256:

-		YYDEBUG(256, *YYCURSOR);

-		if (yybm[0+yych] & 2) {

-			goto yy255;

-		}

-		if (yych == '$') goto yy260;

-		goto yy229;

-yy257:

-		YYDEBUG(257, *YYCURSOR);

-		yyaccept = 4;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(258, *YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy257;

-		}

-		if (yych <= ')') {

-			if (yych <= '\r') {

-				if (yych <= 0x08) {

-					if (yych <= 0x00) goto yy249;

-					goto yy255;

-				} else {

-					if (yych <= '\n') goto yy249;

-					if (yych <= '\f') goto yy255;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= 0x1F) goto yy255;

-					if (yych <= '"') goto yy249;

-					goto yy255;

-				} else {

-					if (yych <= '$') goto yy260;

-					if (yych <= '%') goto yy255;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= ']') {

-				if (yych <= ';') {

-					if (yych <= ':') goto yy255;

-					goto yy249;

-				} else {

-					if (yych == '=') goto yy249;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '^') goto yy249;

-					if (yych <= '{') goto yy255;

-					goto yy249;

-				} else {

-					if (yych == '~') goto yy249;

-					goto yy255;

-				}

-			}

-		}

-yy259:

-		YYDEBUG(259, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'S') goto yy265;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 's') goto yy265;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy260:

-		YYDEBUG(260, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yych <= '\\') {

-			if (yych <= 0x00) goto yy261;

-			if (yych <= '[') goto yy255;

-			goto yy262;

-		} else {

-			if (yych != '{') goto yy255;

-		}

-yy261:

-		YYDEBUG(261, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		if (yyaccept <= 3) {

-			if (yyaccept <= 1) {

-				if (yyaccept <= 0) {

-					goto yy229;

-				} else {

-					goto yy231;

-				}

-			} else {

-				if (yyaccept <= 2) {

-					goto yy227;

-				} else {

-					goto yy244;

-				}

-			}

-		} else {

-			if (yyaccept <= 5) {

-				if (yyaccept <= 4) {

-					goto yy249;

-				} else {

-					goto yy266;

-				}

-			} else {

-				goto yy273;

-			}

-		}

-yy262:

-		YYDEBUG(262, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		if (yybm[0+yych] & 8) {

-			goto yy263;

-		}

-		goto yy255;

-yy263:

-		YYDEBUG(263, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(264, *YYCURSOR);

-		if (yybm[0+yych] & 8) {

-			goto yy263;

-		}

-		if (yych <= 0x00) goto yy229;

-		if (yych == '\\') goto yy262;

-		goto yy255;

-yy265:

-		YYDEBUG(265, *YYCURSOR);

-		yyaccept = 5;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy267;

-		}

-		if (yych <= ';') {

-			if (yych <= ' ') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy266;

-					if (yych <= '\t') goto yy256;

-				} else {

-					if (yych != '\r') goto yy256;

-				}

-			} else {

-				if (yych <= ')') {

-					if (yych <= '"') goto yy266;

-					if (yych <= '%') goto yy256;

-				} else {

-					if (yych <= '/') goto yy256;

-					if (yych <= '9') goto yy257;

-					if (yych <= ':') goto yy256;

-				}

-			}

-		} else {

-			if (yych <= '_') {

-				if (yych <= '@') {

-					if (yych != '=') goto yy256;

-				} else {

-					if (yych <= 'Z') goto yy257;

-					if (yych <= ']') goto yy256;

-					if (yych >= '_') goto yy257;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych <= '`') goto yy256;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych >= 0x7F) goto yy256;

-				}

-			}

-		}

-yy266:

-		YYDEBUG(266, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 421 "Zend/zend_ini_scanner.l"

-		{ /* TRUE value (when used outside option value/offset this causes parse error!) */

-	RETURN_TOKEN(BOOL_TRUE, "1", 1);

-}

-#line 3645 "Zend/zend_ini_scanner.c"

-yy267:

-		YYDEBUG(267, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(268, *YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy267;

-		}

-		goto yy266;

-yy269:

-		YYDEBUG(269, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych != 'U') goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'u') goto yy270;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy270:

-		YYDEBUG(270, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'E') goto yy265;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'e') goto yy265;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy271:

-		YYDEBUG(271, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych != 'F') goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'f') goto yy272;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy272:

-		YYDEBUG(272, *YYCURSOR);

-		yyaccept = 6;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy257;

-		}

-		if (yych <= ')') {

-			if (yych <= '\f') {

-				if (yych <= 0x08) {

-					if (yych >= 0x01) goto yy256;

-				} else {

-					if (yych <= '\t') goto yy274;

-					if (yych >= '\v') goto yy256;

-				}

-			} else {

-				if (yych <= ' ') {

-					if (yych <= '\r') goto yy273;

-					if (yych <= 0x1F) goto yy256;

-					goto yy274;

-				} else {

-					if (yych <= '"') goto yy273;

-					if (yych <= '%') goto yy256;

-				}

-			}

-		} else {

-			if (yych <= ']') {

-				if (yych <= ';') {

-					if (yych <= ':') goto yy256;

-				} else {

-					if (yych != '=') goto yy256;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '^') goto yy273;

-					if (yych <= '{') goto yy256;

-				} else {

-					if (yych != '~') goto yy256;

-				}

-			}

-		}

-yy273:

-		YYDEBUG(273, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 425 "Zend/zend_ini_scanner.l"

-		{ /* FALSE value (when used outside option value/offset this causes parse error!)*/

-	RETURN_TOKEN(BOOL_FALSE, "", 0);

-}

-#line 3855 "Zend/zend_ini_scanner.c"

-yy274:

-		YYDEBUG(274, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(275, *YYCURSOR);

-		if (yych == '\t') goto yy274;

-		if (yych == ' ') goto yy274;

-		goto yy273;

-yy276:

-		YYDEBUG(276, *YYCURSOR);

-		yyaccept = 6;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '<') {

-			if (yych <= ' ') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy273;

-					if (yych <= 0x08) goto yy256;

-					if (yych <= '\t') goto yy274;

-					goto yy273;

-				} else {

-					if (yych == '\r') goto yy273;

-					if (yych <= 0x1F) goto yy256;

-					goto yy274;

-				}

-			} else {

-				if (yych <= '/') {

-					if (yych <= '"') goto yy273;

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy273;

-					goto yy256;

-				} else {

-					if (yych <= '9') goto yy257;

-					if (yych == ';') goto yy273;

-					goto yy256;

-				}

-			}

-		} else {

-			if (yych <= '_') {

-				if (yych <= 'N') {

-					if (yych <= '=') goto yy273;

-					if (yych <= '@') goto yy256;

-					if (yych <= 'M') goto yy257;

-					goto yy279;

-				} else {

-					if (yych <= 'Z') goto yy257;

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy273;

-					goto yy257;

-				}

-			} else {

-				if (yych <= 'z') {

-					if (yych <= '`') goto yy256;

-					if (yych == 'n') goto yy279;

-					goto yy257;

-				} else {

-					if (yych <= '|') {

-						if (yych <= '{') goto yy256;

-						goto yy273;

-					} else {

-						if (yych == '~') goto yy273;

-						goto yy256;

-					}

-				}

-			}

-		}

-yy277:

-		YYDEBUG(277, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych != 'L') goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'l') goto yy278;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy278:

-		YYDEBUG(278, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'L') goto yy272;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'l') goto yy272;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy279:

-		YYDEBUG(279, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'E') goto yy272;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'e') goto yy272;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy280:

-		YYDEBUG(280, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych != 'L') goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'l') goto yy281;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy281:

-		YYDEBUG(281, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych != 'S') goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 's') goto yy282;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy282:

-		YYDEBUG(282, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '=') {

-			if (yych <= '"') {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy249;

-					if (yych <= 0x08) goto yy256;

-					goto yy249;

-				} else {

-					if (yych == '\r') goto yy249;

-					if (yych <= 0x1F) goto yy256;

-					goto yy249;

-				}

-			} else {

-				if (yych <= '9') {

-					if (yych <= '%') goto yy256;

-					if (yych <= ')') goto yy249;

-					if (yych <= '/') goto yy256;

-					goto yy257;

-				} else {

-					if (yych == ';') goto yy249;

-					if (yych <= '<') goto yy256;

-					goto yy249;

-				}

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= 'Z') {

-					if (yych <= '@') goto yy256;

-					if (yych == 'E') goto yy272;

-					goto yy257;

-				} else {

-					if (yych <= ']') goto yy256;

-					if (yych <= '^') goto yy249;

-					if (yych <= '_') goto yy257;

-					goto yy256;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == 'e') goto yy272;

-					if (yych <= 'z') goto yy257;

-					goto yy256;

-				} else {

-					if (yych == '}') goto yy256;

-					if (yych <= '~') goto yy249;

-					goto yy256;

-				}

-			}

-		}

-yy283:

-		YYDEBUG(283, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy284:

-		YYDEBUG(284, *YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy283;

-		}

-		if (yych >= '\r') goto yy287;

-yy285:

-		YYDEBUG(285, *YYCURSOR);

-		++YYCURSOR;

-yy286:

-		YYDEBUG(286, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 585 "Zend/zend_ini_scanner.l"

-		{ /* Comment */

-	BEGIN(INITIAL);

-	SCNG(lineno)++;

-	return END_OF_LINE;

-}

-#line 4248 "Zend/zend_ini_scanner.c"

-yy287:

-		YYDEBUG(287, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy285;

-		goto yy286;

-yy288:

-		YYDEBUG(288, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(289, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy288;

-		}

-		if (yych <= ')') {

-			if (yych <= '\r') {

-				if (yych <= 0x08) {

-					if (yych <= 0x00) goto yy244;

-					goto yy255;

-				} else {

-					if (yych <= '\n') goto yy244;

-					if (yych <= '\f') goto yy255;

-					goto yy244;

-				}

-			} else {

-				if (yych <= '#') {

-					if (yych <= 0x1F) goto yy255;

-					if (yych <= '"') goto yy244;

-					goto yy255;

-				} else {

-					if (yych <= '$') goto yy260;

-					if (yych <= '%') goto yy255;

-					goto yy244;

-				}

-			}

-		} else {

-			if (yych <= ']') {

-				if (yych <= ';') {

-					if (yych <= ':') goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '=') goto yy244;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '^') goto yy244;

-					if (yych <= '{') goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '~') goto yy244;

-					goto yy255;

-				}

-			}

-		}

-yy290:

-		YYDEBUG(290, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(291, *YYCURSOR);

-		if (yych <= '.') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy244;

-					if (yych <= 0x08) goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '\r') goto yy244;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych <= '"') goto yy244;

-					if (yych <= '#') goto yy255;

-					goto yy260;

-				} else {

-					if (yych <= '%') goto yy255;

-					if (yych <= ')') goto yy244;

-					if (yych <= '-') goto yy255;

-					goto yy288;

-				}

-			}

-		} else {

-			if (yych <= '=') {

-				if (yych <= ':') {

-					if (yych <= '/') goto yy255;

-					if (yych <= '9') goto yy290;

-					goto yy255;

-				} else {

-					if (yych == '<') goto yy255;

-					goto yy244;

-				}

-			} else {

-				if (yych <= '{') {

-					if (yych == '^') goto yy244;

-					goto yy255;

-				} else {

-					if (yych == '}') goto yy255;

-					if (yych <= '~') goto yy244;

-					goto yy255;

-				}

-			}

-		}

-yy292:

-		YYDEBUG(292, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(293, *YYCURSOR);

-		if (yych <= '/') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy244;

-					if (yych <= 0x08) goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '\r') goto yy244;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych <= '"') goto yy244;

-					if (yych <= '#') goto yy255;

-					goto yy260;

-				} else {

-					if (yych <= '%') goto yy255;

-					if (yych <= ')') goto yy244;

-					goto yy255;

-				}

-			}

-		} else {

-			if (yych <= ']') {

-				if (yych <= ';') {

-					if (yych <= '9') goto yy292;

-					if (yych <= ':') goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '=') goto yy244;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '^') goto yy244;

-					if (yych <= '{') goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '~') goto yy244;

-					goto yy255;

-				}

-			}

-		}

-yy294:

-		YYDEBUG(294, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(295, *YYCURSOR);

-		if (yych <= '/') {

-			if (yych <= 0x1F) {

-				if (yych <= '\n') {

-					if (yych <= 0x00) goto yy244;

-					if (yych <= 0x08) goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '\r') goto yy244;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych <= '"') goto yy244;

-					if (yych <= '#') goto yy255;

-					goto yy260;

-				} else {

-					if (yych <= '%') goto yy255;

-					if (yych <= ')') goto yy244;

-					goto yy255;

-				}

-			}

-		} else {

-			if (yych <= ']') {

-				if (yych <= ';') {

-					if (yych <= '9') goto yy294;

-					if (yych <= ':') goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '=') goto yy244;

-					goto yy255;

-				}

-			} else {

-				if (yych <= '|') {

-					if (yych <= '^') goto yy244;

-					if (yych <= '{') goto yy255;

-					goto yy244;

-				} else {

-					if (yych == '~') goto yy244;

-					goto yy255;

-				}

-			}

-		}

-yy296:

-		YYDEBUG(296, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(297, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy296;

-		}

-		YYDEBUG(298, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(299, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 368 "Zend/zend_ini_scanner.l"

-		{ /* Raw string */

-	/* Eat leading and trailing single quotes */

-	if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {

-		SCNG(yy_text)++;

-		yyleng = yyleng - 2;

-	}

-	RETURN_TOKEN(TC_RAW, yytext, yyleng);

-}

-#line 4475 "Zend/zend_ini_scanner.c"

-yy300:

-		YYDEBUG(300, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(301, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 401 "Zend/zend_ini_scanner.l"

-		{ /* Variable start */

-	yy_push_state(ST_VARNAME TSRMLS_CC);

-	return TC_DOLLAR_CURLY;

-}

-#line 4486 "Zend/zend_ini_scanner.c"

-yy302:

-		YYDEBUG(302, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy303:

-		YYDEBUG(303, *YYCURSOR);

-		if (yych == '\t') goto yy302;

-		if (yych == ' ') goto yy302;

-		goto yy236;

-yy304:

-		YYDEBUG(304, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy233;

-yy305:

-		YYDEBUG(305, *YYCURSOR);

-		yyaccept = 1;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-yy306:

-		YYDEBUG(306, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych <= '\n') {

-				if (yych <= 0x08) goto yy231;

-				if (yych <= '\t') goto yy305;

-				goto yy304;

-			} else {

-				if (yych == '\r') goto yy308;

-				goto yy231;

-			}

-		} else {

-			if (yych <= '"') {

-				if (yych <= ' ') goto yy305;

-				if (yych <= '!') goto yy231;

-			} else {

-				if (yych == ';') goto yy283;

-				goto yy231;

-			}

-		}

-		YYDEBUG(307, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy238;

-yy308:

-		YYDEBUG(308, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '\n') goto yy304;

-		goto yy233;

-	}

-/* *********************************** */

-yyc_ST_VARNAME:

-	{

-		static const unsigned char yybm[] = {

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128,   0,   0, 128, 128,   0, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128,   0,   0, 128,   0, 128,   0, 128, 

-			  0,   0, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0, 128,   0, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0, 128, 128,   0, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-		};

-		YYDEBUG(309, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych <= ')') {

-			if (yych <= '"') {

-				if (yych <= '\f') {

-					if (yych <= 0x08) goto yy311;

-					if (yych <= '\n') goto yy313;

-				} else {

-					if (yych <= '\r') goto yy313;

-					if (yych >= '!') goto yy313;

-				}

-			} else {

-				if (yych <= '%') {

-					if (yych == '$') goto yy313;

-				} else {

-					if (yych != '\'') goto yy313;

-				}

-			}

-		} else {

-			if (yych <= '[') {

-				if (yych <= '<') {

-					if (yych == ';') goto yy313;

-				} else {

-					if (yych <= '=') goto yy313;

-					if (yych >= '[') goto yy313;

-				}

-			} else {

-				if (yych <= 'z') {

-					if (yych == '^') goto yy313;

-				} else {

-					if (yych == '}') goto yy315;

-					if (yych <= '~') goto yy313;

-				}

-			}

-		}

-yy311:

-		YYDEBUG(311, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy318;

-yy312:

-		YYDEBUG(312, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 406 "Zend/zend_ini_scanner.l"

-		{ /* Variable name */

-	/* Eat leading whitespace */

-	EAT_LEADING_WHITESPACE();

-

-	/* Eat trailing whitespace */

-	EAT_TRAILING_WHITESPACE();

-

-	RETURN_TOKEN(TC_VARNAME, yytext, yyleng);

-}

-#line 4627 "Zend/zend_ini_scanner.c"

-yy313:

-		YYDEBUG(313, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(314, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 603 "Zend/zend_ini_scanner.l"

-		{

-	return 0;

-}

-#line 4637 "Zend/zend_ini_scanner.c"

-yy315:

-		YYDEBUG(315, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(316, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 416 "Zend/zend_ini_scanner.l"

-		{ /* Variable end */

-	yy_pop_state(TSRMLS_C);

-	return '}';

-}

-#line 4648 "Zend/zend_ini_scanner.c"

-yy317:

-		YYDEBUG(317, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy318:

-		YYDEBUG(318, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy317;

-		}

-		goto yy312;

-	}

-}

-#line 607 "Zend/zend_ini_scanner.l"

-

-}

+/* Generated by re2c 0.13.5 */
+#line 1 "Zend/zend_ini_scanner.l"
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Zeev Suraski <zeev@zend.com>                                |
+   |          Jani Taskinen <jani@php.net>                                |
+   |          Marcus Boerger <helly@php.net>                              |
+   |          Nuno Lopes <nlopess@php.net>                                |
+   |          Scott MacVicar <scottmac@php.net>                           |
+   +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#include <errno.h>
+#include "zend.h"
+#include "zend_globals.h"
+#include <zend_ini_parser.h>
+#include "zend_ini_scanner.h"
+
+#if 0
+# define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
+#else
+# define YYDEBUG(s, c)
+#endif
+
+#include "zend_ini_scanner_defs.h"
+
+#define YYCTYPE   unsigned char
+/* allow the scanner to read one null byte after the end of the string (from ZEND_MMAP_AHEAD)
+ * so that if will be able to terminate to match the current token (e.g. non-enclosed string) */
+#define YYFILL(n) { if (YYCURSOR > YYLIMIT) return 0; }
+#define YYCURSOR  SCNG(yy_cursor)
+#define YYLIMIT   SCNG(yy_limit)
+#define YYMARKER  SCNG(yy_marker)
+
+#define YYGETCONDITION()  SCNG(yy_state)
+#define YYSETCONDITION(s) SCNG(yy_state) = s
+
+#define STATE(name)  yyc##name
+
+/* emulate flex constructs */
+#define BEGIN(state) YYSETCONDITION(STATE(state))
+#define YYSTATE      YYGETCONDITION()
+#define yytext       ((char*)SCNG(yy_text))
+#define yyleng       SCNG(yy_leng)
+#define yyless(x)    do {	YYCURSOR = (unsigned char*)yytext + x; \
+							yyleng   = (unsigned int)x; } while(0)
+
+/* #define yymore()     goto yymore_restart */
+
+/* perform sanity check. If this message is triggered you should
+   increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
+#define YYMAXFILL 6
+#if ZEND_MMAP_AHEAD < (YYMAXFILL + 1)
+# error ZEND_MMAP_AHEAD should be greater than YYMAXFILL
+#endif
+
+
+/* How it works (for the core ini directives):
+ * ===========================================
+ *
+ * 1. Scanner scans file for tokens and passes them to parser.
+ * 2. Parser parses the tokens and passes the name/value pairs to the callback
+ *    function which stores them in the configuration hash table.
+ * 3. Later REGISTER_INI_ENTRIES() is called which triggers the actual
+ *    registering of ini entries and uses zend_get_configuration_directive()
+ *    to fetch the previously stored name/value pair from configuration hash table
+ *    and registers the static ini entries which match the name to the value
+ *    into EG(ini_directives) hash table.
+ * 4. PATH section entries are used per-request from down to top, each overriding
+ *    previous if one exists. zend_alter_ini_entry() is called for each entry.
+ *    Settings in PATH section are ZEND_INI_SYSTEM accessible and thus mimics the
+ *    php_admin_* directives used within Apache httpd.conf when PHP is compiled as
+ *    module for Apache.
+ * 5. User defined ini files (like .htaccess for apache) are parsed for each request and
+ *    stored in separate hash defined by SAPI.
+ */
+
+/* TODO: (ordered by importance :-)
+ * ===============================================================================
+ *
+ *  - Separate constant lookup totally from plain strings (using CONSTANT pattern)
+ *  - Add #if .. #else .. #endif and ==, !=, <, > , <=, >= operators
+ *  - Add #include "some.ini"
+ *  - Allow variables to refer to options also when using parse_ini_file()
+ *
+ */
+
+/* Globals Macros */
+#define SCNG	INI_SCNG
+#ifdef ZTS
+ZEND_API ts_rsrc_id ini_scanner_globals_id;
+#else
+ZEND_API zend_ini_scanner_globals ini_scanner_globals;
+#endif
+
+/* Eat leading whitespace */
+#define EAT_LEADING_WHITESPACE()                     \
+	while (yytext[0]) {                              \
+		if (yytext[0] == ' ' || yytext[0] == '\t') { \
+			SCNG(yy_text)++;                         \
+			yyleng--;                                \
+		} else {                                     \
+			break;                                   \
+		}                                            \
+	}
+
+/* Eat trailing whitespace + extra char */
+#define EAT_TRAILING_WHITESPACE_EX(ch)              \
+	while (yyleng > 0 && (                          \
+		(ch != 'X' && yytext[yyleng - 1] ==  ch) || \
+		yytext[yyleng - 1] == '\n' ||               \
+		yytext[yyleng - 1] == '\r' ||               \
+		yytext[yyleng - 1] == '\t' ||               \
+		yytext[yyleng - 1] == ' ')                  \
+	) {                                             \
+		yyleng--;                                   \
+	}
+
+/* Eat trailing whitespace */
+#define EAT_TRAILING_WHITESPACE()	EAT_TRAILING_WHITESPACE_EX('X')
+
+#define zend_ini_copy_value(retval, str, len)	\
+	ZVAL_NEW_STR(retval, STR_INIT(str, len, 1))
+
+
+#define RETURN_TOKEN(type, str, len) {           \
+	zend_ini_copy_value(ini_lval, str, len);     \
+	return type;                                 \
+}
+
+static void _yy_push_state(int new_state TSRMLS_DC)
+{
+	zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));
+	YYSETCONDITION(new_state);
+}
+
+#define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
+
+static void yy_pop_state(TSRMLS_D)
+{
+	int *stack_state;
+	zend_stack_top(&SCNG(state_stack), (void **) &stack_state);
+	YYSETCONDITION(*stack_state);
+	zend_stack_del_top(&SCNG(state_stack));
+}
+
+static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
+{
+	YYCURSOR = (YYCTYPE*)str;
+	SCNG(yy_start) = YYCURSOR;
+	YYLIMIT  = YYCURSOR + len;
+}
+
+#define ini_filename SCNG(filename)
+
+/* {{{ init_ini_scanner()
+*/
+static int init_ini_scanner(int scanner_mode, zend_file_handle *fh TSRMLS_DC)
+{
+	/* Sanity check */
+	if (scanner_mode != ZEND_INI_SCANNER_NORMAL && scanner_mode != ZEND_INI_SCANNER_RAW) {
+		zend_error(E_WARNING, "Invalid scanner mode");
+		return FAILURE;
+	}
+
+	SCNG(lineno) = 1;
+	SCNG(scanner_mode) = scanner_mode;
+	SCNG(yy_in) = fh;
+
+	if (fh != NULL) {
+		ini_filename = zend_strndup(fh->filename, strlen(fh->filename));
+	} else {
+		ini_filename = NULL;
+	}
+
+	zend_stack_init(&SCNG(state_stack));
+	BEGIN(INITIAL);
+
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ shutdown_ini_scanner()
+*/
+void shutdown_ini_scanner(TSRMLS_D)
+{
+	zend_stack_destroy(&SCNG(state_stack));
+	if (ini_filename) {
+		free(ini_filename);
+	}
+}
+/* }}} */
+
+/* {{{ zend_ini_scanner_get_lineno()
+*/
+int zend_ini_scanner_get_lineno(TSRMLS_D)
+{
+	return SCNG(lineno);
+}
+/* }}} */
+
+/* {{{ zend_ini_scanner_get_filename()
+*/
+char *zend_ini_scanner_get_filename(TSRMLS_D)
+{
+	return ini_filename ? ini_filename : "Unknown";
+}
+/* }}} */
+
+/* {{{ zend_ini_open_file_for_scanning()
+*/
+int zend_ini_open_file_for_scanning(zend_file_handle *fh, int scanner_mode TSRMLS_DC)
+{
+	char *buf;
+	size_t size;
+
+	if (zend_stream_fixup(fh, &buf, &size TSRMLS_CC) == FAILURE) {
+		return FAILURE;
+	}
+
+	if (init_ini_scanner(scanner_mode, fh TSRMLS_CC) == FAILURE) {
+		zend_file_handle_dtor(fh TSRMLS_CC);
+		return FAILURE;
+	}
+
+	yy_scan_buffer(buf, size TSRMLS_CC);
+
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ zend_ini_prepare_string_for_scanning()
+*/
+int zend_ini_prepare_string_for_scanning(char *str, int scanner_mode TSRMLS_DC)
+{
+	int len = strlen(str);
+
+	if (init_ini_scanner(scanner_mode, NULL TSRMLS_CC) == FAILURE) {
+		return FAILURE;
+	}
+
+	yy_scan_buffer(str, len TSRMLS_CC);
+
+	return SUCCESS;
+}
+/* }}} */
+
+/* {{{ zend_ini_escape_string()
+ */
+static void zend_ini_escape_string(zval *lval, char *str, int len, char quote_type TSRMLS_DC)
+{
+	register char *s, *t;
+	char *end;
+
+	zend_ini_copy_value(lval, str, len);
+
+	/* convert escape sequences */
+	s = t = Z_STRVAL_P(lval);
+	end = s + Z_STRLEN_P(lval);
+
+	while (s < end) {
+		if (*s == '\\') {
+			s++;
+			if (s >= end) {
+				*t++ = '\\';
+				continue;
+			}
+			switch (*s) {
+				case '"':
+					if (*s != quote_type) {
+						*t++ = '\\';
+						*t++ = *s;
+						break;
+					}
+				case '\\':
+				case '$':
+					*t++ = *s;
+					Z_STRLEN_P(lval)--;
+					break;
+				default:
+					*t++ = '\\';
+					*t++ = *s;
+					break;
+			}
+		} else {
+			*t++ = *s;
+		}
+		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
+			SCNG(lineno)++;
+		}
+		s++;
+	}
+	*t = 0;
+}
+/* }}} */
+
+int ini_lex(zval *ini_lval TSRMLS_DC)
+{
+restart:
+	SCNG(yy_text) = YYCURSOR;
+
+/* yymore_restart: */
+	/* detect EOF */
+	if (YYCURSOR >= YYLIMIT) {
+		if (YYSTATE == STATE(ST_VALUE) || YYSTATE == STATE(ST_RAW)) {
+			BEGIN(INITIAL);
+			return END_OF_LINE;
+		}
+		return 0;
+	}
+
+	/* Eat any UTF-8 BOM we find in the first 3 bytes */
+	if (YYCURSOR == SCNG(yy_start) && YYCURSOR + 3 < YYLIMIT) {
+		if (memcmp(YYCURSOR, "\xef\xbb\xbf", 3) == 0) {
+			YYCURSOR += 3;
+			goto restart;
+		}
+	}
+
+#line 335 "Zend/zend_ini_scanner.c"
+{
+	YYCTYPE yych;
+	unsigned int yyaccept = 0;
+	if (YYGETCONDITION() < 4) {
+		if (YYGETCONDITION() < 2) {
+			if (YYGETCONDITION() < 1) {
+				goto yyc_INITIAL;
+			} else {
+				goto yyc_ST_OFFSET;
+			}
+		} else {
+			if (YYGETCONDITION() < 3) {
+				goto yyc_ST_SECTION_VALUE;
+			} else {
+				goto yyc_ST_VALUE;
+			}
+		}
+	} else {
+		if (YYGETCONDITION() < 6) {
+			if (YYGETCONDITION() < 5) {
+				goto yyc_ST_SECTION_RAW;
+			} else {
+				goto yyc_ST_DOUBLE_QUOTES;
+			}
+		} else {
+			if (YYGETCONDITION() < 7) {
+				goto yyc_ST_VARNAME;
+			} else {
+				goto yyc_ST_RAW;
+			}
+		}
+	}
+/* *********************************** */
+yyc_INITIAL:
+	{
+		static const unsigned char yybm[] = {
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 160,   0, 144, 144,   0, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			240, 128, 128, 144, 128, 144, 128, 144, 
+			128, 128, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 128, 144, 128, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 128, 144, 144, 128, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 128, 128, 128, 128, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+			144, 144, 144, 144, 144, 144, 144, 144, 
+		};
+
+		YYDEBUG(0, *YYCURSOR);
+		YYFILL(5);
+		yych = *YYCURSOR;
+		YYDEBUG(-1, yych);
+		switch (yych) {
+		case '\t':	goto yy4;
+		case '\n':	goto yy6;
+		case '\r':	goto yy8;
+		case ' ':	goto yy9;
+		case '!':
+		case '"':
+		case '$':
+		case '&':
+		case '(':
+		case ')':
+		case '^':
+		case '{':
+		case '|':
+		case '}':
+		case '~':	goto yy10;
+		case '#':	goto yy12;
+		case '%':
+		case '\'':
+		case '*':
+		case '+':
+		case ',':
+		case '-':
+		case '.':
+		case '/':
+		case ':':
+		case '<':
+		case '>':
+		case '?':
+		case '@':
+		case ']':	goto yy13;
+		case ';':	goto yy14;
+		case '=':	goto yy16;
+		case 'F':
+		case 'f':	goto yy18;
+		case 'N':
+		case 'n':	goto yy19;
+		case 'O':
+		case 'o':	goto yy20;
+		case 'T':
+		case 't':	goto yy21;
+		case 'Y':
+		case 'y':	goto yy22;
+		case '[':	goto yy23;
+		default:	goto yy2;
+		}
+yy2:
+		YYDEBUG(2, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy26;
+yy3:
+		YYDEBUG(3, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 427 "Zend/zend_ini_scanner.l"
+		{ /* Get option name */
+	/* Eat leading whitespace */
+	EAT_LEADING_WHITESPACE();
+
+	/* Eat trailing whitespace */
+	EAT_TRAILING_WHITESPACE();
+
+	RETURN_TOKEN(TC_LABEL, yytext, yyleng);
+}
+#line 474 "Zend/zend_ini_scanner.c"
+yy4:
+		YYDEBUG(4, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy68;
+yy5:
+		YYDEBUG(5, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 573 "Zend/zend_ini_scanner.l"
+		{
+	/* eat whitespace */
+	goto restart;
+}
+#line 488 "Zend/zend_ini_scanner.c"
+yy6:
+		YYDEBUG(6, *YYCURSOR);
+		++YYCURSOR;
+yy7:
+		YYDEBUG(7, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 578 "Zend/zend_ini_scanner.l"
+		{
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 500 "Zend/zend_ini_scanner.c"
+yy8:
+		YYDEBUG(8, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy71;
+		goto yy7;
+yy9:
+		YYDEBUG(9, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= ' ') {
+			if (yych <= '\n') {
+				if (yych <= 0x08) goto yy26;
+				if (yych <= '\t') goto yy67;
+				goto yy71;
+			} else {
+				if (yych == '\r') goto yy72;
+				if (yych <= 0x1F) goto yy26;
+				goto yy69;
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych == '#') goto yy58;
+				goto yy26;
+			} else {
+				if (yych <= ';') goto yy53;
+				if (yych == '=') goto yy51;
+				goto yy26;
+			}
+		}
+yy10:
+		YYDEBUG(10, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(11, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 501 "Zend/zend_ini_scanner.l"
+		{ /* Disallow these chars outside option values */
+	return yytext[0];
+}
+#line 539 "Zend/zend_ini_scanner.c"
+yy12:
+		YYDEBUG(12, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy59;
+yy13:
+		YYDEBUG(13, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy26;
+yy14:
+		YYDEBUG(14, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy54;
+		YYDEBUG(15, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 601 "Zend/zend_ini_scanner.l"
+		{
+	return 0;
+}
+#line 560 "Zend/zend_ini_scanner.c"
+yy16:
+		YYDEBUG(16, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy52;
+yy17:
+		YYDEBUG(17, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 437 "Zend/zend_ini_scanner.l"
+		{ /* Start option value */
+	if (SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW) {
+		yy_push_state(ST_RAW TSRMLS_CC);
+	} else {
+		yy_push_state(ST_VALUE TSRMLS_CC);
+	}
+	return '=';
+}
+#line 578 "Zend/zend_ini_scanner.c"
+yy18:
+		YYDEBUG(18, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy48;
+		if (yych == 'a') goto yy48;
+		goto yy26;
+yy19:
+		YYDEBUG(19, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'U') {
+			if (yych == 'O') goto yy44;
+			if (yych <= 'T') goto yy26;
+			goto yy45;
+		} else {
+			if (yych <= 'o') {
+				if (yych <= 'n') goto yy26;
+				goto yy44;
+			} else {
+				if (yych == 'u') goto yy45;
+				goto yy26;
+			}
+		}
+yy20:
+		YYDEBUG(20, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'N') {
+			if (yych == 'F') goto yy38;
+			if (yych <= 'M') goto yy26;
+			goto yy31;
+		} else {
+			if (yych <= 'f') {
+				if (yych <= 'e') goto yy26;
+				goto yy38;
+			} else {
+				if (yych == 'n') goto yy31;
+				goto yy26;
+			}
+		}
+yy21:
+		YYDEBUG(21, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy36;
+		if (yych == 'r') goto yy36;
+		goto yy26;
+yy22:
+		YYDEBUG(22, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy27;
+		if (yych == 'e') goto yy27;
+		goto yy26;
+yy23:
+		YYDEBUG(23, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(24, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 356 "Zend/zend_ini_scanner.l"
+		{ /* Section start */
+	/* Enter section data lookup state */
+	if (SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW) {
+		yy_push_state(ST_SECTION_RAW TSRMLS_CC);
+	} else {
+		yy_push_state(ST_SECTION_VALUE TSRMLS_CC);
+	}
+	return TC_SECTION;
+}
+#line 644 "Zend/zend_ini_scanner.c"
+yy25:
+		YYDEBUG(25, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy26:
+		YYDEBUG(26, *YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy25;
+		}
+		if (yych == '[') goto yy28;
+		goto yy3;
+yy27:
+		YYDEBUG(27, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy31;
+		if (yych == 's') goto yy31;
+		goto yy26;
+yy28:
+		YYDEBUG(28, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(29, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy28;
+		}
+		YYDEBUG(30, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 381 "Zend/zend_ini_scanner.l"
+		{ /* Start of option with offset */
+	/* Eat leading whitespace */
+	EAT_LEADING_WHITESPACE();
+	
+	/* Eat trailing whitespace and [ */
+	EAT_TRAILING_WHITESPACE_EX('[');
+
+	/* Enter offset lookup state */
+	yy_push_state(ST_OFFSET TSRMLS_CC);
+
+	RETURN_TOKEN(TC_OFFSET, yytext, yyleng);
+}
+#line 687 "Zend/zend_ini_scanner.c"
+yy31:
+		YYDEBUG(31, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(32, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy31;
+		}
+		if (yych <= '\'') {
+			if (yych <= ' ') {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy25;
+					if (yych <= '\t') goto yy34;
+				} else {
+					if (yych != '\r') goto yy25;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych == '#') goto yy25;
+				} else {
+					if (yych != '&') goto yy25;
+				}
+			}
+		} else {
+			if (yych <= 'Z') {
+				if (yych <= ';') {
+					if (yych <= ')') goto yy33;
+					if (yych <= ':') goto yy25;
+				} else {
+					if (yych != '=') goto yy25;
+				}
+			} else {
+				if (yych <= '^') {
+					if (yych <= '[') goto yy28;
+					if (yych <= ']') goto yy25;
+				} else {
+					if (yych <= 'z') goto yy25;
+					if (yych >= 0x7F) goto yy25;
+				}
+			}
+		}
+yy33:
+		YYDEBUG(33, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 419 "Zend/zend_ini_scanner.l"
+		{ /* TRUE value (when used outside option value/offset this causes parse error!) */
+	RETURN_TOKEN(BOOL_TRUE, "1", 1);
+}
+#line 737 "Zend/zend_ini_scanner.c"
+yy34:
+		YYDEBUG(34, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(35, *YYCURSOR);
+		if (yych == '\t') goto yy34;
+		if (yych == ' ') goto yy34;
+		goto yy33;
+yy36:
+		YYDEBUG(36, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy37;
+		if (yych != 'u') goto yy26;
+yy37:
+		YYDEBUG(37, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy31;
+		if (yych == 'e') goto yy31;
+		goto yy26;
+yy38:
+		YYDEBUG(38, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'F') goto yy39;
+		if (yych != 'f') goto yy26;
+yy39:
+		YYDEBUG(39, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(40, *YYCURSOR);
+		if (yych <= '&') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy25;
+					if (yych <= '\t') goto yy42;
+				} else {
+					if (yych != '\r') goto yy25;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= ' ') goto yy39;
+					if (yych >= '#') goto yy25;
+				} else {
+					if (yych == '%') goto yy25;
+				}
+			}
+		} else {
+			if (yych <= '=') {
+				if (yych <= ':') {
+					if (yych <= '\'') goto yy25;
+					if (yych >= '*') goto yy25;
+				} else {
+					if (yych == '<') goto yy25;
+				}
+			} else {
+				if (yych <= ']') {
+					if (yych == '[') goto yy28;
+					goto yy25;
+				} else {
+					if (yych <= '^') goto yy41;
+					if (yych <= 'z') goto yy25;
+					if (yych >= 0x7F) goto yy25;
+				}
+			}
+		}
+yy41:
+		YYDEBUG(41, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 423 "Zend/zend_ini_scanner.l"
+		{ /* FALSE value (when used outside option value/offset this causes parse error!)*/
+	RETURN_TOKEN(BOOL_FALSE, "", 0);
+}
+#line 811 "Zend/zend_ini_scanner.c"
+yy42:
+		YYDEBUG(42, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(43, *YYCURSOR);
+		if (yych == '\t') goto yy42;
+		if (yych == ' ') goto yy42;
+		goto yy41;
+yy44:
+		YYDEBUG(44, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '\'') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy26;
+					if (yych <= '\t') goto yy42;
+					goto yy41;
+				} else {
+					if (yych == '\r') goto yy41;
+					goto yy26;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= ' ') goto yy39;
+					if (yych <= '"') goto yy41;
+					goto yy26;
+				} else {
+					if (yych == '%') goto yy26;
+					if (yych <= '&') goto yy41;
+					goto yy26;
+				}
+			}
+		} else {
+			if (yych <= 'N') {
+				if (yych <= ';') {
+					if (yych <= ')') goto yy41;
+					if (yych <= ':') goto yy26;
+					goto yy41;
+				} else {
+					if (yych == '=') goto yy41;
+					if (yych <= 'M') goto yy26;
+					goto yy47;
+				}
+			} else {
+				if (yych <= 'm') {
+					if (yych == '^') goto yy41;
+					goto yy26;
+				} else {
+					if (yych <= 'n') goto yy47;
+					if (yych <= 'z') goto yy26;
+					if (yych <= '~') goto yy41;
+					goto yy26;
+				}
+			}
+		}
+yy45:
+		YYDEBUG(45, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy46;
+		if (yych != 'l') goto yy26;
+yy46:
+		YYDEBUG(46, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy39;
+		if (yych == 'l') goto yy39;
+		goto yy26;
+yy47:
+		YYDEBUG(47, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy39;
+		if (yych == 'e') goto yy39;
+		goto yy26;
+yy48:
+		YYDEBUG(48, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy49;
+		if (yych != 'l') goto yy26;
+yy49:
+		YYDEBUG(49, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy50;
+		if (yych != 's') goto yy26;
+yy50:
+		YYDEBUG(50, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy39;
+		if (yych == 'e') goto yy39;
+		goto yy26;
+yy51:
+		YYDEBUG(51, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy52:
+		YYDEBUG(52, *YYCURSOR);
+		if (yych == '\t') goto yy51;
+		if (yych == ' ') goto yy51;
+		goto yy17;
+yy53:
+		YYDEBUG(53, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy54:
+		YYDEBUG(54, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy53;
+		}
+		if (yych >= '\r') goto yy57;
+yy55:
+		YYDEBUG(55, *YYCURSOR);
+		++YYCURSOR;
+yy56:
+		YYDEBUG(56, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 583 "Zend/zend_ini_scanner.l"
+		{ /* Comment */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 934 "Zend/zend_ini_scanner.c"
+yy57:
+		YYDEBUG(57, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy55;
+		goto yy56;
+yy58:
+		YYDEBUG(58, *YYCURSOR);
+		yyaccept = 1;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy59:
+		YYDEBUG(59, *YYCURSOR);
+		if (yych <= '\'') {
+			if (yych <= ' ') {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy58;
+					if (yych >= '\n') goto yy64;
+				} else {
+					if (yych == '\r') goto yy66;
+					goto yy58;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych == '#') goto yy58;
+				} else {
+					if (yych != '&') goto yy58;
+				}
+			}
+		} else {
+			if (yych <= 'Z') {
+				if (yych <= ';') {
+					if (yych <= ')') goto yy60;
+					if (yych <= ':') goto yy58;
+				} else {
+					if (yych != '=') goto yy58;
+				}
+			} else {
+				if (yych <= '^') {
+					if (yych <= '[') goto yy62;
+					if (yych <= ']') goto yy58;
+				} else {
+					if (yych <= 'z') goto yy58;
+					if (yych >= 0x7F) goto yy58;
+				}
+			}
+		}
+yy60:
+		YYDEBUG(60, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+		YYDEBUG(61, *YYCURSOR);
+		if (yych == '\n') goto yy64;
+		if (yych == '\r') goto yy66;
+		goto yy60;
+yy62:
+		YYDEBUG(62, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+		YYDEBUG(63, *YYCURSOR);
+		if (yych <= '\f') {
+			if (yych <= 0x08) goto yy60;
+			if (yych <= '\t') goto yy62;
+			if (yych >= '\v') goto yy60;
+		} else {
+			if (yych <= '\r') goto yy66;
+			if (yych == ' ') goto yy62;
+			goto yy60;
+		}
+yy64:
+		YYDEBUG(64, *YYCURSOR);
+		++YYCURSOR;
+yy65:
+		YYDEBUG(65, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 589 "Zend/zend_ini_scanner.l"
+		{ /* #Comment */
+	zend_error(E_DEPRECATED, "Comments starting with '#' are deprecated in %s on line %d", zend_ini_scanner_get_filename(TSRMLS_C), SCNG(lineno));
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 1020 "Zend/zend_ini_scanner.c"
+yy66:
+		YYDEBUG(66, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy64;
+		goto yy65;
+yy67:
+		YYDEBUG(67, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy68:
+		YYDEBUG(68, *YYCURSOR);
+		if (yych <= ' ') {
+			if (yych <= '\n') {
+				if (yych <= 0x08) goto yy5;
+				if (yych <= '\t') goto yy67;
+				goto yy71;
+			} else {
+				if (yych == '\r') goto yy72;
+				if (yych <= 0x1F) goto yy5;
+				goto yy67;
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych == '#') goto yy60;
+				goto yy5;
+			} else {
+				if (yych <= ';') goto yy53;
+				if (yych == '=') goto yy51;
+				goto yy5;
+			}
+		}
+yy69:
+		YYDEBUG(69, *YYCURSOR);
+		yyaccept = 1;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+		YYDEBUG(70, *YYCURSOR);
+		if (yych <= '&') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy25;
+					if (yych <= '\t') goto yy67;
+				} else {
+					if (yych == '\r') goto yy72;
+					goto yy25;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= ' ') goto yy69;
+					if (yych <= '"') goto yy3;
+					goto yy58;
+				} else {
+					if (yych == '%') goto yy25;
+					goto yy3;
+				}
+			}
+		} else {
+			if (yych <= '=') {
+				if (yych <= ':') {
+					if (yych <= '\'') goto yy25;
+					if (yych <= ')') goto yy3;
+					goto yy25;
+				} else {
+					if (yych <= ';') goto yy53;
+					if (yych <= '<') goto yy25;
+					goto yy51;
+				}
+			} else {
+				if (yych <= ']') {
+					if (yych == '[') goto yy28;
+					goto yy25;
+				} else {
+					if (yych <= '^') goto yy3;
+					if (yych <= 'z') goto yy25;
+					if (yych <= '~') goto yy3;
+					goto yy25;
+				}
+			}
+		}
+yy71:
+		YYDEBUG(71, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy7;
+yy72:
+		YYDEBUG(72, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '\n') goto yy71;
+		goto yy7;
+	}
+/* *********************************** */
+yyc_ST_DOUBLE_QUOTES:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0, 128,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+		};
+		YYDEBUG(73, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych == '"') goto yy77;
+		if (yych == '$') goto yy79;
+		YYDEBUG(75, *YYCURSOR);
+		++YYCURSOR;
+yy76:
+		YYDEBUG(76, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 533 "Zend/zend_ini_scanner.l"
+		{ /* Escape double quoted string contents */
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+	
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '"':
+				if (YYCURSOR < YYLIMIT && YYCURSOR[-2] == '\\' && *YYCURSOR != '\r' && *YYCURSOR != '\n') {
+					continue;
+				}
+				break;
+			case '$':
+				if (*YYCURSOR == '{') {
+					break;
+				}
+				continue;
+			case '\\':
+				if (YYCURSOR < YYLIMIT && *YYCURSOR != '"') {
+					YYCURSOR++;
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+		
+		YYCURSOR--;
+		break;
+	}
+
+	yyleng = YYCURSOR - SCNG(yy_text);
+	
+	zend_ini_escape_string(ini_lval, yytext, yyleng, '"' TSRMLS_CC);
+	return TC_QUOTED_STRING;
+}
+#line 1196 "Zend/zend_ini_scanner.c"
+yy77:
+		YYDEBUG(77, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy83;
+yy78:
+		YYDEBUG(78, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 528 "Zend/zend_ini_scanner.l"
+		{ /* Double quoted '"' string ends */
+	yy_pop_state(TSRMLS_C);
+	return '"';
+}
+#line 1210 "Zend/zend_ini_scanner.c"
+yy79:
+		YYDEBUG(79, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '{') goto yy76;
+		YYDEBUG(80, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(81, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 399 "Zend/zend_ini_scanner.l"
+		{ /* Variable start */
+	yy_push_state(ST_VARNAME TSRMLS_CC);
+	return TC_DOLLAR_CURLY;
+}
+#line 1224 "Zend/zend_ini_scanner.c"
+yy82:
+		YYDEBUG(82, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy83:
+		YYDEBUG(83, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy82;
+		}
+		goto yy78;
+	}
+/* *********************************** */
+yyc_ST_OFFSET:
+	{
+		static const unsigned char yybm[] = {
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66, 194,  64,  66,  66,  64,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			194,  66,  64,  66,  68,  66,  66,   0, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			114, 114, 114, 114, 114, 114, 114, 114, 
+			114, 114,  66,  64,  66,  66,  66,  66, 
+			 66,  82,  82,  82,  82,  82,  82,  82, 
+			 82,  82,  82,  82,  82,  82,  82,  82, 
+			 82,  82,  82,  82,  82,  82,  82,  82, 
+			 82,  82,  82,  66,  72,  64,  66,  82, 
+			 66,  82,  82,  82,  82,  82,  82,  82, 
+			 82,  82,  82,  82,  82,  82,  82,  82, 
+			 82,  82,  82,  82,  82,  82,  82,  82, 
+			 82,  82,  82,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+			 66,  66,  66,  66,  66,  66,  66,  66, 
+		};
+		YYDEBUG(84, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych <= '-') {
+			if (yych <= ' ') {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy86;
+					if (yych <= '\t') goto yy88;
+					goto yy89;
+				} else {
+					if (yych == '\r') goto yy89;
+					if (yych >= ' ') goto yy88;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych == '"') goto yy91;
+					if (yych >= '$') goto yy93;
+				} else {
+					if (yych == '\'') goto yy94;
+					if (yych >= '-') goto yy95;
+				}
+			}
+		} else {
+			if (yych <= 'Z') {
+				if (yych <= '9') {
+					if (yych <= '.') goto yy96;
+					if (yych >= '0') goto yy97;
+				} else {
+					if (yych == ';') goto yy89;
+					if (yych >= 'A') goto yy99;
+				}
+			} else {
+				if (yych <= '^') {
+					if (yych <= '[') goto yy86;
+					if (yych <= '\\') goto yy101;
+					if (yych <= ']') goto yy102;
+				} else {
+					if (yych == '`') goto yy86;
+					if (yych <= 'z') goto yy99;
+				}
+			}
+		}
+yy86:
+		YYDEBUG(86, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy105;
+yy87:
+		YYDEBUG(87, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 519 "Zend/zend_ini_scanner.l"
+		{ /* Get rest as section/offset value */
+	RETURN_TOKEN(TC_STRING, yytext, yyleng);
+}
+#line 1328 "Zend/zend_ini_scanner.c"
+yy88:
+		YYDEBUG(88, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy131;
+		}
+		if (yych == '"') goto yy133;
+		if (yych == ']') goto yy134;
+		goto yy105;
+yy89:
+		YYDEBUG(89, *YYCURSOR);
+		++YYCURSOR;
+yy90:
+		YYDEBUG(90, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 601 "Zend/zend_ini_scanner.l"
+		{
+	return 0;
+}
+#line 1349 "Zend/zend_ini_scanner.c"
+yy91:
+		YYDEBUG(91, *YYCURSOR);
+		++YYCURSOR;
+yy92:
+		YYDEBUG(92, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 523 "Zend/zend_ini_scanner.l"
+		{ /* Double quoted '"' string start */
+	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);
+	return '"';
+}
+#line 1361 "Zend/zend_ini_scanner.c"
+yy93:
+		YYDEBUG(93, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy90;
+			if (yych <= '[') goto yy104;
+			goto yy109;
+		} else {
+			if (yych == '{') goto yy129;
+			goto yy104;
+		}
+yy94:
+		YYDEBUG(94, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy125;
+		}
+		goto yy90;
+yy95:
+		YYDEBUG(95, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') goto yy105;
+		if (yych <= '9') goto yy123;
+		goto yy105;
+yy96:
+		YYDEBUG(96, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') goto yy105;
+		if (yych <= '9') goto yy121;
+		goto yy105;
+yy97:
+		YYDEBUG(97, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '\'') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy98;
+				if (yych <= '\f') goto yy105;
+			} else {
+				if (yych == '"') goto yy98;
+				if (yych <= '&') goto yy105;
+			}
+		} else {
+			if (yych <= '9') {
+				if (yych == '.') goto yy117;
+				if (yych <= '/') goto yy105;
+				goto yy119;
+			} else {
+				if (yych <= ';') {
+					if (yych <= ':') goto yy105;
+				} else {
+					if (yych != ']') goto yy105;
+				}
+			}
+		}
+yy98:
+		YYDEBUG(98, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 497 "Zend/zend_ini_scanner.l"
+		{ /* Get number option value as string */
+	RETURN_TOKEN(TC_NUMBER, yytext, yyleng);
+}
+#line 1427 "Zend/zend_ini_scanner.c"
+yy99:
+		YYDEBUG(99, *YYCURSOR);
+		yyaccept = 3;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy115;
+		}
+		if (yych <= '"') {
+			if (yych <= '\f') {
+				if (yych != '\n') goto yy105;
+			} else {
+				if (yych <= '\r') goto yy100;
+				if (yych <= '!') goto yy105;
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych != '\'') goto yy105;
+			} else {
+				if (yych <= ';') goto yy100;
+				if (yych != ']') goto yy105;
+			}
+		}
+yy100:
+		YYDEBUG(100, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 493 "Zend/zend_ini_scanner.l"
+		{ /* Get constant option value */
+	RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);
+}
+#line 1457 "Zend/zend_ini_scanner.c"
+yy101:
+		YYDEBUG(101, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy104;
+yy102:
+		YYDEBUG(102, *YYCURSOR);
+		++YYCURSOR;
+yy103:
+		YYDEBUG(103, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 394 "Zend/zend_ini_scanner.l"
+		{ /* End of section or an option offset */
+	BEGIN(INITIAL);
+	return ']';
+}
+#line 1473 "Zend/zend_ini_scanner.c"
+yy104:
+		YYDEBUG(104, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy105:
+		YYDEBUG(105, *YYCURSOR);
+		if (yybm[0+yych] & 2) {
+			goto yy104;
+		}
+		if (yych == '$') goto yy107;
+		if (yych != '\\') goto yy87;
+yy106:
+		YYDEBUG(106, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		goto yy104;
+yy107:
+		YYDEBUG(107, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy108;
+			if (yych <= '[') goto yy104;
+			goto yy109;
+		} else {
+			if (yych != '{') goto yy104;
+		}
+yy108:
+		YYDEBUG(108, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		if (yyaccept <= 1) {
+			if (yyaccept <= 0) {
+				goto yy87;
+			} else {
+				goto yy90;
+			}
+		} else {
+			if (yyaccept <= 2) {
+				goto yy98;
+			} else {
+				goto yy100;
+			}
+		}
+yy109:
+		YYDEBUG(109, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yybm[0+yych] & 4) {
+			goto yy110;
+		}
+		if (yych == '\\') goto yy112;
+		goto yy104;
+yy110:
+		YYDEBUG(110, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(111, *YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy110;
+		}
+		if (yych == '\\') goto yy114;
+		goto yy104;
+yy112:
+		YYDEBUG(112, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(113, *YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy110;
+		}
+		if (yych == '\\') goto yy112;
+		goto yy104;
+yy114:
+		YYDEBUG(114, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yybm[0+yych] & 4) {
+			goto yy110;
+		}
+		if (yych == '\\') goto yy112;
+		goto yy104;
+yy115:
+		YYDEBUG(115, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(116, *YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy115;
+		}
+		if (yych <= '$') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy100;
+				if (yych <= '\f') goto yy104;
+				goto yy100;
+			} else {
+				if (yych == '"') goto yy100;
+				if (yych <= '#') goto yy104;
+				goto yy107;
+			}
+		} else {
+			if (yych <= ';') {
+				if (yych == '\'') goto yy100;
+				if (yych <= ':') goto yy104;
+				goto yy100;
+			} else {
+				if (yych <= '[') goto yy104;
+				if (yych <= '\\') goto yy106;
+				if (yych <= ']') goto yy100;
+				goto yy104;
+			}
+		}
+yy117:
+		YYDEBUG(117, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(118, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy117;
+		}
+		if (yych <= '$') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy98;
+				if (yych <= '\f') goto yy104;
+				goto yy98;
+			} else {
+				if (yych == '"') goto yy98;
+				if (yych <= '#') goto yy104;
+				goto yy107;
+			}
+		} else {
+			if (yych <= ';') {
+				if (yych == '\'') goto yy98;
+				if (yych <= ':') goto yy104;
+				goto yy98;
+			} else {
+				if (yych <= '[') goto yy104;
+				if (yych <= '\\') goto yy106;
+				if (yych <= ']') goto yy98;
+				goto yy104;
+			}
+		}
+yy119:
+		YYDEBUG(119, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(120, *YYCURSOR);
+		if (yych <= '\'') {
+			if (yych <= '!') {
+				if (yych <= '\n') {
+					if (yych <= '\t') goto yy104;
+					goto yy98;
+				} else {
+					if (yych == '\r') goto yy98;
+					goto yy104;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= '"') goto yy98;
+					goto yy104;
+				} else {
+					if (yych <= '$') goto yy107;
+					if (yych <= '&') goto yy104;
+					goto yy98;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '.') {
+					if (yych <= '-') goto yy104;
+					goto yy117;
+				} else {
+					if (yych <= '/') goto yy104;
+					if (yych <= '9') goto yy119;
+					goto yy104;
+				}
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy98;
+					goto yy104;
+				} else {
+					if (yych <= '\\') goto yy106;
+					if (yych <= ']') goto yy98;
+					goto yy104;
+				}
+			}
+		}
+yy121:
+		YYDEBUG(121, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(122, *YYCURSOR);
+		if (yych <= '&') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy98;
+				if (yych <= '\f') goto yy104;
+				goto yy98;
+			} else {
+				if (yych <= '"') {
+					if (yych <= '!') goto yy104;
+					goto yy98;
+				} else {
+					if (yych == '$') goto yy107;
+					goto yy104;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '\'') goto yy98;
+				if (yych <= '/') goto yy104;
+				if (yych <= '9') goto yy121;
+				goto yy104;
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy98;
+					goto yy104;
+				} else {
+					if (yych <= '\\') goto yy106;
+					if (yych <= ']') goto yy98;
+					goto yy104;
+				}
+			}
+		}
+yy123:
+		YYDEBUG(123, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(124, *YYCURSOR);
+		if (yych <= '&') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy98;
+				if (yych <= '\f') goto yy104;
+				goto yy98;
+			} else {
+				if (yych <= '"') {
+					if (yych <= '!') goto yy104;
+					goto yy98;
+				} else {
+					if (yych == '$') goto yy107;
+					goto yy104;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '\'') goto yy98;
+				if (yych <= '/') goto yy104;
+				if (yych <= '9') goto yy123;
+				goto yy104;
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy98;
+					goto yy104;
+				} else {
+					if (yych <= '\\') goto yy106;
+					if (yych <= ']') goto yy98;
+					goto yy104;
+				}
+			}
+		}
+yy125:
+		YYDEBUG(125, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(126, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy125;
+		}
+		YYDEBUG(127, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(128, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 366 "Zend/zend_ini_scanner.l"
+		{ /* Raw string */
+	/* Eat leading and trailing single quotes */
+	if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {
+		SCNG(yy_text)++;
+		yyleng = yyleng - 2;
+	}
+	RETURN_TOKEN(TC_RAW, yytext, yyleng);
+}
+#line 1772 "Zend/zend_ini_scanner.c"
+yy129:
+		YYDEBUG(129, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(130, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 399 "Zend/zend_ini_scanner.l"
+		{ /* Variable start */
+	yy_push_state(ST_VARNAME TSRMLS_CC);
+	return TC_DOLLAR_CURLY;
+}
+#line 1783 "Zend/zend_ini_scanner.c"
+yy131:
+		YYDEBUG(131, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(132, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy131;
+		}
+		if (yych <= '$') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy87;
+				if (yych <= '\f') goto yy104;
+				goto yy87;
+			} else {
+				if (yych == '"') goto yy133;
+				if (yych <= '#') goto yy104;
+				goto yy107;
+			}
+		} else {
+			if (yych <= ';') {
+				if (yych == '\'') goto yy87;
+				if (yych <= ':') goto yy104;
+				goto yy87;
+			} else {
+				if (yych <= '[') goto yy104;
+				if (yych <= '\\') goto yy106;
+				if (yych <= ']') goto yy134;
+				goto yy104;
+			}
+		}
+yy133:
+		YYDEBUG(133, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy92;
+yy134:
+		YYDEBUG(134, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy103;
+	}
+/* *********************************** */
+yyc_ST_RAW:
+	{
+		static const unsigned char yybm[] = {
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64, 192,   0,  64,  64,   0,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			192,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+		};
+		YYDEBUG(135, *YYCURSOR);
+		YYFILL(3);
+		yych = *YYCURSOR;
+		if (yych <= '\f') {
+			if (yych <= 0x08) {
+				if (yych >= 0x01) goto yy139;
+			} else {
+				if (yych <= '\t') goto yy141;
+				if (yych <= '\n') goto yy142;
+				goto yy139;
+			}
+		} else {
+			if (yych <= ' ') {
+				if (yych <= '\r') goto yy144;
+				if (yych <= 0x1F) goto yy139;
+				goto yy141;
+			} else {
+				if (yych == ';') goto yy145;
+				goto yy139;
+			}
+		}
+		YYDEBUG(137, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(138, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 596 "Zend/zend_ini_scanner.l"
+		{ /* End of option value (if EOF is reached before EOL */
+	BEGIN(INITIAL);
+	return END_OF_LINE;
+}
+#line 1893 "Zend/zend_ini_scanner.c"
+yy139:
+		YYDEBUG(139, *YYCURSOR);
+		++YYCURSOR;
+yy140:
+		YYDEBUG(140, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 446 "Zend/zend_ini_scanner.l"
+		{ /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */
+	char *sc = NULL;
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR) {
+			case '\n':
+			case '\r':
+				goto end_raw_value_chars;
+				break;
+			case ';':
+				if (sc == NULL) {
+					sc = YYCURSOR;
+				}
+				/* no break */
+			default:
+				YYCURSOR++;
+				break;
+		}
+	}
+end_raw_value_chars:
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	/* Eat trailing semicolons */
+	while (yytext[yyleng - 1] == ';') {
+		yyleng--;
+	}
+
+	/* Eat leading and trailing double quotes */
+	if (yytext[0] == '"' && yytext[yyleng - 1] == '"') {
+		SCNG(yy_text)++;
+		yyleng = yyleng - 2;
+	} else if (sc) {
+		YYCURSOR = sc;
+		yyleng = YYCURSOR - SCNG(yy_text);
+	}
+	RETURN_TOKEN(TC_RAW, yytext, yyleng);
+}
+#line 1937 "Zend/zend_ini_scanner.c"
+yy141:
+		YYDEBUG(141, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '\r') {
+			if (yych <= 0x08) goto yy140;
+			if (yych <= '\n') goto yy153;
+			if (yych <= '\f') goto yy140;
+			goto yy153;
+		} else {
+			if (yych <= ' ') {
+				if (yych <= 0x1F) goto yy140;
+				goto yy153;
+			} else {
+				if (yych == ';') goto yy153;
+				goto yy140;
+			}
+		}
+yy142:
+		YYDEBUG(142, *YYCURSOR);
+		++YYCURSOR;
+yy143:
+		YYDEBUG(143, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 487 "Zend/zend_ini_scanner.l"
+		{ /* End of option value */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 1968 "Zend/zend_ini_scanner.c"
+yy144:
+		YYDEBUG(144, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy151;
+		goto yy143;
+yy145:
+		YYDEBUG(145, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy147;
+yy146:
+		YYDEBUG(146, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy147:
+		YYDEBUG(147, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy146;
+		}
+		if (yych >= '\r') goto yy150;
+yy148:
+		YYDEBUG(148, *YYCURSOR);
+		++YYCURSOR;
+yy149:
+		YYDEBUG(149, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 583 "Zend/zend_ini_scanner.l"
+		{ /* Comment */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 2002 "Zend/zend_ini_scanner.c"
+yy150:
+		YYDEBUG(150, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy148;
+		goto yy149;
+yy151:
+		YYDEBUG(151, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy143;
+yy152:
+		YYDEBUG(152, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy153:
+		YYDEBUG(153, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy152;
+		}
+		if (yych <= '\f') {
+			if (yych == '\n') goto yy151;
+		} else {
+			if (yych <= '\r') goto yy155;
+			if (yych == ';') goto yy146;
+		}
+		YYDEBUG(154, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 573 "Zend/zend_ini_scanner.l"
+		{
+	/* eat whitespace */
+	goto restart;
+}
+#line 2036 "Zend/zend_ini_scanner.c"
+yy155:
+		YYDEBUG(155, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '\n') goto yy151;
+		goto yy143;
+	}
+/* *********************************** */
+yyc_ST_SECTION_RAW:
+	{
+		static const unsigned char yybm[] = {
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 192,   0, 128, 128,   0, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			192, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128,   0, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+		};
+		YYDEBUG(156, *YYCURSOR);
+		YYFILL(3);
+		yych = *YYCURSOR;
+		if (yych <= '\f') {
+			if (yych == '\n') goto yy160;
+		} else {
+			if (yych <= '\r') goto yy160;
+			if (yych == ']') goto yy162;
+		}
+		YYDEBUG(158, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy169;
+yy159:
+		YYDEBUG(159, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 483 "Zend/zend_ini_scanner.l"
+		{ /* Raw value, only used when SCNG(scanner_mode) == ZEND_INI_SCANNER_RAW. */
+	RETURN_TOKEN(TC_RAW, yytext, yyleng);
+}
+#line 2100 "Zend/zend_ini_scanner.c"
+yy160:
+		YYDEBUG(160, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(161, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 601 "Zend/zend_ini_scanner.l"
+		{
+	return 0;
+}
+#line 2110 "Zend/zend_ini_scanner.c"
+yy162:
+		YYDEBUG(162, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy165;
+yy163:
+		YYDEBUG(163, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 375 "Zend/zend_ini_scanner.l"
+		{ /* End of section */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return ']';
+}
+#line 2125 "Zend/zend_ini_scanner.c"
+yy164:
+		YYDEBUG(164, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy165:
+		YYDEBUG(165, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy164;
+		}
+		if (yych == '\n') goto yy166;
+		if (yych == '\r') goto yy167;
+		goto yy163;
+yy166:
+		YYDEBUG(166, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy163;
+yy167:
+		YYDEBUG(167, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy166;
+		goto yy163;
+yy168:
+		YYDEBUG(168, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy169:
+		YYDEBUG(169, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy168;
+		}
+		goto yy159;
+	}
+/* *********************************** */
+yyc_ST_SECTION_VALUE:
+	{
+		static const unsigned char yybm[] = {
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 134, 128, 132, 132, 128, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			134, 132, 128, 132, 136, 132, 132,   0, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			228, 228, 228, 228, 228, 228, 228, 228, 
+			228, 228, 132, 128, 132, 132, 132, 132, 
+			132, 164, 164, 164, 164, 164, 164, 164, 
+			164, 164, 164, 164, 164, 164, 164, 164, 
+			164, 164, 164, 164, 164, 164, 164, 164, 
+			164, 164, 164, 132, 144, 128, 132, 164, 
+			132, 164, 164, 164, 164, 164, 164, 164, 
+			164, 164, 164, 164, 164, 164, 164, 164, 
+			164, 164, 164, 164, 164, 164, 164, 164, 
+			164, 164, 164, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+			132, 132, 132, 132, 132, 132, 132, 132, 
+		};
+		YYDEBUG(170, *YYCURSOR);
+		YYFILL(3);
+		yych = *YYCURSOR;
+		if (yych <= '-') {
+			if (yych <= ' ') {
+				if (yych <= '\n') {
+					if (yych <= 0x08) goto yy172;
+					if (yych <= '\t') goto yy174;
+					goto yy175;
+				} else {
+					if (yych == '\r') goto yy175;
+					if (yych >= ' ') goto yy174;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych == '"') goto yy177;
+					if (yych >= '$') goto yy179;
+				} else {
+					if (yych == '\'') goto yy180;
+					if (yych >= '-') goto yy181;
+				}
+			}
+		} else {
+			if (yych <= 'Z') {
+				if (yych <= '9') {
+					if (yych <= '.') goto yy182;
+					if (yych >= '0') goto yy183;
+				} else {
+					if (yych == ';') goto yy175;
+					if (yych >= 'A') goto yy185;
+				}
+			} else {
+				if (yych <= '^') {
+					if (yych <= '[') goto yy172;
+					if (yych <= '\\') goto yy187;
+					if (yych <= ']') goto yy188;
+				} else {
+					if (yych == '`') goto yy172;
+					if (yych <= 'z') goto yy185;
+				}
+			}
+		}
+yy172:
+		YYDEBUG(172, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy195;
+yy173:
+		YYDEBUG(173, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 519 "Zend/zend_ini_scanner.l"
+		{ /* Get rest as section/offset value */
+	RETURN_TOKEN(TC_STRING, yytext, yyleng);
+}
+#line 2251 "Zend/zend_ini_scanner.c"
+yy174:
+		YYDEBUG(174, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy221;
+			goto yy195;
+		} else {
+			if (yych <= ' ') goto yy221;
+			if (yych == '"') goto yy223;
+			goto yy195;
+		}
+yy175:
+		YYDEBUG(175, *YYCURSOR);
+		++YYCURSOR;
+yy176:
+		YYDEBUG(176, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 601 "Zend/zend_ini_scanner.l"
+		{
+	return 0;
+}
+#line 2274 "Zend/zend_ini_scanner.c"
+yy177:
+		YYDEBUG(177, *YYCURSOR);
+		++YYCURSOR;
+yy178:
+		YYDEBUG(178, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 523 "Zend/zend_ini_scanner.l"
+		{ /* Double quoted '"' string start */
+	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);
+	return '"';
+}
+#line 2286 "Zend/zend_ini_scanner.c"
+yy179:
+		YYDEBUG(179, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy176;
+			if (yych <= '[') goto yy194;
+			goto yy199;
+		} else {
+			if (yych == '{') goto yy219;
+			goto yy194;
+		}
+yy180:
+		YYDEBUG(180, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy215;
+		}
+		goto yy176;
+yy181:
+		YYDEBUG(181, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') goto yy195;
+		if (yych <= '9') goto yy213;
+		goto yy195;
+yy182:
+		YYDEBUG(182, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') goto yy195;
+		if (yych <= '9') goto yy211;
+		goto yy195;
+yy183:
+		YYDEBUG(183, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '\'') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy184;
+				if (yych <= '\f') goto yy195;
+			} else {
+				if (yych == '"') goto yy184;
+				if (yych <= '&') goto yy195;
+			}
+		} else {
+			if (yych <= '9') {
+				if (yych == '.') goto yy207;
+				if (yych <= '/') goto yy195;
+				goto yy209;
+			} else {
+				if (yych <= ';') {
+					if (yych <= ':') goto yy195;
+				} else {
+					if (yych != ']') goto yy195;
+				}
+			}
+		}
+yy184:
+		YYDEBUG(184, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 497 "Zend/zend_ini_scanner.l"
+		{ /* Get number option value as string */
+	RETURN_TOKEN(TC_NUMBER, yytext, yyleng);
+}
+#line 2352 "Zend/zend_ini_scanner.c"
+yy185:
+		YYDEBUG(185, *YYCURSOR);
+		yyaccept = 3;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy205;
+		}
+		if (yych <= '"') {
+			if (yych <= '\f') {
+				if (yych != '\n') goto yy195;
+			} else {
+				if (yych <= '\r') goto yy186;
+				if (yych <= '!') goto yy195;
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych != '\'') goto yy195;
+			} else {
+				if (yych <= ';') goto yy186;
+				if (yych != ']') goto yy195;
+			}
+		}
+yy186:
+		YYDEBUG(186, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 493 "Zend/zend_ini_scanner.l"
+		{ /* Get constant option value */
+	RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);
+}
+#line 2382 "Zend/zend_ini_scanner.c"
+yy187:
+		YYDEBUG(187, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy194;
+yy188:
+		YYDEBUG(188, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy191;
+yy189:
+		YYDEBUG(189, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 375 "Zend/zend_ini_scanner.l"
+		{ /* End of section */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return ']';
+}
+#line 2401 "Zend/zend_ini_scanner.c"
+yy190:
+		YYDEBUG(190, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy191:
+		YYDEBUG(191, *YYCURSOR);
+		if (yybm[0+yych] & 2) {
+			goto yy190;
+		}
+		if (yych == '\n') goto yy192;
+		if (yych == '\r') goto yy193;
+		goto yy189;
+yy192:
+		YYDEBUG(192, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy189;
+yy193:
+		YYDEBUG(193, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy192;
+		goto yy189;
+yy194:
+		YYDEBUG(194, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy195:
+		YYDEBUG(195, *YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy194;
+		}
+		if (yych == '$') goto yy197;
+		if (yych != '\\') goto yy173;
+yy196:
+		YYDEBUG(196, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		goto yy194;
+yy197:
+		YYDEBUG(197, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy198;
+			if (yych <= '[') goto yy194;
+			goto yy199;
+		} else {
+			if (yych != '{') goto yy194;
+		}
+yy198:
+		YYDEBUG(198, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		if (yyaccept <= 1) {
+			if (yyaccept <= 0) {
+				goto yy173;
+			} else {
+				goto yy176;
+			}
+		} else {
+			if (yyaccept <= 2) {
+				goto yy184;
+			} else {
+				goto yy186;
+			}
+		}
+yy199:
+		YYDEBUG(199, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yybm[0+yych] & 8) {
+			goto yy200;
+		}
+		if (yych == '\\') goto yy202;
+		goto yy194;
+yy200:
+		YYDEBUG(200, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(201, *YYCURSOR);
+		if (yybm[0+yych] & 8) {
+			goto yy200;
+		}
+		if (yych == '\\') goto yy204;
+		goto yy194;
+yy202:
+		YYDEBUG(202, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(203, *YYCURSOR);
+		if (yybm[0+yych] & 8) {
+			goto yy200;
+		}
+		if (yych == '\\') goto yy202;
+		goto yy194;
+yy204:
+		YYDEBUG(204, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yybm[0+yych] & 8) {
+			goto yy200;
+		}
+		if (yych == '\\') goto yy202;
+		goto yy194;
+yy205:
+		YYDEBUG(205, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(206, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy205;
+		}
+		if (yych <= '$') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy186;
+				if (yych <= '\f') goto yy194;
+				goto yy186;
+			} else {
+				if (yych == '"') goto yy186;
+				if (yych <= '#') goto yy194;
+				goto yy197;
+			}
+		} else {
+			if (yych <= ';') {
+				if (yych == '\'') goto yy186;
+				if (yych <= ':') goto yy194;
+				goto yy186;
+			} else {
+				if (yych <= '[') goto yy194;
+				if (yych <= '\\') goto yy196;
+				if (yych <= ']') goto yy186;
+				goto yy194;
+			}
+		}
+yy207:
+		YYDEBUG(207, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(208, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy207;
+		}
+		if (yych <= '$') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy184;
+				if (yych <= '\f') goto yy194;
+				goto yy184;
+			} else {
+				if (yych == '"') goto yy184;
+				if (yych <= '#') goto yy194;
+				goto yy197;
+			}
+		} else {
+			if (yych <= ';') {
+				if (yych == '\'') goto yy184;
+				if (yych <= ':') goto yy194;
+				goto yy184;
+			} else {
+				if (yych <= '[') goto yy194;
+				if (yych <= '\\') goto yy196;
+				if (yych <= ']') goto yy184;
+				goto yy194;
+			}
+		}
+yy209:
+		YYDEBUG(209, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(210, *YYCURSOR);
+		if (yych <= '\'') {
+			if (yych <= '!') {
+				if (yych <= '\n') {
+					if (yych <= '\t') goto yy194;
+					goto yy184;
+				} else {
+					if (yych == '\r') goto yy184;
+					goto yy194;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= '"') goto yy184;
+					goto yy194;
+				} else {
+					if (yych <= '$') goto yy197;
+					if (yych <= '&') goto yy194;
+					goto yy184;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '.') {
+					if (yych <= '-') goto yy194;
+					goto yy207;
+				} else {
+					if (yych <= '/') goto yy194;
+					if (yych <= '9') goto yy209;
+					goto yy194;
+				}
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy184;
+					goto yy194;
+				} else {
+					if (yych <= '\\') goto yy196;
+					if (yych <= ']') goto yy184;
+					goto yy194;
+				}
+			}
+		}
+yy211:
+		YYDEBUG(211, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(212, *YYCURSOR);
+		if (yych <= '&') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy184;
+				if (yych <= '\f') goto yy194;
+				goto yy184;
+			} else {
+				if (yych <= '"') {
+					if (yych <= '!') goto yy194;
+					goto yy184;
+				} else {
+					if (yych == '$') goto yy197;
+					goto yy194;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '\'') goto yy184;
+				if (yych <= '/') goto yy194;
+				if (yych <= '9') goto yy211;
+				goto yy194;
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy184;
+					goto yy194;
+				} else {
+					if (yych <= '\\') goto yy196;
+					if (yych <= ']') goto yy184;
+					goto yy194;
+				}
+			}
+		}
+yy213:
+		YYDEBUG(213, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(214, *YYCURSOR);
+		if (yych <= '&') {
+			if (yych <= '\r') {
+				if (yych == '\n') goto yy184;
+				if (yych <= '\f') goto yy194;
+				goto yy184;
+			} else {
+				if (yych <= '"') {
+					if (yych <= '!') goto yy194;
+					goto yy184;
+				} else {
+					if (yych == '$') goto yy197;
+					goto yy194;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '\'') goto yy184;
+				if (yych <= '/') goto yy194;
+				if (yych <= '9') goto yy213;
+				goto yy194;
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy184;
+					goto yy194;
+				} else {
+					if (yych <= '\\') goto yy196;
+					if (yych <= ']') goto yy184;
+					goto yy194;
+				}
+			}
+		}
+yy215:
+		YYDEBUG(215, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(216, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy215;
+		}
+		YYDEBUG(217, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(218, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 366 "Zend/zend_ini_scanner.l"
+		{ /* Raw string */
+	/* Eat leading and trailing single quotes */
+	if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {
+		SCNG(yy_text)++;
+		yyleng = yyleng - 2;
+	}
+	RETURN_TOKEN(TC_RAW, yytext, yyleng);
+}
+#line 2722 "Zend/zend_ini_scanner.c"
+yy219:
+		YYDEBUG(219, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(220, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 399 "Zend/zend_ini_scanner.l"
+		{ /* Variable start */
+	yy_push_state(ST_VARNAME TSRMLS_CC);
+	return TC_DOLLAR_CURLY;
+}
+#line 2733 "Zend/zend_ini_scanner.c"
+yy221:
+		YYDEBUG(221, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(222, *YYCURSOR);
+		if (yych <= '"') {
+			if (yych <= '\f') {
+				if (yych <= 0x08) goto yy194;
+				if (yych <= '\t') goto yy221;
+				if (yych <= '\n') goto yy173;
+				goto yy194;
+			} else {
+				if (yych <= 0x1F) {
+					if (yych <= '\r') goto yy173;
+					goto yy194;
+				} else {
+					if (yych <= ' ') goto yy221;
+					if (yych <= '!') goto yy194;
+				}
+			}
+		} else {
+			if (yych <= ':') {
+				if (yych <= '$') {
+					if (yych <= '#') goto yy194;
+					goto yy197;
+				} else {
+					if (yych == '\'') goto yy173;
+					goto yy194;
+				}
+			} else {
+				if (yych <= '[') {
+					if (yych <= ';') goto yy173;
+					goto yy194;
+				} else {
+					if (yych <= '\\') goto yy196;
+					if (yych <= ']') goto yy173;
+					goto yy194;
+				}
+			}
+		}
+yy223:
+		YYDEBUG(223, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy178;
+	}
+/* *********************************** */
+yyc_ST_VALUE:
+	{
+		static const unsigned char yybm[] = {
+			160, 162, 162, 162, 162, 162, 162, 162, 
+			162, 176, 128, 162, 162, 128, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			176, 160, 160, 162, 168, 162, 160,  32, 
+			160, 160, 162, 162, 162, 162, 162, 162, 
+			230, 230, 230, 230, 230, 230, 230, 230, 
+			230, 230, 162, 160, 162, 160, 162, 162, 
+			162, 166, 166, 166, 166, 166, 166, 166, 
+			166, 166, 166, 166, 166, 166, 166, 166, 
+			166, 166, 166, 166, 166, 166, 166, 166, 
+			166, 166, 166, 162, 162, 162, 160, 166, 
+			162, 166, 166, 166, 166, 166, 166, 166, 
+			166, 166, 166, 166, 166, 166, 166, 166, 
+			166, 166, 166, 166, 166, 166, 166, 166, 
+			166, 166, 166, 162, 160, 162, 160, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+			162, 162, 162, 162, 162, 162, 162, 162, 
+		};
+		YYDEBUG(224, *YYCURSOR);
+		YYFILL(6);
+		yych = *YYCURSOR;
+		YYDEBUG(-1, yych);
+		switch (yych) {
+		case 0x00:	goto yy226;
+		case '\t':
+		case ' ':	goto yy230;
+		case '\n':	goto yy232;
+		case '\r':	goto yy234;
+		case '!':
+		case '&':
+		case '(':
+		case ')':
+		case '^':
+		case '|':
+		case '~':	goto yy235;
+		case '"':	goto yy237;
+		case '$':	goto yy239;
+		case '\'':	goto yy240;
+		case '-':	goto yy241;
+		case '.':	goto yy242;
+		case '0':
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':	goto yy243;
+		case ';':	goto yy245;
+		case '=':	goto yy246;
+		case 'A':
+		case 'B':
+		case 'C':
+		case 'D':
+		case 'E':
+		case 'G':
+		case 'H':
+		case 'I':
+		case 'J':
+		case 'K':
+		case 'L':
+		case 'M':
+		case 'P':
+		case 'Q':
+		case 'R':
+		case 'S':
+		case 'U':
+		case 'V':
+		case 'W':
+		case 'X':
+		case 'Z':
+		case '_':
+		case 'a':
+		case 'b':
+		case 'c':
+		case 'd':
+		case 'e':
+		case 'g':
+		case 'h':
+		case 'i':
+		case 'j':
+		case 'k':
+		case 'l':
+		case 'm':
+		case 'p':
+		case 'q':
+		case 'r':
+		case 's':
+		case 'u':
+		case 'v':
+		case 'w':
+		case 'x':
+		case 'z':	goto yy248;
+		case 'F':
+		case 'f':	goto yy250;
+		case 'N':
+		case 'n':	goto yy251;
+		case 'O':
+		case 'o':	goto yy252;
+		case 'T':
+		case 't':	goto yy253;
+		case 'Y':
+		case 'y':	goto yy254;
+		default:	goto yy228;
+		}
+yy226:
+		YYDEBUG(226, *YYCURSOR);
+		++YYCURSOR;
+yy227:
+		YYDEBUG(227, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 596 "Zend/zend_ini_scanner.l"
+		{ /* End of option value (if EOF is reached before EOL */
+	BEGIN(INITIAL);
+	return END_OF_LINE;
+}
+#line 2919 "Zend/zend_ini_scanner.c"
+yy228:
+		YYDEBUG(228, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy256;
+yy229:
+		YYDEBUG(229, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 515 "Zend/zend_ini_scanner.l"
+		{ /* Get everything else as option/offset value */
+	RETURN_TOKEN(TC_STRING, yytext, yyleng);
+}
+#line 2932 "Zend/zend_ini_scanner.c"
+yy230:
+		YYDEBUG(230, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy306;
+yy231:
+		YYDEBUG(231, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 569 "Zend/zend_ini_scanner.l"
+		{
+	RETURN_TOKEN(TC_WHITESPACE, yytext, yyleng);
+}
+#line 2945 "Zend/zend_ini_scanner.c"
+yy232:
+		YYDEBUG(232, *YYCURSOR);
+		++YYCURSOR;
+yy233:
+		YYDEBUG(233, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 487 "Zend/zend_ini_scanner.l"
+		{ /* End of option value */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 2958 "Zend/zend_ini_scanner.c"
+yy234:
+		YYDEBUG(234, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy304;
+		goto yy233;
+yy235:
+		YYDEBUG(235, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy303;
+yy236:
+		YYDEBUG(236, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 505 "Zend/zend_ini_scanner.l"
+		{ /* Boolean operators */
+	return yytext[0];
+}
+#line 2976 "Zend/zend_ini_scanner.c"
+yy237:
+		YYDEBUG(237, *YYCURSOR);
+		++YYCURSOR;
+yy238:
+		YYDEBUG(238, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 523 "Zend/zend_ini_scanner.l"
+		{ /* Double quoted '"' string start */
+	yy_push_state(ST_DOUBLE_QUOTES TSRMLS_CC);
+	return '"';
+}
+#line 2988 "Zend/zend_ini_scanner.c"
+yy239:
+		YYDEBUG(239, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy227;
+			if (yych <= '[') goto yy255;
+			goto yy262;
+		} else {
+			if (yych == '{') goto yy300;
+			goto yy255;
+		}
+yy240:
+		YYDEBUG(240, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy296;
+		}
+		goto yy227;
+yy241:
+		YYDEBUG(241, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') goto yy256;
+		if (yych <= '9') goto yy294;
+		goto yy256;
+yy242:
+		YYDEBUG(242, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') goto yy256;
+		if (yych <= '9') goto yy292;
+		goto yy256;
+yy243:
+		YYDEBUG(243, *YYCURSOR);
+		yyaccept = 3;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy244;
+					if (yych <= 0x08) goto yy256;
+				} else {
+					if (yych != '\r') goto yy256;
+				}
+			} else {
+				if (yych <= ')') {
+					if (yych <= '"') goto yy244;
+					if (yych <= '%') goto yy256;
+				} else {
+					if (yych == '.') goto yy288;
+					goto yy256;
+				}
+			}
+		} else {
+			if (yych <= ']') {
+				if (yych <= ';') {
+					if (yych <= '9') goto yy290;
+					if (yych <= ':') goto yy256;
+				} else {
+					if (yych != '=') goto yy256;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '^') goto yy244;
+					if (yych <= '{') goto yy256;
+				} else {
+					if (yych != '~') goto yy256;
+				}
+			}
+		}
+yy244:
+		YYDEBUG(244, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 497 "Zend/zend_ini_scanner.l"
+		{ /* Get number option value as string */
+	RETURN_TOKEN(TC_NUMBER, yytext, yyleng);
+}
+#line 3067 "Zend/zend_ini_scanner.c"
+yy245:
+		YYDEBUG(245, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		goto yy284;
+yy246:
+		YYDEBUG(246, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(247, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 509 "Zend/zend_ini_scanner.l"
+		{ /* Make = used in option value to trigger error */
+	yyless(0);
+	BEGIN(INITIAL);
+	return END_OF_LINE;
+}
+#line 3084 "Zend/zend_ini_scanner.c"
+yy248:
+		YYDEBUG(248, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy257;
+		}
+		if (yych <= ':') {
+			if (yych <= '\r') {
+				if (yych <= 0x08) {
+					if (yych >= 0x01) goto yy256;
+				} else {
+					if (yych <= '\n') goto yy249;
+					if (yych <= '\f') goto yy256;
+				}
+			} else {
+				if (yych <= '"') {
+					if (yych <= 0x1F) goto yy256;
+				} else {
+					if (yych <= '%') goto yy256;
+					if (yych >= '*') goto yy256;
+				}
+			}
+		} else {
+			if (yych <= '^') {
+				if (yych <= '<') {
+					if (yych >= '<') goto yy256;
+				} else {
+					if (yych <= '=') goto yy249;
+					if (yych <= ']') goto yy256;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '{') goto yy256;
+				} else {
+					if (yych != '~') goto yy256;
+				}
+			}
+		}
+yy249:
+		YYDEBUG(249, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 493 "Zend/zend_ini_scanner.l"
+		{ /* Get constant option value */
+	RETURN_TOKEN(TC_CONSTANT, yytext, yyleng);
+}
+#line 3131 "Zend/zend_ini_scanner.c"
+yy250:
+		YYDEBUG(250, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '<') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '/') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					goto yy256;
+				} else {
+					if (yych <= '9') goto yy257;
+					if (yych == ';') goto yy249;
+					goto yy256;
+				}
+			}
+		} else {
+			if (yych <= '_') {
+				if (yych <= 'A') {
+					if (yych <= '=') goto yy249;
+					if (yych <= '@') goto yy256;
+					goto yy280;
+				} else {
+					if (yych <= 'Z') goto yy257;
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					goto yy257;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych <= '`') goto yy256;
+					if (yych <= 'a') goto yy280;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy251:
+		YYDEBUG(251, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 'N') {
+			if (yych <= '%') {
+				if (yych <= '\f') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					if (yych <= '\n') goto yy249;
+					goto yy256;
+				} else {
+					if (yych <= '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					if (yych <= '"') goto yy249;
+					goto yy256;
+				}
+			} else {
+				if (yych <= ':') {
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					if (yych <= '9') goto yy257;
+					goto yy256;
+				} else {
+					if (yych <= '<') {
+						if (yych <= ';') goto yy249;
+						goto yy256;
+					} else {
+						if (yych <= '=') goto yy249;
+						if (yych <= '@') goto yy256;
+						goto yy257;
+					}
+				}
+			}
+		} else {
+			if (yych <= 'n') {
+				if (yych <= 'Z') {
+					if (yych <= 'O') goto yy276;
+					if (yych == 'U') goto yy277;
+					goto yy257;
+				} else {
+					if (yych <= '^') {
+						if (yych <= ']') goto yy256;
+						goto yy249;
+					} else {
+						if (yych == '`') goto yy256;
+						goto yy257;
+					}
+				}
+			} else {
+				if (yych <= 'z') {
+					if (yych <= 'o') goto yy276;
+					if (yych == 'u') goto yy277;
+					goto yy257;
+				} else {
+					if (yych <= '|') {
+						if (yych <= '{') goto yy256;
+						goto yy249;
+					} else {
+						if (yych == '~') goto yy249;
+						goto yy256;
+					}
+				}
+			}
+		}
+yy252:
+		YYDEBUG(252, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 'E') {
+			if (yych <= '%') {
+				if (yych <= '\f') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					if (yych <= '\n') goto yy249;
+					goto yy256;
+				} else {
+					if (yych <= '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					if (yych <= '"') goto yy249;
+					goto yy256;
+				}
+			} else {
+				if (yych <= ':') {
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					if (yych <= '9') goto yy257;
+					goto yy256;
+				} else {
+					if (yych <= '<') {
+						if (yych <= ';') goto yy249;
+						goto yy256;
+					} else {
+						if (yych <= '=') goto yy249;
+						if (yych <= '@') goto yy256;
+						goto yy257;
+					}
+				}
+			}
+		} else {
+			if (yych <= 'e') {
+				if (yych <= 'Z') {
+					if (yych <= 'F') goto yy271;
+					if (yych == 'N') goto yy265;
+					goto yy257;
+				} else {
+					if (yych <= '^') {
+						if (yych <= ']') goto yy256;
+						goto yy249;
+					} else {
+						if (yych == '`') goto yy256;
+						goto yy257;
+					}
+				}
+			} else {
+				if (yych <= 'z') {
+					if (yych <= 'f') goto yy271;
+					if (yych == 'n') goto yy265;
+					goto yy257;
+				} else {
+					if (yych <= '|') {
+						if (yych <= '{') goto yy256;
+						goto yy249;
+					} else {
+						if (yych == '~') goto yy249;
+						goto yy256;
+					}
+				}
+			}
+		}
+yy253:
+		YYDEBUG(253, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'R') goto yy269;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'r') goto yy269;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy254:
+		YYDEBUG(254, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'E') goto yy259;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'e') goto yy259;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy255:
+		YYDEBUG(255, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy256:
+		YYDEBUG(256, *YYCURSOR);
+		if (yybm[0+yych] & 2) {
+			goto yy255;
+		}
+		if (yych == '$') goto yy260;
+		goto yy229;
+yy257:
+		YYDEBUG(257, *YYCURSOR);
+		yyaccept = 4;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(258, *YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy257;
+		}
+		if (yych <= ')') {
+			if (yych <= '\r') {
+				if (yych <= 0x08) {
+					if (yych <= 0x00) goto yy249;
+					goto yy255;
+				} else {
+					if (yych <= '\n') goto yy249;
+					if (yych <= '\f') goto yy255;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= 0x1F) goto yy255;
+					if (yych <= '"') goto yy249;
+					goto yy255;
+				} else {
+					if (yych <= '$') goto yy260;
+					if (yych <= '%') goto yy255;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= ']') {
+				if (yych <= ';') {
+					if (yych <= ':') goto yy255;
+					goto yy249;
+				} else {
+					if (yych == '=') goto yy249;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '^') goto yy249;
+					if (yych <= '{') goto yy255;
+					goto yy249;
+				} else {
+					if (yych == '~') goto yy249;
+					goto yy255;
+				}
+			}
+		}
+yy259:
+		YYDEBUG(259, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'S') goto yy265;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 's') goto yy265;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy260:
+		YYDEBUG(260, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yych <= '\\') {
+			if (yych <= 0x00) goto yy261;
+			if (yych <= '[') goto yy255;
+			goto yy262;
+		} else {
+			if (yych != '{') goto yy255;
+		}
+yy261:
+		YYDEBUG(261, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		if (yyaccept <= 3) {
+			if (yyaccept <= 1) {
+				if (yyaccept <= 0) {
+					goto yy229;
+				} else {
+					goto yy231;
+				}
+			} else {
+				if (yyaccept <= 2) {
+					goto yy227;
+				} else {
+					goto yy244;
+				}
+			}
+		} else {
+			if (yyaccept <= 5) {
+				if (yyaccept <= 4) {
+					goto yy249;
+				} else {
+					goto yy266;
+				}
+			} else {
+				goto yy273;
+			}
+		}
+yy262:
+		YYDEBUG(262, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		if (yybm[0+yych] & 8) {
+			goto yy263;
+		}
+		goto yy255;
+yy263:
+		YYDEBUG(263, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(264, *YYCURSOR);
+		if (yybm[0+yych] & 8) {
+			goto yy263;
+		}
+		if (yych <= 0x00) goto yy229;
+		if (yych == '\\') goto yy262;
+		goto yy255;
+yy265:
+		YYDEBUG(265, *YYCURSOR);
+		yyaccept = 5;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy267;
+		}
+		if (yych <= ';') {
+			if (yych <= ' ') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy266;
+					if (yych <= '\t') goto yy256;
+				} else {
+					if (yych != '\r') goto yy256;
+				}
+			} else {
+				if (yych <= ')') {
+					if (yych <= '"') goto yy266;
+					if (yych <= '%') goto yy256;
+				} else {
+					if (yych <= '/') goto yy256;
+					if (yych <= '9') goto yy257;
+					if (yych <= ':') goto yy256;
+				}
+			}
+		} else {
+			if (yych <= '_') {
+				if (yych <= '@') {
+					if (yych != '=') goto yy256;
+				} else {
+					if (yych <= 'Z') goto yy257;
+					if (yych <= ']') goto yy256;
+					if (yych >= '_') goto yy257;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych <= '`') goto yy256;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych >= 0x7F) goto yy256;
+				}
+			}
+		}
+yy266:
+		YYDEBUG(266, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 419 "Zend/zend_ini_scanner.l"
+		{ /* TRUE value (when used outside option value/offset this causes parse error!) */
+	RETURN_TOKEN(BOOL_TRUE, "1", 1);
+}
+#line 3643 "Zend/zend_ini_scanner.c"
+yy267:
+		YYDEBUG(267, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(268, *YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy267;
+		}
+		goto yy266;
+yy269:
+		YYDEBUG(269, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych != 'U') goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'u') goto yy270;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy270:
+		YYDEBUG(270, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'E') goto yy265;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'e') goto yy265;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy271:
+		YYDEBUG(271, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych != 'F') goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'f') goto yy272;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy272:
+		YYDEBUG(272, *YYCURSOR);
+		yyaccept = 6;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy257;
+		}
+		if (yych <= ')') {
+			if (yych <= '\f') {
+				if (yych <= 0x08) {
+					if (yych >= 0x01) goto yy256;
+				} else {
+					if (yych <= '\t') goto yy274;
+					if (yych >= '\v') goto yy256;
+				}
+			} else {
+				if (yych <= ' ') {
+					if (yych <= '\r') goto yy273;
+					if (yych <= 0x1F) goto yy256;
+					goto yy274;
+				} else {
+					if (yych <= '"') goto yy273;
+					if (yych <= '%') goto yy256;
+				}
+			}
+		} else {
+			if (yych <= ']') {
+				if (yych <= ';') {
+					if (yych <= ':') goto yy256;
+				} else {
+					if (yych != '=') goto yy256;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '^') goto yy273;
+					if (yych <= '{') goto yy256;
+				} else {
+					if (yych != '~') goto yy256;
+				}
+			}
+		}
+yy273:
+		YYDEBUG(273, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 423 "Zend/zend_ini_scanner.l"
+		{ /* FALSE value (when used outside option value/offset this causes parse error!)*/
+	RETURN_TOKEN(BOOL_FALSE, "", 0);
+}
+#line 3853 "Zend/zend_ini_scanner.c"
+yy274:
+		YYDEBUG(274, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(275, *YYCURSOR);
+		if (yych == '\t') goto yy274;
+		if (yych == ' ') goto yy274;
+		goto yy273;
+yy276:
+		YYDEBUG(276, *YYCURSOR);
+		yyaccept = 6;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '<') {
+			if (yych <= ' ') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy273;
+					if (yych <= 0x08) goto yy256;
+					if (yych <= '\t') goto yy274;
+					goto yy273;
+				} else {
+					if (yych == '\r') goto yy273;
+					if (yych <= 0x1F) goto yy256;
+					goto yy274;
+				}
+			} else {
+				if (yych <= '/') {
+					if (yych <= '"') goto yy273;
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy273;
+					goto yy256;
+				} else {
+					if (yych <= '9') goto yy257;
+					if (yych == ';') goto yy273;
+					goto yy256;
+				}
+			}
+		} else {
+			if (yych <= '_') {
+				if (yych <= 'N') {
+					if (yych <= '=') goto yy273;
+					if (yych <= '@') goto yy256;
+					if (yych <= 'M') goto yy257;
+					goto yy279;
+				} else {
+					if (yych <= 'Z') goto yy257;
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy273;
+					goto yy257;
+				}
+			} else {
+				if (yych <= 'z') {
+					if (yych <= '`') goto yy256;
+					if (yych == 'n') goto yy279;
+					goto yy257;
+				} else {
+					if (yych <= '|') {
+						if (yych <= '{') goto yy256;
+						goto yy273;
+					} else {
+						if (yych == '~') goto yy273;
+						goto yy256;
+					}
+				}
+			}
+		}
+yy277:
+		YYDEBUG(277, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych != 'L') goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'l') goto yy278;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy278:
+		YYDEBUG(278, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'L') goto yy272;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'l') goto yy272;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy279:
+		YYDEBUG(279, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'E') goto yy272;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'e') goto yy272;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy280:
+		YYDEBUG(280, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych != 'L') goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'l') goto yy281;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy281:
+		YYDEBUG(281, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych != 'S') goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 's') goto yy282;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy282:
+		YYDEBUG(282, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '=') {
+			if (yych <= '"') {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy249;
+					if (yych <= 0x08) goto yy256;
+					goto yy249;
+				} else {
+					if (yych == '\r') goto yy249;
+					if (yych <= 0x1F) goto yy256;
+					goto yy249;
+				}
+			} else {
+				if (yych <= '9') {
+					if (yych <= '%') goto yy256;
+					if (yych <= ')') goto yy249;
+					if (yych <= '/') goto yy256;
+					goto yy257;
+				} else {
+					if (yych == ';') goto yy249;
+					if (yych <= '<') goto yy256;
+					goto yy249;
+				}
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= 'Z') {
+					if (yych <= '@') goto yy256;
+					if (yych == 'E') goto yy272;
+					goto yy257;
+				} else {
+					if (yych <= ']') goto yy256;
+					if (yych <= '^') goto yy249;
+					if (yych <= '_') goto yy257;
+					goto yy256;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == 'e') goto yy272;
+					if (yych <= 'z') goto yy257;
+					goto yy256;
+				} else {
+					if (yych == '}') goto yy256;
+					if (yych <= '~') goto yy249;
+					goto yy256;
+				}
+			}
+		}
+yy283:
+		YYDEBUG(283, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy284:
+		YYDEBUG(284, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy283;
+		}
+		if (yych >= '\r') goto yy287;
+yy285:
+		YYDEBUG(285, *YYCURSOR);
+		++YYCURSOR;
+yy286:
+		YYDEBUG(286, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 583 "Zend/zend_ini_scanner.l"
+		{ /* Comment */
+	BEGIN(INITIAL);
+	SCNG(lineno)++;
+	return END_OF_LINE;
+}
+#line 4246 "Zend/zend_ini_scanner.c"
+yy287:
+		YYDEBUG(287, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy285;
+		goto yy286;
+yy288:
+		YYDEBUG(288, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(289, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy288;
+		}
+		if (yych <= ')') {
+			if (yych <= '\r') {
+				if (yych <= 0x08) {
+					if (yych <= 0x00) goto yy244;
+					goto yy255;
+				} else {
+					if (yych <= '\n') goto yy244;
+					if (yych <= '\f') goto yy255;
+					goto yy244;
+				}
+			} else {
+				if (yych <= '#') {
+					if (yych <= 0x1F) goto yy255;
+					if (yych <= '"') goto yy244;
+					goto yy255;
+				} else {
+					if (yych <= '$') goto yy260;
+					if (yych <= '%') goto yy255;
+					goto yy244;
+				}
+			}
+		} else {
+			if (yych <= ']') {
+				if (yych <= ';') {
+					if (yych <= ':') goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '=') goto yy244;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '^') goto yy244;
+					if (yych <= '{') goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '~') goto yy244;
+					goto yy255;
+				}
+			}
+		}
+yy290:
+		YYDEBUG(290, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(291, *YYCURSOR);
+		if (yych <= '.') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy244;
+					if (yych <= 0x08) goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '\r') goto yy244;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych <= '"') goto yy244;
+					if (yych <= '#') goto yy255;
+					goto yy260;
+				} else {
+					if (yych <= '%') goto yy255;
+					if (yych <= ')') goto yy244;
+					if (yych <= '-') goto yy255;
+					goto yy288;
+				}
+			}
+		} else {
+			if (yych <= '=') {
+				if (yych <= ':') {
+					if (yych <= '/') goto yy255;
+					if (yych <= '9') goto yy290;
+					goto yy255;
+				} else {
+					if (yych == '<') goto yy255;
+					goto yy244;
+				}
+			} else {
+				if (yych <= '{') {
+					if (yych == '^') goto yy244;
+					goto yy255;
+				} else {
+					if (yych == '}') goto yy255;
+					if (yych <= '~') goto yy244;
+					goto yy255;
+				}
+			}
+		}
+yy292:
+		YYDEBUG(292, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(293, *YYCURSOR);
+		if (yych <= '/') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy244;
+					if (yych <= 0x08) goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '\r') goto yy244;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych <= '"') goto yy244;
+					if (yych <= '#') goto yy255;
+					goto yy260;
+				} else {
+					if (yych <= '%') goto yy255;
+					if (yych <= ')') goto yy244;
+					goto yy255;
+				}
+			}
+		} else {
+			if (yych <= ']') {
+				if (yych <= ';') {
+					if (yych <= '9') goto yy292;
+					if (yych <= ':') goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '=') goto yy244;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '^') goto yy244;
+					if (yych <= '{') goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '~') goto yy244;
+					goto yy255;
+				}
+			}
+		}
+yy294:
+		YYDEBUG(294, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(295, *YYCURSOR);
+		if (yych <= '/') {
+			if (yych <= 0x1F) {
+				if (yych <= '\n') {
+					if (yych <= 0x00) goto yy244;
+					if (yych <= 0x08) goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '\r') goto yy244;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych <= '"') goto yy244;
+					if (yych <= '#') goto yy255;
+					goto yy260;
+				} else {
+					if (yych <= '%') goto yy255;
+					if (yych <= ')') goto yy244;
+					goto yy255;
+				}
+			}
+		} else {
+			if (yych <= ']') {
+				if (yych <= ';') {
+					if (yych <= '9') goto yy294;
+					if (yych <= ':') goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '=') goto yy244;
+					goto yy255;
+				}
+			} else {
+				if (yych <= '|') {
+					if (yych <= '^') goto yy244;
+					if (yych <= '{') goto yy255;
+					goto yy244;
+				} else {
+					if (yych == '~') goto yy244;
+					goto yy255;
+				}
+			}
+		}
+yy296:
+		YYDEBUG(296, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(297, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy296;
+		}
+		YYDEBUG(298, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(299, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 366 "Zend/zend_ini_scanner.l"
+		{ /* Raw string */
+	/* Eat leading and trailing single quotes */
+	if (yytext[0] == '\'' && yytext[yyleng - 1] == '\'') {
+		SCNG(yy_text)++;
+		yyleng = yyleng - 2;
+	}
+	RETURN_TOKEN(TC_RAW, yytext, yyleng);
+}
+#line 4473 "Zend/zend_ini_scanner.c"
+yy300:
+		YYDEBUG(300, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(301, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 399 "Zend/zend_ini_scanner.l"
+		{ /* Variable start */
+	yy_push_state(ST_VARNAME TSRMLS_CC);
+	return TC_DOLLAR_CURLY;
+}
+#line 4484 "Zend/zend_ini_scanner.c"
+yy302:
+		YYDEBUG(302, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy303:
+		YYDEBUG(303, *YYCURSOR);
+		if (yych == '\t') goto yy302;
+		if (yych == ' ') goto yy302;
+		goto yy236;
+yy304:
+		YYDEBUG(304, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy233;
+yy305:
+		YYDEBUG(305, *YYCURSOR);
+		yyaccept = 1;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+yy306:
+		YYDEBUG(306, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych <= '\n') {
+				if (yych <= 0x08) goto yy231;
+				if (yych <= '\t') goto yy305;
+				goto yy304;
+			} else {
+				if (yych == '\r') goto yy308;
+				goto yy231;
+			}
+		} else {
+			if (yych <= '"') {
+				if (yych <= ' ') goto yy305;
+				if (yych <= '!') goto yy231;
+			} else {
+				if (yych == ';') goto yy283;
+				goto yy231;
+			}
+		}
+		YYDEBUG(307, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy238;
+yy308:
+		YYDEBUG(308, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '\n') goto yy304;
+		goto yy233;
+	}
+/* *********************************** */
+yyc_ST_VARNAME:
+	{
+		static const unsigned char yybm[] = {
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128,   0,   0, 128, 128,   0, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128,   0,   0, 128,   0, 128,   0, 128, 
+			  0,   0, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0, 128,   0, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0, 128, 128,   0, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+		};
+		YYDEBUG(309, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych <= ')') {
+			if (yych <= '"') {
+				if (yych <= '\f') {
+					if (yych <= 0x08) goto yy311;
+					if (yych <= '\n') goto yy313;
+				} else {
+					if (yych <= '\r') goto yy313;
+					if (yych >= '!') goto yy313;
+				}
+			} else {
+				if (yych <= '%') {
+					if (yych == '$') goto yy313;
+				} else {
+					if (yych != '\'') goto yy313;
+				}
+			}
+		} else {
+			if (yych <= '[') {
+				if (yych <= '<') {
+					if (yych == ';') goto yy313;
+				} else {
+					if (yych <= '=') goto yy313;
+					if (yych >= '[') goto yy313;
+				}
+			} else {
+				if (yych <= 'z') {
+					if (yych == '^') goto yy313;
+				} else {
+					if (yych == '}') goto yy315;
+					if (yych <= '~') goto yy313;
+				}
+			}
+		}
+yy311:
+		YYDEBUG(311, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy318;
+yy312:
+		YYDEBUG(312, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 404 "Zend/zend_ini_scanner.l"
+		{ /* Variable name */
+	/* Eat leading whitespace */
+	EAT_LEADING_WHITESPACE();
+
+	/* Eat trailing whitespace */
+	EAT_TRAILING_WHITESPACE();
+
+	RETURN_TOKEN(TC_VARNAME, yytext, yyleng);
+}
+#line 4625 "Zend/zend_ini_scanner.c"
+yy313:
+		YYDEBUG(313, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(314, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 601 "Zend/zend_ini_scanner.l"
+		{
+	return 0;
+}
+#line 4635 "Zend/zend_ini_scanner.c"
+yy315:
+		YYDEBUG(315, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(316, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 414 "Zend/zend_ini_scanner.l"
+		{ /* Variable end */
+	yy_pop_state(TSRMLS_C);
+	return '}';
+}
+#line 4646 "Zend/zend_ini_scanner.c"
+yy317:
+		YYDEBUG(317, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy318:
+		YYDEBUG(318, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy317;
+		}
+		goto yy312;
+	}
+}
+#line 605 "Zend/zend_ini_scanner.l"
+
+}
diff --git a/Zend/zend_ini_scanner.l b/Zend/zend_ini_scanner.l
index 6207c76b27..379d86965d 100644
--- a/Zend/zend_ini_scanner.l
+++ b/Zend/zend_ini_scanner.l
@@ -131,11 +131,9 @@ ZEND_API zend_ini_scanner_globals ini_scanner_globals;
 /* Eat trailing whitespace */
 #define EAT_TRAILING_WHITESPACE()	EAT_TRAILING_WHITESPACE_EX('X')
 
-#define zend_ini_copy_value(retval, str, len) {  \
-	Z_STRVAL_P(retval) = zend_strndup(str, len); \
-	Z_STRLEN_P(retval) = len;                    \
-	Z_TYPE_P(retval) = IS_STRING;                \
-}
+#define zend_ini_copy_value(retval, str, len)	\
+	ZVAL_NEW_STR(retval, STR_INIT(str, len, 1))
+
 
 #define RETURN_TOKEN(type, str, len) {           \
 	zend_ini_copy_value(ini_lval, str, len);     \
diff --git a/Zend/zend_ini_scanner_defs.h b/Zend/zend_ini_scanner_defs.h
index 5723954978..287d7bc1fb 100644
--- a/Zend/zend_ini_scanner_defs.h
+++ b/Zend/zend_ini_scanner_defs.h
@@ -1,13 +1,13 @@
-/* Generated by re2c 0.13.5 */

-#line 3 "Zend/zend_ini_scanner_defs.h"

-

-enum YYCONDTYPE {

-	yycINITIAL,

-	yycST_OFFSET,

-	yycST_SECTION_VALUE,

-	yycST_VALUE,

-	yycST_SECTION_RAW,

-	yycST_DOUBLE_QUOTES,

-	yycST_VARNAME,

-	yycST_RAW,

-};

+/* Generated by re2c 0.13.5 */
+#line 3 "Zend/zend_ini_scanner_defs.h"
+
+enum YYCONDTYPE {
+	yycINITIAL,
+	yycST_OFFSET,
+	yycST_SECTION_VALUE,
+	yycST_VALUE,
+	yycST_SECTION_RAW,
+	yycST_DOUBLE_QUOTES,
+	yycST_VARNAME,
+	yycST_RAW,
+};
diff --git a/Zend/zend_interfaces.c b/Zend/zend_interfaces.c
index f9a020c656..cf8889e0df 100644
--- a/Zend/zend_interfaces.c
+++ b/Zend/zend_interfaces.c
@@ -31,24 +31,27 @@ ZEND_API zend_class_entry *zend_ce_serializable;
 
 /* {{{ zend_call_method
  Only returns the returned zval if retval_ptr != NULL */
-ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval* arg1, zval* arg2 TSRMLS_DC)
+ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, int function_name_len, zval *retval_ptr, int param_count, zval* arg1, zval* arg2 TSRMLS_DC)
 {
 	int result;
 	zend_fcall_info fci;
-	zval z_fname;
-	zval *retval;
+	zval retval;
 	HashTable *function_table;
 
-	zval **params[2];
+	zval params[2];
 
-	params[0] = &arg1;
-	params[1] = &arg2;
+	if (param_count > 0) {
+		ZVAL_COPY_VALUE(&params[0], arg1);
+	}
+	if (param_count > 1) {
+		ZVAL_COPY_VALUE(&params[1], arg2);
+	}
 
 	fci.size = sizeof(fci);
 	/*fci.function_table = NULL; will be read form zend_class_entry of object if needed */
-	fci.object_ptr = object_pp ? *object_pp : NULL;
-	fci.function_name = &z_fname;
-	fci.retval_ptr_ptr = retval_ptr_ptr ? retval_ptr_ptr : &retval;
+	fci.object = (object && Z_TYPE_P(object) == IS_OBJECT) ? Z_OBJ_P(object) : NULL;
+	ZVAL_STRINGL(&fci.function_name, function_name, function_name_len);
+	fci.retval = retval_ptr ? retval_ptr : &retval;
 	fci.param_count = param_count;
 	fci.params = params;
 	fci.no_separation = 1;
@@ -57,15 +60,15 @@ ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend
 	if (!fn_proxy && !obj_ce) {
 		/* no interest in caching and no information already present that is
 		 * needed later inside zend_call_function. */
-		ZVAL_STRINGL(&z_fname, function_name, function_name_len, 0);
-		fci.function_table = !object_pp ? EG(function_table) : NULL;
+		fci.function_table = !object ? EG(function_table) : NULL;
 		result = zend_call_function(&fci, NULL TSRMLS_CC);
+		zval_ptr_dtor(&fci.function_name);
 	} else {
 		zend_fcall_info_cache fcic;
 
 		fcic.initialized = 1;
 		if (!obj_ce) {
-			obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL;
+			obj_ce = object ? Z_OBJCE_P(object) : NULL;
 		}
 		if (obj_ce) {
 			function_table = &obj_ce->function_table;
@@ -73,9 +76,9 @@ ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend
 			function_table = EG(function_table);
 		}
 		if (!fn_proxy || !*fn_proxy) {
-			if (zend_hash_find(function_table, function_name, function_name_len+1, (void **) &fcic.function_handler) == FAILURE) {
+			if ((fcic.function_handler = zend_hash_find_ptr(function_table, Z_STR(fci.function_name))) == NULL) {
 				/* error at c-level */
-				zend_error(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name : "", obj_ce ? "::" : "", function_name);
+				zend_error(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);
 			}
 			if (fn_proxy) {
 				*fn_proxy = fcic.function_handler;
@@ -84,8 +87,8 @@ ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend
 			fcic.function_handler = *fn_proxy;
 		}
 		fcic.calling_scope = obj_ce;
-		if (object_pp) {
-			fcic.called_scope = Z_OBJCE_PP(object_pp);
+		if (object) {
+			fcic.called_scope = Z_OBJCE_P(object);
 		} else if (obj_ce &&
 		           !(EG(called_scope) &&
 		             instanceof_function(EG(called_scope), obj_ce TSRMLS_CC))) {
@@ -93,37 +96,40 @@ ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend
 		} else {
 			fcic.called_scope = EG(called_scope);
 		}
-		fcic.object_ptr = object_pp ? *object_pp : NULL;
+		fcic.object = object ? Z_OBJ_P(object) : NULL;
 		result = zend_call_function(&fci, &fcic TSRMLS_CC);
+		zval_ptr_dtor(&fci.function_name);
 	}
 	if (result == FAILURE) {
 		/* error at c-level */
 		if (!obj_ce) {
-			obj_ce = object_pp ? Z_OBJCE_PP(object_pp) : NULL;
+			obj_ce = object ? Z_OBJCE_P(object) : NULL;
 		}
 		if (!EG(exception)) {
-			zend_error(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name : "", obj_ce ? "::" : "", function_name);
+			zend_error(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? obj_ce->name->val : "", obj_ce ? "::" : "", function_name);
 		}
 	}
-	if (!retval_ptr_ptr) {
-		if (retval) {
-			zval_ptr_dtor(&retval);
-		}
+	/* copy arguments back, they might be changed by references */
+	if (param_count > 0 && Z_ISREF(params[0]) && !Z_ISREF_P(arg1)) {
+		ZVAL_COPY_VALUE(arg1, &params[0]);
+	}
+	if (param_count > 1 && Z_ISREF(params[1]) && !Z_ISREF_P(arg2)) {
+		ZVAL_COPY_VALUE(arg2, &params[1]);
+	}
+	if (!retval_ptr) {
+		zval_ptr_dtor(&retval);
 		return NULL;
 	}
-	return *retval_ptr_ptr;
+	return retval_ptr;
 }
 /* }}} */
 
 /* iterator interface, c-level functions used by engine */
 
 /* {{{ zend_user_it_new_iterator */
-ZEND_API zval *zend_user_it_new_iterator(zend_class_entry *ce, zval *object TSRMLS_DC)
+ZEND_API void zend_user_it_new_iterator(zend_class_entry *ce, zval *object, zval *retval TSRMLS_DC)
 {
-	zval *retval;
-
-	return zend_call_method_with_0_params(&object, ce, &ce->iterator_funcs.zf_new_iterator, "getiterator", &retval);
-
+	zend_call_method_with_0_params(object, ce, &ce->iterator_funcs.zf_new_iterator, "getiterator", retval);
 }
 /* }}} */
 
@@ -132,9 +138,9 @@ ZEND_API void zend_user_it_invalidate_current(zend_object_iterator *_iter TSRMLS
 {
 	zend_user_iterator *iter = (zend_user_iterator*)_iter;
 
-	if (iter->value) {
+	if (!ZVAL_IS_UNDEF(&iter->value)) {
 		zval_ptr_dtor(&iter->value);
-		iter->value = NULL;
+		ZVAL_UNDEF(&iter->value);
 	}
 }
 /* }}} */
@@ -143,11 +149,10 @@ ZEND_API void zend_user_it_invalidate_current(zend_object_iterator *_iter TSRMLS
 static void zend_user_it_dtor(zend_object_iterator *_iter TSRMLS_DC)
 {
 	zend_user_iterator *iter = (zend_user_iterator*)_iter;
-	zval *object = (zval*)iter->it.data;
+	zval *object = &iter->it.data;
 
 	zend_user_it_invalidate_current(_iter TSRMLS_CC);
-	zval_ptr_dtor(&object);
-	efree(iter);
+	zval_ptr_dtor(object);
 }
 /* }}} */
 
@@ -156,13 +161,13 @@ ZEND_API int zend_user_it_valid(zend_object_iterator *_iter TSRMLS_DC)
 {
 	if (_iter) {
 		zend_user_iterator *iter = (zend_user_iterator*)_iter;
-		zval *object = (zval*)iter->it.data;
-		zval *more;
+		zval *object = &iter->it.data;
+		zval more;
 		int result;
 
-		zend_call_method_with_0_params(&object, iter->ce, &iter->ce->iterator_funcs.zf_valid, "valid", &more);
-		if (more) {
-			result = i_zend_is_true(more TSRMLS_CC);
+		zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_valid, "valid", &more);
+		if (Z_TYPE(more) != IS_UNDEF) {
+			result = i_zend_is_true(&more TSRMLS_CC);
 			zval_ptr_dtor(&more);
 			return result ? SUCCESS : FAILURE;
 		}
@@ -172,15 +177,15 @@ ZEND_API int zend_user_it_valid(zend_object_iterator *_iter TSRMLS_DC)
 /* }}} */
 
 /* {{{ zend_user_it_get_current_data */
-ZEND_API void zend_user_it_get_current_data(zend_object_iterator *_iter, zval ***data TSRMLS_DC)
+ZEND_API zval *zend_user_it_get_current_data(zend_object_iterator *_iter TSRMLS_DC)
 {
 	zend_user_iterator *iter = (zend_user_iterator*)_iter;
-	zval *object = (zval*)iter->it.data;
+	zval *object = &iter->it.data;
 
-	if (!iter->value) {
-		zend_call_method_with_0_params(&object, iter->ce, &iter->ce->iterator_funcs.zf_current, "current", &iter->value);
-	}
-	*data = &iter->value;
+	if (ZVAL_IS_UNDEF(&iter->value)) {
+		zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_current, "current", &iter->value);
+	}	
+	return &iter->value;
 }
 /* }}} */
 
@@ -198,30 +203,31 @@ static int zend_user_it_get_current_key_default(zend_object_iterator *_iter, cha
 ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key TSRMLS_DC)
 {
 	zend_user_iterator *iter = (zend_user_iterator*)_iter;
-	zval *object = (zval*)iter->it.data;
-	zval *retval;
+	zval *object = &iter->it.data;
+	zval retval;
 
-	zend_call_method_with_0_params(&object, iter->ce, &iter->ce->iterator_funcs.zf_key, "key", &retval);
+	zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_key, "key", &retval);
 
-	if (retval) {
-		ZVAL_ZVAL(key, retval, 1, 1);
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_ZVAL(key, &retval, 1, 1);
 	} else {
 		if (!EG(exception)) {
-			zend_error(E_WARNING, "Nothing returned from %s::key()", iter->ce->name);
+			zend_error(E_WARNING, "Nothing returned from %s::key()", iter->ce->name->val);
 		}
 
 		ZVAL_LONG(key, 0);
 	}
 }
+/* }}} */
 
 /* {{{ zend_user_it_move_forward */
 ZEND_API void zend_user_it_move_forward(zend_object_iterator *_iter TSRMLS_DC)
 {
 	zend_user_iterator *iter = (zend_user_iterator*)_iter;
-	zval *object = (zval*)iter->it.data;
+	zval *object = &iter->it.data;
 
 	zend_user_it_invalidate_current(_iter TSRMLS_CC);
-	zend_call_method_with_0_params(&object, iter->ce, &iter->ce->iterator_funcs.zf_next, "next", NULL);
+	zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_next, "next", NULL);
 }
 /* }}} */
 
@@ -229,10 +235,10 @@ ZEND_API void zend_user_it_move_forward(zend_object_iterator *_iter TSRMLS_DC)
 ZEND_API void zend_user_it_rewind(zend_object_iterator *_iter TSRMLS_DC)
 {
 	zend_user_iterator *iter = (zend_user_iterator*)_iter;
-	zval *object = (zval*)iter->it.data;
+	zval *object = &iter->it.data;
 
 	zend_user_it_invalidate_current(_iter TSRMLS_CC);
-	zend_call_method_with_0_params(&object, iter->ce, &iter->ce->iterator_funcs.zf_rewind, "rewind", NULL);
+	zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_rewind, "rewind", NULL);
 }
 /* }}} */
 
@@ -257,11 +263,12 @@ static zend_object_iterator *zend_user_it_get_iterator(zend_class_entry *ce, zva
 
 	iterator = emalloc(sizeof(zend_user_iterator));
 
-	Z_ADDREF_P(object);
-	iterator->it.data = (void*)object;
+	zend_iterator_init((zend_object_iterator*)iterator TSRMLS_CC);
+
+	ZVAL_COPY(&iterator->it.data, object);
 	iterator->it.funcs = ce->iterator_funcs.funcs;
 	iterator->ce = Z_OBJCE_P(object);
-	iterator->value = NULL;
+	ZVAL_UNDEF(&iterator->value);
 	return (zend_object_iterator*)iterator;
 }
 /* }}} */
@@ -269,22 +276,22 @@ static zend_object_iterator *zend_user_it_get_iterator(zend_class_entry *ce, zva
 /* {{{ zend_user_it_get_new_iterator */
 ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
 {
-	zval *iterator = zend_user_it_new_iterator(ce, object TSRMLS_CC);
+	zval iterator;
 	zend_object_iterator *new_iterator;
 
-	zend_class_entry *ce_it = iterator && Z_TYPE_P(iterator) == IS_OBJECT ? Z_OBJCE_P(iterator) : NULL;
+	zend_user_it_new_iterator(ce, object, &iterator TSRMLS_CC);
+	zend_class_entry *ce_it = (Z_TYPE(iterator) == IS_OBJECT &&
+		Z_OBJ_HT(iterator)->get_class_entry) ? Z_OBJCE(iterator) : NULL;
 
-	if (!ce_it || !ce_it->get_iterator || (ce_it->get_iterator == zend_user_it_get_new_iterator && iterator == object)) {
+	if (!ce_it || !ce_it->get_iterator || (ce_it->get_iterator == zend_user_it_get_new_iterator && Z_OBJ(iterator) == Z_OBJ_P(object))) {
 		if (!EG(exception)) {
-			zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Objects returned by %s::getIterator() must be traversable or implement interface Iterator", ce ? ce->name : Z_OBJCE_P(object)->name);
-		}
-		if (iterator) {
-			zval_ptr_dtor(&iterator);
+			zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Objects returned by %s::getIterator() must be traversable or implement interface Iterator", ce ? ce->name->val : Z_OBJCE_P(object)->name->val);
 		}
+		zval_ptr_dtor(&iterator);
 		return NULL;
 	}
 
-	new_iterator = ce_it->get_iterator(ce_it, iterator, by_ref TSRMLS_CC);
+	new_iterator = ce_it->get_iterator(ce_it, &iterator, by_ref TSRMLS_CC);
 	zval_ptr_dtor(&iterator);
 	return new_iterator;
 }
@@ -305,10 +312,10 @@ static int zend_implement_traversable(zend_class_entry *interface, zend_class_en
 		}
 	}
 	zend_error(E_CORE_ERROR, "Class %s must implement interface %s as part of either %s or %s",
-		class_type->name,
-		zend_ce_traversable->name,
-		zend_ce_iterator->name,
-		zend_ce_aggregate->name);
+		class_type->name->val,
+		zend_ce_traversable->name->val,
+		zend_ce_iterator->name->val,
+		zend_ce_aggregate->name->val);
 	return FAILURE;
 }
 /* }}} */
@@ -328,9 +335,9 @@ static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entr
 				for (i = 0; i < class_type->num_interfaces; i++) {
 					if (class_type->interfaces[i] == zend_ce_iterator) {
 						zend_error(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
-									class_type->name,
-									interface->name,
-									zend_ce_iterator->name);
+									class_type->name->val,
+									interface->name->val,
+									zend_ce_iterator->name->val);
 						return FAILURE;
 					}
 					if (class_type->interfaces[i] == zend_ce_traversable) {
@@ -360,9 +367,9 @@ static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry
 			/* c-level get_iterator cannot be changed */
 			if (class_type->get_iterator == zend_user_it_get_new_iterator) {
 				zend_error(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
-							class_type->name,
-							interface->name,
-							zend_ce_aggregate->name);
+							class_type->name->val,
+							interface->name->val,
+							zend_ce_aggregate->name->val);
 			}
 			return FAILURE;
 		}
@@ -400,23 +407,23 @@ static int zend_implement_arrayaccess(zend_class_entry *interface, zend_class_en
 ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC)
 {
 	zend_class_entry * ce = Z_OBJCE_P(object);
-	zval *retval;
+	zval retval;
 	int result;
 
-	zend_call_method_with_0_params(&object, ce, &ce->serialize_func, "serialize", &retval);
+	zend_call_method_with_0_params(object, ce, &ce->serialize_func, "serialize", &retval);
 
 
-	if (!retval || EG(exception)) {
+	if (Z_TYPE(retval) == IS_UNDEF || EG(exception)) {
 		result = FAILURE;
 	} else {
-		switch(Z_TYPE_P(retval)) {
+		switch(Z_TYPE(retval)) {
 		case IS_NULL:
 			/* we could also make this '*buf_len = 0' but this allows to skip variables */
 			zval_ptr_dtor(&retval);
 			return FAILURE;
 		case IS_STRING:
-			*buffer = (unsigned char*)estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
-			*buf_len = Z_STRLEN_P(retval);
+			*buffer = (unsigned char*)estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
+			*buf_len = Z_STRLEN(retval);
 			result = SUCCESS;
 			break;
 		default: /* failure */
@@ -427,23 +434,22 @@ ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, zend_uint
 	}
 
 	if (result == FAILURE && !EG(exception)) {
-		zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "%s::serialize() must return a string or NULL", ce->name);
+		zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "%s::serialize() must return a string or NULL", ce->name->val);
 	}
 	return result;
 }
 /* }}} */
 
 /* {{{ zend_user_unserialize */
-ZEND_API int zend_user_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC)
+ZEND_API int zend_user_unserialize(zval *object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC)
 {
-	zval * zdata;
+	zval zdata;
 
-	object_init_ex(*object, ce);
+	object_init_ex(object, ce);
 
-	MAKE_STD_ZVAL(zdata);
-	ZVAL_STRINGL(zdata, (char*)buf, buf_len, 1);
+	ZVAL_STRINGL(&zdata, (char*)buf, buf_len);
 
-	zend_call_method_with_1_params(object, ce, &ce->unserialize_func, "unserialize", NULL, zdata);
+	zend_call_method_with_1_params(object, ce, &ce->unserialize_func, "unserialize", NULL, &zdata);
 
 	zval_ptr_dtor(&zdata);
 
@@ -458,14 +464,14 @@ ZEND_API int zend_user_unserialize(zval **object, zend_class_entry *ce, const un
 ZEND_API int zend_class_serialize_deny(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *ce = Z_OBJCE_P(object);
-	zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Serialization of '%s' is not allowed", ce->name);
+	zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Serialization of '%s' is not allowed", ce->name->val);
 	return FAILURE;
 }
 /* }}} */
 
-ZEND_API int zend_class_unserialize_deny(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
+ZEND_API int zend_class_unserialize_deny(zval *object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC) /* {{{ */
 {
-	zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Unserialization of '%s' is not allowed", ce->name);
+	zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Unserialization of '%s' is not allowed", ce->name->val);
 	return FAILURE;
 }
 /* }}} */
diff --git a/Zend/zend_interfaces.h b/Zend/zend_interfaces.h
index 7b70bc49d4..7fe0e4e2f0 100644
--- a/Zend/zend_interfaces.h
+++ b/Zend/zend_interfaces.h
@@ -35,10 +35,10 @@ extern ZEND_API zend_class_entry *zend_ce_serializable;
 typedef struct _zend_user_iterator {
 	zend_object_iterator     it;
 	zend_class_entry         *ce;
-	zval                     *value;
+	zval                     value;
 } zend_user_iterator;
 
-ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, int function_name_len, zval **retval_ptr_ptr, int param_count, zval* arg1, zval* arg2 TSRMLS_DC);
+ZEND_API zval* zend_call_method(zval *object_pp, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, int function_name_len, zval *retval, int param_count, zval* arg1, zval* arg2 TSRMLS_DC);
 
 #define zend_call_method_with_0_params(obj, obj_ce, fn_proxy, function_name, retval) \
 	zend_call_method(obj, obj_ce, fn_proxy, function_name, sizeof(function_name)-1, retval, 0, NULL, NULL TSRMLS_CC)
@@ -52,20 +52,20 @@ ZEND_API zval* zend_call_method(zval **object_pp, zend_class_entry *obj_ce, zend
 ZEND_API void zend_user_it_rewind(zend_object_iterator *_iter TSRMLS_DC);
 ZEND_API int zend_user_it_valid(zend_object_iterator *_iter TSRMLS_DC);
 ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key TSRMLS_DC);
-ZEND_API void zend_user_it_get_current_data(zend_object_iterator *_iter, zval ***data TSRMLS_DC);
+ZEND_API zval *zend_user_it_get_current_data(zend_object_iterator *_iter TSRMLS_DC);
 ZEND_API void zend_user_it_move_forward(zend_object_iterator *_iter TSRMLS_DC);
 ZEND_API void zend_user_it_invalidate_current(zend_object_iterator *_iter TSRMLS_DC);
 
-ZEND_API zval *zend_user_it_new_iterator(zend_class_entry *ce, zval *object TSRMLS_DC);
+ZEND_API void zend_user_it_new_iterator(zend_class_entry *ce, zval *object, zval *iterator TSRMLS_DC);
 ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 
 ZEND_API void zend_register_interfaces(TSRMLS_D);
 
 ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC);
-ZEND_API int zend_user_unserialize(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
+ZEND_API int zend_user_unserialize(zval *object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
 
 ZEND_API int zend_class_serialize_deny(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC);
-ZEND_API int zend_class_unserialize_deny(zval **object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
+ZEND_API int zend_class_unserialize_deny(zval *object, zend_class_entry *ce, const unsigned char *buf, zend_uint buf_len, zend_unserialize_data *data TSRMLS_DC);
 
 END_EXTERN_C()
 
diff --git a/Zend/zend_iterators.c b/Zend/zend_iterators.c
index a2854c4b74..faf4f91d84 100644
--- a/Zend/zend_iterators.c
+++ b/Zend/zend_iterators.c
@@ -24,8 +24,13 @@
 
 static zend_class_entry zend_iterator_class_entry;
 
+static void iter_wrapper_dtor(zend_object *object TSRMLS_DC);
+
 static zend_object_handlers iterator_object_handlers = {
-	ZEND_OBJECTS_STORE_HANDLERS,
+	0,
+	iter_wrapper_dtor,
+	NULL,
+	NULL,
 	NULL, /* prop read */
 	NULL, /* prop write */
 	NULL, /* read dim */
@@ -51,26 +56,27 @@ static zend_object_handlers iterator_object_handlers = {
 ZEND_API void zend_register_iterator_wrapper(TSRMLS_D)
 {
 	INIT_CLASS_ENTRY(zend_iterator_class_entry, "__iterator_wrapper", NULL);
-	str_free(zend_iterator_class_entry.name);
-	zend_iterator_class_entry.name = "__iterator_wrapper";
 }
 
-static void iter_wrapper_dtor(void *object, zend_object_handle handle TSRMLS_DC)
+static void iter_wrapper_dtor(zend_object *object TSRMLS_DC)
 {
 	zend_object_iterator *iter = (zend_object_iterator*)object;
 	iter->funcs->dtor(iter TSRMLS_CC);
 }
 
-ZEND_API zval *zend_iterator_wrap(zend_object_iterator *iter TSRMLS_DC)
+ZEND_API void zend_iterator_init(zend_object_iterator *iter TSRMLS_DC)
 {
-	zval *wrapped;
+	zend_object_std_init(&iter->std, &zend_iterator_class_entry TSRMLS_CC);
+	iter->std.handlers = &iterator_object_handlers;
+}
 
-	MAKE_STD_ZVAL(wrapped);
-	Z_TYPE_P(wrapped) = IS_OBJECT;
-	Z_OBJ_HANDLE_P(wrapped) = zend_objects_store_put(iter, iter_wrapper_dtor, NULL, NULL TSRMLS_CC);
-	Z_OBJ_HT_P(wrapped) = &iterator_object_handlers;
+ZEND_API void zend_iterator_dtor(zend_object_iterator *iter TSRMLS_DC)
+{
+	if (--GC_REFCOUNT(iter) > 0) {
+		return;
+	}
 
-	return wrapped;
+	zend_objects_store_del(&iter->std TSRMLS_CC);
 }
 
 ZEND_API enum zend_object_iterator_kind zend_iterator_unwrap(
@@ -79,7 +85,7 @@ ZEND_API enum zend_object_iterator_kind zend_iterator_unwrap(
 	switch (Z_TYPE_P(array_ptr)) {
 		case IS_OBJECT:
 			if (Z_OBJ_HT_P(array_ptr) == &iterator_object_handlers) {
-				*iter = (zend_object_iterator *)zend_object_store_get_object(array_ptr TSRMLS_CC);
+				*iter = (zend_object_iterator *)Z_OBJ_P(array_ptr);
 				return ZEND_ITER_OBJECT;
 			}
 			if (Z_OBJPROP_P(array_ptr)) {
diff --git a/Zend/zend_iterators.h b/Zend/zend_iterators.h
index 873f36efbe..09346aee90 100644
--- a/Zend/zend_iterators.h
+++ b/Zend/zend_iterators.h
@@ -36,7 +36,7 @@ typedef struct _zend_object_iterator_funcs {
 	int (*valid)(zend_object_iterator *iter TSRMLS_DC);
 
 	/* fetch the item data for the current element */
-	void (*get_current_data)(zend_object_iterator *iter, zval ***data TSRMLS_DC);
+	zval *(*get_current_data)(zend_object_iterator *iter TSRMLS_DC);
 
 	/* fetch the key for the current element (optional, may be NULL). The key
 	 * should be written into the provided zval* using the ZVAL_* macros. If
@@ -55,7 +55,8 @@ typedef struct _zend_object_iterator_funcs {
 } zend_object_iterator_funcs;
 
 struct _zend_object_iterator {
-	void *data;
+	zend_object std;
+	zval data;
 	zend_object_iterator_funcs *funcs;
 	ulong index; /* private to fe_reset/fe_fetch opcodes */
 };
@@ -82,7 +83,8 @@ BEGIN_EXTERN_C()
 ZEND_API enum zend_object_iterator_kind zend_iterator_unwrap(zval *array_ptr, zend_object_iterator **iter TSRMLS_DC);
 
 /* given an iterator, wrap it up as a zval for use by the engine opcodes */
-ZEND_API zval *zend_iterator_wrap(zend_object_iterator *iter TSRMLS_DC);
+ZEND_API void zend_iterator_init(zend_object_iterator *iter TSRMLS_DC);
+ZEND_API void zend_iterator_dtor(zend_object_iterator *iter TSRMLS_DC);
 
 ZEND_API void zend_register_iterator_wrapper(TSRMLS_D);
 END_EXTERN_C()
diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index 56e702e8f9..ace4f6c284 100644
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -571,8 +571,8 @@ parameter:
 
 optional_class_type:
 		/* empty */					{ $$.op_type = IS_UNUSED; }
-	|	T_ARRAY						{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_ARRAY; }
-	|	T_CALLABLE					{ $$.op_type = IS_CONST; Z_TYPE($$.u.constant)=IS_CALLABLE; }
+	|	T_ARRAY						{ $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_ARRAY; }
+	|	T_CALLABLE					{ $$.op_type = IS_CONST; Z_TYPE_INFO($$.u.constant)=IS_CALLABLE; }
 	|	fully_qualified_class_name			{ $$ = $1; }
 ;
 
@@ -611,9 +611,9 @@ global_var:
 
 static_var_list:
 		static_var_list ',' T_VARIABLE { zend_do_fetch_static_variable(&$3, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
-	|	static_var_list ',' T_VARIABLE '=' static_scalar { zend_do_fetch_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); }
+	|	static_var_list ',' T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($5.u.constant) = 0; zend_do_fetch_static_variable(&$3, &$5, ZEND_FETCH_STATIC TSRMLS_CC); }
 	|	T_VARIABLE  { zend_do_fetch_static_variable(&$1, NULL, ZEND_FETCH_STATIC TSRMLS_CC); }
-	|	T_VARIABLE '=' static_scalar { zend_do_fetch_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); }
+	|	T_VARIABLE '=' static_scalar { Z_CONST_FLAGS($3.u.constant) = 0; zend_do_fetch_static_variable(&$1, &$3, ZEND_FETCH_STATIC TSRMLS_CC); }
 
 ;
 
@@ -667,8 +667,8 @@ trait_precedence:
 ;
 
 trait_reference_list:
-		fully_qualified_class_name									{ zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STRVAL($1.u.constant) TSRMLS_CC); }
-	|	trait_reference_list ',' fully_qualified_class_name			{ zend_resolve_class_name(&$3 TSRMLS_CC); zend_add_to_list(&$1.u.op.ptr, Z_STRVAL($3.u.constant) TSRMLS_CC); $$ = $1; }
+		fully_qualified_class_name									{ zend_resolve_class_name(&$1 TSRMLS_CC); zend_init_list(&$$.u.op.ptr, Z_STR($1.u.constant) TSRMLS_CC); }
+	|	trait_reference_list ',' fully_qualified_class_name			{ zend_resolve_class_name(&$3 TSRMLS_CC); zend_add_to_list(&$1.u.op.ptr, Z_STR($3.u.constant) TSRMLS_CC); $$ = $1; }
 ;
 
 trait_method_reference:
@@ -738,7 +738,7 @@ echo_expr_list:
 
 
 for_expr:
-		/* empty */			{ $$.op_type = IS_CONST;  Z_TYPE($$.u.constant) = IS_BOOL;  Z_LVAL($$.u.constant) = 1; }
+		/* empty */			{ $$.op_type = IS_CONST;  ZVAL_BOOL(&$$.u.constant, 1); }
 	|	non_empty_for_expr	{ $$ = $1; }
 ;
 
@@ -812,8 +812,8 @@ expr_without_variable:
 	|	expr '%' expr 	{ zend_do_binary_op(ZEND_MOD, &$$, &$1, &$3 TSRMLS_CC); }
 	| 	expr T_SL expr	{ zend_do_binary_op(ZEND_SL, &$$, &$1, &$3 TSRMLS_CC); }
 	|	expr T_SR expr	{ zend_do_binary_op(ZEND_SR, &$$, &$1, &$3 TSRMLS_CC); }
-	|	'+' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } }
-	|	'-' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; INIT_PZVAL(&$1.u.constant); zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } }
+	|	'+' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { add_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_ADD, &$$, &$1, &$2 TSRMLS_CC); } }
+	|	'-' expr %prec T_INC { ZVAL_LONG(&$1.u.constant, 0); if ($2.op_type == IS_CONST) { sub_function(&$2.u.constant, &$1.u.constant, &$2.u.constant TSRMLS_CC); $$ = $2; } else { $1.op_type = IS_CONST; zend_do_binary_op(ZEND_SUB, &$$, &$1, &$2 TSRMLS_CC); } }
 	|	'!' expr { zend_do_unary_op(ZEND_BOOL_NOT, &$$, &$2 TSRMLS_CC); }
 	|	'~' expr { zend_do_unary_op(ZEND_BW_NOT, &$$, &$2 TSRMLS_CC); }
 	|	expr T_IS_IDENTICAL expr		{ zend_do_binary_op(ZEND_IS_IDENTICAL, &$$, &$1, &$3 TSRMLS_CC); }
@@ -909,16 +909,16 @@ function_call:
 ;
 
 class_name:
-		T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1, 1);}
+		T_STATIC { $$.op_type = IS_CONST; ZVAL_STRINGL(&$$.u.constant, "static", sizeof("static")-1);}
 	|	namespace_name { $$ = $1; }
 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); $$ = $2; }
+	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
 ;
 
 fully_qualified_class_name:
 		namespace_name { $$ = $1; }
 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); $$ = $2; }
+	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); $$ = $2; }
 ;
 
 
@@ -954,7 +954,7 @@ exit_expr:
 ;
 
 backticks_expr:
-		/* empty */	{ ZVAL_EMPTY_STRING(&$$.u.constant); INIT_PZVAL(&$$.u.constant); $$.op_type = IS_CONST; }
+		/* empty */	{ ZVAL_EMPTY_STRING(&$$.u.constant); $$.op_type = IS_CONST; }
 	|	T_ENCAPSED_AND_WHITESPACE	{ $$ = $1; }
 	|	encaps_list	{ $$ = $1; }
 ;
@@ -978,7 +978,7 @@ common_scalar:
 	|	T_FUNC_C					{ $$ = $1; }
 	|	T_NS_C						{ $$ = $1; }
 	|	T_START_HEREDOC T_ENCAPSED_AND_WHITESPACE T_END_HEREDOC { $$ = $2; }
-	|	T_START_HEREDOC T_END_HEREDOC { ZVAL_EMPTY_STRING(&$$.u.constant); INIT_PZVAL(&$$.u.constant); $$.op_type = IS_CONST; }
+	|	T_START_HEREDOC T_END_HEREDOC { ZVAL_EMPTY_STRING(&$$.u.constant); $$.op_type = IS_CONST; }
 ;
 
 static_class_constant:
@@ -986,7 +986,9 @@ static_class_constant:
 ;
 
 static_scalar: /* compile-time evaluated scalars */
-	static_scalar_value { zend_do_constant_expression(&$$, $1.u.ast TSRMLS_CC); }
+		static_scalar_value { zend_do_constant_expression(&$$, $1.u.ast TSRMLS_CC); }
+	|	T_ARRAY '(' static_array_pair_list ')' { $$ = $3; Z_TYPE_INFO($$.u.constant) = IS_CONSTANT_ARRAY_EX; }
+	|	'[' static_array_pair_list ']' { $$ = $2; Z_TYPE_INFO($$.u.constant) = IS_CONSTANT_ARRAY_EX; }
 ;
 
 static_scalar_value:
@@ -994,17 +996,14 @@ static_scalar_value:
 	|	static_class_name_scalar	{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
 	|	namespace_name 		{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_CT, 1 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	T_ARRAY '(' static_array_pair_list ')' { $$ = $3; }
-	|	'[' static_array_pair_list ']' { $$ = $2; }
+	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_CT, 0 TSRMLS_CC); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
 	|	static_class_constant { $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
 	|	T_CLASS_C			{ $$.u.ast = zend_ast_create_constant(&$1.u.constant); }
 	|	static_operation { $$ = $1; }
 ;
 
 static_operation:
-		static_scalar_value '[' static_scalar_value ']' { $$.u.ast = zend_ast_create_binary(ZEND_FETCH_DIM_R, $1.u.ast, $3.u.ast); }
-	|	static_scalar_value '+' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_ADD, $1.u.ast, $3.u.ast); }
+		static_scalar_value '+' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_ADD, $1.u.ast, $3.u.ast); }
 	|	static_scalar_value '-' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_SUB, $1.u.ast, $3.u.ast); }
 	|	static_scalar_value '*' static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_MUL, $1.u.ast, $3.u.ast); }
 	|	static_scalar_value T_POW static_scalar_value { $$.u.ast = zend_ast_create_binary(ZEND_POW, $1.u.ast, $3.u.ast); }
@@ -1045,7 +1044,7 @@ scalar:
 	|	class_constant		{ $$ = $1; }
 	|	namespace_name	{ zend_do_fetch_constant(&$$, NULL, &$1, ZEND_RT, 1 TSRMLS_CC); }
 	|	T_NAMESPACE T_NS_SEPARATOR namespace_name { $$.op_type = IS_CONST; ZVAL_EMPTY_STRING(&$$.u.constant);  zend_do_build_namespace_name(&$$, &$$, &$3 TSRMLS_CC); $3 = $$; zend_do_fetch_constant(&$$, NULL, &$3, ZEND_RT, 0 TSRMLS_CC); }
-	|	T_NS_SEPARATOR namespace_name { char *tmp = estrndup(Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); memcpy(&(tmp[1]), Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); tmp[0] = '\\'; efree(Z_STRVAL($2.u.constant)); Z_STRVAL($2.u.constant) = tmp; ++Z_STRLEN($2.u.constant); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); }
+	|	T_NS_SEPARATOR namespace_name { zval tmp; ZVAL_NEW_STR(&tmp, STR_ALLOC(Z_STRLEN($2.u.constant)+1, 0)); Z_STRVAL(tmp)[0] = '\\'; memcpy(Z_STRVAL(tmp) + 1, Z_STRVAL($2.u.constant), Z_STRLEN($2.u.constant)+1); if (Z_DELREF($2.u.constant) == 0) {efree(Z_STR($2.u.constant));} Z_STR($2.u.constant) = Z_STR(tmp); zend_do_fetch_constant(&$$, NULL, &$2, ZEND_RT, 0 TSRMLS_CC); }
 	|	common_scalar			{ $$ = $1; }
 	|	'"' encaps_list '"' 	{ $$ = $2; }
 	|	T_START_HEREDOC encaps_list T_END_HEREDOC { $$ = $2; }
@@ -1054,8 +1053,8 @@ scalar:
 
 
 static_array_pair_list:
-		/* empty */ { $$.op_type = IS_CONST; INIT_PZVAL(&$$.u.constant); array_init(&$$.u.constant); $$.u.ast = zend_ast_create_constant(&$$.u.constant); }
-	|	non_empty_static_array_pair_list possible_comma	{ zend_ast_dynamic_shrink(&$1.u.ast); $$ = $1; }
+		/* empty */ { $$.op_type = IS_CONST; array_init(&$$.u.constant); }
+	|	non_empty_static_array_pair_list possible_comma	{ $$ = $1; }
 ;
 
 possible_comma:
@@ -1064,10 +1063,10 @@ possible_comma:
 ;
 
 non_empty_static_array_pair_list:
-		non_empty_static_array_pair_list ',' static_scalar_value T_DOUBLE_ARROW static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); zend_ast_dynamic_add(&$$.u.ast, $5.u.ast); }
-	|	non_empty_static_array_pair_list ',' static_scalar_value { zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); }
-	|	static_scalar_value T_DOUBLE_ARROW static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); zend_ast_dynamic_add(&$$.u.ast, $3.u.ast); }
-	|	static_scalar_value { $$.u.ast = zend_ast_create_dynamic(ZEND_INIT_ARRAY); zend_ast_dynamic_add(&$$.u.ast, NULL); zend_ast_dynamic_add(&$$.u.ast, $1.u.ast); }
+		non_empty_static_array_pair_list ',' static_scalar T_DOUBLE_ARROW static_scalar	{ zend_do_add_static_array_element(&$$, &$3, &$5 TSRMLS_CC); }
+	|	non_empty_static_array_pair_list ',' static_scalar { zend_do_add_static_array_element(&$$, NULL, &$3 TSRMLS_CC); }
+	|	static_scalar T_DOUBLE_ARROW static_scalar { $$.op_type = IS_CONST; array_init(&$$.u.constant); zend_do_add_static_array_element(&$$, &$1, &$3 TSRMLS_CC); }
+	|	static_scalar { $$.op_type = IS_CONST; array_init(&$$.u.constant); zend_do_add_static_array_element(&$$, NULL, &$1 TSRMLS_CC); }
 ;
 
 expr:
@@ -1216,8 +1215,8 @@ assignment_list_element:
 
 
 array_pair_list:
-		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 TSRMLS_CC); }
-	|	non_empty_array_pair_list possible_comma	{ $$ = $1; }
+		/* empty */ { zend_do_init_array(&$$, NULL, NULL, 0 TSRMLS_CC); zend_do_end_array(&$$, &$$ TSRMLS_CC); }
+	|	non_empty_array_pair_list possible_comma	{ zend_do_end_array(&$$, &$1 TSRMLS_CC); }
 ;
 
 non_empty_array_pair_list:
diff --git a/Zend/zend_language_scanner.c b/Zend/zend_language_scanner.c
index ae41cde77f..be8be6c782 100644
--- a/Zend/zend_language_scanner.c
+++ b/Zend/zend_language_scanner.c
@@ -1,7857 +1,7876 @@
-/* Generated by re2c 0.13.5 */

-#line 1 "Zend/zend_language_scanner.l"

-/*

-   +----------------------------------------------------------------------+

-   | Zend Engine                                                          |

-   +----------------------------------------------------------------------+

-   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |

-   +----------------------------------------------------------------------+

-   | This source file is subject to version 2.00 of the Zend license,     |

-   | that is bundled with this package in the file LICENSE, and is        |

-   | available through the world-wide-web at the following url:           |

-   | http://www.zend.com/license/2_00.txt.                                |

-   | If you did not receive a copy of the Zend license and are unable to  |

-   | obtain it through the world-wide-web, please send a note to          |

-   | license@zend.com so we can mail you a copy immediately.              |

-   +----------------------------------------------------------------------+

-   | Authors: Marcus Boerger <helly@php.net>                              |

-   |          Nuno Lopes <nlopess@php.net>                                |

-   |          Scott MacVicar <scottmac@php.net>                           |

-   | Flex version authors:                                                |

-   |          Andi Gutmans <andi@zend.com>                                |

-   |          Zeev Suraski <zeev@zend.com>                                |

-   +----------------------------------------------------------------------+

-*/

-

-/* $Id$ */

-

-#if 0

-# define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)

-#else

-# define YYDEBUG(s, c)

-#endif

-

-#include "zend_language_scanner_defs.h"

-

-#include <errno.h>

-#include "zend.h"

-#ifdef PHP_WIN32

-# include <Winuser.h>

-#endif

-#include "zend_alloc.h"

-#include <zend_language_parser.h>

-#include "zend_compile.h"

-#include "zend_language_scanner.h"

-#include "zend_highlight.h"

-#include "zend_constants.h"

-#include "zend_variables.h"

-#include "zend_operators.h"

-#include "zend_API.h"

-#include "zend_strtod.h"

-#include "zend_exceptions.h"

-#include "zend_virtual_cwd.h"

-#include "tsrm_config_common.h"

-

-#define YYCTYPE   unsigned char

-#define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }

-#define YYCURSOR  SCNG(yy_cursor)

-#define YYLIMIT   SCNG(yy_limit)

-#define YYMARKER  SCNG(yy_marker)

-

-#define YYGETCONDITION()  SCNG(yy_state)

-#define YYSETCONDITION(s) SCNG(yy_state) = s

-

-#define STATE(name)  yyc##name

-

-/* emulate flex constructs */

-#define BEGIN(state) YYSETCONDITION(STATE(state))

-#define YYSTATE      YYGETCONDITION()

-#define yytext       ((char*)SCNG(yy_text))

-#define yyleng       SCNG(yy_leng)

-#define yyless(x)    do { YYCURSOR = (unsigned char*)yytext + x; \

-                          yyleng   = (unsigned int)x; } while(0)

-#define yymore()     goto yymore_restart

-

-/* perform sanity check. If this message is triggered you should

-   increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */

-#define YYMAXFILL 16

-#if ZEND_MMAP_AHEAD < YYMAXFILL

-# error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL

-#endif

-

-#ifdef HAVE_STDARG_H

-# include <stdarg.h>

-#endif

-

-#ifdef HAVE_UNISTD_H

-# include <unistd.h>

-#endif

-

-/* Globals Macros */

-#define SCNG	LANG_SCNG

-#ifdef ZTS

-ZEND_API ts_rsrc_id language_scanner_globals_id;

-#else

-ZEND_API zend_php_scanner_globals language_scanner_globals;

-#endif

-

-#define HANDLE_NEWLINES(s, l)													\

-do {																			\

-	char *p = (s), *boundary = p+(l);											\

-																				\

-	while (p<boundary) {														\

-		if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) {					\

-			CG(zend_lineno)++;													\

-		}																		\

-		p++;																	\

-	}																			\

-} while (0)

-

-#define HANDLE_NEWLINE(c) \

-{ \

-	if (c == '\n' || c == '\r') { \

-		CG(zend_lineno)++; \

-	} \

-}

-

-/* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */

-#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)

-#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    CG(doc_comment_len)

-

-#define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)

-

-#define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')

-#define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))

-

-BEGIN_EXTERN_C()

-

-static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)

-{

-	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding(TSRMLS_C);

-	assert(internal_encoding && zend_multibyte_check_lexer_compatibility(internal_encoding));

-	return zend_multibyte_encoding_converter(to, to_length, from, from_length, internal_encoding, LANG_SCNG(script_encoding) TSRMLS_CC);

-}

-

-static size_t encoding_filter_script_to_intermediate(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)

-{

-	return zend_multibyte_encoding_converter(to, to_length, from, from_length, zend_multibyte_encoding_utf8, LANG_SCNG(script_encoding) TSRMLS_CC);

-}

-

-static size_t encoding_filter_intermediate_to_script(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)

-{

-	return zend_multibyte_encoding_converter(to, to_length, from, from_length,

-LANG_SCNG(script_encoding), zend_multibyte_encoding_utf8 TSRMLS_CC);

-}

-

-static size_t encoding_filter_intermediate_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)

-{

-	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding(TSRMLS_C);

-	assert(internal_encoding && zend_multibyte_check_lexer_compatibility(internal_encoding));

-	return zend_multibyte_encoding_converter(to, to_length, from, from_length,

-internal_encoding, zend_multibyte_encoding_utf8 TSRMLS_CC);

-}

-

-

-static void _yy_push_state(int new_state TSRMLS_DC)

-{

-	zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));

-	YYSETCONDITION(new_state);

-}

-

-#define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)

-

-static void yy_pop_state(TSRMLS_D)

-{

-	int *stack_state;

-	zend_stack_top(&SCNG(state_stack), (void **) &stack_state);

-	YYSETCONDITION(*stack_state);

-	zend_stack_del_top(&SCNG(state_stack));

-}

-

-static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)

-{

-	YYCURSOR       = (YYCTYPE*)str;

-	YYLIMIT        = YYCURSOR + len;

-	if (!SCNG(yy_start)) {

-		SCNG(yy_start) = YYCURSOR;

-	}

-}

-

-void startup_scanner(TSRMLS_D)

-{

-	CG(parse_error) = 0;

-	CG(doc_comment) = NULL;

-	CG(doc_comment_len) = 0;

-	zend_stack_init(&SCNG(state_stack));

-	zend_ptr_stack_init(&SCNG(heredoc_label_stack));

-}

-

-static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) {

-    efree(heredoc_label->label);

-}

-

-void shutdown_scanner(TSRMLS_D)

-{

-	CG(parse_error) = 0;

-	RESET_DOC_COMMENT();

-	zend_stack_destroy(&SCNG(state_stack));

-	zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);

-	zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));

-}

-

-ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)

-{

-	lex_state->yy_leng   = SCNG(yy_leng);

-	lex_state->yy_start  = SCNG(yy_start);

-	lex_state->yy_text   = SCNG(yy_text);

-	lex_state->yy_cursor = SCNG(yy_cursor);

-	lex_state->yy_marker = SCNG(yy_marker);

-	lex_state->yy_limit  = SCNG(yy_limit);

-

-	lex_state->state_stack = SCNG(state_stack);

-	zend_stack_init(&SCNG(state_stack));

-

-	lex_state->heredoc_label_stack = SCNG(heredoc_label_stack);

-	zend_ptr_stack_init(&SCNG(heredoc_label_stack));

-

-	lex_state->in = SCNG(yy_in);

-	lex_state->yy_state = YYSTATE;

-	lex_state->filename = zend_get_compiled_filename(TSRMLS_C);

-	lex_state->lineno = CG(zend_lineno);

-

-	lex_state->script_org = SCNG(script_org);

-	lex_state->script_org_size = SCNG(script_org_size);

-	lex_state->script_filtered = SCNG(script_filtered);

-	lex_state->script_filtered_size = SCNG(script_filtered_size);

-	lex_state->input_filter = SCNG(input_filter);

-	lex_state->output_filter = SCNG(output_filter);

-	lex_state->script_encoding = SCNG(script_encoding);

-}

-

-ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)

-{

-	SCNG(yy_leng)   = lex_state->yy_leng;

-	SCNG(yy_start)  = lex_state->yy_start;

-	SCNG(yy_text)   = lex_state->yy_text;

-	SCNG(yy_cursor) = lex_state->yy_cursor;

-	SCNG(yy_marker) = lex_state->yy_marker;

-	SCNG(yy_limit)  = lex_state->yy_limit;

-

-	zend_stack_destroy(&SCNG(state_stack));

-	SCNG(state_stack) = lex_state->state_stack;

-

-	zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);

-	zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));

-	SCNG(heredoc_label_stack) = lex_state->heredoc_label_stack;

-

-	SCNG(yy_in) = lex_state->in;

-	YYSETCONDITION(lex_state->yy_state);

-	CG(zend_lineno) = lex_state->lineno;

-	zend_restore_compiled_filename(lex_state->filename TSRMLS_CC);

-

-	if (SCNG(script_filtered)) {

-		efree(SCNG(script_filtered));

-		SCNG(script_filtered) = NULL;

-	}

-	SCNG(script_org) = lex_state->script_org;

-	SCNG(script_org_size) = lex_state->script_org_size;

-	SCNG(script_filtered) = lex_state->script_filtered;

-	SCNG(script_filtered_size) = lex_state->script_filtered_size;

-	SCNG(input_filter) = lex_state->input_filter;

-	SCNG(output_filter) = lex_state->output_filter;

-	SCNG(script_encoding) = lex_state->script_encoding;

-

-	RESET_DOC_COMMENT();

-}

-

-ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)

-{

-	zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);

-	/* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */

-	file_handle->opened_path = NULL;

-	if (file_handle->free_filename) {

-		file_handle->filename = NULL;

-	}

-}

-

-#define BOM_UTF32_BE	"\x00\x00\xfe\xff"

-#define	BOM_UTF32_LE	"\xff\xfe\x00\x00"

-#define	BOM_UTF16_BE	"\xfe\xff"

-#define	BOM_UTF16_LE	"\xff\xfe"

-#define	BOM_UTF8		"\xef\xbb\xbf"

-

-static const zend_encoding *zend_multibyte_detect_utf_encoding(const unsigned char *script, size_t script_size TSRMLS_DC)

-{

-	const unsigned char *p;

-	int wchar_size = 2;

-	int le = 0;

-

-	/* utf-16 or utf-32? */

-	p = script;

-	while ((p-script) < script_size) {

-		p = memchr(p, 0, script_size-(p-script)-2);

-		if (!p) {

-			break;

-		}

-		if (*(p+1) == '\0' && *(p+2) == '\0') {

-			wchar_size = 4;

-			break;

-		}

-

-		/* searching for UTF-32 specific byte orders, so this will do */

-		p += 4;

-	}

-

-	/* BE or LE? */

-	p = script;

-	while ((p-script) < script_size) {

-		if (*p == '\0' && *(p+wchar_size-1) != '\0') {

-			/* BE */

-			le = 0;

-			break;

-		} else if (*p != '\0' && *(p+wchar_size-1) == '\0') {

-			/* LE* */

-			le = 1;

-			break;

-		}

-		p += wchar_size;

-	}

-

-	if (wchar_size == 2) {

-		return le ? zend_multibyte_encoding_utf16le : zend_multibyte_encoding_utf16be;

-	} else {

-		return le ? zend_multibyte_encoding_utf32le : zend_multibyte_encoding_utf32be;

-	}

-

-	return NULL;

-}

-

-static const zend_encoding* zend_multibyte_detect_unicode(TSRMLS_D)

-{

-	const zend_encoding *script_encoding = NULL;

-	int bom_size;

-	unsigned char *pos1, *pos2;

-

-	if (LANG_SCNG(script_org_size) < sizeof(BOM_UTF32_LE)-1) {

-		return NULL;

-	}

-

-	/* check out BOM */

-	if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_BE, sizeof(BOM_UTF32_BE)-1)) {

-		script_encoding = zend_multibyte_encoding_utf32be;

-		bom_size = sizeof(BOM_UTF32_BE)-1;

-	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_LE, sizeof(BOM_UTF32_LE)-1)) {

-		script_encoding = zend_multibyte_encoding_utf32le;

-		bom_size = sizeof(BOM_UTF32_LE)-1;

-	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_BE, sizeof(BOM_UTF16_BE)-1)) {

-		script_encoding = zend_multibyte_encoding_utf16be;

-		bom_size = sizeof(BOM_UTF16_BE)-1;

-	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_LE, sizeof(BOM_UTF16_LE)-1)) {

-		script_encoding = zend_multibyte_encoding_utf16le;

-		bom_size = sizeof(BOM_UTF16_LE)-1;

-	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF8, sizeof(BOM_UTF8)-1)) {

-		script_encoding = zend_multibyte_encoding_utf8;

-		bom_size = sizeof(BOM_UTF8)-1;

-	}

-

-	if (script_encoding) {

-		/* remove BOM */

-		LANG_SCNG(script_org) += bom_size;

-		LANG_SCNG(script_org_size) -= bom_size;

-

-		return script_encoding;

-	}

-

-	/* script contains NULL bytes -> auto-detection */

-	if ((pos1 = memchr(LANG_SCNG(script_org), 0, LANG_SCNG(script_org_size)))) {

-		/* check if the NULL byte is after the __HALT_COMPILER(); */

-		pos2 = LANG_SCNG(script_org);

-

-		while (pos1 - pos2 >= sizeof("__HALT_COMPILER();")-1) {

-			pos2 = memchr(pos2, '_', pos1 - pos2);

-			if (!pos2) break;

-			pos2++;

-			if (strncasecmp((char*)pos2, "_HALT_COMPILER", sizeof("_HALT_COMPILER")-1) == 0) {

-				pos2 += sizeof("_HALT_COMPILER")-1;

-				while (*pos2 == ' '  ||

-					   *pos2 == '\t' ||

-					   *pos2 == '\r' ||

-					   *pos2 == '\n') {

-					pos2++;

-				}

-				if (*pos2 == '(') {

-					pos2++;

-					while (*pos2 == ' '  ||

-						   *pos2 == '\t' ||

-						   *pos2 == '\r' ||

-						   *pos2 == '\n') {

-						pos2++;

-					}

-					if (*pos2 == ')') {

-						pos2++;

-						while (*pos2 == ' '  ||

-							   *pos2 == '\t' ||

-							   *pos2 == '\r' ||

-							   *pos2 == '\n') {

-							pos2++;

-						}

-						if (*pos2 == ';') {

-							return NULL;

-						}

-					}

-				}

-			}

-		}

-		/* make best effort if BOM is missing */

-		return zend_multibyte_detect_utf_encoding(LANG_SCNG(script_org), LANG_SCNG(script_org_size) TSRMLS_CC);

-	}

-

-	return NULL;

-}

-

-static const zend_encoding* zend_multibyte_find_script_encoding(TSRMLS_D)

-{

-	const zend_encoding *script_encoding;

-

-	if (CG(detect_unicode)) {

-		/* check out bom(byte order mark) and see if containing wchars */

-		script_encoding = zend_multibyte_detect_unicode(TSRMLS_C);

-		if (script_encoding != NULL) {

-			/* bom or wchar detection is prior to 'script_encoding' option */

-			return script_encoding;

-		}

-	}

-

-	/* if no script_encoding specified, just leave alone */

-	if (!CG(script_encoding_list) || !CG(script_encoding_list_size)) {

-		return NULL;

-	}

-

-	/* if multiple encodings specified, detect automagically */

-	if (CG(script_encoding_list_size) > 1) {

-		return zend_multibyte_encoding_detector(LANG_SCNG(script_org), LANG_SCNG(script_org_size), CG(script_encoding_list), CG(script_encoding_list_size) TSRMLS_CC);

-	}

-

-	return CG(script_encoding_list)[0];

-}

-

-ZEND_API int zend_multibyte_set_filter(const zend_encoding *onetime_encoding TSRMLS_DC)

-{

-	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding(TSRMLS_C);

-	const zend_encoding *script_encoding = onetime_encoding ? onetime_encoding: zend_multibyte_find_script_encoding(TSRMLS_C);

-

-	if (!script_encoding) {

-		return FAILURE;

-	}

-

-	/* judge input/output filter */

-	LANG_SCNG(script_encoding) = script_encoding;

-	LANG_SCNG(input_filter) = NULL;

-	LANG_SCNG(output_filter) = NULL;

-

-	if (!internal_encoding || LANG_SCNG(script_encoding) == internal_encoding) {

-		if (!zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {

-			/* and if not, work around w/ script_encoding -> utf-8 -> script_encoding conversion */

-			LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;

-			LANG_SCNG(output_filter) = encoding_filter_intermediate_to_script;

-		} else {

-			LANG_SCNG(input_filter) = NULL;

-			LANG_SCNG(output_filter) = NULL;

-		}

-		return SUCCESS;

-	}

-

-	if (zend_multibyte_check_lexer_compatibility(internal_encoding)) {

-		LANG_SCNG(input_filter) = encoding_filter_script_to_internal;

-		LANG_SCNG(output_filter) = NULL;

-	} else if (zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {

-		LANG_SCNG(input_filter) = NULL;

-		LANG_SCNG(output_filter) = encoding_filter_script_to_internal;

-	} else {

-		/* both script and internal encodings are incompatible w/ flex */

-		LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;

-		LANG_SCNG(output_filter) = encoding_filter_intermediate_to_internal;

-	}

-

-	return 0;

-}

-

-ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)

-{

-	const char *file_path = NULL;

-	char *buf;

-	size_t size, offset = 0;

-

-	/* The shebang line was read, get the current position to obtain the buffer start */

-	if (CG(start_lineno) == 2 && file_handle->type == ZEND_HANDLE_FP && file_handle->handle.fp) {

-		if ((offset = ftell(file_handle->handle.fp)) == -1) {

-			offset = 0;

-		}

-	}

-

-	if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) {

-		return FAILURE;

-	}

-

-	zend_llist_add_element(&CG(open_files), file_handle);

-	if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {

-		zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));

-		size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;

-		fh->handle.stream.handle = (void*)(((char*)fh) + diff);

-		file_handle->handle.stream.handle = fh->handle.stream.handle;

-	}

-

-	/* Reset the scanner for scanning the new file */

-	SCNG(yy_in) = file_handle;

-	SCNG(yy_start) = NULL;

-

-	if (size != -1) {

-		if (CG(multibyte)) {

-			SCNG(script_org) = (unsigned char*)buf;

-			SCNG(script_org_size) = size;

-			SCNG(script_filtered) = NULL;

-

-			zend_multibyte_set_filter(NULL TSRMLS_CC);

-

-			if (SCNG(input_filter)) {

-				if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC)) {

-					zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "

-							"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));

-				}

-				buf = (char*)SCNG(script_filtered);

-				size = SCNG(script_filtered_size);

-			}

-		}

-		SCNG(yy_start) = (unsigned char *)buf - offset;

-		yy_scan_buffer(buf, size TSRMLS_CC);

-	} else {

-		zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");

-	}

-

-	BEGIN(INITIAL);

-

-	if (file_handle->opened_path) {

-		file_path = file_handle->opened_path;

-	} else {

-		file_path = file_handle->filename;

-	}

-

-	zend_set_compiled_filename(file_path TSRMLS_CC);

-

-	if (CG(start_lineno)) {

-		CG(zend_lineno) = CG(start_lineno);

-		CG(start_lineno) = 0;

-	} else {

-		CG(zend_lineno) = 1;

-	}

-

-	RESET_DOC_COMMENT();

-	CG(increment_lineno) = 0;

-	return SUCCESS;

-}

-END_EXTERN_C()

-

-

-ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)

-{

-	zend_lex_state original_lex_state;

-	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));

-	zend_op_array *original_active_op_array = CG(active_op_array);

-	zend_op_array *retval=NULL;

-	int compiler_result;

-	zend_bool compilation_successful=0;

-	znode retval_znode;

-	zend_bool original_in_compilation = CG(in_compilation);

-

-	retval_znode.op_type = IS_CONST;

-	INIT_PZVAL(&retval_znode.u.constant);

-	ZVAL_LONG(&retval_znode.u.constant, 1);

-

-	zend_save_lexical_state(&original_lex_state TSRMLS_CC);

-

-	retval = op_array; /* success oriented */

-

-	if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {

-		if (type==ZEND_REQUIRE) {

-			zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename TSRMLS_CC);

-			zend_bailout();

-		} else {

-			zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename TSRMLS_CC);

-		}

-		compilation_successful=0;

-	} else {

-		init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);

-		CG(in_compilation) = 1;

-		CG(active_op_array) = op_array;

-		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));

-		zend_init_compiler_context(TSRMLS_C);

-		compiler_result = zendparse(TSRMLS_C);

-		zend_do_return(&retval_znode, 0 TSRMLS_CC);

-		CG(in_compilation) = original_in_compilation;

-		if (compiler_result != 0) { /* parser error */

-			zend_bailout();

-		}

-		compilation_successful=1;

-	}

-

-	if (retval) {

-		CG(active_op_array) = original_active_op_array;

-		if (compilation_successful) {

-			pass_two(op_array TSRMLS_CC);

-			zend_release_labels(0 TSRMLS_CC);

-		} else {

-			efree(op_array);

-			retval = NULL;

-		}

-	}

-	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

-	return retval;

-}

-

-

-zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)

-{

-	zend_file_handle file_handle;

-	zval tmp;

-	zend_op_array *retval;

-	char *opened_path = NULL;

-

-	if (filename->type != IS_STRING) {

-		tmp = *filename;

-		zval_copy_ctor(&tmp);

-		convert_to_string(&tmp);

-		filename = &tmp;

-	}

-	file_handle.filename = Z_STRVAL_P(filename);

-	file_handle.free_filename = 0;

-	file_handle.type = ZEND_HANDLE_FILENAME;

-	file_handle.opened_path = NULL;

-	file_handle.handle.fp = NULL;

-

-	retval = zend_compile_file(&file_handle, type TSRMLS_CC);

-	if (retval && file_handle.handle.stream.handle) {

-		int dummy = 1;

-

-		if (!file_handle.opened_path) {

-			file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRLEN_P(filename));

-		}

-

-		zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);

-

-		if (opened_path) {

-			efree(opened_path);

-		}

-	}

-	zend_destroy_file_handle(&file_handle TSRMLS_CC);

-

-	if (filename==&tmp) {

-		zval_dtor(&tmp);

-	}

-	return retval;

-}

-

-ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)

-{

-	char *buf;

-	size_t size;

-

-	/* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */

-	Z_STRVAL_P(str) = str_erealloc(Z_STRVAL_P(str), Z_STRLEN_P(str) + ZEND_MMAP_AHEAD);

-	memset(Z_STRVAL_P(str) + Z_STRLEN_P(str), 0, ZEND_MMAP_AHEAD);

-

-	SCNG(yy_in) = NULL;

-	SCNG(yy_start) = NULL;

-

-	buf = Z_STRVAL_P(str);

-	size = Z_STRLEN_P(str);

-

-	if (CG(multibyte)) {

-		SCNG(script_org) = (unsigned char*)buf;

-		SCNG(script_org_size) = size;

-		SCNG(script_filtered) = NULL;

-

-		zend_multibyte_set_filter(zend_multibyte_get_internal_encoding(TSRMLS_C) TSRMLS_CC);

-

-		if (SCNG(input_filter)) {

-			if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC)) {

-				zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "

-						"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));

-			}

-			buf = (char*)SCNG(script_filtered);

-			size = SCNG(script_filtered_size);

-		}

-	}

-

-	yy_scan_buffer(buf, size TSRMLS_CC);

-

-	zend_set_compiled_filename(filename TSRMLS_CC);

-	CG(zend_lineno) = 1;

-	CG(increment_lineno) = 0;

-	RESET_DOC_COMMENT();

-	return SUCCESS;

-}

-

-

-ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D)

-{

-	size_t offset = SCNG(yy_cursor) - SCNG(yy_start);

-	if (SCNG(input_filter)) {

-		size_t original_offset = offset, length = 0;

-		do {

-			unsigned char *p = NULL;

-			if ((size_t)-1 == SCNG(input_filter)(&p, &length, SCNG(script_org), offset TSRMLS_CC)) {

-				return (size_t)-1;

-			}

-			efree(p);

-			if (length > original_offset) {

-				offset--;

-			} else if (length < original_offset) {

-				offset++;

-			}

-		} while (original_offset != length);

-	}

-	return offset;

-}

-

-

-zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)

-{

-	zend_lex_state original_lex_state;

-	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));

-	zend_op_array *original_active_op_array = CG(active_op_array);

-	zend_op_array *retval;

-	zval tmp;

-	int compiler_result;

-	zend_bool original_in_compilation = CG(in_compilation);

-

-	if (Z_STRLEN_P(source_string)==0) {

-		efree(op_array);

-		return NULL;

-	}

-

-	CG(in_compilation) = 1;

-

-	tmp = *source_string;

-	zval_copy_ctor(&tmp);

-	convert_to_string(&tmp);

-	source_string = &tmp;

-

-	zend_save_lexical_state(&original_lex_state TSRMLS_CC);

-	if (zend_prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {

-		efree(op_array);

-		retval = NULL;

-	} else {

-		zend_bool orig_interactive = CG(interactive);

-

-		CG(interactive) = 0;

-		init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);

-		CG(interactive) = orig_interactive;

-		CG(active_op_array) = op_array;

-		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));

-		zend_init_compiler_context(TSRMLS_C);

-		BEGIN(ST_IN_SCRIPTING);

-		compiler_result = zendparse(TSRMLS_C);

-

-		if (SCNG(script_filtered)) {

-			efree(SCNG(script_filtered));

-			SCNG(script_filtered) = NULL;

-		}

-

-		if (compiler_result != 0) {

-			CG(active_op_array) = original_active_op_array;

-			CG(unclean_shutdown)=1;

-			destroy_op_array(op_array TSRMLS_CC);

-			efree(op_array);

-			retval = NULL;

-		} else {

-			zend_do_return(NULL, 0 TSRMLS_CC);

-			CG(active_op_array) = original_active_op_array;

-			pass_two(op_array TSRMLS_CC);

-			zend_release_labels(0 TSRMLS_CC);

-			retval = op_array;

-		}

-	}

-	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

-	zval_dtor(&tmp);

-	CG(in_compilation) = original_in_compilation;

-	return retval;

-}

-

-

-BEGIN_EXTERN_C()

-int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)

-{

-	zend_lex_state original_lex_state;

-	zend_file_handle file_handle;

-

-	file_handle.type = ZEND_HANDLE_FILENAME;

-	file_handle.filename = filename;

-	file_handle.free_filename = 0;

-	file_handle.opened_path = NULL;

-	zend_save_lexical_state(&original_lex_state TSRMLS_CC);

-	if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {

-		zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename TSRMLS_CC);

-		zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

-		return FAILURE;

-	}

-	zend_highlight(syntax_highlighter_ini TSRMLS_CC);

-	if (SCNG(script_filtered)) {

-		efree(SCNG(script_filtered));

-		SCNG(script_filtered) = NULL;

-	}

-	zend_destroy_file_handle(&file_handle TSRMLS_CC);

-	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

-	return SUCCESS;

-}

-

-int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC)

-{

-	zend_lex_state original_lex_state;

-	zval tmp = *str;

-

-	str = &tmp;

-	zval_copy_ctor(str);

-	zend_save_lexical_state(&original_lex_state TSRMLS_CC);

-	if (zend_prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {

-		zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

-		return FAILURE;

-	}

-	BEGIN(INITIAL);

-	zend_highlight(syntax_highlighter_ini TSRMLS_CC);

-	if (SCNG(script_filtered)) {

-		efree(SCNG(script_filtered));

-		SCNG(script_filtered) = NULL;

-	}

-	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);

-	zval_dtor(str);

-	return SUCCESS;

-}

-

-ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, const zend_encoding *old_encoding TSRMLS_DC)

-{

-	size_t length;

-	unsigned char *new_yy_start;

-

-	/* convert and set */

-	if (!SCNG(input_filter)) {

-		if (SCNG(script_filtered)) {

-			efree(SCNG(script_filtered));

-			SCNG(script_filtered) = NULL;

-		}

-		SCNG(script_filtered_size) = 0;

-		length = SCNG(script_org_size);

-		new_yy_start = SCNG(script_org);

-	} else {

-		if ((size_t)-1 == SCNG(input_filter)(&new_yy_start, &length, SCNG(script_org), SCNG(script_org_size) TSRMLS_CC)) {

-			zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "

-					"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));

-		}

-		SCNG(script_filtered) = new_yy_start;

-		SCNG(script_filtered_size) = length;

-	}

-

-	SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));

-	SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));

-	SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));

-	SCNG(yy_limit) = new_yy_start + (SCNG(yy_limit) - SCNG(yy_start));

-

-	SCNG(yy_start) = new_yy_start;

-}

-

-

-# define zend_copy_value(zendlval, yytext, yyleng) \

-	if (SCNG(output_filter)) { \

-		size_t sz = 0; \

-		SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC); \

-		Z_STRLEN_P(zendlval) = sz; \

-	} else { \

-		Z_STRVAL_P(zendlval) = (char *) estrndup(yytext, yyleng); \

-		Z_STRLEN_P(zendlval) = yyleng; \

-	}

-

-static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)

-{

-	register char *s, *t;

-	char *end;

-

-	ZVAL_STRINGL(zendlval, str, len, 1);

-

-	/* convert escape sequences */

-	s = t = Z_STRVAL_P(zendlval);

-	end = s+Z_STRLEN_P(zendlval);

-	while (s<end) {

-		if (*s=='\\') {

-			s++;

-			if (s >= end) {

-				*t++ = '\\';

-				break;

-			}

-

-			switch(*s) {

-				case 'n':

-					*t++ = '\n';

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case 'r':

-					*t++ = '\r';

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case 't':

-					*t++ = '\t';

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case 'f':

-					*t++ = '\f';

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case 'v':

-					*t++ = '\v';

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case 'e':

-#ifdef PHP_WIN32

-					*t++ = VK_ESCAPE;

-#else

-					*t++ = '\e';

-#endif

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case '"':

-				case '`':

-					if (*s != quote_type) {

-						*t++ = '\\';

-						*t++ = *s;

-						break;

-					}

-				case '\\':

-				case '$':

-					*t++ = *s;

-					Z_STRLEN_P(zendlval)--;

-					break;

-				case 'x':

-				case 'X':

-					if (ZEND_IS_HEX(*(s+1))) {

-						char hex_buf[3] = { 0, 0, 0 };

-

-						Z_STRLEN_P(zendlval)--; /* for the 'x' */

-

-						hex_buf[0] = *(++s);

-						Z_STRLEN_P(zendlval)--;

-						if (ZEND_IS_HEX(*(s+1))) {

-							hex_buf[1] = *(++s);

-							Z_STRLEN_P(zendlval)--;

-						}

-						*t++ = (char) strtol(hex_buf, NULL, 16);

-					} else {

-						*t++ = '\\';

-						*t++ = *s;

-					}

-					break;

-				default:

-					/* check for an octal */

-					if (ZEND_IS_OCT(*s)) {

-						char octal_buf[4] = { 0, 0, 0, 0 };

-

-						octal_buf[0] = *s;

-						Z_STRLEN_P(zendlval)--;

-						if (ZEND_IS_OCT(*(s+1))) {

-							octal_buf[1] = *(++s);

-							Z_STRLEN_P(zendlval)--;

-							if (ZEND_IS_OCT(*(s+1))) {

-								octal_buf[2] = *(++s);

-								Z_STRLEN_P(zendlval)--;

-							}

-						}

-						*t++ = (char) strtol(octal_buf, NULL, 8);

-					} else {

-						*t++ = '\\';

-						*t++ = *s;

-					}

-					break;

-			}

-		} else {

-			*t++ = *s;

-		}

-

-		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {

-			CG(zend_lineno)++;

-		}

-		s++;

-	}

-	*t = 0;

-	if (SCNG(output_filter)) {

-		size_t sz = 0;

-		s = Z_STRVAL_P(zendlval);

-		SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);

-		Z_STRLEN_P(zendlval) = sz;

-		efree(s);

-	}

-}

-

-

-int lex_scan(zval *zendlval TSRMLS_DC)

-{

-restart:

-	SCNG(yy_text) = YYCURSOR;

-

-yymore_restart:

-

-

-#line 1001 "Zend/zend_language_scanner.c"

-{

-	YYCTYPE yych;

-	unsigned int yyaccept = 0;

-	if (YYGETCONDITION() < 5) {

-		if (YYGETCONDITION() < 2) {

-			if (YYGETCONDITION() < 1) {

-				goto yyc_ST_IN_SCRIPTING;

-			} else {

-				goto yyc_ST_LOOKING_FOR_PROPERTY;

-			}

-		} else {

-			if (YYGETCONDITION() < 3) {

-				goto yyc_ST_BACKQUOTE;

-			} else {

-				if (YYGETCONDITION() < 4) {

-					goto yyc_ST_DOUBLE_QUOTES;

-				} else {

-					goto yyc_ST_HEREDOC;

-				}

-			}

-		}

-	} else {

-		if (YYGETCONDITION() < 7) {

-			if (YYGETCONDITION() < 6) {

-				goto yyc_ST_LOOKING_FOR_VARNAME;

-			} else {

-				goto yyc_ST_VAR_OFFSET;

-			}

-		} else {

-			if (YYGETCONDITION() < 8) {

-				goto yyc_INITIAL;

-			} else {

-				if (YYGETCONDITION() < 9) {

-					goto yyc_ST_END_HEREDOC;

-				} else {

-					goto yyc_ST_NOWDOC;

-				}

-			}

-		}

-	}

-/* *********************************** */

-yyc_INITIAL:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0, 128, 128,   0,   0, 128,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-		};

-

-		YYDEBUG(0, *YYCURSOR);

-		YYFILL(8);

-		yych = *YYCURSOR;

-		if (yych != '<') goto yy4;

-		YYDEBUG(2, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '?') {

-			if (yych == '%') goto yy7;

-			if (yych >= '?') goto yy5;

-		} else {

-			if (yych <= 'S') {

-				if (yych >= 'S') goto yy9;

-			} else {

-				if (yych == 's') goto yy9;

-			}

-		}

-yy3:

-		YYDEBUG(3, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1749 "Zend/zend_language_scanner.l"

-		{

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-

-inline_char_handler:

-

-	while (1) {

-		YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);

-

-		YYCURSOR = ptr ? ptr + 1 : YYLIMIT;

-

-		if (YYCURSOR < YYLIMIT) {

-			switch (*YYCURSOR) {

-				case '?':

-					if (CG(short_tags) || !strncasecmp((char*)YYCURSOR + 1, "php", 3) || (*(YYCURSOR + 1) == '=')) { /* Assume [ \t\n\r] follows "php" */

-						break;

-					}

-					continue;

-				case '%':

-					if (CG(asp_tags)) {

-						break;

-					}

-					continue;

-				case 's':

-				case 'S':

-					/* Probably NOT an opening PHP <script> tag, so don't end the HTML chunk yet

-					 * If it is, the PHP <script> tag rule checks for any HTML scanned before it */

-					YYCURSOR--;

-					yymore();

-				default:

-					continue;

-			}

-

-			YYCURSOR--;

-		}

-

-		break;

-	}

-

-inline_html:

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	if (SCNG(output_filter)) {

-		int readsize;

-		size_t sz = 0;

-		readsize = SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC);

-		Z_STRLEN_P(zendlval) = sz;

-		if (readsize < yyleng) {

-			yyless(readsize);

-		}

-	} else {

-	  Z_STRVAL_P(zendlval) = (char *) estrndup(yytext, yyleng);

-	  Z_STRLEN_P(zendlval) = yyleng;

-	}

-	zendlval->type = IS_STRING;

-	HANDLE_NEWLINES(yytext, yyleng);

-	return T_INLINE_HTML;

-}

-#line 1160 "Zend/zend_language_scanner.c"

-yy4:

-		YYDEBUG(4, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy3;

-yy5:

-		YYDEBUG(5, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 'O') {

-			if (yych == '=') goto yy45;

-		} else {

-			if (yych <= 'P') goto yy47;

-			if (yych == 'p') goto yy47;

-		}

-yy6:

-		YYDEBUG(6, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1739 "Zend/zend_language_scanner.l"

-		{

-	if (CG(short_tags)) {

-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-		BEGIN(ST_IN_SCRIPTING);

-		return T_OPEN_TAG;

-	} else {

-		goto inline_char_handler;

-	}

-}

-#line 1188 "Zend/zend_language_scanner.c"

-yy7:

-		YYDEBUG(7, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '=') goto yy43;

-		YYDEBUG(8, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1720 "Zend/zend_language_scanner.l"

-		{

-	if (CG(asp_tags)) {

-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-		BEGIN(ST_IN_SCRIPTING);

-		return T_OPEN_TAG;

-	} else {

-		goto inline_char_handler;

-	}

-}

-#line 1205 "Zend/zend_language_scanner.c"

-yy9:

-		YYDEBUG(9, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy11;

-		if (yych == 'c') goto yy11;

-yy10:

-		YYDEBUG(10, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		if (yyaccept <= 0) {

-			goto yy3;

-		} else {

-			goto yy6;

-		}

-yy11:

-		YYDEBUG(11, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy12;

-		if (yych != 'r') goto yy10;

-yy12:

-		YYDEBUG(12, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy13;

-		if (yych != 'i') goto yy10;

-yy13:

-		YYDEBUG(13, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy14;

-		if (yych != 'p') goto yy10;

-yy14:

-		YYDEBUG(14, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy15;

-		if (yych != 't') goto yy10;

-yy15:

-		YYDEBUG(15, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy10;

-		if (yych == 'l') goto yy10;

-		goto yy17;

-yy16:

-		YYDEBUG(16, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(8);

-		yych = *YYCURSOR;

-yy17:

-		YYDEBUG(17, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy16;

-		}

-		if (yych == 'L') goto yy18;

-		if (yych != 'l') goto yy10;

-yy18:

-		YYDEBUG(18, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy19;

-		if (yych != 'a') goto yy10;

-yy19:

-		YYDEBUG(19, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy20;

-		if (yych != 'n') goto yy10;

-yy20:

-		YYDEBUG(20, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'G') goto yy21;

-		if (yych != 'g') goto yy10;

-yy21:

-		YYDEBUG(21, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy22;

-		if (yych != 'u') goto yy10;

-yy22:

-		YYDEBUG(22, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy23;

-		if (yych != 'a') goto yy10;

-yy23:

-		YYDEBUG(23, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'G') goto yy24;

-		if (yych != 'g') goto yy10;

-yy24:

-		YYDEBUG(24, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy25;

-		if (yych != 'e') goto yy10;

-yy25:

-		YYDEBUG(25, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(26, *YYCURSOR);

-		if (yych <= '\r') {

-			if (yych <= 0x08) goto yy10;

-			if (yych <= '\n') goto yy25;

-			if (yych <= '\f') goto yy10;

-			goto yy25;

-		} else {

-			if (yych <= ' ') {

-				if (yych <= 0x1F) goto yy10;

-				goto yy25;

-			} else {

-				if (yych != '=') goto yy10;

-			}

-		}

-yy27:

-		YYDEBUG(27, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(5);

-		yych = *YYCURSOR;

-		YYDEBUG(28, *YYCURSOR);

-		if (yych <= '!') {

-			if (yych <= '\f') {

-				if (yych <= 0x08) goto yy10;

-				if (yych <= '\n') goto yy27;

-				goto yy10;

-			} else {

-				if (yych <= '\r') goto yy27;

-				if (yych == ' ') goto yy27;

-				goto yy10;

-			}

-		} else {

-			if (yych <= 'O') {

-				if (yych <= '"') goto yy30;

-				if (yych == '\'') goto yy31;

-				goto yy10;

-			} else {

-				if (yych <= 'P') goto yy29;

-				if (yych != 'p') goto yy10;

-			}

-		}

-yy29:

-		YYDEBUG(29, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy42;

-		if (yych == 'h') goto yy42;

-		goto yy10;

-yy30:

-		YYDEBUG(30, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy39;

-		if (yych == 'p') goto yy39;

-		goto yy10;

-yy31:

-		YYDEBUG(31, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy32;

-		if (yych != 'p') goto yy10;

-yy32:

-		YYDEBUG(32, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy33;

-		if (yych != 'h') goto yy10;

-yy33:

-		YYDEBUG(33, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy34;

-		if (yych != 'p') goto yy10;

-yy34:

-		YYDEBUG(34, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '\'') goto yy10;

-yy35:

-		YYDEBUG(35, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(36, *YYCURSOR);

-		if (yych <= '\r') {

-			if (yych <= 0x08) goto yy10;

-			if (yych <= '\n') goto yy35;

-			if (yych <= '\f') goto yy10;

-			goto yy35;

-		} else {

-			if (yych <= ' ') {

-				if (yych <= 0x1F) goto yy10;

-				goto yy35;

-			} else {

-				if (yych != '>') goto yy10;

-			}

-		}

-		YYDEBUG(37, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(38, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1686 "Zend/zend_language_scanner.l"

-		{

-	YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));

-

-	if (bracket != SCNG(yy_text)) {

-		/* Handle previously scanned HTML, as possible <script> tags found are assumed to not be PHP's */

-		YYCURSOR = bracket;

-		goto inline_html;

-	}

-

-	HANDLE_NEWLINES(yytext, yyleng);

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-	BEGIN(ST_IN_SCRIPTING);

-	return T_OPEN_TAG;

-}

-#line 1406 "Zend/zend_language_scanner.c"

-yy39:

-		YYDEBUG(39, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy40;

-		if (yych != 'h') goto yy10;

-yy40:

-		YYDEBUG(40, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy41;

-		if (yych != 'p') goto yy10;

-yy41:

-		YYDEBUG(41, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '"') goto yy35;

-		goto yy10;

-yy42:

-		YYDEBUG(42, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy35;

-		if (yych == 'p') goto yy35;

-		goto yy10;

-yy43:

-		YYDEBUG(43, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(44, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1702 "Zend/zend_language_scanner.l"

-		{

-	if (CG(asp_tags)) {

-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-		BEGIN(ST_IN_SCRIPTING);

-		return T_OPEN_TAG_WITH_ECHO;

-	} else {

-		goto inline_char_handler;

-	}

-}

-#line 1443 "Zend/zend_language_scanner.c"

-yy45:

-		YYDEBUG(45, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(46, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1713 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-	BEGIN(ST_IN_SCRIPTING);

-	return T_OPEN_TAG_WITH_ECHO;

-}

-#line 1455 "Zend/zend_language_scanner.c"

-yy47:

-		YYDEBUG(47, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy48;

-		if (yych != 'h') goto yy10;

-yy48:

-		YYDEBUG(48, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy49;

-		if (yych != 'p') goto yy10;

-yy49:

-		YYDEBUG(49, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '\f') {

-			if (yych <= 0x08) goto yy10;

-			if (yych >= '\v') goto yy10;

-		} else {

-			if (yych <= '\r') goto yy52;

-			if (yych != ' ') goto yy10;

-		}

-yy50:

-		YYDEBUG(50, *YYCURSOR);

-		++YYCURSOR;

-yy51:

-		YYDEBUG(51, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1731 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-	HANDLE_NEWLINE(yytext[yyleng-1]);

-	BEGIN(ST_IN_SCRIPTING);

-	return T_OPEN_TAG;

-}

-#line 1489 "Zend/zend_language_scanner.c"

-yy52:

-		YYDEBUG(52, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '\n') goto yy50;

-		goto yy51;

-	}

-/* *********************************** */

-yyc_ST_BACKQUOTE:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128,   0,   0,   0,   0,   0,   0, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-		};

-		YYDEBUG(53, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych <= '_') {

-			if (yych != '$') goto yy60;

-		} else {

-			if (yych <= '`') goto yy58;

-			if (yych == '{') goto yy57;

-			goto yy60;

-		}

-		YYDEBUG(55, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '_') {

-			if (yych <= '@') goto yy56;

-			if (yych <= 'Z') goto yy63;

-			if (yych >= '_') goto yy63;

-		} else {

-			if (yych <= 'z') {

-				if (yych >= 'a') goto yy63;

-			} else {

-				if (yych <= '{') goto yy66;

-				if (yych >= 0x7F) goto yy63;

-			}

-		}

-yy56:

-		YYDEBUG(56, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2194 "Zend/zend_language_scanner.l"

-		{

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-	if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {

-		YYCURSOR++;

-	}

-

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '`':

-				break;

-			case '$':

-				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {

-					break;

-				}

-				continue;

-			case '{':

-				if (*YYCURSOR == '$') {

-					break;

-				}

-				continue;

-			case '\\':

-				if (YYCURSOR < YYLIMIT) {

-					YYCURSOR++;

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-

-		YYCURSOR--;

-		break;

-	}

-

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);

-	return T_ENCAPSED_AND_WHITESPACE;

-}

-#line 1601 "Zend/zend_language_scanner.c"

-yy57:

-		YYDEBUG(57, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '$') goto yy61;

-		goto yy56;

-yy58:

-		YYDEBUG(58, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(59, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2138 "Zend/zend_language_scanner.l"

-		{

-	BEGIN(ST_IN_SCRIPTING);

-	return '`';

-}

-#line 1617 "Zend/zend_language_scanner.c"

-yy60:

-		YYDEBUG(60, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy56;

-yy61:

-		YYDEBUG(61, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(62, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2125 "Zend/zend_language_scanner.l"

-		{

-	Z_LVAL_P(zendlval) = (long) '{';

-	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);

-	yyless(1);

-	return T_CURLY_OPEN;

-}

-#line 1634 "Zend/zend_language_scanner.c"

-yy63:

-		YYDEBUG(63, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(64, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy63;

-		}

-		if (yych == '-') goto yy68;

-		if (yych == '[') goto yy70;

-yy65:

-		YYDEBUG(65, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1831 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 1656 "Zend/zend_language_scanner.c"

-yy66:

-		YYDEBUG(66, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(67, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1465 "Zend/zend_language_scanner.l"

-		{

-	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);

-	return T_DOLLAR_OPEN_CURLY_BRACES;

-}

-#line 1667 "Zend/zend_language_scanner.c"

-yy68:

-		YYDEBUG(68, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '>') goto yy72;

-yy69:

-		YYDEBUG(69, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		goto yy65;

-yy70:

-		YYDEBUG(70, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(71, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1823 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 1);

-	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 1689 "Zend/zend_language_scanner.c"

-yy72:

-		YYDEBUG(72, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '_') {

-			if (yych <= '@') goto yy69;

-			if (yych <= 'Z') goto yy73;

-			if (yych <= '^') goto yy69;

-		} else {

-			if (yych <= '`') goto yy69;

-			if (yych <= 'z') goto yy73;

-			if (yych <= '~') goto yy69;

-		}

-yy73:

-		YYDEBUG(73, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(74, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1813 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 3);

-	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 1715 "Zend/zend_language_scanner.c"

-	}

-/* *********************************** */

-yyc_ST_DOUBLE_QUOTES:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128,   0,   0,   0,   0,   0,   0, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-		};

-		YYDEBUG(75, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych <= '#') {

-			if (yych == '"') goto yy80;

-			goto yy82;

-		} else {

-			if (yych <= '$') goto yy77;

-			if (yych == '{') goto yy79;

-			goto yy82;

-		}

-yy77:

-		YYDEBUG(77, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '_') {

-			if (yych <= '@') goto yy78;

-			if (yych <= 'Z') goto yy85;

-			if (yych >= '_') goto yy85;

-		} else {

-			if (yych <= 'z') {

-				if (yych >= 'a') goto yy85;

-			} else {

-				if (yych <= '{') goto yy88;

-				if (yych >= 0x7F) goto yy85;

-			}

-		}

-yy78:

-		YYDEBUG(78, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2144 "Zend/zend_language_scanner.l"

-		{

-	if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {

-		YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;

-		SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);

-

-		goto double_quotes_scan_done;

-	}

-

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-	if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {

-		YYCURSOR++;

-	}

-

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '"':

-				break;

-			case '$':

-				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {

-					break;

-				}

-				continue;

-			case '{':

-				if (*YYCURSOR == '$') {

-					break;

-				}

-				continue;

-			case '\\':

-				if (YYCURSOR < YYLIMIT) {

-					YYCURSOR++;

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-

-		YYCURSOR--;

-		break;

-	}

-

-double_quotes_scan_done:

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);

-	return T_ENCAPSED_AND_WHITESPACE;

-}

-#line 1832 "Zend/zend_language_scanner.c"

-yy79:

-		YYDEBUG(79, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '$') goto yy83;

-		goto yy78;

-yy80:

-		YYDEBUG(80, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(81, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2133 "Zend/zend_language_scanner.l"

-		{

-	BEGIN(ST_IN_SCRIPTING);

-	return '"';

-}

-#line 1848 "Zend/zend_language_scanner.c"

-yy82:

-		YYDEBUG(82, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy78;

-yy83:

-		YYDEBUG(83, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(84, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2125 "Zend/zend_language_scanner.l"

-		{

-	Z_LVAL_P(zendlval) = (long) '{';

-	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);

-	yyless(1);

-	return T_CURLY_OPEN;

-}

-#line 1865 "Zend/zend_language_scanner.c"

-yy85:

-		YYDEBUG(85, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(86, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy85;

-		}

-		if (yych == '-') goto yy90;

-		if (yych == '[') goto yy92;

-yy87:

-		YYDEBUG(87, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1831 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 1887 "Zend/zend_language_scanner.c"

-yy88:

-		YYDEBUG(88, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(89, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1465 "Zend/zend_language_scanner.l"

-		{

-	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);

-	return T_DOLLAR_OPEN_CURLY_BRACES;

-}

-#line 1898 "Zend/zend_language_scanner.c"

-yy90:

-		YYDEBUG(90, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '>') goto yy94;

-yy91:

-		YYDEBUG(91, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		goto yy87;

-yy92:

-		YYDEBUG(92, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(93, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1823 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 1);

-	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 1920 "Zend/zend_language_scanner.c"

-yy94:

-		YYDEBUG(94, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '_') {

-			if (yych <= '@') goto yy91;

-			if (yych <= 'Z') goto yy95;

-			if (yych <= '^') goto yy91;

-		} else {

-			if (yych <= '`') goto yy91;

-			if (yych <= 'z') goto yy95;

-			if (yych <= '~') goto yy91;

-		}

-yy95:

-		YYDEBUG(95, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(96, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1813 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 3);

-	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 1946 "Zend/zend_language_scanner.c"

-	}

-/* *********************************** */

-yyc_ST_END_HEREDOC:

-	YYDEBUG(97, *YYCURSOR);

-	YYFILL(1);

-	yych = *YYCURSOR;

-	YYDEBUG(99, *YYCURSOR);

-	++YYCURSOR;

-	YYDEBUG(100, *YYCURSOR);

-	yyleng = YYCURSOR - SCNG(yy_text);

-#line 2111 "Zend/zend_language_scanner.l"

-	{

-	zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));

-

-	YYCURSOR += heredoc_label->length - 1;

-	yyleng = heredoc_label->length;

-

-	heredoc_label_dtor(heredoc_label);

-	efree(heredoc_label);

-

-	BEGIN(ST_IN_SCRIPTING);

-	return T_END_HEREDOC;

-}

-#line 1970 "Zend/zend_language_scanner.c"

-/* *********************************** */

-yyc_ST_HEREDOC:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128,   0,   0,   0,   0,   0,   0, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-		};

-		YYDEBUG(101, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych == '$') goto yy103;

-		if (yych == '{') goto yy105;

-		goto yy106;

-yy103:

-		YYDEBUG(103, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '_') {

-			if (yych <= '@') goto yy104;

-			if (yych <= 'Z') goto yy109;

-			if (yych >= '_') goto yy109;

-		} else {

-			if (yych <= 'z') {

-				if (yych >= 'a') goto yy109;

-			} else {

-				if (yych <= '{') goto yy112;

-				if (yych >= 0x7F) goto yy109;

-			}

-		}

-yy104:

-		YYDEBUG(104, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2236 "Zend/zend_language_scanner.l"

-		{

-	int newline = 0;

-

-	zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));

-

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-

-	YYCURSOR--;

-

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '\r':

-				if (*YYCURSOR == '\n') {

-					YYCURSOR++;

-				}

-				/* fall through */

-			case '\n':

-				/* Check for ending label on the next line */

-				if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {

-					YYCTYPE *end = YYCURSOR + heredoc_label->length;

-

-					if (*end == ';') {

-						end++;

-					}

-

-					if (*end == '\n' || *end == '\r') {

-						/* newline before label will be subtracted from returned text, but

-						 * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */

-						if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {

-							newline = 2; /* Windows newline */

-						} else {

-							newline = 1;

-						}

-

-						CG(increment_lineno) = 1; /* For newline before label */

-						BEGIN(ST_END_HEREDOC);

-

-						goto heredoc_scan_done;

-					}

-				}

-				continue;

-			case '$':

-				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {

-					break;

-				}

-				continue;

-			case '{':

-				if (*YYCURSOR == '$') {

-					break;

-				}

-				continue;

-			case '\\':

-				if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {

-					YYCURSOR++;

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-

-		YYCURSOR--;

-		break;

-	}

-

-heredoc_scan_done:

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);

-	return T_ENCAPSED_AND_WHITESPACE;

-}

-#line 2105 "Zend/zend_language_scanner.c"

-yy105:

-		YYDEBUG(105, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '$') goto yy107;

-		goto yy104;

-yy106:

-		YYDEBUG(106, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy104;

-yy107:

-		YYDEBUG(107, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(108, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2125 "Zend/zend_language_scanner.l"

-		{

-	Z_LVAL_P(zendlval) = (long) '{';

-	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);

-	yyless(1);

-	return T_CURLY_OPEN;

-}

-#line 2127 "Zend/zend_language_scanner.c"

-yy109:

-		YYDEBUG(109, *YYCURSOR);

-		yyaccept = 0;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(110, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy109;

-		}

-		if (yych == '-') goto yy114;

-		if (yych == '[') goto yy116;

-yy111:

-		YYDEBUG(111, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1831 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 2149 "Zend/zend_language_scanner.c"

-yy112:

-		YYDEBUG(112, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(113, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1465 "Zend/zend_language_scanner.l"

-		{

-	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);

-	return T_DOLLAR_OPEN_CURLY_BRACES;

-}

-#line 2160 "Zend/zend_language_scanner.c"

-yy114:

-		YYDEBUG(114, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '>') goto yy118;

-yy115:

-		YYDEBUG(115, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		goto yy111;

-yy116:

-		YYDEBUG(116, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(117, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1823 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 1);

-	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 2182 "Zend/zend_language_scanner.c"

-yy118:

-		YYDEBUG(118, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '_') {

-			if (yych <= '@') goto yy115;

-			if (yych <= 'Z') goto yy119;

-			if (yych <= '^') goto yy115;

-		} else {

-			if (yych <= '`') goto yy115;

-			if (yych <= 'z') goto yy119;

-			if (yych <= '~') goto yy115;

-		}

-yy119:

-		YYDEBUG(119, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(120, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1813 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 3);

-	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 2208 "Zend/zend_language_scanner.c"

-	}

-/* *********************************** */

-yyc_ST_IN_SCRIPTING:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0, 192,  64,   0,   0,  64,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			192,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			 60,  60,  44,  44,  44,  44,  44,  44, 

-			 44,  44,   0,   0,   0,   0,   0,   0, 

-			  0,  36,  36,  36,  36,  36,  36,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   0,   0,   0,   0,   4, 

-			  0,  36,  36,  36,  36,  36,  36,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   0,   0,   0,   0,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-			  4,   4,   4,   4,   4,   4,   4,   4, 

-		};

-		YYDEBUG(121, *YYCURSOR);

-		YYFILL(16);

-		yych = *YYCURSOR;

-		YYDEBUG(-1, yych);

-		switch (yych) {

-		case 0x00:

-		case 0x01:

-		case 0x02:

-		case 0x03:

-		case 0x04:

-		case 0x05:

-		case 0x06:

-		case 0x07:

-		case 0x08:

-		case '\v':

-		case '\f':

-		case 0x0E:

-		case 0x0F:

-		case 0x10:

-		case 0x11:

-		case 0x12:

-		case 0x13:

-		case 0x14:

-		case 0x15:

-		case 0x16:

-		case 0x17:

-		case 0x18:

-		case 0x19:

-		case 0x1A:

-		case 0x1B:

-		case 0x1C:

-		case 0x1D:

-		case 0x1E:

-		case 0x1F:	goto yy184;

-		case '\t':

-		case '\n':

-		case '\r':

-		case ' ':	goto yy140;

-		case '!':	goto yy154;

-		case '"':	goto yy180;

-		case '#':	goto yy176;

-		case '$':	goto yy165;

-		case '%':	goto yy159;

-		case '&':	goto yy160;

-		case '\'':	goto yy178;

-		case '(':	goto yy148;

-		case ')':

-		case ',':

-		case ';':

-		case '@':

-		case '[':

-		case ']':

-		case '~':	goto yy166;

-		case '*':	goto yy157;

-		case '+':	goto yy153;

-		case '-':	goto yy138;

-		case '.':	goto yy145;

-		case '/':	goto yy158;

-		case '0':	goto yy172;

-		case '1':

-		case '2':

-		case '3':

-		case '4':

-		case '5':

-		case '6':

-		case '7':

-		case '8':

-		case '9':	goto yy174;

-		case ':':	goto yy142;

-		case '<':	goto yy155;

-		case '=':	goto yy151;

-		case '>':	goto yy156;

-		case '?':	goto yy167;

-		case 'A':

-		case 'a':	goto yy133;

-		case 'B':

-		case 'b':	goto yy135;

-		case 'C':

-		case 'c':	goto yy127;

-		case 'D':

-		case 'd':	goto yy125;

-		case 'E':

-		case 'e':	goto yy123;

-		case 'F':

-		case 'f':	goto yy126;

-		case 'G':

-		case 'g':	goto yy136;

-		case 'I':

-		case 'i':	goto yy131;

-		case 'L':

-		case 'l':	goto yy152;

-		case 'N':

-		case 'n':	goto yy146;

-		case 'O':

-		case 'o':	goto yy163;

-		case 'P':

-		case 'p':	goto yy137;

-		case 'R':

-		case 'r':	goto yy128;

-		case 'S':

-		case 's':	goto yy134;

-		case 'T':

-		case 't':	goto yy130;

-		case 'U':

-		case 'u':	goto yy149;

-		case 'V':

-		case 'v':	goto yy147;

-		case 'W':

-		case 'w':	goto yy132;

-		case 'X':

-		case 'x':	goto yy164;

-		case 'Y':

-		case 'y':	goto yy129;

-		case '\\':	goto yy143;

-		case '^':	goto yy162;

-		case '_':	goto yy150;

-		case '`':	goto yy182;

-		case '{':	goto yy168;

-		case '|':	goto yy161;

-		case '}':	goto yy170;

-		default:	goto yy175;

-		}

-yy123:

-		YYDEBUG(123, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(-1, yych);

-		switch ((yych = *YYCURSOR)) {

-		case 'C':

-		case 'c':	goto yy742;

-		case 'L':

-		case 'l':	goto yy743;

-		case 'M':

-		case 'm':	goto yy744;

-		case 'N':

-		case 'n':	goto yy745;

-		case 'V':

-		case 'v':	goto yy746;

-		case 'X':

-		case 'x':	goto yy747;

-		default:	goto yy187;

-		}

-yy124:

-		YYDEBUG(124, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1854 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, yytext, yyleng);

-	zendlval->type = IS_STRING;

-	return T_STRING;

-}

-#line 2397 "Zend/zend_language_scanner.c"

-yy125:

-		YYDEBUG(125, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'O') {

-			if (yych <= 'H') {

-				if (yych == 'E') goto yy724;

-				goto yy187;

-			} else {

-				if (yych <= 'I') goto yy725;

-				if (yych <= 'N') goto yy187;

-				goto yy726;

-			}

-		} else {

-			if (yych <= 'h') {

-				if (yych == 'e') goto yy724;

-				goto yy187;

-			} else {

-				if (yych <= 'i') goto yy725;

-				if (yych == 'o') goto yy726;

-				goto yy187;

-			}

-		}

-yy126:

-		YYDEBUG(126, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'U') {

-			if (yych <= 'N') {

-				if (yych == 'I') goto yy700;

-				goto yy187;

-			} else {

-				if (yych <= 'O') goto yy701;

-				if (yych <= 'T') goto yy187;

-				goto yy702;

-			}

-		} else {

-			if (yych <= 'n') {

-				if (yych == 'i') goto yy700;

-				goto yy187;

-			} else {

-				if (yych <= 'o') goto yy701;

-				if (yych == 'u') goto yy702;

-				goto yy187;

-			}

-		}

-yy127:

-		YYDEBUG(127, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'O') {

-			if (yych <= 'K') {

-				if (yych == 'A') goto yy665;

-				goto yy187;

-			} else {

-				if (yych <= 'L') goto yy666;

-				if (yych <= 'N') goto yy187;

-				goto yy667;

-			}

-		} else {

-			if (yych <= 'k') {

-				if (yych == 'a') goto yy665;

-				goto yy187;

-			} else {

-				if (yych <= 'l') goto yy666;

-				if (yych == 'o') goto yy667;

-				goto yy187;

-			}

-		}

-yy128:

-		YYDEBUG(128, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy647;

-		if (yych == 'e') goto yy647;

-		goto yy187;

-yy129:

-		YYDEBUG(129, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy642;

-		if (yych == 'i') goto yy642;

-		goto yy187;

-yy130:

-		YYDEBUG(130, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'R') {

-			if (yych == 'H') goto yy630;

-			if (yych <= 'Q') goto yy187;

-			goto yy631;

-		} else {

-			if (yych <= 'h') {

-				if (yych <= 'g') goto yy187;

-				goto yy630;

-			} else {

-				if (yych == 'r') goto yy631;

-				goto yy187;

-			}

-		}

-yy131:

-		YYDEBUG(131, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'S') {

-			if (yych <= 'L') {

-				if (yych == 'F') goto yy577;

-				goto yy187;

-			} else {

-				if (yych <= 'M') goto yy579;

-				if (yych <= 'N') goto yy580;

-				if (yych <= 'R') goto yy187;

-				goto yy581;

-			}

-		} else {

-			if (yych <= 'm') {

-				if (yych == 'f') goto yy577;

-				if (yych <= 'l') goto yy187;

-				goto yy579;

-			} else {

-				if (yych <= 'n') goto yy580;

-				if (yych == 's') goto yy581;

-				goto yy187;

-			}

-		}

-yy132:

-		YYDEBUG(132, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy572;

-		if (yych == 'h') goto yy572;

-		goto yy187;

-yy133:

-		YYDEBUG(133, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'S') {

-			if (yych <= 'M') {

-				if (yych == 'B') goto yy554;

-				goto yy187;

-			} else {

-				if (yych <= 'N') goto yy555;

-				if (yych <= 'Q') goto yy187;

-				if (yych <= 'R') goto yy556;

-				goto yy557;

-			}

-		} else {

-			if (yych <= 'n') {

-				if (yych == 'b') goto yy554;

-				if (yych <= 'm') goto yy187;

-				goto yy555;

-			} else {

-				if (yych <= 'q') goto yy187;

-				if (yych <= 'r') goto yy556;

-				if (yych <= 's') goto yy557;

-				goto yy187;

-			}

-		}

-yy134:

-		YYDEBUG(134, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'W') {

-			if (yych == 'T') goto yy542;

-			if (yych <= 'V') goto yy187;

-			goto yy543;

-		} else {

-			if (yych <= 't') {

-				if (yych <= 's') goto yy187;

-				goto yy542;

-			} else {

-				if (yych == 'w') goto yy543;

-				goto yy187;

-			}

-		}

-yy135:

-		YYDEBUG(135, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= ';') {

-			if (yych <= '"') {

-				if (yych <= '!') goto yy187;

-				goto yy534;

-			} else {

-				if (yych == '\'') goto yy535;

-				goto yy187;

-			}

-		} else {

-			if (yych <= 'R') {

-				if (yych <= '<') goto yy533;

-				if (yych <= 'Q') goto yy187;

-				goto yy536;

-			} else {

-				if (yych == 'r') goto yy536;

-				goto yy187;

-			}

-		}

-yy136:

-		YYDEBUG(136, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'O') {

-			if (yych == 'L') goto yy523;

-			if (yych <= 'N') goto yy187;

-			goto yy524;

-		} else {

-			if (yych <= 'l') {

-				if (yych <= 'k') goto yy187;

-				goto yy523;

-			} else {

-				if (yych == 'o') goto yy524;

-				goto yy187;

-			}

-		}

-yy137:

-		YYDEBUG(137, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'U') {

-			if (yych == 'R') goto yy499;

-			if (yych <= 'T') goto yy187;

-			goto yy500;

-		} else {

-			if (yych <= 'r') {

-				if (yych <= 'q') goto yy187;

-				goto yy499;

-			} else {

-				if (yych == 'u') goto yy500;

-				goto yy187;

-			}

-		}

-yy138:

-		YYDEBUG(138, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '<') {

-			if (yych == '-') goto yy495;

-		} else {

-			if (yych <= '=') goto yy493;

-			if (yych <= '>') goto yy497;

-		}

-yy139:

-		YYDEBUG(139, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1454 "Zend/zend_language_scanner.l"

-		{

-	return yytext[0];

-}

-#line 2633 "Zend/zend_language_scanner.c"

-yy140:

-		YYDEBUG(140, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy492;

-yy141:

-		YYDEBUG(141, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1175 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-	HANDLE_NEWLINES(yytext, yyleng);

-	return T_WHITESPACE;

-}

-#line 2648 "Zend/zend_language_scanner.c"

-yy142:

-		YYDEBUG(142, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == ':') goto yy489;

-		goto yy139;

-yy143:

-		YYDEBUG(143, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(144, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1202 "Zend/zend_language_scanner.l"

-		{

-	return T_NS_SEPARATOR;

-}

-#line 2663 "Zend/zend_language_scanner.c"

-yy145:

-		YYDEBUG(145, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '/') {

-			if (yych == '.') goto yy486;

-			goto yy139;

-		} else {

-			if (yych <= '9') goto yy482;

-			if (yych == '=') goto yy484;

-			goto yy139;

-		}

-yy146:

-		YYDEBUG(146, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'E') {

-			if (yych == 'A') goto yy470;

-			if (yych <= 'D') goto yy187;

-			goto yy471;

-		} else {

-			if (yych <= 'a') {

-				if (yych <= '`') goto yy187;

-				goto yy470;

-			} else {

-				if (yych == 'e') goto yy471;

-				goto yy187;

-			}

-		}

-yy147:

-		YYDEBUG(147, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy467;

-		if (yych == 'a') goto yy467;

-		goto yy187;

-yy148:

-		YYDEBUG(148, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 'S') {

-			if (yych <= 'D') {

-				if (yych <= ' ') {

-					if (yych == '\t') goto yy392;

-					if (yych <= 0x1F) goto yy139;

-					goto yy392;

-				} else {

-					if (yych <= '@') goto yy139;

-					if (yych == 'C') goto yy139;

-					goto yy392;

-				}

-			} else {

-				if (yych <= 'I') {

-					if (yych == 'F') goto yy392;

-					if (yych <= 'H') goto yy139;

-					goto yy392;

-				} else {

-					if (yych == 'O') goto yy392;

-					if (yych <= 'Q') goto yy139;

-					goto yy392;

-				}

-			}

-		} else {

-			if (yych <= 'f') {

-				if (yych <= 'b') {

-					if (yych == 'U') goto yy392;

-					if (yych <= '`') goto yy139;

-					goto yy392;

-				} else {

-					if (yych == 'd') goto yy392;

-					if (yych <= 'e') goto yy139;

-					goto yy392;

-				}

-			} else {

-				if (yych <= 'o') {

-					if (yych == 'i') goto yy392;

-					if (yych <= 'n') goto yy139;

-					goto yy392;

-				} else {

-					if (yych <= 's') {

-						if (yych <= 'q') goto yy139;

-						goto yy392;

-					} else {

-						if (yych == 'u') goto yy392;

-						goto yy139;

-					}

-				}

-			}

-		}

-yy149:

-		YYDEBUG(149, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'S') {

-			if (yych == 'N') goto yy383;

-			if (yych <= 'R') goto yy187;

-			goto yy384;

-		} else {

-			if (yych <= 'n') {

-				if (yych <= 'm') goto yy187;

-				goto yy383;

-			} else {

-				if (yych == 's') goto yy384;

-				goto yy187;

-			}

-		}

-yy150:

-		YYDEBUG(150, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '_') goto yy301;

-		goto yy187;

-yy151:

-		YYDEBUG(151, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '<') goto yy139;

-		if (yych <= '=') goto yy295;

-		if (yych <= '>') goto yy297;

-		goto yy139;

-yy152:

-		YYDEBUG(152, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy291;

-		if (yych == 'i') goto yy291;

-		goto yy187;

-yy153:

-		YYDEBUG(153, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '+') goto yy289;

-		if (yych == '=') goto yy287;

-		goto yy139;

-yy154:

-		YYDEBUG(154, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '=') goto yy284;

-		goto yy139;

-yy155:

-		YYDEBUG(155, *YYCURSOR);

-		yyaccept = 1;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= ';') {

-			if (yych == '/') goto yy256;

-			goto yy139;

-		} else {

-			if (yych <= '<') goto yy254;

-			if (yych <= '=') goto yy257;

-			if (yych <= '>') goto yy259;

-			goto yy139;

-		}

-yy156:

-		YYDEBUG(156, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '<') goto yy139;

-		if (yych <= '=') goto yy250;

-		if (yych <= '>') goto yy248;

-		goto yy139;

-yy157:

-		YYDEBUG(157, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '*') goto yy242;

-		if (yych == '=') goto yy244;

-		goto yy139;

-yy158:

-		YYDEBUG(158, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '.') {

-			if (yych == '*') goto yy234;

-			goto yy139;

-		} else {

-			if (yych <= '/') goto yy236;

-			if (yych == '=') goto yy237;

-			goto yy139;

-		}

-yy159:

-		YYDEBUG(159, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '<') goto yy139;

-		if (yych <= '=') goto yy230;

-		if (yych <= '>') goto yy228;

-		goto yy139;

-yy160:

-		YYDEBUG(160, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '&') goto yy224;

-		if (yych == '=') goto yy226;

-		goto yy139;

-yy161:

-		YYDEBUG(161, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '=') goto yy222;

-		if (yych == '|') goto yy220;

-		goto yy139;

-yy162:

-		YYDEBUG(162, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '=') goto yy218;

-		goto yy139;

-yy163:

-		YYDEBUG(163, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy216;

-		if (yych == 'r') goto yy216;

-		goto yy187;

-yy164:

-		YYDEBUG(164, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy213;

-		if (yych == 'o') goto yy213;

-		goto yy187;

-yy165:

-		YYDEBUG(165, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '_') {

-			if (yych <= '@') goto yy139;

-			if (yych <= 'Z') goto yy210;

-			if (yych <= '^') goto yy139;

-			goto yy210;

-		} else {

-			if (yych <= '`') goto yy139;

-			if (yych <= 'z') goto yy210;

-			if (yych <= '~') goto yy139;

-			goto yy210;

-		}

-yy166:

-		YYDEBUG(166, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy139;

-yy167:

-		YYDEBUG(167, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '>') goto yy206;

-		goto yy139;

-yy168:

-		YYDEBUG(168, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(169, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1459 "Zend/zend_language_scanner.l"

-		{

-	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);

-	return '{';

-}

-#line 2902 "Zend/zend_language_scanner.c"

-yy170:

-		YYDEBUG(170, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(171, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1471 "Zend/zend_language_scanner.l"

-		{

-	RESET_DOC_COMMENT();

-	if (!zend_stack_is_empty(&SCNG(state_stack))) {

-		yy_pop_state(TSRMLS_C);

-	}

-	return '}';

-}

-#line 2916 "Zend/zend_language_scanner.c"

-yy172:

-		YYDEBUG(172, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 'E') {

-			if (yych <= '9') {

-				if (yych == '.') goto yy188;

-				if (yych >= '0') goto yy191;

-			} else {

-				if (yych == 'B') goto yy199;

-				if (yych >= 'E') goto yy193;

-			}

-		} else {

-			if (yych <= 'b') {

-				if (yych == 'X') goto yy198;

-				if (yych >= 'b') goto yy199;

-			} else {

-				if (yych <= 'e') {

-					if (yych >= 'e') goto yy193;

-				} else {

-					if (yych == 'x') goto yy198;

-				}

-			}

-		}

-yy173:

-		YYDEBUG(173, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1521 "Zend/zend_language_scanner.l"

-		{

-	if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */

-		Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);

-	} else {

-		errno = 0;

-		Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);

-		if (errno == ERANGE) { /* Overflow */

-			if (yytext[0] == '0') { /* octal overflow */

-				Z_DVAL_P(zendlval) = zend_oct_strtod(yytext, NULL);

-			} else {

-				Z_DVAL_P(zendlval) = zend_strtod(yytext, NULL);

-			}

-			zendlval->type = IS_DOUBLE;

-			return T_DNUMBER;

-		}

-	}

-

-	zendlval->type = IS_LONG;

-	return T_LNUMBER;

-}

-#line 2965 "Zend/zend_language_scanner.c"

-yy174:

-		YYDEBUG(174, *YYCURSOR);

-		yyaccept = 2;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '9') {

-			if (yych == '.') goto yy188;

-			if (yych <= '/') goto yy173;

-			goto yy191;

-		} else {

-			if (yych <= 'E') {

-				if (yych <= 'D') goto yy173;

-				goto yy193;

-			} else {

-				if (yych == 'e') goto yy193;

-				goto yy173;

-			}

-		}

-yy175:

-		YYDEBUG(175, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy187;

-yy176:

-		YYDEBUG(176, *YYCURSOR);

-		++YYCURSOR;

-yy177:

-		YYDEBUG(177, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1861 "Zend/zend_language_scanner.l"

-		{

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '\r':

-				if (*YYCURSOR == '\n') {

-					YYCURSOR++;

-				}

-				/* fall through */

-			case '\n':

-				CG(zend_lineno)++;

-				break;

-			case '%':

-				if (!CG(asp_tags)) {

-					continue;

-				}

-				/* fall through */

-			case '?':

-				if (*YYCURSOR == '>') {

-					YYCURSOR--;

-					break;

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-

-		break;

-	}

-

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	return T_COMMENT;

-}

-#line 3027 "Zend/zend_language_scanner.c"

-yy178:

-		YYDEBUG(178, *YYCURSOR);

-		++YYCURSOR;

-yy179:

-		YYDEBUG(179, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1948 "Zend/zend_language_scanner.l"

-		{

-	register char *s, *t;

-	char *end;

-	int bprefix = (yytext[0] != '\'') ? 1 : 0;

-

-	while (1) {

-		if (YYCURSOR < YYLIMIT) {

-			if (*YYCURSOR == '\'') {

-				YYCURSOR++;

-				yyleng = YYCURSOR - SCNG(yy_text);

-

-				break;

-			} else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {

-				YYCURSOR++;

-			}

-		} else {

-			yyleng = YYLIMIT - SCNG(yy_text);

-

-			/* Unclosed single quotes; treat similar to double quotes, but without a separate token

-			 * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."

-			 * rule, which continued in ST_IN_SCRIPTING state after the quote */

-			return T_ENCAPSED_AND_WHITESPACE;

-		}

-	}

-

-	ZVAL_STRINGL(zendlval, yytext+bprefix+1, yyleng-bprefix-2, 1);

-

-	/* convert escape sequences */

-	s = t = Z_STRVAL_P(zendlval);

-	end = s+Z_STRLEN_P(zendlval);

-	while (s<end) {

-		if (*s=='\\') {

-			s++;

-

-			switch(*s) {

-				case '\\':

-				case '\'':

-					*t++ = *s;

-					Z_STRLEN_P(zendlval)--;

-					break;

-				default:

-					*t++ = '\\';

-					*t++ = *s;

-					break;

-			}

-		} else {

-			*t++ = *s;

-		}

-

-		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {

-			CG(zend_lineno)++;

-		}

-		s++;

-	}

-	*t = 0;

-

-	if (SCNG(output_filter)) {

-		size_t sz = 0;

-		s = Z_STRVAL_P(zendlval);

-		SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);

-		Z_STRLEN_P(zendlval) = sz;

-		efree(s);

-	}

-	return T_CONSTANT_ENCAPSED_STRING;

-}

-#line 3100 "Zend/zend_language_scanner.c"

-yy180:

-		YYDEBUG(180, *YYCURSOR);

-		++YYCURSOR;

-yy181:

-		YYDEBUG(181, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2015 "Zend/zend_language_scanner.l"

-		{

-	int bprefix = (yytext[0] != '"') ? 1 : 0;

-

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '"':

-				yyleng = YYCURSOR - SCNG(yy_text);

-				zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"' TSRMLS_CC);

-				return T_CONSTANT_ENCAPSED_STRING;

-			case '$':

-				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {

-					break;

-				}

-				continue;

-			case '{':

-				if (*YYCURSOR == '$') {

-					break;

-				}

-				continue;

-			case '\\':

-				if (YYCURSOR < YYLIMIT) {

-					YYCURSOR++;

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-

-		YYCURSOR--;

-		break;

-	}

-

-	/* Remember how much was scanned to save rescanning */

-	SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);

-

-	YYCURSOR = SCNG(yy_text) + yyleng;

-

-	BEGIN(ST_DOUBLE_QUOTES);

-	return '"';

-}

-#line 3148 "Zend/zend_language_scanner.c"

-yy182:

-		YYDEBUG(182, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(183, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2105 "Zend/zend_language_scanner.l"

-		{

-	BEGIN(ST_BACKQUOTE);

-	return '`';

-}

-#line 3159 "Zend/zend_language_scanner.c"

-yy184:

-		YYDEBUG(184, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(185, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2368 "Zend/zend_language_scanner.l"

-		{

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-

-	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);

-	goto restart;

-}

-#line 3174 "Zend/zend_language_scanner.c"

-yy186:

-		YYDEBUG(186, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy187:

-		YYDEBUG(187, *YYCURSOR);

-		if (yybm[0+yych] & 4) {

-			goto yy186;

-		}

-		goto yy124;

-yy188:

-		YYDEBUG(188, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(189, *YYCURSOR);

-		if (yybm[0+yych] & 8) {

-			goto yy188;

-		}

-		if (yych == 'E') goto yy193;

-		if (yych == 'e') goto yy193;

-yy190:

-		YYDEBUG(190, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1580 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));

-	return T_DNUMBER;

-}

-#line 3206 "Zend/zend_language_scanner.c"

-yy191:

-		YYDEBUG(191, *YYCURSOR);

-		yyaccept = 2;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(192, *YYCURSOR);

-		if (yych <= '9') {

-			if (yych == '.') goto yy188;

-			if (yych <= '/') goto yy173;

-			goto yy191;

-		} else {

-			if (yych <= 'E') {

-				if (yych <= 'D') goto yy173;

-			} else {

-				if (yych != 'e') goto yy173;

-			}

-		}

-yy193:

-		YYDEBUG(193, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= ',') {

-			if (yych == '+') goto yy195;

-		} else {

-			if (yych <= '-') goto yy195;

-			if (yych <= '/') goto yy194;

-			if (yych <= '9') goto yy196;

-		}

-yy194:

-		YYDEBUG(194, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		if (yyaccept <= 2) {

-			if (yyaccept <= 1) {

-				if (yyaccept <= 0) {

-					goto yy124;

-				} else {

-					goto yy139;

-				}

-			} else {

-				goto yy173;

-			}

-		} else {

-			if (yyaccept <= 4) {

-				if (yyaccept <= 3) {

-					goto yy190;

-				} else {

-					goto yy235;

-				}

-			} else {

-				goto yy255;

-			}

-		}

-yy195:

-		YYDEBUG(195, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= '/') goto yy194;

-		if (yych >= ':') goto yy194;

-yy196:

-		YYDEBUG(196, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(197, *YYCURSOR);

-		if (yych <= '/') goto yy190;

-		if (yych <= '9') goto yy196;

-		goto yy190;

-yy198:

-		YYDEBUG(198, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yybm[0+yych] & 32) {

-			goto yy203;

-		}

-		goto yy194;

-yy199:

-		YYDEBUG(199, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yybm[0+yych] & 16) {

-			goto yy200;

-		}

-		goto yy194;

-yy200:

-		YYDEBUG(200, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(201, *YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy200;

-		}

-		YYDEBUG(202, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1497 "Zend/zend_language_scanner.l"

-		{

-	char *bin = yytext + 2; /* Skip "0b" */

-	int len = yyleng - 2;

-

-	/* Skip any leading 0s */

-	while (*bin == '0') {

-		++bin;

-		--len;

-	}

-

-	if (len < SIZEOF_LONG * 8) {

-		if (len == 0) {

-			Z_LVAL_P(zendlval) = 0;

-		} else {

-			Z_LVAL_P(zendlval) = strtol(bin, NULL, 2);

-		}

-		zendlval->type = IS_LONG;

-		return T_LNUMBER;

-	} else {

-		ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, NULL));

-		return T_DNUMBER;

-	}

-}

-#line 3322 "Zend/zend_language_scanner.c"

-yy203:

-		YYDEBUG(203, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(204, *YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy203;

-		}

-		YYDEBUG(205, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1542 "Zend/zend_language_scanner.l"

-		{

-	char *hex = yytext + 2; /* Skip "0x" */

-	int len = yyleng - 2;

-

-	/* Skip any leading 0s */

-	while (*hex == '0') {

-		hex++;

-		len--;

-	}

-

-	if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {

-		if (len == 0) {

-			Z_LVAL_P(zendlval) = 0;

-		} else {

-			Z_LVAL_P(zendlval) = strtol(hex, NULL, 16);

-		}

-		zendlval->type = IS_LONG;

-		return T_LNUMBER;

-	} else {

-		ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, NULL));

-		return T_DNUMBER;

-	}

-}

-#line 3358 "Zend/zend_language_scanner.c"

-yy206:

-		YYDEBUG(206, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '\n') goto yy208;

-		if (yych == '\r') goto yy209;

-yy207:

-		YYDEBUG(207, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1929 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-	BEGIN(INITIAL);

-	return T_CLOSE_TAG;  /* implicit ';' at php-end tag */

-}

-#line 3373 "Zend/zend_language_scanner.c"

-yy208:

-		YYDEBUG(208, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy207;

-yy209:

-		YYDEBUG(209, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy208;

-		goto yy207;

-yy210:

-		YYDEBUG(210, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(211, *YYCURSOR);

-		if (yych <= '^') {

-			if (yych <= '9') {

-				if (yych >= '0') goto yy210;

-			} else {

-				if (yych <= '@') goto yy212;

-				if (yych <= 'Z') goto yy210;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= '_') goto yy210;

-			} else {

-				if (yych <= 'z') goto yy210;

-				if (yych >= 0x7F) goto yy210;

-			}

-		}

-yy212:

-		YYDEBUG(212, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1831 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 3413 "Zend/zend_language_scanner.c"

-yy213:

-		YYDEBUG(213, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy214;

-		if (yych != 'r') goto yy187;

-yy214:

-		YYDEBUG(214, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(215, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1442 "Zend/zend_language_scanner.l"

-		{

-	return T_LOGICAL_XOR;

-}

-#line 3431 "Zend/zend_language_scanner.c"

-yy216:

-		YYDEBUG(216, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(217, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1434 "Zend/zend_language_scanner.l"

-		{

-	return T_LOGICAL_OR;

-}

-#line 3444 "Zend/zend_language_scanner.c"

-yy218:

-		YYDEBUG(218, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(219, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1422 "Zend/zend_language_scanner.l"

-		{

-	return T_XOR_EQUAL;

-}

-#line 3454 "Zend/zend_language_scanner.c"

-yy220:

-		YYDEBUG(220, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(221, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1426 "Zend/zend_language_scanner.l"

-		{

-	return T_BOOLEAN_OR;

-}

-#line 3464 "Zend/zend_language_scanner.c"

-yy222:

-		YYDEBUG(222, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(223, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1418 "Zend/zend_language_scanner.l"

-		{

-	return T_OR_EQUAL;

-}

-#line 3474 "Zend/zend_language_scanner.c"

-yy224:

-		YYDEBUG(224, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(225, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1430 "Zend/zend_language_scanner.l"

-		{

-	return T_BOOLEAN_AND;

-}

-#line 3484 "Zend/zend_language_scanner.c"

-yy226:

-		YYDEBUG(226, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(227, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1414 "Zend/zend_language_scanner.l"

-		{

-	return T_AND_EQUAL;

-}

-#line 3494 "Zend/zend_language_scanner.c"

-yy228:

-		YYDEBUG(228, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '\n') goto yy232;

-		if (yych == '\r') goto yy233;

-yy229:

-		YYDEBUG(229, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1936 "Zend/zend_language_scanner.l"

-		{

-	if (CG(asp_tags)) {

-		BEGIN(INITIAL);

-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */

-	} else {

-		yyless(1);

-		return yytext[0];

-	}

-}

-#line 3514 "Zend/zend_language_scanner.c"

-yy230:

-		YYDEBUG(230, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(231, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1402 "Zend/zend_language_scanner.l"

-		{

-	return T_MOD_EQUAL;

-}

-#line 3524 "Zend/zend_language_scanner.c"

-yy232:

-		YYDEBUG(232, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy229;

-yy233:

-		YYDEBUG(233, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy232;

-		goto yy229;

-yy234:

-		YYDEBUG(234, *YYCURSOR);

-		yyaccept = 4;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych == '*') goto yy239;

-yy235:

-		YYDEBUG(235, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1895 "Zend/zend_language_scanner.l"

-		{

-	int doc_com;

-

-	if (yyleng > 2) {

-		doc_com = 1;

-		RESET_DOC_COMMENT();

-	} else {

-		doc_com = 0;

-	}

-

-	while (YYCURSOR < YYLIMIT) {

-		if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {

-			break;

-		}

-	}

-

-	if (YYCURSOR < YYLIMIT) {

-		YYCURSOR++;

-	} else {

-		zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));

-	}

-

-	yyleng = YYCURSOR - SCNG(yy_text);

-	HANDLE_NEWLINES(yytext, yyleng);

-

-	if (doc_com) {

-		CG(doc_comment) = estrndup(yytext, yyleng);

-		CG(doc_comment_len) = yyleng;

-		return T_DOC_COMMENT;

-	}

-

-	return T_COMMENT;

-}

-#line 3576 "Zend/zend_language_scanner.c"

-yy236:

-		YYDEBUG(236, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy177;

-yy237:

-		YYDEBUG(237, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(238, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1394 "Zend/zend_language_scanner.l"

-		{

-	return T_DIV_EQUAL;

-}

-#line 3590 "Zend/zend_language_scanner.c"

-yy239:

-		YYDEBUG(239, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yybm[0+yych] & 64) {

-			goto yy240;

-		}

-		goto yy194;

-yy240:

-		YYDEBUG(240, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(241, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy240;

-		}

-		goto yy235;

-yy242:

-		YYDEBUG(242, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '=') goto yy246;

-		YYDEBUG(243, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1386 "Zend/zend_language_scanner.l"

-		{

-	return T_POW;

-}

-#line 3618 "Zend/zend_language_scanner.c"

-yy244:

-		YYDEBUG(244, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(245, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1382 "Zend/zend_language_scanner.l"

-		{

-	return T_MUL_EQUAL;

-}

-#line 3628 "Zend/zend_language_scanner.c"

-yy246:

-		YYDEBUG(246, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(247, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1390 "Zend/zend_language_scanner.l"

-		{

-	return T_POW_EQUAL;

-}

-#line 3638 "Zend/zend_language_scanner.c"

-yy248:

-		YYDEBUG(248, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '=') goto yy252;

-		YYDEBUG(249, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1450 "Zend/zend_language_scanner.l"

-		{

-	return T_SR;

-}

-#line 3649 "Zend/zend_language_scanner.c"

-yy250:

-		YYDEBUG(250, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(251, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1370 "Zend/zend_language_scanner.l"

-		{

-	return T_IS_GREATER_OR_EQUAL;

-}

-#line 3659 "Zend/zend_language_scanner.c"

-yy252:

-		YYDEBUG(252, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(253, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1410 "Zend/zend_language_scanner.l"

-		{

-	return T_SR_EQUAL;

-}

-#line 3669 "Zend/zend_language_scanner.c"

-yy254:

-		YYDEBUG(254, *YYCURSOR);

-		yyaccept = 5;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= ';') goto yy255;

-		if (yych <= '<') goto yy270;

-		if (yych <= '=') goto yy268;

-yy255:

-		YYDEBUG(255, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1446 "Zend/zend_language_scanner.l"

-		{

-	return T_SL;

-}

-#line 3684 "Zend/zend_language_scanner.c"

-yy256:

-		YYDEBUG(256, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy261;

-		if (yych == 's') goto yy261;

-		goto yy194;

-yy257:

-		YYDEBUG(257, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(258, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1366 "Zend/zend_language_scanner.l"

-		{

-	return T_IS_SMALLER_OR_EQUAL;

-}

-#line 3700 "Zend/zend_language_scanner.c"

-yy259:

-		YYDEBUG(259, *YYCURSOR);

-		++YYCURSOR;

-yy260:

-		YYDEBUG(260, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1362 "Zend/zend_language_scanner.l"

-		{

-	return T_IS_NOT_EQUAL;

-}

-#line 3711 "Zend/zend_language_scanner.c"

-yy261:

-		YYDEBUG(261, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy262;

-		if (yych != 'c') goto yy194;

-yy262:

-		YYDEBUG(262, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy263;

-		if (yych != 'r') goto yy194;

-yy263:

-		YYDEBUG(263, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy264;

-		if (yych != 'i') goto yy194;

-yy264:

-		YYDEBUG(264, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy265;

-		if (yych != 'p') goto yy194;

-yy265:

-		YYDEBUG(265, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy266;

-		if (yych != 't') goto yy194;

-yy266:

-		YYDEBUG(266, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(267, *YYCURSOR);

-		if (yych <= '\r') {

-			if (yych <= 0x08) goto yy194;

-			if (yych <= '\n') goto yy266;

-			if (yych <= '\f') goto yy194;

-			goto yy266;

-		} else {

-			if (yych <= ' ') {

-				if (yych <= 0x1F) goto yy194;

-				goto yy266;

-			} else {

-				if (yych == '>') goto yy206;

-				goto yy194;

-			}

-		}

-yy268:

-		YYDEBUG(268, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(269, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1406 "Zend/zend_language_scanner.l"

-		{

-	return T_SL_EQUAL;

-}

-#line 3766 "Zend/zend_language_scanner.c"

-yy270:

-		YYDEBUG(270, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-		YYDEBUG(271, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy270;

-		}

-		if (yych <= 'Z') {

-			if (yych <= '&') {

-				if (yych == '"') goto yy275;

-				goto yy194;

-			} else {

-				if (yych <= '\'') goto yy274;

-				if (yych <= '@') goto yy194;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych != '_') goto yy194;

-			} else {

-				if (yych <= 'z') goto yy272;

-				if (yych <= '~') goto yy194;

-			}

-		}

-yy272:

-		YYDEBUG(272, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(2);

-		yych = *YYCURSOR;

-		YYDEBUG(273, *YYCURSOR);

-		if (yych <= '@') {

-			if (yych <= '\f') {

-				if (yych == '\n') goto yy279;

-				goto yy194;

-			} else {

-				if (yych <= '\r') goto yy281;

-				if (yych <= '/') goto yy194;

-				if (yych <= '9') goto yy272;

-				goto yy194;

-			}

-		} else {

-			if (yych <= '_') {

-				if (yych <= 'Z') goto yy272;

-				if (yych <= '^') goto yy194;

-				goto yy272;

-			} else {

-				if (yych <= '`') goto yy194;

-				if (yych <= 'z') goto yy272;

-				if (yych <= '~') goto yy194;

-				goto yy272;

-			}

-		}

-yy274:

-		YYDEBUG(274, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\'') goto yy194;

-		if (yych <= '/') goto yy283;

-		if (yych <= '9') goto yy194;

-		goto yy283;

-yy275:

-		YYDEBUG(275, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '"') goto yy194;

-		if (yych <= '/') goto yy277;

-		if (yych <= '9') goto yy194;

-		goto yy277;

-yy276:

-		YYDEBUG(276, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-yy277:

-		YYDEBUG(277, *YYCURSOR);

-		if (yych <= 'Z') {

-			if (yych <= '/') {

-				if (yych != '"') goto yy194;

-			} else {

-				if (yych <= '9') goto yy276;

-				if (yych <= '@') goto yy194;

-				goto yy276;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych == '_') goto yy276;

-				goto yy194;

-			} else {

-				if (yych <= 'z') goto yy276;

-				if (yych <= '~') goto yy194;

-				goto yy276;

-			}

-		}

-yy278:

-		YYDEBUG(278, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy279;

-		if (yych == '\r') goto yy281;

-		goto yy194;

-yy279:

-		YYDEBUG(279, *YYCURSOR);

-		++YYCURSOR;

-yy280:

-		YYDEBUG(280, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2057 "Zend/zend_language_scanner.l"

-		{

-	char *s;

-	int bprefix = (yytext[0] != '<') ? 1 : 0;

-	zend_heredoc_label *heredoc_label = emalloc(sizeof(zend_heredoc_label));

-

-	CG(zend_lineno)++;

-	heredoc_label->length = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);

-	s = yytext+bprefix+3;

-	while ((*s == ' ') || (*s == '\t')) {

-		s++;

-		heredoc_label->length--;

-	}

-

-	if (*s == '\'') {

-		s++;

-		heredoc_label->length -= 2;

-

-		BEGIN(ST_NOWDOC);

-	} else {

-		if (*s == '"') {

-			s++;

-			heredoc_label->length -= 2;

-		}

-

-		BEGIN(ST_HEREDOC);

-	}

-

-	heredoc_label->label = estrndup(s, heredoc_label->length);

-

-	/* Check for ending label on the next line */

-	if (heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, heredoc_label->length)) {

-		YYCTYPE *end = YYCURSOR + heredoc_label->length;

-

-		if (*end == ';') {

-			end++;

-		}

-

-		if (*end == '\n' || *end == '\r') {

-			BEGIN(ST_END_HEREDOC);

-		}

-	}

-

-	zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) heredoc_label);

-

-	return T_START_HEREDOC;

-}

-#line 3918 "Zend/zend_language_scanner.c"

-yy281:

-		YYDEBUG(281, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '\n') goto yy279;

-		goto yy280;

-yy282:

-		YYDEBUG(282, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-yy283:

-		YYDEBUG(283, *YYCURSOR);

-		if (yych <= 'Z') {

-			if (yych <= '/') {

-				if (yych == '\'') goto yy278;

-				goto yy194;

-			} else {

-				if (yych <= '9') goto yy282;

-				if (yych <= '@') goto yy194;

-				goto yy282;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych == '_') goto yy282;

-				goto yy194;

-			} else {

-				if (yych <= 'z') goto yy282;

-				if (yych <= '~') goto yy194;

-				goto yy282;

-			}

-		}

-yy284:

-		YYDEBUG(284, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '=') goto yy260;

-		YYDEBUG(285, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(286, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1354 "Zend/zend_language_scanner.l"

-		{

-	return T_IS_NOT_IDENTICAL;

-}

-#line 3962 "Zend/zend_language_scanner.c"

-yy287:

-		YYDEBUG(287, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(288, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1374 "Zend/zend_language_scanner.l"

-		{

-	return T_PLUS_EQUAL;

-}

-#line 3972 "Zend/zend_language_scanner.c"

-yy289:

-		YYDEBUG(289, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(290, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1342 "Zend/zend_language_scanner.l"

-		{

-	return T_INC;

-}

-#line 3982 "Zend/zend_language_scanner.c"

-yy291:

-		YYDEBUG(291, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy292;

-		if (yych != 's') goto yy187;

-yy292:

-		YYDEBUG(292, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy293;

-		if (yych != 't') goto yy187;

-yy293:

-		YYDEBUG(293, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(294, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1330 "Zend/zend_language_scanner.l"

-		{

-	return T_LIST;

-}

-#line 4005 "Zend/zend_language_scanner.c"

-yy295:

-		YYDEBUG(295, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '=') goto yy299;

-		YYDEBUG(296, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1358 "Zend/zend_language_scanner.l"

-		{

-	return T_IS_EQUAL;

-}

-#line 4016 "Zend/zend_language_scanner.c"

-yy297:

-		YYDEBUG(297, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(298, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1326 "Zend/zend_language_scanner.l"

-		{

-	return T_DOUBLE_ARROW;

-}

-#line 4026 "Zend/zend_language_scanner.c"

-yy299:

-		YYDEBUG(299, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(300, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1350 "Zend/zend_language_scanner.l"

-		{

-	return T_IS_IDENTICAL;

-}

-#line 4036 "Zend/zend_language_scanner.c"

-yy301:

-		YYDEBUG(301, *YYCURSOR);

-		yych = *++YYCURSOR;

-		YYDEBUG(-1, yych);

-		switch (yych) {

-		case 'C':

-		case 'c':	goto yy303;

-		case 'D':

-		case 'd':	goto yy308;

-		case 'F':

-		case 'f':	goto yy305;

-		case 'H':

-		case 'h':	goto yy302;

-		case 'L':

-		case 'l':	goto yy307;

-		case 'M':

-		case 'm':	goto yy306;

-		case 'N':

-		case 'n':	goto yy309;

-		case 'T':

-		case 't':	goto yy304;

-		default:	goto yy187;

-		}

-yy302:

-		YYDEBUG(302, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy370;

-		if (yych == 'a') goto yy370;

-		goto yy187;

-yy303:

-		YYDEBUG(303, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy363;

-		if (yych == 'l') goto yy363;

-		goto yy187;

-yy304:

-		YYDEBUG(304, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy356;

-		if (yych == 'r') goto yy356;

-		goto yy187;

-yy305:

-		YYDEBUG(305, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'U') {

-			if (yych == 'I') goto yy340;

-			if (yych <= 'T') goto yy187;

-			goto yy341;

-		} else {

-			if (yych <= 'i') {

-				if (yych <= 'h') goto yy187;

-				goto yy340;

-			} else {

-				if (yych == 'u') goto yy341;

-				goto yy187;

-			}

-		}

-yy306:

-		YYDEBUG(306, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy332;

-		if (yych == 'e') goto yy332;

-		goto yy187;

-yy307:

-		YYDEBUG(307, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy326;

-		if (yych == 'i') goto yy326;

-		goto yy187;

-yy308:

-		YYDEBUG(308, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy321;

-		if (yych == 'i') goto yy321;

-		goto yy187;

-yy309:

-		YYDEBUG(309, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy310;

-		if (yych != 'a') goto yy187;

-yy310:

-		YYDEBUG(310, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'M') goto yy311;

-		if (yych != 'm') goto yy187;

-yy311:

-		YYDEBUG(311, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy312;

-		if (yych != 'e') goto yy187;

-yy312:

-		YYDEBUG(312, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy313;

-		if (yych != 's') goto yy187;

-yy313:

-		YYDEBUG(313, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy314;

-		if (yych != 'p') goto yy187;

-yy314:

-		YYDEBUG(314, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy315;

-		if (yych != 'a') goto yy187;

-yy315:

-		YYDEBUG(315, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy316;

-		if (yych != 'c') goto yy187;

-yy316:

-		YYDEBUG(316, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy317;

-		if (yych != 'e') goto yy187;

-yy317:

-		YYDEBUG(317, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(318, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(319, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(320, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1676 "Zend/zend_language_scanner.l"

-		{

-	if (CG(current_namespace)) {

-		*zendlval = *CG(current_namespace);

-		zval_copy_ctor(zendlval);

-	} else {

-		ZVAL_EMPTY_STRING(zendlval);

-	}

-	return T_NS_C;

-}

-#line 4176 "Zend/zend_language_scanner.c"

-yy321:

-		YYDEBUG(321, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy322;

-		if (yych != 'r') goto yy187;

-yy322:

-		YYDEBUG(322, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(323, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(324, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(325, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1651 "Zend/zend_language_scanner.l"

-		{

-	char *filename = zend_get_compiled_filename(TSRMLS_C);

-	const size_t filename_len = strlen(filename);

-	char *dirname;

-

-	if (!filename) {

-		filename = "";

-	}

-

-	dirname = estrndup(filename, filename_len);

-	zend_dirname(dirname, filename_len);

-

-	if (strcmp(dirname, ".") == 0) {

-		dirname = erealloc(dirname, MAXPATHLEN);

-#if HAVE_GETCWD

-		VCWD_GETCWD(dirname, MAXPATHLEN);

-#elif HAVE_GETWD

-		VCWD_GETWD(dirname);

-#endif

-	}

-

-	ZVAL_STRING(zendlval, dirname, 0);

-	return T_DIR;

-}

-#line 4221 "Zend/zend_language_scanner.c"

-yy326:

-		YYDEBUG(326, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy327;

-		if (yych != 'n') goto yy187;

-yy327:

-		YYDEBUG(327, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy328;

-		if (yych != 'e') goto yy187;

-yy328:

-		YYDEBUG(328, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(329, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(330, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(331, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1636 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_LONG(zendlval, CG(zend_lineno));

-	return T_LINE;

-}

-#line 4251 "Zend/zend_language_scanner.c"

-yy332:

-		YYDEBUG(332, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy333;

-		if (yych != 't') goto yy187;

-yy333:

-		YYDEBUG(333, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy334;

-		if (yych != 'h') goto yy187;

-yy334:

-		YYDEBUG(334, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy335;

-		if (yych != 'o') goto yy187;

-yy335:

-		YYDEBUG(335, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy336;

-		if (yych != 'd') goto yy187;

-yy336:

-		YYDEBUG(336, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(337, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(338, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(339, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1623 "Zend/zend_language_scanner.l"

-		{

-	const char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL;

-	const char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL;

-

-	Z_STRLEN_P(zendlval) = zend_spprintf(&Z_STRVAL_P(zendlval), 0, "%s%s%s",

-		class_name ? class_name : "",

-		class_name && func_name ? "::" : "",

-		func_name ? func_name : ""

-		);

-	zendlval->type = IS_STRING;

-	return T_METHOD_C;

-}

-#line 4299 "Zend/zend_language_scanner.c"

-yy340:

-		YYDEBUG(340, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy351;

-		if (yych == 'l') goto yy351;

-		goto yy187;

-yy341:

-		YYDEBUG(341, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy342;

-		if (yych != 'n') goto yy187;

-yy342:

-		YYDEBUG(342, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy343;

-		if (yych != 'c') goto yy187;

-yy343:

-		YYDEBUG(343, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy344;

-		if (yych != 't') goto yy187;

-yy344:

-		YYDEBUG(344, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy345;

-		if (yych != 'i') goto yy187;

-yy345:

-		YYDEBUG(345, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy346;

-		if (yych != 'o') goto yy187;

-yy346:

-		YYDEBUG(346, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy347;

-		if (yych != 'n') goto yy187;

-yy347:

-		YYDEBUG(347, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(348, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(349, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(350, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1613 "Zend/zend_language_scanner.l"

-		{

-	zend_op_array *op_array = CG(active_op_array);

-	if (op_array && op_array->function_name) {

-		ZVAL_STRING(zendlval, op_array->function_name, 1);

-	} else {

-		ZVAL_EMPTY_STRING(zendlval);

-	}

-	return T_FUNC_C;

-}

-#line 4360 "Zend/zend_language_scanner.c"

-yy351:

-		YYDEBUG(351, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy352;

-		if (yych != 'e') goto yy187;

-yy352:

-		YYDEBUG(352, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(353, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(354, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(355, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1641 "Zend/zend_language_scanner.l"

-		{

-	char *filename = zend_get_compiled_filename(TSRMLS_C);

-

-	if (!filename) {

-		filename = "";

-	}

-	ZVAL_STRING(zendlval, filename, 1);

-	return T_FILE;

-}

-#line 4390 "Zend/zend_language_scanner.c"

-yy356:

-		YYDEBUG(356, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy357;

-		if (yych != 'a') goto yy187;

-yy357:

-		YYDEBUG(357, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy358;

-		if (yych != 'i') goto yy187;

-yy358:

-		YYDEBUG(358, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy359;

-		if (yych != 't') goto yy187;

-yy359:

-		YYDEBUG(359, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(360, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(361, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(362, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1603 "Zend/zend_language_scanner.l"

-		{

-	zend_class_entry *ce = CG(active_class_entry);

-	if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {

-		ZVAL_STRINGL(zendlval, ce->name, ce->name_length, 1);

-	} else {

-		ZVAL_EMPTY_STRING(zendlval);

-	}

-	return T_TRAIT_C;

-}

-#line 4430 "Zend/zend_language_scanner.c"

-yy363:

-		YYDEBUG(363, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy364;

-		if (yych != 'a') goto yy187;

-yy364:

-		YYDEBUG(364, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy365;

-		if (yych != 's') goto yy187;

-yy365:

-		YYDEBUG(365, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy366;

-		if (yych != 's') goto yy187;

-yy366:

-		YYDEBUG(366, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(367, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(368, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(369, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1585 "Zend/zend_language_scanner.l"

-		{

-	zend_class_entry *ce = CG(active_class_entry);

-	if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {

-		/* We create a special __CLASS__ constant that is going to be resolved

-		   at run-time */

-		Z_STRLEN_P(zendlval) = sizeof("__CLASS__")-1;

-		Z_STRVAL_P(zendlval) = estrndup("__CLASS__", Z_STRLEN_P(zendlval));

-		zendlval->type = IS_CONSTANT;

-	} else {

-		if (ce && ce->name) {

-			ZVAL_STRINGL(zendlval, ce->name, ce->name_length, 1);

-		} else {

-			ZVAL_EMPTY_STRING(zendlval);

-		}

-	}

-	return T_CLASS_C;

-}

-#line 4478 "Zend/zend_language_scanner.c"

-yy370:

-		YYDEBUG(370, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy371;

-		if (yych != 'l') goto yy187;

-yy371:

-		YYDEBUG(371, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy372;

-		if (yych != 't') goto yy187;

-yy372:

-		YYDEBUG(372, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '_') goto yy187;

-		YYDEBUG(373, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy374;

-		if (yych != 'c') goto yy187;

-yy374:

-		YYDEBUG(374, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy375;

-		if (yych != 'o') goto yy187;

-yy375:

-		YYDEBUG(375, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'M') goto yy376;

-		if (yych != 'm') goto yy187;

-yy376:

-		YYDEBUG(376, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy377;

-		if (yych != 'p') goto yy187;

-yy377:

-		YYDEBUG(377, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy378;

-		if (yych != 'i') goto yy187;

-yy378:

-		YYDEBUG(378, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy379;

-		if (yych != 'l') goto yy187;

-yy379:

-		YYDEBUG(379, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy380;

-		if (yych != 'e') goto yy187;

-yy380:

-		YYDEBUG(380, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy381;

-		if (yych != 'r') goto yy187;

-yy381:

-		YYDEBUG(381, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(382, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1294 "Zend/zend_language_scanner.l"

-		{

-	return T_HALT_COMPILER;

-}

-#line 4544 "Zend/zend_language_scanner.c"

-yy383:

-		YYDEBUG(383, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy387;

-		if (yych == 's') goto yy387;

-		goto yy187;

-yy384:

-		YYDEBUG(384, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy385;

-		if (yych != 'e') goto yy187;

-yy385:

-		YYDEBUG(385, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(386, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1274 "Zend/zend_language_scanner.l"

-		{

-	return T_USE;

-}

-#line 4568 "Zend/zend_language_scanner.c"

-yy387:

-		YYDEBUG(387, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy388;

-		if (yych != 'e') goto yy187;

-yy388:

-		YYDEBUG(388, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy389;

-		if (yych != 't') goto yy187;

-yy389:

-		YYDEBUG(389, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(390, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1322 "Zend/zend_language_scanner.l"

-		{

-	return T_UNSET;

-}

-#line 4591 "Zend/zend_language_scanner.c"

-yy391:

-		YYDEBUG(391, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(7);

-		yych = *YYCURSOR;

-yy392:

-		YYDEBUG(392, *YYCURSOR);

-		if (yych <= 'S') {

-			if (yych <= 'D') {

-				if (yych <= ' ') {

-					if (yych == '\t') goto yy391;

-					if (yych <= 0x1F) goto yy194;

-					goto yy391;

-				} else {

-					if (yych <= 'A') {

-						if (yych <= '@') goto yy194;

-						goto yy396;

-					} else {

-						if (yych <= 'B') goto yy394;

-						if (yych <= 'C') goto yy194;

-						goto yy399;

-					}

-				}

-			} else {

-				if (yych <= 'I') {

-					if (yych == 'F') goto yy400;

-					if (yych <= 'H') goto yy194;

-					goto yy401;

-				} else {

-					if (yych <= 'O') {

-						if (yych <= 'N') goto yy194;

-						goto yy395;

-					} else {

-						if (yych <= 'Q') goto yy194;

-						if (yych <= 'R') goto yy398;

-						goto yy397;

-					}

-				}

-			}

-		} else {

-			if (yych <= 'f') {

-				if (yych <= 'a') {

-					if (yych == 'U') goto yy393;

-					if (yych <= '`') goto yy194;

-					goto yy396;

-				} else {

-					if (yych <= 'c') {

-						if (yych <= 'b') goto yy394;

-						goto yy194;

-					} else {

-						if (yych <= 'd') goto yy399;

-						if (yych <= 'e') goto yy194;

-						goto yy400;

-					}

-				}

-			} else {

-				if (yych <= 'q') {

-					if (yych <= 'i') {

-						if (yych <= 'h') goto yy194;

-						goto yy401;

-					} else {

-						if (yych == 'o') goto yy395;

-						goto yy194;

-					}

-				} else {

-					if (yych <= 's') {

-						if (yych <= 'r') goto yy398;

-						goto yy397;

-					} else {

-						if (yych != 'u') goto yy194;

-					}

-				}

-			}

-		}

-yy393:

-		YYDEBUG(393, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy460;

-		if (yych == 'n') goto yy460;

-		goto yy194;

-yy394:

-		YYDEBUG(394, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'O') {

-			if (yych == 'I') goto yy447;

-			if (yych <= 'N') goto yy194;

-			goto yy448;

-		} else {

-			if (yych <= 'i') {

-				if (yych <= 'h') goto yy194;

-				goto yy447;

-			} else {

-				if (yych == 'o') goto yy448;

-				goto yy194;

-			}

-		}

-yy395:

-		YYDEBUG(395, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'B') goto yy439;

-		if (yych == 'b') goto yy439;

-		goto yy194;

-yy396:

-		YYDEBUG(396, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy432;

-		if (yych == 'r') goto yy432;

-		goto yy194;

-yy397:

-		YYDEBUG(397, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy424;

-		if (yych == 't') goto yy424;

-		goto yy194;

-yy398:

-		YYDEBUG(398, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy422;

-		if (yych == 'e') goto yy422;

-		goto yy194;

-yy399:

-		YYDEBUG(399, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy418;

-		if (yych == 'o') goto yy418;

-		goto yy194;

-yy400:

-		YYDEBUG(400, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy411;

-		if (yych == 'l') goto yy411;

-		goto yy194;

-yy401:

-		YYDEBUG(401, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy402;

-		if (yych != 'n') goto yy194;

-yy402:

-		YYDEBUG(402, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy403;

-		if (yych != 't') goto yy194;

-yy403:

-		YYDEBUG(403, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy404;

-		if (yych != 'e') goto yy406;

-yy404:

-		YYDEBUG(404, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'G') goto yy409;

-		if (yych == 'g') goto yy409;

-		goto yy194;

-yy405:

-		YYDEBUG(405, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy406:

-		YYDEBUG(406, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy405;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy405;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(407, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(408, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1222 "Zend/zend_language_scanner.l"

-		{

-	return T_INT_CAST;

-}

-#line 4767 "Zend/zend_language_scanner.c"

-yy409:

-		YYDEBUG(409, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy410;

-		if (yych != 'e') goto yy194;

-yy410:

-		YYDEBUG(410, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy405;

-		if (yych == 'r') goto yy405;

-		goto yy194;

-yy411:

-		YYDEBUG(411, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy412;

-		if (yych != 'o') goto yy194;

-yy412:

-		YYDEBUG(412, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy413;

-		if (yych != 'a') goto yy194;

-yy413:

-		YYDEBUG(413, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy414;

-		if (yych != 't') goto yy194;

-yy414:

-		YYDEBUG(414, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(415, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy414;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy414;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(416, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(417, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1226 "Zend/zend_language_scanner.l"

-		{

-	return T_DOUBLE_CAST;

-}

-#line 4815 "Zend/zend_language_scanner.c"

-yy418:

-		YYDEBUG(418, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy419;

-		if (yych != 'u') goto yy194;

-yy419:

-		YYDEBUG(419, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'B') goto yy420;

-		if (yych != 'b') goto yy194;

-yy420:

-		YYDEBUG(420, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy421;

-		if (yych != 'l') goto yy194;

-yy421:

-		YYDEBUG(421, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy414;

-		if (yych == 'e') goto yy414;

-		goto yy194;

-yy422:

-		YYDEBUG(422, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy423;

-		if (yych != 'a') goto yy194;

-yy423:

-		YYDEBUG(423, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy414;

-		if (yych == 'l') goto yy414;

-		goto yy194;

-yy424:

-		YYDEBUG(424, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy425;

-		if (yych != 'r') goto yy194;

-yy425:

-		YYDEBUG(425, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy426;

-		if (yych != 'i') goto yy194;

-yy426:

-		YYDEBUG(426, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy427;

-		if (yych != 'n') goto yy194;

-yy427:

-		YYDEBUG(427, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'G') goto yy428;

-		if (yych != 'g') goto yy194;

-yy428:

-		YYDEBUG(428, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(429, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy428;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy428;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(430, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(431, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1230 "Zend/zend_language_scanner.l"

-		{

-	return T_STRING_CAST;

-}

-#line 4889 "Zend/zend_language_scanner.c"

-yy432:

-		YYDEBUG(432, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy433;

-		if (yych != 'r') goto yy194;

-yy433:

-		YYDEBUG(433, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy434;

-		if (yych != 'a') goto yy194;

-yy434:

-		YYDEBUG(434, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'Y') goto yy435;

-		if (yych != 'y') goto yy194;

-yy435:

-		YYDEBUG(435, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(436, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy435;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy435;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(437, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(438, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1234 "Zend/zend_language_scanner.l"

-		{

-	return T_ARRAY_CAST;

-}

-#line 4926 "Zend/zend_language_scanner.c"

-yy439:

-		YYDEBUG(439, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'J') goto yy440;

-		if (yych != 'j') goto yy194;

-yy440:

-		YYDEBUG(440, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy441;

-		if (yych != 'e') goto yy194;

-yy441:

-		YYDEBUG(441, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy442;

-		if (yych != 'c') goto yy194;

-yy442:

-		YYDEBUG(442, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy443;

-		if (yych != 't') goto yy194;

-yy443:

-		YYDEBUG(443, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(444, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy443;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy443;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(445, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(446, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1238 "Zend/zend_language_scanner.l"

-		{

-	return T_OBJECT_CAST;

-}

-#line 4968 "Zend/zend_language_scanner.c"

-yy447:

-		YYDEBUG(447, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy457;

-		if (yych == 'n') goto yy457;

-		goto yy194;

-yy448:

-		YYDEBUG(448, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy449;

-		if (yych != 'o') goto yy194;

-yy449:

-		YYDEBUG(449, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy450;

-		if (yych != 'l') goto yy194;

-yy450:

-		YYDEBUG(450, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy455;

-		if (yych == 'e') goto yy455;

-		goto yy452;

-yy451:

-		YYDEBUG(451, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy452:

-		YYDEBUG(452, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy451;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy451;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(453, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(454, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1242 "Zend/zend_language_scanner.l"

-		{

-	return T_BOOL_CAST;

-}

-#line 5013 "Zend/zend_language_scanner.c"

-yy455:

-		YYDEBUG(455, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy456;

-		if (yych != 'a') goto yy194;

-yy456:

-		YYDEBUG(456, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy451;

-		if (yych == 'n') goto yy451;

-		goto yy194;

-yy457:

-		YYDEBUG(457, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy458;

-		if (yych != 'a') goto yy194;

-yy458:

-		YYDEBUG(458, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy459;

-		if (yych != 'r') goto yy194;

-yy459:

-		YYDEBUG(459, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'Y') goto yy428;

-		if (yych == 'y') goto yy428;

-		goto yy194;

-yy460:

-		YYDEBUG(460, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy461;

-		if (yych != 's') goto yy194;

-yy461:

-		YYDEBUG(461, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy462;

-		if (yych != 'e') goto yy194;

-yy462:

-		YYDEBUG(462, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy463;

-		if (yych != 't') goto yy194;

-yy463:

-		YYDEBUG(463, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(464, *YYCURSOR);

-		if (yych <= 0x1F) {

-			if (yych == '\t') goto yy463;

-			goto yy194;

-		} else {

-			if (yych <= ' ') goto yy463;

-			if (yych != ')') goto yy194;

-		}

-		YYDEBUG(465, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(466, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1246 "Zend/zend_language_scanner.l"

-		{

-	return T_UNSET_CAST;

-}

-#line 5077 "Zend/zend_language_scanner.c"

-yy467:

-		YYDEBUG(467, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy468;

-		if (yych != 'r') goto yy187;

-yy468:

-		YYDEBUG(468, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(469, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1218 "Zend/zend_language_scanner.l"

-		{

-	return T_VAR;

-}

-#line 5095 "Zend/zend_language_scanner.c"

-yy470:

-		YYDEBUG(470, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'M') goto yy474;

-		if (yych == 'm') goto yy474;

-		goto yy187;

-yy471:

-		YYDEBUG(471, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'W') goto yy472;

-		if (yych != 'w') goto yy187;

-yy472:

-		YYDEBUG(472, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(473, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1210 "Zend/zend_language_scanner.l"

-		{

-	return T_NEW;

-}

-#line 5119 "Zend/zend_language_scanner.c"

-yy474:

-		YYDEBUG(474, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy475;

-		if (yych != 'e') goto yy187;

-yy475:

-		YYDEBUG(475, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy476;

-		if (yych != 's') goto yy187;

-yy476:

-		YYDEBUG(476, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy477;

-		if (yych != 'p') goto yy187;

-yy477:

-		YYDEBUG(477, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy478;

-		if (yych != 'a') goto yy187;

-yy478:

-		YYDEBUG(478, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy479;

-		if (yych != 'c') goto yy187;

-yy479:

-		YYDEBUG(479, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy480;

-		if (yych != 'e') goto yy187;

-yy480:

-		YYDEBUG(480, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(481, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1270 "Zend/zend_language_scanner.l"

-		{

-	return T_NAMESPACE;

-}

-#line 5162 "Zend/zend_language_scanner.c"

-yy482:

-		YYDEBUG(482, *YYCURSOR);

-		yyaccept = 3;

-		YYMARKER = ++YYCURSOR;

-		YYFILL(3);

-		yych = *YYCURSOR;

-		YYDEBUG(483, *YYCURSOR);

-		if (yych <= 'D') {

-			if (yych <= '/') goto yy190;

-			if (yych <= '9') goto yy482;

-			goto yy190;

-		} else {

-			if (yych <= 'E') goto yy193;

-			if (yych == 'e') goto yy193;

-			goto yy190;

-		}

-yy484:

-		YYDEBUG(484, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(485, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1398 "Zend/zend_language_scanner.l"

-		{

-	return T_CONCAT_EQUAL;

-}

-#line 5188 "Zend/zend_language_scanner.c"

-yy486:

-		YYDEBUG(486, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych != '.') goto yy194;

-		YYDEBUG(487, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(488, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1206 "Zend/zend_language_scanner.l"

-		{

-	return T_ELLIPSIS;

-}

-#line 5201 "Zend/zend_language_scanner.c"

-yy489:

-		YYDEBUG(489, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(490, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1198 "Zend/zend_language_scanner.l"

-		{

-	return T_PAAMAYIM_NEKUDOTAYIM;

-}

-#line 5211 "Zend/zend_language_scanner.c"

-yy491:

-		YYDEBUG(491, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy492:

-		YYDEBUG(492, *YYCURSOR);

-		if (yych <= '\f') {

-			if (yych <= 0x08) goto yy141;

-			if (yych <= '\n') goto yy491;

-			goto yy141;

-		} else {

-			if (yych <= '\r') goto yy491;

-			if (yych == ' ') goto yy491;

-			goto yy141;

-		}

-yy493:

-		YYDEBUG(493, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(494, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1378 "Zend/zend_language_scanner.l"

-		{

-	return T_MINUS_EQUAL;

-}

-#line 5237 "Zend/zend_language_scanner.c"

-yy495:

-		YYDEBUG(495, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(496, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1346 "Zend/zend_language_scanner.l"

-		{

-	return T_DEC;

-}

-#line 5247 "Zend/zend_language_scanner.c"

-yy497:

-		YYDEBUG(497, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(498, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1170 "Zend/zend_language_scanner.l"

-		{

-	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);

-	return T_OBJECT_OPERATOR;

-}

-#line 5258 "Zend/zend_language_scanner.c"

-yy499:

-		YYDEBUG(499, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'O') {

-			if (yych == 'I') goto yy506;

-			if (yych <= 'N') goto yy187;

-			goto yy507;

-		} else {

-			if (yych <= 'i') {

-				if (yych <= 'h') goto yy187;

-				goto yy506;

-			} else {

-				if (yych == 'o') goto yy507;

-				goto yy187;

-			}

-		}

-yy500:

-		YYDEBUG(500, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'B') goto yy501;

-		if (yych != 'b') goto yy187;

-yy501:

-		YYDEBUG(501, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy502;

-		if (yych != 'l') goto yy187;

-yy502:

-		YYDEBUG(502, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy503;

-		if (yych != 'i') goto yy187;

-yy503:

-		YYDEBUG(503, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy504;

-		if (yych != 'c') goto yy187;

-yy504:

-		YYDEBUG(504, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(505, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1318 "Zend/zend_language_scanner.l"

-		{

-	return T_PUBLIC;

-}

-#line 5307 "Zend/zend_language_scanner.c"

-yy506:

-		YYDEBUG(506, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'V') {

-			if (yych == 'N') goto yy515;

-			if (yych <= 'U') goto yy187;

-			goto yy516;

-		} else {

-			if (yych <= 'n') {

-				if (yych <= 'm') goto yy187;

-				goto yy515;

-			} else {

-				if (yych == 'v') goto yy516;

-				goto yy187;

-			}

-		}

-yy507:

-		YYDEBUG(507, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy508;

-		if (yych != 't') goto yy187;

-yy508:

-		YYDEBUG(508, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy509;

-		if (yych != 'e') goto yy187;

-yy509:

-		YYDEBUG(509, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy510;

-		if (yych != 'c') goto yy187;

-yy510:

-		YYDEBUG(510, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy511;

-		if (yych != 't') goto yy187;

-yy511:

-		YYDEBUG(511, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy512;

-		if (yych != 'e') goto yy187;

-yy512:

-		YYDEBUG(512, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy513;

-		if (yych != 'd') goto yy187;

-yy513:

-		YYDEBUG(513, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(514, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1314 "Zend/zend_language_scanner.l"

-		{

-	return T_PROTECTED;

-}

-#line 5366 "Zend/zend_language_scanner.c"

-yy515:

-		YYDEBUG(515, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy521;

-		if (yych == 't') goto yy521;

-		goto yy187;

-yy516:

-		YYDEBUG(516, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy517;

-		if (yych != 'a') goto yy187;

-yy517:

-		YYDEBUG(517, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy518;

-		if (yych != 't') goto yy187;

-yy518:

-		YYDEBUG(518, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy519;

-		if (yych != 'e') goto yy187;

-yy519:

-		YYDEBUG(519, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(520, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1310 "Zend/zend_language_scanner.l"

-		{

-	return T_PRIVATE;

-}

-#line 5400 "Zend/zend_language_scanner.c"

-yy521:

-		YYDEBUG(521, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(522, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1146 "Zend/zend_language_scanner.l"

-		{

-	return T_PRINT;

-}

-#line 5413 "Zend/zend_language_scanner.c"

-yy523:

-		YYDEBUG(523, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy528;

-		if (yych == 'o') goto yy528;

-		goto yy187;

-yy524:

-		YYDEBUG(524, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy525;

-		if (yych != 't') goto yy187;

-yy525:

-		YYDEBUG(525, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy526;

-		if (yych != 'o') goto yy187;

-yy526:

-		YYDEBUG(526, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(527, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1138 "Zend/zend_language_scanner.l"

-		{

-	return T_GOTO;

-}

-#line 5442 "Zend/zend_language_scanner.c"

-yy528:

-		YYDEBUG(528, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'B') goto yy529;

-		if (yych != 'b') goto yy187;

-yy529:

-		YYDEBUG(529, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy530;

-		if (yych != 'a') goto yy187;

-yy530:

-		YYDEBUG(530, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy531;

-		if (yych != 'l') goto yy187;

-yy531:

-		YYDEBUG(531, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(532, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1282 "Zend/zend_language_scanner.l"

-		{

-	return T_GLOBAL;

-}

-#line 5470 "Zend/zend_language_scanner.c"

-yy533:

-		YYDEBUG(533, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '<') goto yy541;

-		goto yy194;

-yy534:

-		YYDEBUG(534, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy181;

-yy535:

-		YYDEBUG(535, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy179;

-yy536:

-		YYDEBUG(536, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy537;

-		if (yych != 'e') goto yy187;

-yy537:

-		YYDEBUG(537, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy538;

-		if (yych != 'a') goto yy187;

-yy538:

-		YYDEBUG(538, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'K') goto yy539;

-		if (yych != 'k') goto yy187;

-yy539:

-		YYDEBUG(539, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(540, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1130 "Zend/zend_language_scanner.l"

-		{

-	return T_BREAK;

-}

-#line 5511 "Zend/zend_language_scanner.c"

-yy541:

-		YYDEBUG(541, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == '<') goto yy270;

-		goto yy194;

-yy542:

-		YYDEBUG(542, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy549;

-		if (yych == 'a') goto yy549;

-		goto yy187;

-yy543:

-		YYDEBUG(543, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy544;

-		if (yych != 'i') goto yy187;

-yy544:

-		YYDEBUG(544, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy545;

-		if (yych != 't') goto yy187;

-yy545:

-		YYDEBUG(545, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy546;

-		if (yych != 'c') goto yy187;

-yy546:

-		YYDEBUG(546, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy547;

-		if (yych != 'h') goto yy187;

-yy547:

-		YYDEBUG(547, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(548, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1114 "Zend/zend_language_scanner.l"

-		{

-	return T_SWITCH;

-}

-#line 5555 "Zend/zend_language_scanner.c"

-yy549:

-		YYDEBUG(549, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy550;

-		if (yych != 't') goto yy187;

-yy550:

-		YYDEBUG(550, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy551;

-		if (yych != 'i') goto yy187;

-yy551:

-		YYDEBUG(551, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy552;

-		if (yych != 'c') goto yy187;

-yy552:

-		YYDEBUG(552, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(553, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1298 "Zend/zend_language_scanner.l"

-		{

-	return T_STATIC;

-}

-#line 5583 "Zend/zend_language_scanner.c"

-yy554:

-		YYDEBUG(554, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy565;

-		if (yych == 's') goto yy565;

-		goto yy187;

-yy555:

-		YYDEBUG(555, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy563;

-		if (yych == 'd') goto yy563;

-		goto yy187;

-yy556:

-		YYDEBUG(556, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy559;

-		if (yych == 'r') goto yy559;

-		goto yy187;

-yy557:

-		YYDEBUG(557, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(558, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1110 "Zend/zend_language_scanner.l"

-		{

-	return T_AS;

-}

-#line 5614 "Zend/zend_language_scanner.c"

-yy559:

-		YYDEBUG(559, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy560;

-		if (yych != 'a') goto yy187;

-yy560:

-		YYDEBUG(560, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'Y') goto yy561;

-		if (yych != 'y') goto yy187;

-yy561:

-		YYDEBUG(561, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(562, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1334 "Zend/zend_language_scanner.l"

-		{

-	return T_ARRAY;

-}

-#line 5637 "Zend/zend_language_scanner.c"

-yy563:

-		YYDEBUG(563, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(564, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1438 "Zend/zend_language_scanner.l"

-		{

-	return T_LOGICAL_AND;

-}

-#line 5650 "Zend/zend_language_scanner.c"

-yy565:

-		YYDEBUG(565, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy566;

-		if (yych != 't') goto yy187;

-yy566:

-		YYDEBUG(566, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy567;

-		if (yych != 'r') goto yy187;

-yy567:

-		YYDEBUG(567, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy568;

-		if (yych != 'a') goto yy187;

-yy568:

-		YYDEBUG(568, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy569;

-		if (yych != 'c') goto yy187;

-yy569:

-		YYDEBUG(569, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy570;

-		if (yych != 't') goto yy187;

-yy570:

-		YYDEBUG(570, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(571, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1302 "Zend/zend_language_scanner.l"

-		{

-	return T_ABSTRACT;

-}

-#line 5688 "Zend/zend_language_scanner.c"

-yy572:

-		YYDEBUG(572, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy573;

-		if (yych != 'i') goto yy187;

-yy573:

-		YYDEBUG(573, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy574;

-		if (yych != 'l') goto yy187;

-yy574:

-		YYDEBUG(574, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy575;

-		if (yych != 'e') goto yy187;

-yy575:

-		YYDEBUG(575, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(576, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1070 "Zend/zend_language_scanner.l"

-		{

-	return T_WHILE;

-}

-#line 5716 "Zend/zend_language_scanner.c"

-yy577:

-		YYDEBUG(577, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(578, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1054 "Zend/zend_language_scanner.l"

-		{

-	return T_IF;

-}

-#line 5729 "Zend/zend_language_scanner.c"

-yy579:

-		YYDEBUG(579, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy621;

-		if (yych == 'p') goto yy621;

-		goto yy187;

-yy580:

-		YYDEBUG(580, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'T') {

-			if (yych <= 'C') {

-				if (yych <= 'B') goto yy187;

-				goto yy588;

-			} else {

-				if (yych <= 'R') goto yy187;

-				if (yych <= 'S') goto yy586;

-				goto yy587;

-			}

-		} else {

-			if (yych <= 'r') {

-				if (yych == 'c') goto yy588;

-				goto yy187;

-			} else {

-				if (yych <= 's') goto yy586;

-				if (yych <= 't') goto yy587;

-				goto yy187;

-			}

-		}

-yy581:

-		YYDEBUG(581, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy582;

-		if (yych != 's') goto yy187;

-yy582:

-		YYDEBUG(582, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy583;

-		if (yych != 'e') goto yy187;

-yy583:

-		YYDEBUG(583, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy584;

-		if (yych != 't') goto yy187;

-yy584:

-		YYDEBUG(584, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(585, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1286 "Zend/zend_language_scanner.l"

-		{

-	return T_ISSET;

-}

-#line 5785 "Zend/zend_language_scanner.c"

-yy586:

-		YYDEBUG(586, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy607;

-		if (yych == 't') goto yy607;

-		goto yy187;

-yy587:

-		YYDEBUG(587, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy600;

-		if (yych == 'e') goto yy600;

-		goto yy187;

-yy588:

-		YYDEBUG(588, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy589;

-		if (yych != 'l') goto yy187;

-yy589:

-		YYDEBUG(589, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy590;

-		if (yych != 'u') goto yy187;

-yy590:

-		YYDEBUG(590, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy591;

-		if (yych != 'd') goto yy187;

-yy591:

-		YYDEBUG(591, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy592;

-		if (yych != 'e') goto yy187;

-yy592:

-		YYDEBUG(592, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '^') {

-			if (yych <= '9') {

-				if (yych >= '0') goto yy186;

-			} else {

-				if (yych <= '@') goto yy593;

-				if (yych <= 'Z') goto yy186;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= '_') goto yy594;

-			} else {

-				if (yych <= 'z') goto yy186;

-				if (yych >= 0x7F) goto yy186;

-			}

-		}

-yy593:

-		YYDEBUG(593, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1254 "Zend/zend_language_scanner.l"

-		{

-	return T_INCLUDE;

-}

-#line 5843 "Zend/zend_language_scanner.c"

-yy594:

-		YYDEBUG(594, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy595;

-		if (yych != 'o') goto yy187;

-yy595:

-		YYDEBUG(595, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy596;

-		if (yych != 'n') goto yy187;

-yy596:

-		YYDEBUG(596, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy597;

-		if (yych != 'c') goto yy187;

-yy597:

-		YYDEBUG(597, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy598;

-		if (yych != 'e') goto yy187;

-yy598:

-		YYDEBUG(598, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(599, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1258 "Zend/zend_language_scanner.l"

-		{

-	return T_INCLUDE_ONCE;

-}

-#line 5876 "Zend/zend_language_scanner.c"

-yy600:

-		YYDEBUG(600, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy601;

-		if (yych != 'r') goto yy187;

-yy601:

-		YYDEBUG(601, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'F') goto yy602;

-		if (yych != 'f') goto yy187;

-yy602:

-		YYDEBUG(602, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy603;

-		if (yych != 'a') goto yy187;

-yy603:

-		YYDEBUG(603, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy604;

-		if (yych != 'c') goto yy187;

-yy604:

-		YYDEBUG(604, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy605;

-		if (yych != 'e') goto yy187;

-yy605:

-		YYDEBUG(605, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(606, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1154 "Zend/zend_language_scanner.l"

-		{

-	return T_INTERFACE;

-}

-#line 5914 "Zend/zend_language_scanner.c"

-yy607:

-		YYDEBUG(607, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'E') {

-			if (yych == 'A') goto yy608;

-			if (yych <= 'D') goto yy187;

-			goto yy609;

-		} else {

-			if (yych <= 'a') {

-				if (yych <= '`') goto yy187;

-			} else {

-				if (yych == 'e') goto yy609;

-				goto yy187;

-			}

-		}

-yy608:

-		YYDEBUG(608, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy615;

-		if (yych == 'n') goto yy615;

-		goto yy187;

-yy609:

-		YYDEBUG(609, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy610;

-		if (yych != 'a') goto yy187;

-yy610:

-		YYDEBUG(610, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy611;

-		if (yych != 'd') goto yy187;

-yy611:

-		YYDEBUG(611, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy612;

-		if (yych != 'o') goto yy187;

-yy612:

-		YYDEBUG(612, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'F') goto yy613;

-		if (yych != 'f') goto yy187;

-yy613:

-		YYDEBUG(613, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(614, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1278 "Zend/zend_language_scanner.l"

-		{

-        return T_INSTEADOF;

-}

-#line 5968 "Zend/zend_language_scanner.c"

-yy615:

-		YYDEBUG(615, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy616;

-		if (yych != 'c') goto yy187;

-yy616:

-		YYDEBUG(616, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy617;

-		if (yych != 'e') goto yy187;

-yy617:

-		YYDEBUG(617, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy618;

-		if (yych != 'o') goto yy187;

-yy618:

-		YYDEBUG(618, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'F') goto yy619;

-		if (yych != 'f') goto yy187;

-yy619:

-		YYDEBUG(619, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(620, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1106 "Zend/zend_language_scanner.l"

-		{

-	return T_INSTANCEOF;

-}

-#line 6001 "Zend/zend_language_scanner.c"

-yy621:

-		YYDEBUG(621, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy622;

-		if (yych != 'l') goto yy187;

-yy622:

-		YYDEBUG(622, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy623;

-		if (yych != 'e') goto yy187;

-yy623:

-		YYDEBUG(623, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'M') goto yy624;

-		if (yych != 'm') goto yy187;

-yy624:

-		YYDEBUG(624, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy625;

-		if (yych != 'e') goto yy187;

-yy625:

-		YYDEBUG(625, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy626;

-		if (yych != 'n') goto yy187;

-yy626:

-		YYDEBUG(626, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy627;

-		if (yych != 't') goto yy187;

-yy627:

-		YYDEBUG(627, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy628;

-		if (yych != 's') goto yy187;

-yy628:

-		YYDEBUG(628, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(629, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1166 "Zend/zend_language_scanner.l"

-		{

-	return T_IMPLEMENTS;

-}

-#line 6049 "Zend/zend_language_scanner.c"

-yy630:

-		YYDEBUG(630, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy638;

-		if (yych == 'r') goto yy638;

-		goto yy187;

-yy631:

-		YYDEBUG(631, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'Y') {

-			if (yych == 'A') goto yy634;

-			if (yych <= 'X') goto yy187;

-		} else {

-			if (yych <= 'a') {

-				if (yych <= '`') goto yy187;

-				goto yy634;

-			} else {

-				if (yych != 'y') goto yy187;

-			}

-		}

-		YYDEBUG(632, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(633, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1038 "Zend/zend_language_scanner.l"

-		{

-	return T_TRY;

-}

-#line 6081 "Zend/zend_language_scanner.c"

-yy634:

-		YYDEBUG(634, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy635;

-		if (yych != 'i') goto yy187;

-yy635:

-		YYDEBUG(635, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy636;

-		if (yych != 't') goto yy187;

-yy636:

-		YYDEBUG(636, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(637, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1158 "Zend/zend_language_scanner.l"

-		{

-	return T_TRAIT;

-}

-#line 6104 "Zend/zend_language_scanner.c"

-yy638:

-		YYDEBUG(638, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy639;

-		if (yych != 'o') goto yy187;

-yy639:

-		YYDEBUG(639, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'W') goto yy640;

-		if (yych != 'w') goto yy187;

-yy640:

-		YYDEBUG(640, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(641, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1050 "Zend/zend_language_scanner.l"

-		{

-	return T_THROW;

-}

-#line 6127 "Zend/zend_language_scanner.c"

-yy642:

-		YYDEBUG(642, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy643;

-		if (yych != 'e') goto yy187;

-yy643:

-		YYDEBUG(643, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy644;

-		if (yych != 'l') goto yy187;

-yy644:

-		YYDEBUG(644, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy645;

-		if (yych != 'd') goto yy187;

-yy645:

-		YYDEBUG(645, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(646, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1034 "Zend/zend_language_scanner.l"

-		{

-	return T_YIELD;

-}

-#line 6155 "Zend/zend_language_scanner.c"

-yy647:

-		YYDEBUG(647, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'T') {

-			if (yych == 'Q') goto yy649;

-			if (yych <= 'S') goto yy187;

-		} else {

-			if (yych <= 'q') {

-				if (yych <= 'p') goto yy187;

-				goto yy649;

-			} else {

-				if (yych != 't') goto yy187;

-			}

-		}

-		YYDEBUG(648, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy661;

-		if (yych == 'u') goto yy661;

-		goto yy187;

-yy649:

-		YYDEBUG(649, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy650;

-		if (yych != 'u') goto yy187;

-yy650:

-		YYDEBUG(650, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy651;

-		if (yych != 'i') goto yy187;

-yy651:

-		YYDEBUG(651, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy652;

-		if (yych != 'r') goto yy187;

-yy652:

-		YYDEBUG(652, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy653;

-		if (yych != 'e') goto yy187;

-yy653:

-		YYDEBUG(653, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '^') {

-			if (yych <= '9') {

-				if (yych >= '0') goto yy186;

-			} else {

-				if (yych <= '@') goto yy654;

-				if (yych <= 'Z') goto yy186;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= '_') goto yy655;

-			} else {

-				if (yych <= 'z') goto yy186;

-				if (yych >= 0x7F) goto yy186;

-			}

-		}

-yy654:

-		YYDEBUG(654, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1262 "Zend/zend_language_scanner.l"

-		{

-	return T_REQUIRE;

-}

-#line 6220 "Zend/zend_language_scanner.c"

-yy655:

-		YYDEBUG(655, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy656;

-		if (yych != 'o') goto yy187;

-yy656:

-		YYDEBUG(656, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy657;

-		if (yych != 'n') goto yy187;

-yy657:

-		YYDEBUG(657, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy658;

-		if (yych != 'c') goto yy187;

-yy658:

-		YYDEBUG(658, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy659;

-		if (yych != 'e') goto yy187;

-yy659:

-		YYDEBUG(659, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(660, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1266 "Zend/zend_language_scanner.l"

-		{

-	return T_REQUIRE_ONCE;

-}

-#line 6253 "Zend/zend_language_scanner.c"

-yy661:

-		YYDEBUG(661, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy662;

-		if (yych != 'r') goto yy187;

-yy662:

-		YYDEBUG(662, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy663;

-		if (yych != 'n') goto yy187;

-yy663:

-		YYDEBUG(663, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(664, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1030 "Zend/zend_language_scanner.l"

-		{

-	return T_RETURN;

-}

-#line 6276 "Zend/zend_language_scanner.c"

-yy665:

-		YYDEBUG(665, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'T') {

-			if (yych <= 'L') {

-				if (yych <= 'K') goto yy187;

-				goto yy688;

-			} else {

-				if (yych <= 'R') goto yy187;

-				if (yych <= 'S') goto yy687;

-				goto yy686;

-			}

-		} else {

-			if (yych <= 'r') {

-				if (yych == 'l') goto yy688;

-				goto yy187;

-			} else {

-				if (yych <= 's') goto yy687;

-				if (yych <= 't') goto yy686;

-				goto yy187;

-			}

-		}

-yy666:

-		YYDEBUG(666, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'O') {

-			if (yych == 'A') goto yy678;

-			if (yych <= 'N') goto yy187;

-			goto yy679;

-		} else {

-			if (yych <= 'a') {

-				if (yych <= '`') goto yy187;

-				goto yy678;

-			} else {

-				if (yych == 'o') goto yy679;

-				goto yy187;

-			}

-		}

-yy667:

-		YYDEBUG(667, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy668;

-		if (yych != 'n') goto yy187;

-yy668:

-		YYDEBUG(668, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'T') {

-			if (yych <= 'R') goto yy187;

-			if (yych >= 'T') goto yy670;

-		} else {

-			if (yych <= 'r') goto yy187;

-			if (yych <= 's') goto yy669;

-			if (yych <= 't') goto yy670;

-			goto yy187;

-		}

-yy669:

-		YYDEBUG(669, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy676;

-		if (yych == 't') goto yy676;

-		goto yy187;

-yy670:

-		YYDEBUG(670, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy671;

-		if (yych != 'i') goto yy187;

-yy671:

-		YYDEBUG(671, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy672;

-		if (yych != 'n') goto yy187;

-yy672:

-		YYDEBUG(672, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy673;

-		if (yych != 'u') goto yy187;

-yy673:

-		YYDEBUG(673, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy674;

-		if (yych != 'e') goto yy187;

-yy674:

-		YYDEBUG(674, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(675, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1134 "Zend/zend_language_scanner.l"

-		{

-	return T_CONTINUE;

-}

-#line 6370 "Zend/zend_language_scanner.c"

-yy676:

-		YYDEBUG(676, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(677, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1026 "Zend/zend_language_scanner.l"

-		{

-	return T_CONST;

-}

-#line 6383 "Zend/zend_language_scanner.c"

-yy678:

-		YYDEBUG(678, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy683;

-		if (yych == 's') goto yy683;

-		goto yy187;

-yy679:

-		YYDEBUG(679, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy680;

-		if (yych != 'n') goto yy187;

-yy680:

-		YYDEBUG(680, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy681;

-		if (yych != 'e') goto yy187;

-yy681:

-		YYDEBUG(681, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(682, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1214 "Zend/zend_language_scanner.l"

-		{

-	return T_CLONE;

-}

-#line 6412 "Zend/zend_language_scanner.c"

-yy683:

-		YYDEBUG(683, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy684;

-		if (yych != 's') goto yy187;

-yy684:

-		YYDEBUG(684, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(685, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1150 "Zend/zend_language_scanner.l"

-		{

-	return T_CLASS;

-}

-#line 6430 "Zend/zend_language_scanner.c"

-yy686:

-		YYDEBUG(686, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy697;

-		if (yych == 'c') goto yy697;

-		goto yy187;

-yy687:

-		YYDEBUG(687, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy695;

-		if (yych == 'e') goto yy695;

-		goto yy187;

-yy688:

-		YYDEBUG(688, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy689;

-		if (yych != 'l') goto yy187;

-yy689:

-		YYDEBUG(689, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy690;

-		if (yych != 'a') goto yy187;

-yy690:

-		YYDEBUG(690, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'B') goto yy691;

-		if (yych != 'b') goto yy187;

-yy691:

-		YYDEBUG(691, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy692;

-		if (yych != 'l') goto yy187;

-yy692:

-		YYDEBUG(692, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy693;

-		if (yych != 'e') goto yy187;

-yy693:

-		YYDEBUG(693, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(694, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1338 "Zend/zend_language_scanner.l"

-		{

- return T_CALLABLE;

-}

-#line 6480 "Zend/zend_language_scanner.c"

-yy695:

-		YYDEBUG(695, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(696, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1122 "Zend/zend_language_scanner.l"

-		{

-	return T_CASE;

-}

-#line 6493 "Zend/zend_language_scanner.c"

-yy697:

-		YYDEBUG(697, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy698;

-		if (yych != 'h') goto yy187;

-yy698:

-		YYDEBUG(698, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(699, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1042 "Zend/zend_language_scanner.l"

-		{

-	return T_CATCH;

-}

-#line 6511 "Zend/zend_language_scanner.c"

-yy700:

-		YYDEBUG(700, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy717;

-		if (yych == 'n') goto yy717;

-		goto yy187;

-yy701:

-		YYDEBUG(701, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy710;

-		if (yych == 'r') goto yy710;

-		goto yy187;

-yy702:

-		YYDEBUG(702, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy703;

-		if (yych != 'n') goto yy187;

-yy703:

-		YYDEBUG(703, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy704;

-		if (yych != 'c') goto yy187;

-yy704:

-		YYDEBUG(704, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy705;

-		if (yych != 't') goto yy187;

-yy705:

-		YYDEBUG(705, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy706;

-		if (yych != 'i') goto yy187;

-yy706:

-		YYDEBUG(706, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy707;

-		if (yych != 'o') goto yy187;

-yy707:

-		YYDEBUG(707, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy708;

-		if (yych != 'n') goto yy187;

-yy708:

-		YYDEBUG(708, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(709, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1022 "Zend/zend_language_scanner.l"

-		{

-	return T_FUNCTION;

-}

-#line 6566 "Zend/zend_language_scanner.c"

-yy710:

-		YYDEBUG(710, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '^') {

-			if (yych <= '@') {

-				if (yych <= '/') goto yy711;

-				if (yych <= '9') goto yy186;

-			} else {

-				if (yych == 'E') goto yy712;

-				if (yych <= 'Z') goto yy186;

-			}

-		} else {

-			if (yych <= 'd') {

-				if (yych != '`') goto yy186;

-			} else {

-				if (yych <= 'e') goto yy712;

-				if (yych <= 'z') goto yy186;

-				if (yych >= 0x7F) goto yy186;

-			}

-		}

-yy711:

-		YYDEBUG(711, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1082 "Zend/zend_language_scanner.l"

-		{

-	return T_FOR;

-}

-#line 6594 "Zend/zend_language_scanner.c"

-yy712:

-		YYDEBUG(712, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy713;

-		if (yych != 'a') goto yy187;

-yy713:

-		YYDEBUG(713, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy714;

-		if (yych != 'c') goto yy187;

-yy714:

-		YYDEBUG(714, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy715;

-		if (yych != 'h') goto yy187;

-yy715:

-		YYDEBUG(715, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(716, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1090 "Zend/zend_language_scanner.l"

-		{

-	return T_FOREACH;

-}

-#line 6622 "Zend/zend_language_scanner.c"

-yy717:

-		YYDEBUG(717, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy718;

-		if (yych != 'a') goto yy187;

-yy718:

-		YYDEBUG(718, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy719;

-		if (yych != 'l') goto yy187;

-yy719:

-		YYDEBUG(719, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '^') {

-			if (yych <= '@') {

-				if (yych <= '/') goto yy720;

-				if (yych <= '9') goto yy186;

-			} else {

-				if (yych == 'L') goto yy721;

-				if (yych <= 'Z') goto yy186;

-			}

-		} else {

-			if (yych <= 'k') {

-				if (yych != '`') goto yy186;

-			} else {

-				if (yych <= 'l') goto yy721;

-				if (yych <= 'z') goto yy186;

-				if (yych >= 0x7F) goto yy186;

-			}

-		}

-yy720:

-		YYDEBUG(720, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1306 "Zend/zend_language_scanner.l"

-		{

-	return T_FINAL;

-}

-#line 6660 "Zend/zend_language_scanner.c"

-yy721:

-		YYDEBUG(721, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'Y') goto yy722;

-		if (yych != 'y') goto yy187;

-yy722:

-		YYDEBUG(722, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(723, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1046 "Zend/zend_language_scanner.l"

-		{

-	return T_FINALLY;

-}

-#line 6678 "Zend/zend_language_scanner.c"

-yy724:

-		YYDEBUG(724, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'F') {

-			if (yych == 'C') goto yy730;

-			if (yych <= 'E') goto yy187;

-			goto yy731;

-		} else {

-			if (yych <= 'c') {

-				if (yych <= 'b') goto yy187;

-				goto yy730;

-			} else {

-				if (yych == 'f') goto yy731;

-				goto yy187;

-			}

-		}

-yy725:

-		YYDEBUG(725, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy728;

-		if (yych == 'e') goto yy728;

-		goto yy187;

-yy726:

-		YYDEBUG(726, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(727, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1078 "Zend/zend_language_scanner.l"

-		{

-	return T_DO;

-}

-#line 6713 "Zend/zend_language_scanner.c"

-yy728:

-		YYDEBUG(728, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(729, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1018 "Zend/zend_language_scanner.l"

-		{

-	return T_EXIT;

-}

-#line 6726 "Zend/zend_language_scanner.c"

-yy730:

-		YYDEBUG(730, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy737;

-		if (yych == 'l') goto yy737;

-		goto yy187;

-yy731:

-		YYDEBUG(731, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy732;

-		if (yych != 'a') goto yy187;

-yy732:

-		YYDEBUG(732, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'U') goto yy733;

-		if (yych != 'u') goto yy187;

-yy733:

-		YYDEBUG(733, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy734;

-		if (yych != 'l') goto yy187;

-yy734:

-		YYDEBUG(734, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy735;

-		if (yych != 't') goto yy187;

-yy735:

-		YYDEBUG(735, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(736, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1126 "Zend/zend_language_scanner.l"

-		{

-	return T_DEFAULT;

-}

-#line 6765 "Zend/zend_language_scanner.c"

-yy737:

-		YYDEBUG(737, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy738;

-		if (yych != 'a') goto yy187;

-yy738:

-		YYDEBUG(738, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy739;

-		if (yych != 'r') goto yy187;

-yy739:

-		YYDEBUG(739, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy740;

-		if (yych != 'e') goto yy187;

-yy740:

-		YYDEBUG(740, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(741, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1098 "Zend/zend_language_scanner.l"

-		{

-	return T_DECLARE;

-}

-#line 6793 "Zend/zend_language_scanner.c"

-yy742:

-		YYDEBUG(742, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy804;

-		if (yych == 'h') goto yy804;

-		goto yy187;

-yy743:

-		YYDEBUG(743, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy798;

-		if (yych == 's') goto yy798;

-		goto yy187;

-yy744:

-		YYDEBUG(744, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'P') goto yy794;

-		if (yych == 'p') goto yy794;

-		goto yy187;

-yy745:

-		YYDEBUG(745, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy760;

-		if (yych == 'd') goto yy760;

-		goto yy187;

-yy746:

-		YYDEBUG(746, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy757;

-		if (yych == 'a') goto yy757;

-		goto yy187;

-yy747:

-		YYDEBUG(747, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych <= 'T') {

-			if (yych == 'I') goto yy748;

-			if (yych <= 'S') goto yy187;

-			goto yy749;

-		} else {

-			if (yych <= 'i') {

-				if (yych <= 'h') goto yy187;

-			} else {

-				if (yych == 't') goto yy749;

-				goto yy187;

-			}

-		}

-yy748:

-		YYDEBUG(748, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy755;

-		if (yych == 't') goto yy755;

-		goto yy187;

-yy749:

-		YYDEBUG(749, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy750;

-		if (yych != 'e') goto yy187;

-yy750:

-		YYDEBUG(750, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'N') goto yy751;

-		if (yych != 'n') goto yy187;

-yy751:

-		YYDEBUG(751, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'D') goto yy752;

-		if (yych != 'd') goto yy187;

-yy752:

-		YYDEBUG(752, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'S') goto yy753;

-		if (yych != 's') goto yy187;

-yy753:

-		YYDEBUG(753, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(754, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1162 "Zend/zend_language_scanner.l"

-		{

-	return T_EXTENDS;

-}

-#line 6877 "Zend/zend_language_scanner.c"

-yy755:

-		YYDEBUG(755, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(756, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1014 "Zend/zend_language_scanner.l"

-		{

-	return T_EXIT;

-}

-#line 6890 "Zend/zend_language_scanner.c"

-yy757:

-		YYDEBUG(757, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy758;

-		if (yych != 'l') goto yy187;

-yy758:

-		YYDEBUG(758, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(759, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1250 "Zend/zend_language_scanner.l"

-		{

-	return T_EVAL;

-}

-#line 6908 "Zend/zend_language_scanner.c"

-yy760:

-		YYDEBUG(760, *YYCURSOR);

-		yych = *++YYCURSOR;

-		YYDEBUG(-1, yych);

-		switch (yych) {

-		case 'D':

-		case 'd':	goto yy761;

-		case 'F':

-		case 'f':	goto yy762;

-		case 'I':

-		case 'i':	goto yy763;

-		case 'S':

-		case 's':	goto yy764;

-		case 'W':

-		case 'w':	goto yy765;

-		default:	goto yy187;

-		}

-yy761:

-		YYDEBUG(761, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy787;

-		if (yych == 'e') goto yy787;

-		goto yy187;

-yy762:

-		YYDEBUG(762, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy779;

-		if (yych == 'o') goto yy779;

-		goto yy187;

-yy763:

-		YYDEBUG(763, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'F') goto yy777;

-		if (yych == 'f') goto yy777;

-		goto yy187;

-yy764:

-		YYDEBUG(764, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'W') goto yy771;

-		if (yych == 'w') goto yy771;

-		goto yy187;

-yy765:

-		YYDEBUG(765, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy766;

-		if (yych != 'h') goto yy187;

-yy766:

-		YYDEBUG(766, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy767;

-		if (yych != 'i') goto yy187;

-yy767:

-		YYDEBUG(767, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy768;

-		if (yych != 'l') goto yy187;

-yy768:

-		YYDEBUG(768, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy769;

-		if (yych != 'e') goto yy187;

-yy769:

-		YYDEBUG(769, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(770, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1074 "Zend/zend_language_scanner.l"

-		{

-	return T_ENDWHILE;

-}

-#line 6982 "Zend/zend_language_scanner.c"

-yy771:

-		YYDEBUG(771, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'I') goto yy772;

-		if (yych != 'i') goto yy187;

-yy772:

-		YYDEBUG(772, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy773;

-		if (yych != 't') goto yy187;

-yy773:

-		YYDEBUG(773, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy774;

-		if (yych != 'c') goto yy187;

-yy774:

-		YYDEBUG(774, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy775;

-		if (yych != 'h') goto yy187;

-yy775:

-		YYDEBUG(775, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(776, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1118 "Zend/zend_language_scanner.l"

-		{

-	return T_ENDSWITCH;

-}

-#line 7015 "Zend/zend_language_scanner.c"

-yy777:

-		YYDEBUG(777, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(778, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1062 "Zend/zend_language_scanner.l"

-		{

-	return T_ENDIF;

-}

-#line 7028 "Zend/zend_language_scanner.c"

-yy779:

-		YYDEBUG(779, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy780;

-		if (yych != 'r') goto yy187;

-yy780:

-		YYDEBUG(780, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '^') {

-			if (yych <= '@') {

-				if (yych <= '/') goto yy781;

-				if (yych <= '9') goto yy186;

-			} else {

-				if (yych == 'E') goto yy782;

-				if (yych <= 'Z') goto yy186;

-			}

-		} else {

-			if (yych <= 'd') {

-				if (yych != '`') goto yy186;

-			} else {

-				if (yych <= 'e') goto yy782;

-				if (yych <= 'z') goto yy186;

-				if (yych >= 0x7F) goto yy186;

-			}

-		}

-yy781:

-		YYDEBUG(781, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1086 "Zend/zend_language_scanner.l"

-		{

-	return T_ENDFOR;

-}

-#line 7061 "Zend/zend_language_scanner.c"

-yy782:

-		YYDEBUG(782, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy783;

-		if (yych != 'a') goto yy187;

-yy783:

-		YYDEBUG(783, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy784;

-		if (yych != 'c') goto yy187;

-yy784:

-		YYDEBUG(784, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'H') goto yy785;

-		if (yych != 'h') goto yy187;

-yy785:

-		YYDEBUG(785, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(786, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1094 "Zend/zend_language_scanner.l"

-		{

-	return T_ENDFOREACH;

-}

-#line 7089 "Zend/zend_language_scanner.c"

-yy787:

-		YYDEBUG(787, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'C') goto yy788;

-		if (yych != 'c') goto yy187;

-yy788:

-		YYDEBUG(788, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'L') goto yy789;

-		if (yych != 'l') goto yy187;

-yy789:

-		YYDEBUG(789, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'A') goto yy790;

-		if (yych != 'a') goto yy187;

-yy790:

-		YYDEBUG(790, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'R') goto yy791;

-		if (yych != 'r') goto yy187;

-yy791:

-		YYDEBUG(791, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy792;

-		if (yych != 'e') goto yy187;

-yy792:

-		YYDEBUG(792, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(793, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1102 "Zend/zend_language_scanner.l"

-		{

-	return T_ENDDECLARE;

-}

-#line 7127 "Zend/zend_language_scanner.c"

-yy794:

-		YYDEBUG(794, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'T') goto yy795;

-		if (yych != 't') goto yy187;

-yy795:

-		YYDEBUG(795, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'Y') goto yy796;

-		if (yych != 'y') goto yy187;

-yy796:

-		YYDEBUG(796, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(797, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1290 "Zend/zend_language_scanner.l"

-		{

-	return T_EMPTY;

-}

-#line 7150 "Zend/zend_language_scanner.c"

-yy798:

-		YYDEBUG(798, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'E') goto yy799;

-		if (yych != 'e') goto yy187;

-yy799:

-		YYDEBUG(799, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '^') {

-			if (yych <= '@') {

-				if (yych <= '/') goto yy800;

-				if (yych <= '9') goto yy186;

-			} else {

-				if (yych == 'I') goto yy801;

-				if (yych <= 'Z') goto yy186;

-			}

-		} else {

-			if (yych <= 'h') {

-				if (yych != '`') goto yy186;

-			} else {

-				if (yych <= 'i') goto yy801;

-				if (yych <= 'z') goto yy186;

-				if (yych >= 0x7F) goto yy186;

-			}

-		}

-yy800:

-		YYDEBUG(800, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1066 "Zend/zend_language_scanner.l"

-		{

-	return T_ELSE;

-}

-#line 7183 "Zend/zend_language_scanner.c"

-yy801:

-		YYDEBUG(801, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'F') goto yy802;

-		if (yych != 'f') goto yy187;

-yy802:

-		YYDEBUG(802, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(803, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1058 "Zend/zend_language_scanner.l"

-		{

-	return T_ELSEIF;

-}

-#line 7201 "Zend/zend_language_scanner.c"

-yy804:

-		YYDEBUG(804, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yych == 'O') goto yy805;

-		if (yych != 'o') goto yy187;

-yy805:

-		YYDEBUG(805, *YYCURSOR);

-		++YYCURSOR;

-		if (yybm[0+(yych = *YYCURSOR)] & 4) {

-			goto yy186;

-		}

-		YYDEBUG(806, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1142 "Zend/zend_language_scanner.l"

-		{

-	return T_ECHO;

-}

-#line 7219 "Zend/zend_language_scanner.c"

-	}

-/* *********************************** */

-yyc_ST_LOOKING_FOR_PROPERTY:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0, 128, 128,   0,   0, 128,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,   0,   0,   0,   0,   0,   0, 

-			  0,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,   0,   0,   0,   0,  64, 

-			  0,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,   0,   0,   0,   0,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-			 64,  64,  64,  64,  64,  64,  64,  64, 

-		};

-		YYDEBUG(807, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych <= '-') {

-			if (yych <= '\r') {

-				if (yych <= 0x08) goto yy815;

-				if (yych <= '\n') goto yy809;

-				if (yych <= '\f') goto yy815;

-			} else {

-				if (yych == ' ') goto yy809;

-				if (yych <= ',') goto yy815;

-				goto yy811;

-			}

-		} else {

-			if (yych <= '_') {

-				if (yych <= '@') goto yy815;

-				if (yych <= 'Z') goto yy813;

-				if (yych <= '^') goto yy815;

-				goto yy813;

-			} else {

-				if (yych <= '`') goto yy815;

-				if (yych <= 'z') goto yy813;

-				if (yych <= '~') goto yy815;

-				goto yy813;

-			}

-		}

-yy809:

-		YYDEBUG(809, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy821;

-yy810:

-		YYDEBUG(810, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1175 "Zend/zend_language_scanner.l"

-		{

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */

-	HANDLE_NEWLINES(yytext, yyleng);

-	return T_WHITESPACE;

-}

-#line 7298 "Zend/zend_language_scanner.c"

-yy811:

-		YYDEBUG(811, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) == '>') goto yy818;

-yy812:

-		YYDEBUG(812, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1192 "Zend/zend_language_scanner.l"

-		{

-	yyless(0);

-	yy_pop_state(TSRMLS_C);

-	goto restart;

-}

-#line 7312 "Zend/zend_language_scanner.c"

-yy813:

-		YYDEBUG(813, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy817;

-yy814:

-		YYDEBUG(814, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1185 "Zend/zend_language_scanner.l"

-		{

-	yy_pop_state(TSRMLS_C);

-	zend_copy_value(zendlval, yytext, yyleng);

-	zendlval->type = IS_STRING;

-	return T_STRING;

-}

-#line 7328 "Zend/zend_language_scanner.c"

-yy815:

-		YYDEBUG(815, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy812;

-yy816:

-		YYDEBUG(816, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy817:

-		YYDEBUG(817, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy816;

-		}

-		goto yy814;

-yy818:

-		YYDEBUG(818, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(819, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1181 "Zend/zend_language_scanner.l"

-		{

-	return T_OBJECT_OPERATOR;

-}

-#line 7353 "Zend/zend_language_scanner.c"

-yy820:

-		YYDEBUG(820, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy821:

-		YYDEBUG(821, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy820;

-		}

-		goto yy810;

-	}

-/* *********************************** */

-yyc_ST_LOOKING_FOR_VARNAME:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128,   0,   0,   0,   0,   0,   0, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			  0, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128,   0,   0,   0,   0, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-			128, 128, 128, 128, 128, 128, 128, 128, 

-		};

-		YYDEBUG(822, *YYCURSOR);

-		YYFILL(2);

-		yych = *YYCURSOR;

-		if (yych <= '_') {

-			if (yych <= '@') goto yy826;

-			if (yych <= 'Z') goto yy824;

-			if (yych <= '^') goto yy826;

-		} else {

-			if (yych <= '`') goto yy826;

-			if (yych <= 'z') goto yy824;

-			if (yych <= '~') goto yy826;

-		}

-yy824:

-		YYDEBUG(824, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= '_') {

-			if (yych <= '@') {

-				if (yych <= '/') goto yy825;

-				if (yych <= '9') goto yy828;

-			} else {

-				if (yych <= '[') goto yy828;

-				if (yych >= '_') goto yy828;

-			}

-		} else {

-			if (yych <= '|') {

-				if (yych <= '`') goto yy825;

-				if (yych <= 'z') goto yy828;

-			} else {

-				if (yych != '~') goto yy828;

-			}

-		}

-yy825:

-		YYDEBUG(825, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1490 "Zend/zend_language_scanner.l"

-		{

-	yyless(0);

-	yy_pop_state(TSRMLS_C);

-	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);

-	goto restart;

-}

-#line 7445 "Zend/zend_language_scanner.c"

-yy826:

-		YYDEBUG(826, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy825;

-yy827:

-		YYDEBUG(827, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy828:

-		YYDEBUG(828, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy827;

-		}

-		if (yych == '[') goto yy830;

-		if (yych == '}') goto yy830;

-		YYDEBUG(829, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		goto yy825;

-yy830:

-		YYDEBUG(830, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(831, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1480 "Zend/zend_language_scanner.l"

-		{

-	yyless(yyleng - 1);

-	zend_copy_value(zendlval, yytext, yyleng);

-	zendlval->type = IS_STRING;

-	yy_pop_state(TSRMLS_C);

-	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);

-	return T_STRING_VARNAME;

-}

-#line 7479 "Zend/zend_language_scanner.c"

-	}

-/* *********************************** */

-yyc_ST_NOWDOC:

-	YYDEBUG(832, *YYCURSOR);

-	YYFILL(1);

-	yych = *YYCURSOR;

-	YYDEBUG(834, *YYCURSOR);

-	++YYCURSOR;

-	YYDEBUG(835, *YYCURSOR);

-	yyleng = YYCURSOR - SCNG(yy_text);

-#line 2310 "Zend/zend_language_scanner.l"

-	{

-	int newline = 0;

-

-	zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));

-

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-

-	YYCURSOR--;

-

-	while (YYCURSOR < YYLIMIT) {

-		switch (*YYCURSOR++) {

-			case '\r':

-				if (*YYCURSOR == '\n') {

-					YYCURSOR++;

-				}

-				/* fall through */

-			case '\n':

-				/* Check for ending label on the next line */

-				if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {

-					YYCTYPE *end = YYCURSOR + heredoc_label->length;

-

-					if (*end == ';') {

-						end++;

-					}

-

-					if (*end == '\n' || *end == '\r') {

-						/* newline before label will be subtracted from returned text, but

-						 * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */

-						if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {

-							newline = 2; /* Windows newline */

-						} else {

-							newline = 1;

-						}

-

-						CG(increment_lineno) = 1; /* For newline before label */

-						BEGIN(ST_END_HEREDOC);

-

-						goto nowdoc_scan_done;

-					}

-				}

-				/* fall through */

-			default:

-				continue;

-		}

-	}

-

-nowdoc_scan_done:

-	yyleng = YYCURSOR - SCNG(yy_text);

-

-	zend_copy_value(zendlval, yytext, yyleng - newline);

-	zendlval->type = IS_STRING;

-	HANDLE_NEWLINES(yytext, yyleng - newline);

-	return T_ENCAPSED_AND_WHITESPACE;

-}

-#line 7547 "Zend/zend_language_scanner.c"

-/* *********************************** */

-yyc_ST_VAR_OFFSET:

-	{

-		static const unsigned char yybm[] = {

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			  0,   0,   0,   0,   0,   0,   0,   0, 

-			240, 240, 112, 112, 112, 112, 112, 112, 

-			112, 112,   0,   0,   0,   0,   0,   0, 

-			  0,  80,  80,  80,  80,  80,  80,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,   0,   0,   0,   0,  16, 

-			  0,  80,  80,  80,  80,  80,  80,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,   0,   0,   0,   0,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-			 16,  16,  16,  16,  16,  16,  16,  16, 

-		};

-		YYDEBUG(836, *YYCURSOR);

-		YYFILL(3);

-		yych = *YYCURSOR;

-		if (yych <= '/') {

-			if (yych <= ' ') {

-				if (yych <= '\f') {

-					if (yych <= 0x08) goto yy850;

-					if (yych <= '\n') goto yy846;

-					goto yy850;

-				} else {

-					if (yych <= '\r') goto yy846;

-					if (yych <= 0x1F) goto yy850;

-					goto yy846;

-				}

-			} else {

-				if (yych <= '$') {

-					if (yych <= '"') goto yy845;

-					if (yych <= '#') goto yy846;

-					goto yy841;

-				} else {

-					if (yych == '\'') goto yy846;

-					goto yy845;

-				}

-			}

-		} else {

-			if (yych <= '\\') {

-				if (yych <= '@') {

-					if (yych <= '0') goto yy838;

-					if (yych <= '9') goto yy840;

-					goto yy845;

-				} else {

-					if (yych <= 'Z') goto yy848;

-					if (yych <= '[') goto yy845;

-					goto yy846;

-				}

-			} else {

-				if (yych <= '_') {

-					if (yych <= ']') goto yy843;

-					if (yych <= '^') goto yy845;

-					goto yy848;

-				} else {

-					if (yych <= '`') goto yy845;

-					if (yych <= 'z') goto yy848;

-					if (yych <= '~') goto yy845;

-					goto yy848;

-				}

-			}

-		}

-yy838:

-		YYDEBUG(838, *YYCURSOR);

-		yyaccept = 0;

-		yych = *(YYMARKER = ++YYCURSOR);

-		if (yych <= 'W') {

-			if (yych <= '9') {

-				if (yych >= '0') goto yy862;

-			} else {

-				if (yych == 'B') goto yy859;

-			}

-		} else {

-			if (yych <= 'b') {

-				if (yych <= 'X') goto yy861;

-				if (yych >= 'b') goto yy859;

-			} else {

-				if (yych == 'x') goto yy861;

-			}

-		}

-yy839:

-		YYDEBUG(839, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1566 "Zend/zend_language_scanner.l"

-		{ /* Offset could be treated as a long */

-	if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {

-		ZVAL_LONG(zendlval, strtol(yytext, NULL, 10));

-	} else {

-		ZVAL_STRINGL(zendlval, yytext, yyleng, 1);

-	}

-	return T_NUM_STRING;

-}

-#line 7663 "Zend/zend_language_scanner.c"

-yy840:

-		YYDEBUG(840, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy858;

-yy841:

-		YYDEBUG(841, *YYCURSOR);

-		++YYCURSOR;

-		if ((yych = *YYCURSOR) <= '_') {

-			if (yych <= '@') goto yy842;

-			if (yych <= 'Z') goto yy854;

-			if (yych >= '_') goto yy854;

-		} else {

-			if (yych <= '`') goto yy842;

-			if (yych <= 'z') goto yy854;

-			if (yych >= 0x7F) goto yy854;

-		}

-yy842:

-		YYDEBUG(842, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1842 "Zend/zend_language_scanner.l"

-		{

-	/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */

-	return yytext[0];

-}

-#line 7688 "Zend/zend_language_scanner.c"

-yy843:

-		YYDEBUG(843, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(844, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1837 "Zend/zend_language_scanner.l"

-		{

-	yy_pop_state(TSRMLS_C);

-	return ']';

-}

-#line 7699 "Zend/zend_language_scanner.c"

-yy845:

-		YYDEBUG(845, *YYCURSOR);

-		yych = *++YYCURSOR;

-		goto yy842;

-yy846:

-		YYDEBUG(846, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(847, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1847 "Zend/zend_language_scanner.l"

-		{

-	/* Invalid rule to return a more explicit parse error with proper line number */

-	yyless(0);

-	yy_pop_state(TSRMLS_C);

-	return T_ENCAPSED_AND_WHITESPACE;

-}

-#line 7716 "Zend/zend_language_scanner.c"

-yy848:

-		YYDEBUG(848, *YYCURSOR);

-		++YYCURSOR;

-		yych = *YYCURSOR;

-		goto yy853;

-yy849:

-		YYDEBUG(849, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1854 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, yytext, yyleng);

-	zendlval->type = IS_STRING;

-	return T_STRING;

-}

-#line 7731 "Zend/zend_language_scanner.c"

-yy850:

-		YYDEBUG(850, *YYCURSOR);

-		++YYCURSOR;

-		YYDEBUG(851, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 2368 "Zend/zend_language_scanner.l"

-		{

-	if (YYCURSOR > YYLIMIT) {

-		return 0;

-	}

-

-	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);

-	goto restart;

-}

-#line 7746 "Zend/zend_language_scanner.c"

-yy852:

-		YYDEBUG(852, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy853:

-		YYDEBUG(853, *YYCURSOR);

-		if (yybm[0+yych] & 16) {

-			goto yy852;

-		}

-		goto yy849;

-yy854:

-		YYDEBUG(854, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(855, *YYCURSOR);

-		if (yych <= '^') {

-			if (yych <= '9') {

-				if (yych >= '0') goto yy854;

-			} else {

-				if (yych <= '@') goto yy856;

-				if (yych <= 'Z') goto yy854;

-			}

-		} else {

-			if (yych <= '`') {

-				if (yych <= '_') goto yy854;

-			} else {

-				if (yych <= 'z') goto yy854;

-				if (yych >= 0x7F) goto yy854;

-			}

-		}

-yy856:

-		YYDEBUG(856, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1831 "Zend/zend_language_scanner.l"

-		{

-	zend_copy_value(zendlval, (yytext+1), (yyleng-1));

-	zendlval->type = IS_STRING;

-	return T_VARIABLE;

-}

-#line 7788 "Zend/zend_language_scanner.c"

-yy857:

-		YYDEBUG(857, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-yy858:

-		YYDEBUG(858, *YYCURSOR);

-		if (yybm[0+yych] & 32) {

-			goto yy857;

-		}

-		goto yy839;

-yy859:

-		YYDEBUG(859, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yybm[0+yych] & 128) {

-			goto yy867;

-		}

-yy860:

-		YYDEBUG(860, *YYCURSOR);

-		YYCURSOR = YYMARKER;

-		goto yy839;

-yy861:

-		YYDEBUG(861, *YYCURSOR);

-		yych = *++YYCURSOR;

-		if (yybm[0+yych] & 64) {

-			goto yy865;

-		}

-		goto yy860;

-yy862:

-		YYDEBUG(862, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(863, *YYCURSOR);

-		if (yych <= '/') goto yy864;

-		if (yych <= '9') goto yy862;

-yy864:

-		YYDEBUG(864, *YYCURSOR);

-		yyleng = YYCURSOR - SCNG(yy_text);

-#line 1575 "Zend/zend_language_scanner.l"

-		{ /* Offset must be treated as a string */

-	ZVAL_STRINGL(zendlval, yytext, yyleng, 1);

-	return T_NUM_STRING;

-}

-#line 7833 "Zend/zend_language_scanner.c"

-yy865:

-		YYDEBUG(865, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(866, *YYCURSOR);

-		if (yybm[0+yych] & 64) {

-			goto yy865;

-		}

-		goto yy864;

-yy867:

-		YYDEBUG(867, *YYCURSOR);

-		++YYCURSOR;

-		YYFILL(1);

-		yych = *YYCURSOR;

-		YYDEBUG(868, *YYCURSOR);

-		if (yybm[0+yych] & 128) {

-			goto yy867;

-		}

-		goto yy864;

-	}

-}

-#line 2377 "Zend/zend_language_scanner.l"

-

-}

+/* Generated by re2c 0.13.5 */
+#line 1 "Zend/zend_language_scanner.l"
+/*
+   +----------------------------------------------------------------------+
+   | Zend Engine                                                          |
+   +----------------------------------------------------------------------+
+   | Copyright (c) 1998-2014 Zend Technologies Ltd. (http://www.zend.com) |
+   +----------------------------------------------------------------------+
+   | This source file is subject to version 2.00 of the Zend license,     |
+   | that is bundled with this package in the file LICENSE, and is        |
+   | available through the world-wide-web at the following url:           |
+   | http://www.zend.com/license/2_00.txt.                                |
+   | If you did not receive a copy of the Zend license and are unable to  |
+   | obtain it through the world-wide-web, please send a note to          |
+   | license@zend.com so we can mail you a copy immediately.              |
+   +----------------------------------------------------------------------+
+   | Authors: Marcus Boerger <helly@php.net>                              |
+   |          Nuno Lopes <nlopess@php.net>                                |
+   |          Scott MacVicar <scottmac@php.net>                           |
+   | Flex version authors:                                                |
+   |          Andi Gutmans <andi@zend.com>                                |
+   |          Zeev Suraski <zeev@zend.com>                                |
+   +----------------------------------------------------------------------+
+*/
+
+/* $Id$ */
+
+#if 0
+# define YYDEBUG(s, c) printf("state: %d char: %c\n", s, c)
+#else
+# define YYDEBUG(s, c)
+#endif
+
+#include "zend_language_scanner_defs.h"
+
+#include <errno.h>
+#include "zend.h"
+#ifdef PHP_WIN32
+# include <Winuser.h>
+#endif
+#include "zend_alloc.h"
+#include <zend_language_parser.h>
+#include "zend_compile.h"
+#include "zend_language_scanner.h"
+#include "zend_highlight.h"
+#include "zend_constants.h"
+#include "zend_variables.h"
+#include "zend_operators.h"
+#include "zend_API.h"
+#include "zend_strtod.h"
+#include "zend_exceptions.h"
+#include "zend_virtual_cwd.h"
+#include "tsrm_config_common.h"
+
+#define YYCTYPE   unsigned char
+#define YYFILL(n) { if ((YYCURSOR + n) >= (YYLIMIT + ZEND_MMAP_AHEAD)) { return 0; } }
+#define YYCURSOR  SCNG(yy_cursor)
+#define YYLIMIT   SCNG(yy_limit)
+#define YYMARKER  SCNG(yy_marker)
+
+#define YYGETCONDITION()  SCNG(yy_state)
+#define YYSETCONDITION(s) SCNG(yy_state) = s
+
+#define STATE(name)  yyc##name
+
+/* emulate flex constructs */
+#define BEGIN(state) YYSETCONDITION(STATE(state))
+#define YYSTATE      YYGETCONDITION()
+#define yytext       ((char*)SCNG(yy_text))
+#define yyleng       SCNG(yy_leng)
+#define yyless(x)    do { YYCURSOR = (unsigned char*)yytext + x; \
+                          yyleng   = (unsigned int)x; } while(0)
+#define yymore()     goto yymore_restart
+
+/* perform sanity check. If this message is triggered you should
+   increase the ZEND_MMAP_AHEAD value in the zend_streams.h file */
+#define YYMAXFILL 16
+#if ZEND_MMAP_AHEAD < YYMAXFILL
+# error ZEND_MMAP_AHEAD should be greater than or equal to YYMAXFILL
+#endif
+
+#ifdef HAVE_STDARG_H
+# include <stdarg.h>
+#endif
+
+#ifdef HAVE_UNISTD_H
+# include <unistd.h>
+#endif
+
+/* Globals Macros */
+#define SCNG	LANG_SCNG
+#ifdef ZTS
+ZEND_API ts_rsrc_id language_scanner_globals_id;
+#else
+ZEND_API zend_php_scanner_globals language_scanner_globals;
+#endif
+
+#define HANDLE_NEWLINES(s, l)													\
+do {																			\
+	char *p = (s), *boundary = p+(l);											\
+																				\
+	while (p<boundary) {														\
+		if (*p == '\n' || (*p == '\r' && (*(p+1) != '\n'))) {					\
+			CG(zend_lineno)++;													\
+		}																		\
+		p++;																	\
+	}																			\
+} while (0)
+
+#define HANDLE_NEWLINE(c) \
+{ \
+	if (c == '\n' || c == '\r') { \
+		CG(zend_lineno)++; \
+	} \
+}
+
+/* To save initial string length after scanning to first variable */
+#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(scanned_string_len) = (len)
+#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    SCNG(scanned_string_len)
+
+#define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
+
+#define ZEND_IS_OCT(c)  ((c)>='0' && (c)<='7')
+#define ZEND_IS_HEX(c)  (((c)>='0' && (c)<='9') || ((c)>='a' && (c)<='f') || ((c)>='A' && (c)<='F'))
+
+BEGIN_EXTERN_C()
+
+static size_t encoding_filter_script_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)
+{
+	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding(TSRMLS_C);
+	assert(internal_encoding && zend_multibyte_check_lexer_compatibility(internal_encoding));
+	return zend_multibyte_encoding_converter(to, to_length, from, from_length, internal_encoding, LANG_SCNG(script_encoding) TSRMLS_CC);
+}
+
+static size_t encoding_filter_script_to_intermediate(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)
+{
+	return zend_multibyte_encoding_converter(to, to_length, from, from_length, zend_multibyte_encoding_utf8, LANG_SCNG(script_encoding) TSRMLS_CC);
+}
+
+static size_t encoding_filter_intermediate_to_script(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)
+{
+	return zend_multibyte_encoding_converter(to, to_length, from, from_length,
+LANG_SCNG(script_encoding), zend_multibyte_encoding_utf8 TSRMLS_CC);
+}
+
+static size_t encoding_filter_intermediate_to_internal(unsigned char **to, size_t *to_length, const unsigned char *from, size_t from_length TSRMLS_DC)
+{
+	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding(TSRMLS_C);
+	assert(internal_encoding && zend_multibyte_check_lexer_compatibility(internal_encoding));
+	return zend_multibyte_encoding_converter(to, to_length, from, from_length,
+internal_encoding, zend_multibyte_encoding_utf8 TSRMLS_CC);
+}
+
+
+static void _yy_push_state(int new_state TSRMLS_DC)
+{
+	zend_stack_push(&SCNG(state_stack), (void *) &YYGETCONDITION(), sizeof(int));
+	YYSETCONDITION(new_state);
+}
+
+#define yy_push_state(state_and_tsrm) _yy_push_state(yyc##state_and_tsrm)
+
+static void yy_pop_state(TSRMLS_D)
+{
+	int *stack_state;
+	zend_stack_top(&SCNG(state_stack), (void **) &stack_state);
+	YYSETCONDITION(*stack_state);
+	zend_stack_del_top(&SCNG(state_stack));
+}
+
+static void yy_scan_buffer(char *str, unsigned int len TSRMLS_DC)
+{
+	YYCURSOR       = (YYCTYPE*)str;
+	YYLIMIT        = YYCURSOR + len;
+	if (!SCNG(yy_start)) {
+		SCNG(yy_start) = YYCURSOR;
+	}
+}
+
+void startup_scanner(TSRMLS_D)
+{
+	CG(parse_error) = 0;
+	CG(doc_comment) = NULL;
+	zend_stack_init(&SCNG(state_stack));
+	zend_ptr_stack_init(&SCNG(heredoc_label_stack));
+}
+
+static void heredoc_label_dtor(zend_heredoc_label *heredoc_label) {
+    efree(heredoc_label->label);
+}
+
+void shutdown_scanner(TSRMLS_D)
+{
+	CG(parse_error) = 0;
+	RESET_DOC_COMMENT();
+	zend_stack_destroy(&SCNG(state_stack));
+	zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);
+	zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));
+}
+
+ZEND_API void zend_save_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
+{
+	lex_state->yy_leng   = SCNG(yy_leng);
+	lex_state->yy_start  = SCNG(yy_start);
+	lex_state->yy_text   = SCNG(yy_text);
+	lex_state->yy_cursor = SCNG(yy_cursor);
+	lex_state->yy_marker = SCNG(yy_marker);
+	lex_state->yy_limit  = SCNG(yy_limit);
+
+	lex_state->state_stack = SCNG(state_stack);
+	zend_stack_init(&SCNG(state_stack));
+
+	lex_state->heredoc_label_stack = SCNG(heredoc_label_stack);
+	zend_ptr_stack_init(&SCNG(heredoc_label_stack));
+
+	lex_state->in = SCNG(yy_in);
+	lex_state->yy_state = YYSTATE;
+	lex_state->filename = zend_get_compiled_filename(TSRMLS_C);
+	lex_state->lineno = CG(zend_lineno);
+
+	lex_state->script_org = SCNG(script_org);
+	lex_state->script_org_size = SCNG(script_org_size);
+	lex_state->script_filtered = SCNG(script_filtered);
+	lex_state->script_filtered_size = SCNG(script_filtered_size);
+	lex_state->input_filter = SCNG(input_filter);
+	lex_state->output_filter = SCNG(output_filter);
+	lex_state->script_encoding = SCNG(script_encoding);
+}
+
+ZEND_API void zend_restore_lexical_state(zend_lex_state *lex_state TSRMLS_DC)
+{
+	SCNG(yy_leng)   = lex_state->yy_leng;
+	SCNG(yy_start)  = lex_state->yy_start;
+	SCNG(yy_text)   = lex_state->yy_text;
+	SCNG(yy_cursor) = lex_state->yy_cursor;
+	SCNG(yy_marker) = lex_state->yy_marker;
+	SCNG(yy_limit)  = lex_state->yy_limit;
+
+	zend_stack_destroy(&SCNG(state_stack));
+	SCNG(state_stack) = lex_state->state_stack;
+
+	zend_ptr_stack_clean(&SCNG(heredoc_label_stack), (void (*)(void *)) &heredoc_label_dtor, 1);
+	zend_ptr_stack_destroy(&SCNG(heredoc_label_stack));
+	SCNG(heredoc_label_stack) = lex_state->heredoc_label_stack;
+
+	SCNG(yy_in) = lex_state->in;
+	YYSETCONDITION(lex_state->yy_state);
+	CG(zend_lineno) = lex_state->lineno;
+	zend_restore_compiled_filename(lex_state->filename TSRMLS_CC);
+
+	if (SCNG(script_filtered)) {
+		efree(SCNG(script_filtered));
+		SCNG(script_filtered) = NULL;
+	}
+	SCNG(script_org) = lex_state->script_org;
+	SCNG(script_org_size) = lex_state->script_org_size;
+	SCNG(script_filtered) = lex_state->script_filtered;
+	SCNG(script_filtered_size) = lex_state->script_filtered_size;
+	SCNG(input_filter) = lex_state->input_filter;
+	SCNG(output_filter) = lex_state->output_filter;
+	SCNG(script_encoding) = lex_state->script_encoding;
+
+	RESET_DOC_COMMENT();
+}
+
+ZEND_API void zend_destroy_file_handle(zend_file_handle *file_handle TSRMLS_DC)
+{
+	zend_llist_del_element(&CG(open_files), file_handle, (int (*)(void *, void *)) zend_compare_file_handles);
+	/* zend_file_handle_dtor() operates on the copy, so we have to NULLify the original here */
+	file_handle->opened_path = NULL;
+	if (file_handle->free_filename) {
+		file_handle->filename = NULL;
+	}
+}
+
+#define BOM_UTF32_BE	"\x00\x00\xfe\xff"
+#define	BOM_UTF32_LE	"\xff\xfe\x00\x00"
+#define	BOM_UTF16_BE	"\xfe\xff"
+#define	BOM_UTF16_LE	"\xff\xfe"
+#define	BOM_UTF8		"\xef\xbb\xbf"
+
+static const zend_encoding *zend_multibyte_detect_utf_encoding(const unsigned char *script, size_t script_size TSRMLS_DC)
+{
+	const unsigned char *p;
+	int wchar_size = 2;
+	int le = 0;
+
+	/* utf-16 or utf-32? */
+	p = script;
+	while ((p-script) < script_size) {
+		p = memchr(p, 0, script_size-(p-script)-2);
+		if (!p) {
+			break;
+		}
+		if (*(p+1) == '\0' && *(p+2) == '\0') {
+			wchar_size = 4;
+			break;
+		}
+
+		/* searching for UTF-32 specific byte orders, so this will do */
+		p += 4;
+	}
+
+	/* BE or LE? */
+	p = script;
+	while ((p-script) < script_size) {
+		if (*p == '\0' && *(p+wchar_size-1) != '\0') {
+			/* BE */
+			le = 0;
+			break;
+		} else if (*p != '\0' && *(p+wchar_size-1) == '\0') {
+			/* LE* */
+			le = 1;
+			break;
+		}
+		p += wchar_size;
+	}
+
+	if (wchar_size == 2) {
+		return le ? zend_multibyte_encoding_utf16le : zend_multibyte_encoding_utf16be;
+	} else {
+		return le ? zend_multibyte_encoding_utf32le : zend_multibyte_encoding_utf32be;
+	}
+
+	return NULL;
+}
+
+static const zend_encoding* zend_multibyte_detect_unicode(TSRMLS_D)
+{
+	const zend_encoding *script_encoding = NULL;
+	int bom_size;
+	unsigned char *pos1, *pos2;
+
+	if (LANG_SCNG(script_org_size) < sizeof(BOM_UTF32_LE)-1) {
+		return NULL;
+	}
+
+	/* check out BOM */
+	if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_BE, sizeof(BOM_UTF32_BE)-1)) {
+		script_encoding = zend_multibyte_encoding_utf32be;
+		bom_size = sizeof(BOM_UTF32_BE)-1;
+	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF32_LE, sizeof(BOM_UTF32_LE)-1)) {
+		script_encoding = zend_multibyte_encoding_utf32le;
+		bom_size = sizeof(BOM_UTF32_LE)-1;
+	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_BE, sizeof(BOM_UTF16_BE)-1)) {
+		script_encoding = zend_multibyte_encoding_utf16be;
+		bom_size = sizeof(BOM_UTF16_BE)-1;
+	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF16_LE, sizeof(BOM_UTF16_LE)-1)) {
+		script_encoding = zend_multibyte_encoding_utf16le;
+		bom_size = sizeof(BOM_UTF16_LE)-1;
+	} else if (!memcmp(LANG_SCNG(script_org), BOM_UTF8, sizeof(BOM_UTF8)-1)) {
+		script_encoding = zend_multibyte_encoding_utf8;
+		bom_size = sizeof(BOM_UTF8)-1;
+	}
+
+	if (script_encoding) {
+		/* remove BOM */
+		LANG_SCNG(script_org) += bom_size;
+		LANG_SCNG(script_org_size) -= bom_size;
+
+		return script_encoding;
+	}
+
+	/* script contains NULL bytes -> auto-detection */
+	if ((pos1 = memchr(LANG_SCNG(script_org), 0, LANG_SCNG(script_org_size)))) {
+		/* check if the NULL byte is after the __HALT_COMPILER(); */
+		pos2 = LANG_SCNG(script_org);
+
+		while (pos1 - pos2 >= sizeof("__HALT_COMPILER();")-1) {
+			pos2 = memchr(pos2, '_', pos1 - pos2);
+			if (!pos2) break;
+			pos2++;
+			if (strncasecmp((char*)pos2, "_HALT_COMPILER", sizeof("_HALT_COMPILER")-1) == 0) {
+				pos2 += sizeof("_HALT_COMPILER")-1;
+				while (*pos2 == ' '  ||
+					   *pos2 == '\t' ||
+					   *pos2 == '\r' ||
+					   *pos2 == '\n') {
+					pos2++;
+				}
+				if (*pos2 == '(') {
+					pos2++;
+					while (*pos2 == ' '  ||
+						   *pos2 == '\t' ||
+						   *pos2 == '\r' ||
+						   *pos2 == '\n') {
+						pos2++;
+					}
+					if (*pos2 == ')') {
+						pos2++;
+						while (*pos2 == ' '  ||
+							   *pos2 == '\t' ||
+							   *pos2 == '\r' ||
+							   *pos2 == '\n') {
+							pos2++;
+						}
+						if (*pos2 == ';') {
+							return NULL;
+						}
+					}
+				}
+			}
+		}
+		/* make best effort if BOM is missing */
+		return zend_multibyte_detect_utf_encoding(LANG_SCNG(script_org), LANG_SCNG(script_org_size) TSRMLS_CC);
+	}
+
+	return NULL;
+}
+
+static const zend_encoding* zend_multibyte_find_script_encoding(TSRMLS_D)
+{
+	const zend_encoding *script_encoding;
+
+	if (CG(detect_unicode)) {
+		/* check out bom(byte order mark) and see if containing wchars */
+		script_encoding = zend_multibyte_detect_unicode(TSRMLS_C);
+		if (script_encoding != NULL) {
+			/* bom or wchar detection is prior to 'script_encoding' option */
+			return script_encoding;
+		}
+	}
+
+	/* if no script_encoding specified, just leave alone */
+	if (!CG(script_encoding_list) || !CG(script_encoding_list_size)) {
+		return NULL;
+	}
+
+	/* if multiple encodings specified, detect automagically */
+	if (CG(script_encoding_list_size) > 1) {
+		return zend_multibyte_encoding_detector(LANG_SCNG(script_org), LANG_SCNG(script_org_size), CG(script_encoding_list), CG(script_encoding_list_size) TSRMLS_CC);
+	}
+
+	return CG(script_encoding_list)[0];
+}
+
+ZEND_API int zend_multibyte_set_filter(const zend_encoding *onetime_encoding TSRMLS_DC)
+{
+	const zend_encoding *internal_encoding = zend_multibyte_get_internal_encoding(TSRMLS_C);
+	const zend_encoding *script_encoding = onetime_encoding ? onetime_encoding: zend_multibyte_find_script_encoding(TSRMLS_C);
+
+	if (!script_encoding) {
+		return FAILURE;
+	}
+
+	/* judge input/output filter */
+	LANG_SCNG(script_encoding) = script_encoding;
+	LANG_SCNG(input_filter) = NULL;
+	LANG_SCNG(output_filter) = NULL;
+
+	if (!internal_encoding || LANG_SCNG(script_encoding) == internal_encoding) {
+		if (!zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {
+			/* and if not, work around w/ script_encoding -> utf-8 -> script_encoding conversion */
+			LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;
+			LANG_SCNG(output_filter) = encoding_filter_intermediate_to_script;
+		} else {
+			LANG_SCNG(input_filter) = NULL;
+			LANG_SCNG(output_filter) = NULL;
+		}
+		return SUCCESS;
+	}
+
+	if (zend_multibyte_check_lexer_compatibility(internal_encoding)) {
+		LANG_SCNG(input_filter) = encoding_filter_script_to_internal;
+		LANG_SCNG(output_filter) = NULL;
+	} else if (zend_multibyte_check_lexer_compatibility(LANG_SCNG(script_encoding))) {
+		LANG_SCNG(input_filter) = NULL;
+		LANG_SCNG(output_filter) = encoding_filter_script_to_internal;
+	} else {
+		/* both script and internal encodings are incompatible w/ flex */
+		LANG_SCNG(input_filter) = encoding_filter_script_to_intermediate;
+		LANG_SCNG(output_filter) = encoding_filter_intermediate_to_internal;
+	}
+
+	return 0;
+}
+
+ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
+{
+	const char *file_path = NULL;
+	char *buf;
+	size_t size, offset = 0;
+	zend_string *compiled_filename;
+
+	/* The shebang line was read, get the current position to obtain the buffer start */
+	if (CG(start_lineno) == 2 && file_handle->type == ZEND_HANDLE_FP && file_handle->handle.fp) {
+		if ((offset = ftell(file_handle->handle.fp)) == -1) {
+			offset = 0;
+		}
+	}
+
+	if (zend_stream_fixup(file_handle, &buf, &size TSRMLS_CC) == FAILURE) {
+		return FAILURE;
+	}
+
+	zend_llist_add_element(&CG(open_files), file_handle);
+	if (file_handle->handle.stream.handle >= (void*)file_handle && file_handle->handle.stream.handle <= (void*)(file_handle+1)) {
+		zend_file_handle *fh = (zend_file_handle*)zend_llist_get_last(&CG(open_files));
+		size_t diff = (char*)file_handle->handle.stream.handle - (char*)file_handle;
+		fh->handle.stream.handle = (void*)(((char*)fh) + diff);
+		file_handle->handle.stream.handle = fh->handle.stream.handle;
+	}
+
+	/* Reset the scanner for scanning the new file */
+	SCNG(yy_in) = file_handle;
+	SCNG(yy_start) = NULL;
+
+	if (size != -1) {
+		if (CG(multibyte)) {
+			SCNG(script_org) = (unsigned char*)buf;
+			SCNG(script_org_size) = size;
+			SCNG(script_filtered) = NULL;
+
+			zend_multibyte_set_filter(NULL TSRMLS_CC);
+
+			if (SCNG(input_filter)) {
+				if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC)) {
+					zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
+							"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
+				}
+				buf = (char*)SCNG(script_filtered);
+				size = SCNG(script_filtered_size);
+			}
+		}
+		SCNG(yy_start) = (unsigned char *)buf - offset;
+		yy_scan_buffer(buf, size TSRMLS_CC);
+	} else {
+		zend_error_noreturn(E_COMPILE_ERROR, "zend_stream_mmap() failed");
+	}
+
+	BEGIN(INITIAL);
+
+	if (file_handle->opened_path) {
+		file_path = file_handle->opened_path;
+	} else {
+		file_path = file_handle->filename;
+	}
+
+	compiled_filename = STR_INIT(file_path, strlen(file_path), 0);
+	zend_set_compiled_filename(compiled_filename TSRMLS_CC);
+	STR_RELEASE(compiled_filename);
+
+	if (CG(start_lineno)) {
+		CG(zend_lineno) = CG(start_lineno);
+		CG(start_lineno) = 0;
+	} else {
+		CG(zend_lineno) = 1;
+	}
+
+	RESET_DOC_COMMENT();
+	CG(increment_lineno) = 0;
+	return SUCCESS;
+}
+END_EXTERN_C()
+
+
+ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSRMLS_DC)
+{
+	zend_lex_state original_lex_state;
+	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
+	zend_op_array *original_active_op_array = CG(active_op_array);
+	zend_op_array *retval=NULL;
+	int compiler_result;
+	zend_bool compilation_successful=0;
+	znode retval_znode;
+	zend_bool original_in_compilation = CG(in_compilation);
+
+	retval_znode.op_type = IS_CONST;
+	ZVAL_LONG(&retval_znode.u.constant, 1);
+
+	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
+
+	retval = op_array; /* success oriented */
+
+	if (open_file_for_scanning(file_handle TSRMLS_CC)==FAILURE) {
+		if (type==ZEND_REQUIRE) {
+			zend_message_dispatcher(ZMSG_FAILED_REQUIRE_FOPEN, file_handle->filename TSRMLS_CC);
+			zend_bailout();
+		} else {
+			zend_message_dispatcher(ZMSG_FAILED_INCLUDE_FOPEN, file_handle->filename TSRMLS_CC);
+		}
+		compilation_successful=0;
+	} else {
+		init_op_array(op_array, ZEND_USER_FUNCTION, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
+		CG(in_compilation) = 1;
+		CG(active_op_array) = op_array;
+		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));
+		zend_init_compiler_context(TSRMLS_C);
+		compiler_result = zendparse(TSRMLS_C);
+		zend_do_return(&retval_znode, 0 TSRMLS_CC);
+		CG(in_compilation) = original_in_compilation;
+		if (compiler_result != 0) { /* parser error */
+			zend_bailout();
+		}
+		compilation_successful=1;
+	}
+
+	if (retval) {
+		CG(active_op_array) = original_active_op_array;
+		if (compilation_successful) {
+			pass_two(op_array TSRMLS_CC);
+			zend_release_labels(0 TSRMLS_CC);
+		} else {
+			efree(op_array);
+			retval = NULL;
+		}
+	}
+	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
+	return retval;
+}
+
+
+zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
+{
+	zend_file_handle file_handle;
+	zval tmp;
+	zend_op_array *retval;
+	char *opened_path = NULL;
+
+	if (Z_TYPE_P(filename) != IS_STRING) {
+		tmp = *filename;
+		zval_copy_ctor(&tmp);
+		convert_to_string(&tmp);
+		filename = &tmp;
+	}
+	file_handle.filename = Z_STRVAL_P(filename);
+	file_handle.free_filename = 0;
+	file_handle.type = ZEND_HANDLE_FILENAME;
+	file_handle.opened_path = NULL;
+	file_handle.handle.fp = NULL;
+
+	retval = zend_compile_file(&file_handle, type TSRMLS_CC);
+	if (retval && file_handle.handle.stream.handle) {
+		if (!file_handle.opened_path) {
+			file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRLEN_P(filename));
+		}
+
+		zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path));
+
+		if (opened_path) {
+			efree(opened_path);
+		}
+	}
+	zend_destroy_file_handle(&file_handle TSRMLS_CC);
+
+	if (filename==&tmp) {
+		zval_dtor(&tmp);
+	}
+	return retval;
+}
+
+ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
+{
+	char *buf;
+	size_t size, old_len;
+	zend_string *new_compiled_filename;
+
+	/* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */
+	old_len = Z_STRLEN_P(str);
+	Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);
+	Z_TYPE_INFO_P(str) = IS_STRING_EX;
+	memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);
+
+	SCNG(yy_in) = NULL;
+	SCNG(yy_start) = NULL;
+
+	buf = Z_STRVAL_P(str);
+	size = old_len;
+
+	if (CG(multibyte)) {
+		SCNG(script_org) = (unsigned char*)buf;
+		SCNG(script_org_size) = size;
+		SCNG(script_filtered) = NULL;
+
+		zend_multibyte_set_filter(zend_multibyte_get_internal_encoding(TSRMLS_C) TSRMLS_CC);
+
+		if (SCNG(input_filter)) {
+			if ((size_t)-1 == SCNG(input_filter)(&SCNG(script_filtered), &SCNG(script_filtered_size), SCNG(script_org), SCNG(script_org_size) TSRMLS_CC)) {
+				zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
+						"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
+			}
+			buf = (char*)SCNG(script_filtered);
+			size = SCNG(script_filtered_size);
+		}
+	}
+
+	yy_scan_buffer(buf, size TSRMLS_CC);
+
+	new_compiled_filename = STR_INIT(filename, strlen(filename), 0);
+	zend_set_compiled_filename(new_compiled_filename TSRMLS_CC);
+	STR_RELEASE(new_compiled_filename);
+	CG(zend_lineno) = 1;
+	CG(increment_lineno) = 0;
+	RESET_DOC_COMMENT();
+	return SUCCESS;
+}
+
+
+ZEND_API size_t zend_get_scanned_file_offset(TSRMLS_D)
+{
+	size_t offset = SCNG(yy_cursor) - SCNG(yy_start);
+	if (SCNG(input_filter)) {
+		size_t original_offset = offset, length = 0;
+		do {
+			unsigned char *p = NULL;
+			if ((size_t)-1 == SCNG(input_filter)(&p, &length, SCNG(script_org), offset TSRMLS_CC)) {
+				return (size_t)-1;
+			}
+			efree(p);
+			if (length > original_offset) {
+				offset--;
+			} else if (length < original_offset) {
+				offset++;
+			}
+		} while (original_offset != length);
+	}
+	return offset;
+}
+
+
+zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
+{
+	zend_lex_state original_lex_state;
+	zend_op_array *op_array = (zend_op_array *) emalloc(sizeof(zend_op_array));
+	zend_op_array *original_active_op_array = CG(active_op_array);
+	zend_op_array *retval;
+	zval tmp;
+	int compiler_result;
+	zend_bool original_in_compilation = CG(in_compilation);
+
+	if (Z_STRLEN_P(source_string)==0) {
+		efree(op_array);
+		return NULL;
+	}
+
+	CG(in_compilation) = 1;
+
+	ZVAL_DUP(&tmp, source_string);
+	convert_to_string(&tmp);
+	source_string = &tmp;
+
+	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
+	if (zend_prepare_string_for_scanning(source_string, filename TSRMLS_CC)==FAILURE) {
+		efree(op_array);
+		retval = NULL;
+	} else {
+		zend_bool orig_interactive = CG(interactive);
+
+		CG(interactive) = 0;
+		init_op_array(op_array, ZEND_EVAL_CODE, INITIAL_OP_ARRAY_SIZE TSRMLS_CC);
+		CG(interactive) = orig_interactive;
+		CG(active_op_array) = op_array;
+		zend_stack_push(&CG(context_stack), (void *) &CG(context), sizeof(CG(context)));
+		zend_init_compiler_context(TSRMLS_C);
+		BEGIN(ST_IN_SCRIPTING);
+		compiler_result = zendparse(TSRMLS_C);
+
+		if (SCNG(script_filtered)) {
+			efree(SCNG(script_filtered));
+			SCNG(script_filtered) = NULL;
+		}
+
+		if (compiler_result != 0) {
+			CG(active_op_array) = original_active_op_array;
+			CG(unclean_shutdown)=1;
+			destroy_op_array(op_array TSRMLS_CC);
+			efree(op_array);
+			retval = NULL;
+		} else {
+			zend_do_return(NULL, 0 TSRMLS_CC);
+			CG(active_op_array) = original_active_op_array;
+			pass_two(op_array TSRMLS_CC);
+			zend_release_labels(0 TSRMLS_CC);
+			retval = op_array;
+		}
+	}
+	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
+	zval_dtor(&tmp);
+	CG(in_compilation) = original_in_compilation;
+	return retval;
+}
+
+
+BEGIN_EXTERN_C()
+int highlight_file(char *filename, zend_syntax_highlighter_ini *syntax_highlighter_ini TSRMLS_DC)
+{
+	zend_lex_state original_lex_state;
+	zend_file_handle file_handle;
+
+	file_handle.type = ZEND_HANDLE_FILENAME;
+	file_handle.filename = filename;
+	file_handle.free_filename = 0;
+	file_handle.opened_path = NULL;
+	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
+	if (open_file_for_scanning(&file_handle TSRMLS_CC)==FAILURE) {
+		zend_message_dispatcher(ZMSG_FAILED_HIGHLIGHT_FOPEN, filename TSRMLS_CC);
+		zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
+		return FAILURE;
+	}
+	zend_highlight(syntax_highlighter_ini TSRMLS_CC);
+	if (SCNG(script_filtered)) {
+		efree(SCNG(script_filtered));
+		SCNG(script_filtered) = NULL;
+	}
+	zend_destroy_file_handle(&file_handle TSRMLS_CC);
+	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
+	return SUCCESS;
+}
+
+int highlight_string(zval *str, zend_syntax_highlighter_ini *syntax_highlighter_ini, char *str_name TSRMLS_DC)
+{
+	zend_lex_state original_lex_state;
+	zval tmp = *str;
+
+	str = &tmp;
+	zval_copy_ctor(str);
+	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
+	if (zend_prepare_string_for_scanning(str, str_name TSRMLS_CC)==FAILURE) {
+		zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
+		return FAILURE;
+	}
+	BEGIN(INITIAL);
+	zend_highlight(syntax_highlighter_ini TSRMLS_CC);
+	if (SCNG(script_filtered)) {
+		efree(SCNG(script_filtered));
+		SCNG(script_filtered) = NULL;
+	}
+	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
+	zval_dtor(str);
+	return SUCCESS;
+}
+
+ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter, const zend_encoding *old_encoding TSRMLS_DC)
+{
+	size_t length;
+	unsigned char *new_yy_start;
+
+	/* convert and set */
+	if (!SCNG(input_filter)) {
+		if (SCNG(script_filtered)) {
+			efree(SCNG(script_filtered));
+			SCNG(script_filtered) = NULL;
+		}
+		SCNG(script_filtered_size) = 0;
+		length = SCNG(script_org_size);
+		new_yy_start = SCNG(script_org);
+	} else {
+		if ((size_t)-1 == SCNG(input_filter)(&new_yy_start, &length, SCNG(script_org), SCNG(script_org_size) TSRMLS_CC)) {
+			zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
+					"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
+		}
+		if (SCNG(script_filtered)) {
+			efree(SCNG(script_filtered));
+		}
+		SCNG(script_filtered) = new_yy_start;
+		SCNG(script_filtered_size) = length;
+	}
+
+	SCNG(yy_cursor) = new_yy_start + (SCNG(yy_cursor) - SCNG(yy_start));
+	SCNG(yy_marker) = new_yy_start + (SCNG(yy_marker) - SCNG(yy_start));
+	SCNG(yy_text) = new_yy_start + (SCNG(yy_text) - SCNG(yy_start));
+	SCNG(yy_limit) = new_yy_start + (SCNG(yy_limit) - SCNG(yy_start));
+
+	SCNG(yy_start) = new_yy_start;
+}
+
+
+// TODO: avoid reallocation ???
+# define zend_copy_value(zendlval, yytext, yyleng) \
+	if (SCNG(output_filter)) { \
+		size_t sz = 0; \
+		char *s = NULL; \
+		SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC); \
+		ZVAL_STRINGL(zendlval, s, sz); \
+		efree(s); \
+	} else { \
+		ZVAL_STRINGL(zendlval, yytext, yyleng); \
+	}
+
+// TODO: some extensions might need content, but we don't copy it intentional ???
+#if 0
+# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
+	ZVAL_STRINGL(zendlval, yytext, yyleng)
+#else
+# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
+	ZVAL_EMPTY_STRING(zendlval)
+#endif
+
+static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
+{
+	register char *s, *t;
+	char *end;
+
+	ZVAL_STRINGL(zendlval, str, len);
+
+	/* convert escape sequences */
+	s = t = Z_STRVAL_P(zendlval);
+	end = s+Z_STRLEN_P(zendlval);
+	while (s<end) {
+		if (*s=='\\') {
+			s++;
+			if (s >= end) {
+				*t++ = '\\';
+				break;
+			}
+
+			switch(*s) {
+				case 'n':
+					*t++ = '\n';
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case 'r':
+					*t++ = '\r';
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case 't':
+					*t++ = '\t';
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case 'f':
+					*t++ = '\f';
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case 'v':
+					*t++ = '\v';
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case 'e':
+#ifdef PHP_WIN32
+					*t++ = VK_ESCAPE;
+#else
+					*t++ = '\e';
+#endif
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case '"':
+				case '`':
+					if (*s != quote_type) {
+						*t++ = '\\';
+						*t++ = *s;
+						break;
+					}
+				case '\\':
+				case '$':
+					*t++ = *s;
+					Z_STRLEN_P(zendlval)--;
+					break;
+				case 'x':
+				case 'X':
+					if (ZEND_IS_HEX(*(s+1))) {
+						char hex_buf[3] = { 0, 0, 0 };
+
+						Z_STRLEN_P(zendlval)--; /* for the 'x' */
+
+						hex_buf[0] = *(++s);
+						Z_STRLEN_P(zendlval)--;
+						if (ZEND_IS_HEX(*(s+1))) {
+							hex_buf[1] = *(++s);
+							Z_STRLEN_P(zendlval)--;
+						}
+						*t++ = (char) strtol(hex_buf, NULL, 16);
+					} else {
+						*t++ = '\\';
+						*t++ = *s;
+					}
+					break;
+				default:
+					/* check for an octal */
+					if (ZEND_IS_OCT(*s)) {
+						char octal_buf[4] = { 0, 0, 0, 0 };
+
+						octal_buf[0] = *s;
+						Z_STRLEN_P(zendlval)--;
+						if (ZEND_IS_OCT(*(s+1))) {
+							octal_buf[1] = *(++s);
+							Z_STRLEN_P(zendlval)--;
+							if (ZEND_IS_OCT(*(s+1))) {
+								octal_buf[2] = *(++s);
+								Z_STRLEN_P(zendlval)--;
+							}
+						}
+						*t++ = (char) strtol(octal_buf, NULL, 8);
+					} else {
+						*t++ = '\\';
+						*t++ = *s;
+					}
+					break;
+			}
+		} else {
+			*t++ = *s;
+		}
+
+		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
+			CG(zend_lineno)++;
+		}
+		s++;
+	}
+	*t = 0;
+	if (SCNG(output_filter)) {
+		size_t sz = 0;
+		unsigned char *str;
+		// TODO: avoid realocation ???
+		s = Z_STRVAL_P(zendlval);
+		SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);
+		zval_ptr_dtor(zendlval);
+		ZVAL_STRINGL(zendlval, str, sz);
+		efree(str);
+	}
+}
+
+
+int lex_scan(zval *zendlval TSRMLS_DC)
+{
+restart:
+	SCNG(yy_text) = YYCURSOR;
+
+yymore_restart:
+
+
+#line 1021 "Zend/zend_language_scanner.c"
+{
+	YYCTYPE yych;
+	unsigned int yyaccept = 0;
+	if (YYGETCONDITION() < 5) {
+		if (YYGETCONDITION() < 2) {
+			if (YYGETCONDITION() < 1) {
+				goto yyc_ST_IN_SCRIPTING;
+			} else {
+				goto yyc_ST_LOOKING_FOR_PROPERTY;
+			}
+		} else {
+			if (YYGETCONDITION() < 3) {
+				goto yyc_ST_BACKQUOTE;
+			} else {
+				if (YYGETCONDITION() < 4) {
+					goto yyc_ST_DOUBLE_QUOTES;
+				} else {
+					goto yyc_ST_HEREDOC;
+				}
+			}
+		}
+	} else {
+		if (YYGETCONDITION() < 7) {
+			if (YYGETCONDITION() < 6) {
+				goto yyc_ST_LOOKING_FOR_VARNAME;
+			} else {
+				goto yyc_ST_VAR_OFFSET;
+			}
+		} else {
+			if (YYGETCONDITION() < 8) {
+				goto yyc_INITIAL;
+			} else {
+				if (YYGETCONDITION() < 9) {
+					goto yyc_ST_END_HEREDOC;
+				} else {
+					goto yyc_ST_NOWDOC;
+				}
+			}
+		}
+	}
+/* *********************************** */
+yyc_INITIAL:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0, 128, 128,   0,   0, 128,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+		};
+
+		YYDEBUG(0, *YYCURSOR);
+		YYFILL(8);
+		yych = *YYCURSOR;
+		if (yych != '<') goto yy4;
+		YYDEBUG(2, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '?') {
+			if (yych == '%') goto yy7;
+			if (yych >= '?') goto yy5;
+		} else {
+			if (yych <= 'S') {
+				if (yych >= 'S') goto yy9;
+			} else {
+				if (yych == 's') goto yy9;
+			}
+		}
+yy3:
+		YYDEBUG(3, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1780 "Zend/zend_language_scanner.l"
+		{
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+
+inline_char_handler:
+
+	while (1) {
+		YYCTYPE *ptr = memchr(YYCURSOR, '<', YYLIMIT - YYCURSOR);
+
+		YYCURSOR = ptr ? ptr + 1 : YYLIMIT;
+
+		if (YYCURSOR < YYLIMIT) {
+			switch (*YYCURSOR) {
+				case '?':
+					if (CG(short_tags) || !strncasecmp((char*)YYCURSOR + 1, "php", 3) || (*(YYCURSOR + 1) == '=')) { /* Assume [ \t\n\r] follows "php" */
+						break;
+					}
+					continue;
+				case '%':
+					if (CG(asp_tags)) {
+						break;
+					}
+					continue;
+				case 's':
+				case 'S':
+					/* Probably NOT an opening PHP <script> tag, so don't end the HTML chunk yet
+					 * If it is, the PHP <script> tag rule checks for any HTML scanned before it */
+					YYCURSOR--;
+					yymore();
+				default:
+					continue;
+			}
+
+			YYCURSOR--;
+		}
+
+		break;
+	}
+
+inline_html:
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	if (SCNG(output_filter)) {
+		int readsize;
+		char *s = NULL;
+		size_t sz = 0;
+		// TODO: avoid reallocation ???
+		readsize = SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC);
+		ZVAL_STRINGL(zendlval, s, sz);
+		efree(s);
+		if (readsize < yyleng) {
+			yyless(readsize);
+		}
+	} else {
+	  ZVAL_STRINGL(zendlval, yytext, yyleng);
+	}
+	HANDLE_NEWLINES(yytext, yyleng);
+	return T_INLINE_HTML;
+}
+#line 1181 "Zend/zend_language_scanner.c"
+yy4:
+		YYDEBUG(4, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy3;
+yy5:
+		YYDEBUG(5, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 'O') {
+			if (yych == '=') goto yy45;
+		} else {
+			if (yych <= 'P') goto yy47;
+			if (yych == 'p') goto yy47;
+		}
+yy6:
+		YYDEBUG(6, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1770 "Zend/zend_language_scanner.l"
+		{
+	if (CG(short_tags)) {
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
+		BEGIN(ST_IN_SCRIPTING);
+		return T_OPEN_TAG;
+	} else {
+		goto inline_char_handler;
+	}
+}
+#line 1209 "Zend/zend_language_scanner.c"
+yy7:
+		YYDEBUG(7, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '=') goto yy43;
+		YYDEBUG(8, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1751 "Zend/zend_language_scanner.l"
+		{
+	if (CG(asp_tags)) {
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
+		BEGIN(ST_IN_SCRIPTING);
+		return T_OPEN_TAG;
+	} else {
+		goto inline_char_handler;
+	}
+}
+#line 1226 "Zend/zend_language_scanner.c"
+yy9:
+		YYDEBUG(9, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy11;
+		if (yych == 'c') goto yy11;
+yy10:
+		YYDEBUG(10, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		if (yyaccept <= 0) {
+			goto yy3;
+		} else {
+			goto yy6;
+		}
+yy11:
+		YYDEBUG(11, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy12;
+		if (yych != 'r') goto yy10;
+yy12:
+		YYDEBUG(12, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy13;
+		if (yych != 'i') goto yy10;
+yy13:
+		YYDEBUG(13, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy14;
+		if (yych != 'p') goto yy10;
+yy14:
+		YYDEBUG(14, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy15;
+		if (yych != 't') goto yy10;
+yy15:
+		YYDEBUG(15, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy10;
+		if (yych == 'l') goto yy10;
+		goto yy17;
+yy16:
+		YYDEBUG(16, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(8);
+		yych = *YYCURSOR;
+yy17:
+		YYDEBUG(17, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy16;
+		}
+		if (yych == 'L') goto yy18;
+		if (yych != 'l') goto yy10;
+yy18:
+		YYDEBUG(18, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy19;
+		if (yych != 'a') goto yy10;
+yy19:
+		YYDEBUG(19, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy20;
+		if (yych != 'n') goto yy10;
+yy20:
+		YYDEBUG(20, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'G') goto yy21;
+		if (yych != 'g') goto yy10;
+yy21:
+		YYDEBUG(21, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy22;
+		if (yych != 'u') goto yy10;
+yy22:
+		YYDEBUG(22, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy23;
+		if (yych != 'a') goto yy10;
+yy23:
+		YYDEBUG(23, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'G') goto yy24;
+		if (yych != 'g') goto yy10;
+yy24:
+		YYDEBUG(24, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy25;
+		if (yych != 'e') goto yy10;
+yy25:
+		YYDEBUG(25, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(26, *YYCURSOR);
+		if (yych <= '\r') {
+			if (yych <= 0x08) goto yy10;
+			if (yych <= '\n') goto yy25;
+			if (yych <= '\f') goto yy10;
+			goto yy25;
+		} else {
+			if (yych <= ' ') {
+				if (yych <= 0x1F) goto yy10;
+				goto yy25;
+			} else {
+				if (yych != '=') goto yy10;
+			}
+		}
+yy27:
+		YYDEBUG(27, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(5);
+		yych = *YYCURSOR;
+		YYDEBUG(28, *YYCURSOR);
+		if (yych <= '!') {
+			if (yych <= '\f') {
+				if (yych <= 0x08) goto yy10;
+				if (yych <= '\n') goto yy27;
+				goto yy10;
+			} else {
+				if (yych <= '\r') goto yy27;
+				if (yych == ' ') goto yy27;
+				goto yy10;
+			}
+		} else {
+			if (yych <= 'O') {
+				if (yych <= '"') goto yy30;
+				if (yych == '\'') goto yy31;
+				goto yy10;
+			} else {
+				if (yych <= 'P') goto yy29;
+				if (yych != 'p') goto yy10;
+			}
+		}
+yy29:
+		YYDEBUG(29, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy42;
+		if (yych == 'h') goto yy42;
+		goto yy10;
+yy30:
+		YYDEBUG(30, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy39;
+		if (yych == 'p') goto yy39;
+		goto yy10;
+yy31:
+		YYDEBUG(31, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy32;
+		if (yych != 'p') goto yy10;
+yy32:
+		YYDEBUG(32, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy33;
+		if (yych != 'h') goto yy10;
+yy33:
+		YYDEBUG(33, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy34;
+		if (yych != 'p') goto yy10;
+yy34:
+		YYDEBUG(34, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '\'') goto yy10;
+yy35:
+		YYDEBUG(35, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(36, *YYCURSOR);
+		if (yych <= '\r') {
+			if (yych <= 0x08) goto yy10;
+			if (yych <= '\n') goto yy35;
+			if (yych <= '\f') goto yy10;
+			goto yy35;
+		} else {
+			if (yych <= ' ') {
+				if (yych <= 0x1F) goto yy10;
+				goto yy35;
+			} else {
+				if (yych != '>') goto yy10;
+			}
+		}
+		YYDEBUG(37, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(38, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1717 "Zend/zend_language_scanner.l"
+		{
+	YYCTYPE *bracket = (YYCTYPE*)zend_memrchr(yytext, '<', yyleng - (sizeof("script language=php>") - 1));
+
+	if (bracket != SCNG(yy_text)) {
+		/* Handle previously scanned HTML, as possible <script> tags found are assumed to not be PHP's */
+		YYCURSOR = bracket;
+		goto inline_html;
+	}
+
+	HANDLE_NEWLINES(yytext, yyleng);
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
+	BEGIN(ST_IN_SCRIPTING);
+	return T_OPEN_TAG;
+}
+#line 1427 "Zend/zend_language_scanner.c"
+yy39:
+		YYDEBUG(39, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy40;
+		if (yych != 'h') goto yy10;
+yy40:
+		YYDEBUG(40, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy41;
+		if (yych != 'p') goto yy10;
+yy41:
+		YYDEBUG(41, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '"') goto yy35;
+		goto yy10;
+yy42:
+		YYDEBUG(42, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy35;
+		if (yych == 'p') goto yy35;
+		goto yy10;
+yy43:
+		YYDEBUG(43, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(44, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1733 "Zend/zend_language_scanner.l"
+		{
+	if (CG(asp_tags)) {
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
+		BEGIN(ST_IN_SCRIPTING);
+		return T_OPEN_TAG_WITH_ECHO;
+	} else {
+		goto inline_char_handler;
+	}
+}
+#line 1464 "Zend/zend_language_scanner.c"
+yy45:
+		YYDEBUG(45, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(46, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1744 "Zend/zend_language_scanner.l"
+		{
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
+	BEGIN(ST_IN_SCRIPTING);
+	return T_OPEN_TAG_WITH_ECHO;
+}
+#line 1476 "Zend/zend_language_scanner.c"
+yy47:
+		YYDEBUG(47, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy48;
+		if (yych != 'h') goto yy10;
+yy48:
+		YYDEBUG(48, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy49;
+		if (yych != 'p') goto yy10;
+yy49:
+		YYDEBUG(49, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '\f') {
+			if (yych <= 0x08) goto yy10;
+			if (yych >= '\v') goto yy10;
+		} else {
+			if (yych <= '\r') goto yy52;
+			if (yych != ' ') goto yy10;
+		}
+yy50:
+		YYDEBUG(50, *YYCURSOR);
+		++YYCURSOR;
+yy51:
+		YYDEBUG(51, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1762 "Zend/zend_language_scanner.l"
+		{
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
+	HANDLE_NEWLINE(yytext[yyleng-1]);
+	BEGIN(ST_IN_SCRIPTING);
+	return T_OPEN_TAG;
+}
+#line 1510 "Zend/zend_language_scanner.c"
+yy52:
+		YYDEBUG(52, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '\n') goto yy50;
+		goto yy51;
+	}
+/* *********************************** */
+yyc_ST_BACKQUOTE:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128,   0,   0,   0,   0,   0,   0, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+		};
+		YYDEBUG(53, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych <= '_') {
+			if (yych != '$') goto yy60;
+		} else {
+			if (yych <= '`') goto yy58;
+			if (yych == '{') goto yy57;
+			goto yy60;
+		}
+		YYDEBUG(55, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '_') {
+			if (yych <= '@') goto yy56;
+			if (yych <= 'Z') goto yy63;
+			if (yych >= '_') goto yy63;
+		} else {
+			if (yych <= 'z') {
+				if (yych >= 'a') goto yy63;
+			} else {
+				if (yych <= '{') goto yy66;
+				if (yych >= 0x7F) goto yy63;
+			}
+		}
+yy56:
+		YYDEBUG(56, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2223 "Zend/zend_language_scanner.l"
+		{
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+	if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
+		YYCURSOR++;
+	}
+
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '`':
+				break;
+			case '$':
+				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
+					break;
+				}
+				continue;
+			case '{':
+				if (*YYCURSOR == '$') {
+					break;
+				}
+				continue;
+			case '\\':
+				if (YYCURSOR < YYLIMIT) {
+					YYCURSOR++;
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+
+		YYCURSOR--;
+		break;
+	}
+
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	zend_scan_escape_string(zendlval, yytext, yyleng, '`' TSRMLS_CC);
+	return T_ENCAPSED_AND_WHITESPACE;
+}
+#line 1622 "Zend/zend_language_scanner.c"
+yy57:
+		YYDEBUG(57, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '$') goto yy61;
+		goto yy56;
+yy58:
+		YYDEBUG(58, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(59, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2167 "Zend/zend_language_scanner.l"
+		{
+	BEGIN(ST_IN_SCRIPTING);
+	return '`';
+}
+#line 1638 "Zend/zend_language_scanner.c"
+yy60:
+		YYDEBUG(60, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy56;
+yy61:
+		YYDEBUG(61, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(62, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2154 "Zend/zend_language_scanner.l"
+		{
+	Z_LVAL_P(zendlval) = (long) '{';
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
+	yyless(1);
+	return T_CURLY_OPEN;
+}
+#line 1655 "Zend/zend_language_scanner.c"
+yy63:
+		YYDEBUG(63, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(64, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy63;
+		}
+		if (yych == '-') goto yy68;
+		if (yych == '[') goto yy70;
+yy65:
+		YYDEBUG(65, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1861 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 1676 "Zend/zend_language_scanner.c"
+yy66:
+		YYDEBUG(66, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(67, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1484 "Zend/zend_language_scanner.l"
+		{
+	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
+	return T_DOLLAR_OPEN_CURLY_BRACES;
+}
+#line 1687 "Zend/zend_language_scanner.c"
+yy68:
+		YYDEBUG(68, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '>') goto yy72;
+yy69:
+		YYDEBUG(69, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		goto yy65;
+yy70:
+		YYDEBUG(70, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(71, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1854 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 1);
+	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 1708 "Zend/zend_language_scanner.c"
+yy72:
+		YYDEBUG(72, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '_') {
+			if (yych <= '@') goto yy69;
+			if (yych <= 'Z') goto yy73;
+			if (yych <= '^') goto yy69;
+		} else {
+			if (yych <= '`') goto yy69;
+			if (yych <= 'z') goto yy73;
+			if (yych <= '~') goto yy69;
+		}
+yy73:
+		YYDEBUG(73, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(74, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1845 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 3);
+	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 1733 "Zend/zend_language_scanner.c"
+	}
+/* *********************************** */
+yyc_ST_DOUBLE_QUOTES:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128,   0,   0,   0,   0,   0,   0, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+		};
+		YYDEBUG(75, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych <= '#') {
+			if (yych == '"') goto yy80;
+			goto yy82;
+		} else {
+			if (yych <= '$') goto yy77;
+			if (yych == '{') goto yy79;
+			goto yy82;
+		}
+yy77:
+		YYDEBUG(77, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '_') {
+			if (yych <= '@') goto yy78;
+			if (yych <= 'Z') goto yy85;
+			if (yych >= '_') goto yy85;
+		} else {
+			if (yych <= 'z') {
+				if (yych >= 'a') goto yy85;
+			} else {
+				if (yych <= '{') goto yy88;
+				if (yych >= 0x7F) goto yy85;
+			}
+		}
+yy78:
+		YYDEBUG(78, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2173 "Zend/zend_language_scanner.l"
+		{
+	if (GET_DOUBLE_QUOTES_SCANNED_LENGTH()) {
+		YYCURSOR += GET_DOUBLE_QUOTES_SCANNED_LENGTH() - 1;
+		SET_DOUBLE_QUOTES_SCANNED_LENGTH(0);
+
+		goto double_quotes_scan_done;
+	}
+
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+	if (yytext[0] == '\\' && YYCURSOR < YYLIMIT) {
+		YYCURSOR++;
+	}
+
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '"':
+				break;
+			case '$':
+				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
+					break;
+				}
+				continue;
+			case '{':
+				if (*YYCURSOR == '$') {
+					break;
+				}
+				continue;
+			case '\\':
+				if (YYCURSOR < YYLIMIT) {
+					YYCURSOR++;
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+
+		YYCURSOR--;
+		break;
+	}
+
+double_quotes_scan_done:
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	zend_scan_escape_string(zendlval, yytext, yyleng, '"' TSRMLS_CC);
+	return T_ENCAPSED_AND_WHITESPACE;
+}
+#line 1850 "Zend/zend_language_scanner.c"
+yy79:
+		YYDEBUG(79, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '$') goto yy83;
+		goto yy78;
+yy80:
+		YYDEBUG(80, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(81, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2162 "Zend/zend_language_scanner.l"
+		{
+	BEGIN(ST_IN_SCRIPTING);
+	return '"';
+}
+#line 1866 "Zend/zend_language_scanner.c"
+yy82:
+		YYDEBUG(82, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy78;
+yy83:
+		YYDEBUG(83, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(84, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2154 "Zend/zend_language_scanner.l"
+		{
+	Z_LVAL_P(zendlval) = (long) '{';
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
+	yyless(1);
+	return T_CURLY_OPEN;
+}
+#line 1883 "Zend/zend_language_scanner.c"
+yy85:
+		YYDEBUG(85, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(86, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy85;
+		}
+		if (yych == '-') goto yy90;
+		if (yych == '[') goto yy92;
+yy87:
+		YYDEBUG(87, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1861 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 1904 "Zend/zend_language_scanner.c"
+yy88:
+		YYDEBUG(88, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(89, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1484 "Zend/zend_language_scanner.l"
+		{
+	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
+	return T_DOLLAR_OPEN_CURLY_BRACES;
+}
+#line 1915 "Zend/zend_language_scanner.c"
+yy90:
+		YYDEBUG(90, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '>') goto yy94;
+yy91:
+		YYDEBUG(91, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		goto yy87;
+yy92:
+		YYDEBUG(92, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(93, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1854 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 1);
+	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 1936 "Zend/zend_language_scanner.c"
+yy94:
+		YYDEBUG(94, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '_') {
+			if (yych <= '@') goto yy91;
+			if (yych <= 'Z') goto yy95;
+			if (yych <= '^') goto yy91;
+		} else {
+			if (yych <= '`') goto yy91;
+			if (yych <= 'z') goto yy95;
+			if (yych <= '~') goto yy91;
+		}
+yy95:
+		YYDEBUG(95, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(96, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1845 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 3);
+	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 1961 "Zend/zend_language_scanner.c"
+	}
+/* *********************************** */
+yyc_ST_END_HEREDOC:
+	YYDEBUG(97, *YYCURSOR);
+	YYFILL(1);
+	yych = *YYCURSOR;
+	YYDEBUG(99, *YYCURSOR);
+	++YYCURSOR;
+	YYDEBUG(100, *YYCURSOR);
+	yyleng = YYCURSOR - SCNG(yy_text);
+#line 2140 "Zend/zend_language_scanner.l"
+	{
+	zend_heredoc_label *heredoc_label = zend_ptr_stack_pop(&SCNG(heredoc_label_stack));
+
+	YYCURSOR += heredoc_label->length - 1;
+	yyleng = heredoc_label->length;
+
+	heredoc_label_dtor(heredoc_label);
+	efree(heredoc_label);
+
+	BEGIN(ST_IN_SCRIPTING);
+	return T_END_HEREDOC;
+}
+#line 1985 "Zend/zend_language_scanner.c"
+/* *********************************** */
+yyc_ST_HEREDOC:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128,   0,   0,   0,   0,   0,   0, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+		};
+		YYDEBUG(101, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych == '$') goto yy103;
+		if (yych == '{') goto yy105;
+		goto yy106;
+yy103:
+		YYDEBUG(103, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '_') {
+			if (yych <= '@') goto yy104;
+			if (yych <= 'Z') goto yy109;
+			if (yych >= '_') goto yy109;
+		} else {
+			if (yych <= 'z') {
+				if (yych >= 'a') goto yy109;
+			} else {
+				if (yych <= '{') goto yy112;
+				if (yych >= 0x7F) goto yy109;
+			}
+		}
+yy104:
+		YYDEBUG(104, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2265 "Zend/zend_language_scanner.l"
+		{
+	int newline = 0;
+
+	zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));
+
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+
+	YYCURSOR--;
+
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '\r':
+				if (*YYCURSOR == '\n') {
+					YYCURSOR++;
+				}
+				/* fall through */
+			case '\n':
+				/* Check for ending label on the next line */
+				if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {
+					YYCTYPE *end = YYCURSOR + heredoc_label->length;
+
+					if (*end == ';') {
+						end++;
+					}
+
+					if (*end == '\n' || *end == '\r') {
+						/* newline before label will be subtracted from returned text, but
+						 * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
+						if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
+							newline = 2; /* Windows newline */
+						} else {
+							newline = 1;
+						}
+
+						CG(increment_lineno) = 1; /* For newline before label */
+						BEGIN(ST_END_HEREDOC);
+
+						goto heredoc_scan_done;
+					}
+				}
+				continue;
+			case '$':
+				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
+					break;
+				}
+				continue;
+			case '{':
+				if (*YYCURSOR == '$') {
+					break;
+				}
+				continue;
+			case '\\':
+				if (YYCURSOR < YYLIMIT && *YYCURSOR != '\n' && *YYCURSOR != '\r') {
+					YYCURSOR++;
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+
+		YYCURSOR--;
+		break;
+	}
+
+heredoc_scan_done:
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	zend_scan_escape_string(zendlval, yytext, yyleng - newline, 0 TSRMLS_CC);
+	return T_ENCAPSED_AND_WHITESPACE;
+}
+#line 2120 "Zend/zend_language_scanner.c"
+yy105:
+		YYDEBUG(105, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '$') goto yy107;
+		goto yy104;
+yy106:
+		YYDEBUG(106, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy104;
+yy107:
+		YYDEBUG(107, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(108, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2154 "Zend/zend_language_scanner.l"
+		{
+	Z_LVAL_P(zendlval) = (long) '{';
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
+	yyless(1);
+	return T_CURLY_OPEN;
+}
+#line 2142 "Zend/zend_language_scanner.c"
+yy109:
+		YYDEBUG(109, *YYCURSOR);
+		yyaccept = 0;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(110, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy109;
+		}
+		if (yych == '-') goto yy114;
+		if (yych == '[') goto yy116;
+yy111:
+		YYDEBUG(111, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1861 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 2163 "Zend/zend_language_scanner.c"
+yy112:
+		YYDEBUG(112, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(113, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1484 "Zend/zend_language_scanner.l"
+		{
+	yy_push_state(ST_LOOKING_FOR_VARNAME TSRMLS_CC);
+	return T_DOLLAR_OPEN_CURLY_BRACES;
+}
+#line 2174 "Zend/zend_language_scanner.c"
+yy114:
+		YYDEBUG(114, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '>') goto yy118;
+yy115:
+		YYDEBUG(115, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		goto yy111;
+yy116:
+		YYDEBUG(116, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(117, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1854 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 1);
+	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 2195 "Zend/zend_language_scanner.c"
+yy118:
+		YYDEBUG(118, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '_') {
+			if (yych <= '@') goto yy115;
+			if (yych <= 'Z') goto yy119;
+			if (yych <= '^') goto yy115;
+		} else {
+			if (yych <= '`') goto yy115;
+			if (yych <= 'z') goto yy119;
+			if (yych <= '~') goto yy115;
+		}
+yy119:
+		YYDEBUG(119, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(120, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1845 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 3);
+	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 2220 "Zend/zend_language_scanner.c"
+	}
+/* *********************************** */
+yyc_ST_IN_SCRIPTING:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0, 192,  64,   0,   0,  64,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			192,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			 60,  60,  44,  44,  44,  44,  44,  44, 
+			 44,  44,   0,   0,   0,   0,   0,   0, 
+			  0,  36,  36,  36,  36,  36,  36,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   0,   0,   0,   0,   4, 
+			  0,  36,  36,  36,  36,  36,  36,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   0,   0,   0,   0,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+			  4,   4,   4,   4,   4,   4,   4,   4, 
+		};
+		YYDEBUG(121, *YYCURSOR);
+		YYFILL(16);
+		yych = *YYCURSOR;
+		YYDEBUG(-1, yych);
+		switch (yych) {
+		case 0x00:
+		case 0x01:
+		case 0x02:
+		case 0x03:
+		case 0x04:
+		case 0x05:
+		case 0x06:
+		case 0x07:
+		case 0x08:
+		case '\v':
+		case '\f':
+		case 0x0E:
+		case 0x0F:
+		case 0x10:
+		case 0x11:
+		case 0x12:
+		case 0x13:
+		case 0x14:
+		case 0x15:
+		case 0x16:
+		case 0x17:
+		case 0x18:
+		case 0x19:
+		case 0x1A:
+		case 0x1B:
+		case 0x1C:
+		case 0x1D:
+		case 0x1E:
+		case 0x1F:	goto yy184;
+		case '\t':
+		case '\n':
+		case '\r':
+		case ' ':	goto yy140;
+		case '!':	goto yy154;
+		case '"':	goto yy180;
+		case '#':	goto yy176;
+		case '$':	goto yy165;
+		case '%':	goto yy159;
+		case '&':	goto yy160;
+		case '\'':	goto yy178;
+		case '(':	goto yy148;
+		case ')':
+		case ',':
+		case ';':
+		case '@':
+		case '[':
+		case ']':
+		case '~':	goto yy166;
+		case '*':	goto yy157;
+		case '+':	goto yy153;
+		case '-':	goto yy138;
+		case '.':	goto yy145;
+		case '/':	goto yy158;
+		case '0':	goto yy172;
+		case '1':
+		case '2':
+		case '3':
+		case '4':
+		case '5':
+		case '6':
+		case '7':
+		case '8':
+		case '9':	goto yy174;
+		case ':':	goto yy142;
+		case '<':	goto yy155;
+		case '=':	goto yy151;
+		case '>':	goto yy156;
+		case '?':	goto yy167;
+		case 'A':
+		case 'a':	goto yy133;
+		case 'B':
+		case 'b':	goto yy135;
+		case 'C':
+		case 'c':	goto yy127;
+		case 'D':
+		case 'd':	goto yy125;
+		case 'E':
+		case 'e':	goto yy123;
+		case 'F':
+		case 'f':	goto yy126;
+		case 'G':
+		case 'g':	goto yy136;
+		case 'I':
+		case 'i':	goto yy131;
+		case 'L':
+		case 'l':	goto yy152;
+		case 'N':
+		case 'n':	goto yy146;
+		case 'O':
+		case 'o':	goto yy163;
+		case 'P':
+		case 'p':	goto yy137;
+		case 'R':
+		case 'r':	goto yy128;
+		case 'S':
+		case 's':	goto yy134;
+		case 'T':
+		case 't':	goto yy130;
+		case 'U':
+		case 'u':	goto yy149;
+		case 'V':
+		case 'v':	goto yy147;
+		case 'W':
+		case 'w':	goto yy132;
+		case 'X':
+		case 'x':	goto yy164;
+		case 'Y':
+		case 'y':	goto yy129;
+		case '\\':	goto yy143;
+		case '^':	goto yy162;
+		case '_':	goto yy150;
+		case '`':	goto yy182;
+		case '{':	goto yy168;
+		case '|':	goto yy161;
+		case '}':	goto yy170;
+		default:	goto yy175;
+		}
+yy123:
+		YYDEBUG(123, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(-1, yych);
+		switch ((yych = *YYCURSOR)) {
+		case 'C':
+		case 'c':	goto yy742;
+		case 'L':
+		case 'l':	goto yy743;
+		case 'M':
+		case 'm':	goto yy744;
+		case 'N':
+		case 'n':	goto yy745;
+		case 'V':
+		case 'v':	goto yy746;
+		case 'X':
+		case 'x':	goto yy747;
+		default:	goto yy187;
+		}
+yy124:
+		YYDEBUG(124, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1883 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, yytext, yyleng);
+	return T_STRING;
+}
+#line 2408 "Zend/zend_language_scanner.c"
+yy125:
+		YYDEBUG(125, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'O') {
+			if (yych <= 'H') {
+				if (yych == 'E') goto yy724;
+				goto yy187;
+			} else {
+				if (yych <= 'I') goto yy725;
+				if (yych <= 'N') goto yy187;
+				goto yy726;
+			}
+		} else {
+			if (yych <= 'h') {
+				if (yych == 'e') goto yy724;
+				goto yy187;
+			} else {
+				if (yych <= 'i') goto yy725;
+				if (yych == 'o') goto yy726;
+				goto yy187;
+			}
+		}
+yy126:
+		YYDEBUG(126, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'U') {
+			if (yych <= 'N') {
+				if (yych == 'I') goto yy700;
+				goto yy187;
+			} else {
+				if (yych <= 'O') goto yy701;
+				if (yych <= 'T') goto yy187;
+				goto yy702;
+			}
+		} else {
+			if (yych <= 'n') {
+				if (yych == 'i') goto yy700;
+				goto yy187;
+			} else {
+				if (yych <= 'o') goto yy701;
+				if (yych == 'u') goto yy702;
+				goto yy187;
+			}
+		}
+yy127:
+		YYDEBUG(127, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'O') {
+			if (yych <= 'K') {
+				if (yych == 'A') goto yy665;
+				goto yy187;
+			} else {
+				if (yych <= 'L') goto yy666;
+				if (yych <= 'N') goto yy187;
+				goto yy667;
+			}
+		} else {
+			if (yych <= 'k') {
+				if (yych == 'a') goto yy665;
+				goto yy187;
+			} else {
+				if (yych <= 'l') goto yy666;
+				if (yych == 'o') goto yy667;
+				goto yy187;
+			}
+		}
+yy128:
+		YYDEBUG(128, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy647;
+		if (yych == 'e') goto yy647;
+		goto yy187;
+yy129:
+		YYDEBUG(129, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy642;
+		if (yych == 'i') goto yy642;
+		goto yy187;
+yy130:
+		YYDEBUG(130, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'R') {
+			if (yych == 'H') goto yy630;
+			if (yych <= 'Q') goto yy187;
+			goto yy631;
+		} else {
+			if (yych <= 'h') {
+				if (yych <= 'g') goto yy187;
+				goto yy630;
+			} else {
+				if (yych == 'r') goto yy631;
+				goto yy187;
+			}
+		}
+yy131:
+		YYDEBUG(131, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'S') {
+			if (yych <= 'L') {
+				if (yych == 'F') goto yy577;
+				goto yy187;
+			} else {
+				if (yych <= 'M') goto yy579;
+				if (yych <= 'N') goto yy580;
+				if (yych <= 'R') goto yy187;
+				goto yy581;
+			}
+		} else {
+			if (yych <= 'm') {
+				if (yych == 'f') goto yy577;
+				if (yych <= 'l') goto yy187;
+				goto yy579;
+			} else {
+				if (yych <= 'n') goto yy580;
+				if (yych == 's') goto yy581;
+				goto yy187;
+			}
+		}
+yy132:
+		YYDEBUG(132, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy572;
+		if (yych == 'h') goto yy572;
+		goto yy187;
+yy133:
+		YYDEBUG(133, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'S') {
+			if (yych <= 'M') {
+				if (yych == 'B') goto yy554;
+				goto yy187;
+			} else {
+				if (yych <= 'N') goto yy555;
+				if (yych <= 'Q') goto yy187;
+				if (yych <= 'R') goto yy556;
+				goto yy557;
+			}
+		} else {
+			if (yych <= 'n') {
+				if (yych == 'b') goto yy554;
+				if (yych <= 'm') goto yy187;
+				goto yy555;
+			} else {
+				if (yych <= 'q') goto yy187;
+				if (yych <= 'r') goto yy556;
+				if (yych <= 's') goto yy557;
+				goto yy187;
+			}
+		}
+yy134:
+		YYDEBUG(134, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'W') {
+			if (yych == 'T') goto yy542;
+			if (yych <= 'V') goto yy187;
+			goto yy543;
+		} else {
+			if (yych <= 't') {
+				if (yych <= 's') goto yy187;
+				goto yy542;
+			} else {
+				if (yych == 'w') goto yy543;
+				goto yy187;
+			}
+		}
+yy135:
+		YYDEBUG(135, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= ';') {
+			if (yych <= '"') {
+				if (yych <= '!') goto yy187;
+				goto yy534;
+			} else {
+				if (yych == '\'') goto yy535;
+				goto yy187;
+			}
+		} else {
+			if (yych <= 'R') {
+				if (yych <= '<') goto yy533;
+				if (yych <= 'Q') goto yy187;
+				goto yy536;
+			} else {
+				if (yych == 'r') goto yy536;
+				goto yy187;
+			}
+		}
+yy136:
+		YYDEBUG(136, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'O') {
+			if (yych == 'L') goto yy523;
+			if (yych <= 'N') goto yy187;
+			goto yy524;
+		} else {
+			if (yych <= 'l') {
+				if (yych <= 'k') goto yy187;
+				goto yy523;
+			} else {
+				if (yych == 'o') goto yy524;
+				goto yy187;
+			}
+		}
+yy137:
+		YYDEBUG(137, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'U') {
+			if (yych == 'R') goto yy499;
+			if (yych <= 'T') goto yy187;
+			goto yy500;
+		} else {
+			if (yych <= 'r') {
+				if (yych <= 'q') goto yy187;
+				goto yy499;
+			} else {
+				if (yych == 'u') goto yy500;
+				goto yy187;
+			}
+		}
+yy138:
+		YYDEBUG(138, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '<') {
+			if (yych == '-') goto yy495;
+		} else {
+			if (yych <= '=') goto yy493;
+			if (yych <= '>') goto yy497;
+		}
+yy139:
+		YYDEBUG(139, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1473 "Zend/zend_language_scanner.l"
+		{
+	return yytext[0];
+}
+#line 2644 "Zend/zend_language_scanner.c"
+yy140:
+		YYDEBUG(140, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy492;
+yy141:
+		YYDEBUG(141, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1195 "Zend/zend_language_scanner.l"
+		{
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
+	HANDLE_NEWLINES(yytext, yyleng);
+	return T_WHITESPACE;
+}
+#line 2659 "Zend/zend_language_scanner.c"
+yy142:
+		YYDEBUG(142, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == ':') goto yy489;
+		goto yy139;
+yy143:
+		YYDEBUG(143, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(144, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1221 "Zend/zend_language_scanner.l"
+		{
+	return T_NS_SEPARATOR;
+}
+#line 2674 "Zend/zend_language_scanner.c"
+yy145:
+		YYDEBUG(145, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '/') {
+			if (yych == '.') goto yy486;
+			goto yy139;
+		} else {
+			if (yych <= '9') goto yy482;
+			if (yych == '=') goto yy484;
+			goto yy139;
+		}
+yy146:
+		YYDEBUG(146, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'E') {
+			if (yych == 'A') goto yy470;
+			if (yych <= 'D') goto yy187;
+			goto yy471;
+		} else {
+			if (yych <= 'a') {
+				if (yych <= '`') goto yy187;
+				goto yy470;
+			} else {
+				if (yych == 'e') goto yy471;
+				goto yy187;
+			}
+		}
+yy147:
+		YYDEBUG(147, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy467;
+		if (yych == 'a') goto yy467;
+		goto yy187;
+yy148:
+		YYDEBUG(148, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 'S') {
+			if (yych <= 'D') {
+				if (yych <= ' ') {
+					if (yych == '\t') goto yy392;
+					if (yych <= 0x1F) goto yy139;
+					goto yy392;
+				} else {
+					if (yych <= '@') goto yy139;
+					if (yych == 'C') goto yy139;
+					goto yy392;
+				}
+			} else {
+				if (yych <= 'I') {
+					if (yych == 'F') goto yy392;
+					if (yych <= 'H') goto yy139;
+					goto yy392;
+				} else {
+					if (yych == 'O') goto yy392;
+					if (yych <= 'Q') goto yy139;
+					goto yy392;
+				}
+			}
+		} else {
+			if (yych <= 'f') {
+				if (yych <= 'b') {
+					if (yych == 'U') goto yy392;
+					if (yych <= '`') goto yy139;
+					goto yy392;
+				} else {
+					if (yych == 'd') goto yy392;
+					if (yych <= 'e') goto yy139;
+					goto yy392;
+				}
+			} else {
+				if (yych <= 'o') {
+					if (yych == 'i') goto yy392;
+					if (yych <= 'n') goto yy139;
+					goto yy392;
+				} else {
+					if (yych <= 's') {
+						if (yych <= 'q') goto yy139;
+						goto yy392;
+					} else {
+						if (yych == 'u') goto yy392;
+						goto yy139;
+					}
+				}
+			}
+		}
+yy149:
+		YYDEBUG(149, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'S') {
+			if (yych == 'N') goto yy383;
+			if (yych <= 'R') goto yy187;
+			goto yy384;
+		} else {
+			if (yych <= 'n') {
+				if (yych <= 'm') goto yy187;
+				goto yy383;
+			} else {
+				if (yych == 's') goto yy384;
+				goto yy187;
+			}
+		}
+yy150:
+		YYDEBUG(150, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '_') goto yy301;
+		goto yy187;
+yy151:
+		YYDEBUG(151, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '<') goto yy139;
+		if (yych <= '=') goto yy295;
+		if (yych <= '>') goto yy297;
+		goto yy139;
+yy152:
+		YYDEBUG(152, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy291;
+		if (yych == 'i') goto yy291;
+		goto yy187;
+yy153:
+		YYDEBUG(153, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '+') goto yy289;
+		if (yych == '=') goto yy287;
+		goto yy139;
+yy154:
+		YYDEBUG(154, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '=') goto yy284;
+		goto yy139;
+yy155:
+		YYDEBUG(155, *YYCURSOR);
+		yyaccept = 1;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= ';') {
+			if (yych == '/') goto yy256;
+			goto yy139;
+		} else {
+			if (yych <= '<') goto yy254;
+			if (yych <= '=') goto yy257;
+			if (yych <= '>') goto yy259;
+			goto yy139;
+		}
+yy156:
+		YYDEBUG(156, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '<') goto yy139;
+		if (yych <= '=') goto yy250;
+		if (yych <= '>') goto yy248;
+		goto yy139;
+yy157:
+		YYDEBUG(157, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '*') goto yy242;
+		if (yych == '=') goto yy244;
+		goto yy139;
+yy158:
+		YYDEBUG(158, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '.') {
+			if (yych == '*') goto yy234;
+			goto yy139;
+		} else {
+			if (yych <= '/') goto yy236;
+			if (yych == '=') goto yy237;
+			goto yy139;
+		}
+yy159:
+		YYDEBUG(159, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '<') goto yy139;
+		if (yych <= '=') goto yy230;
+		if (yych <= '>') goto yy228;
+		goto yy139;
+yy160:
+		YYDEBUG(160, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '&') goto yy224;
+		if (yych == '=') goto yy226;
+		goto yy139;
+yy161:
+		YYDEBUG(161, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '=') goto yy222;
+		if (yych == '|') goto yy220;
+		goto yy139;
+yy162:
+		YYDEBUG(162, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '=') goto yy218;
+		goto yy139;
+yy163:
+		YYDEBUG(163, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy216;
+		if (yych == 'r') goto yy216;
+		goto yy187;
+yy164:
+		YYDEBUG(164, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy213;
+		if (yych == 'o') goto yy213;
+		goto yy187;
+yy165:
+		YYDEBUG(165, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '_') {
+			if (yych <= '@') goto yy139;
+			if (yych <= 'Z') goto yy210;
+			if (yych <= '^') goto yy139;
+			goto yy210;
+		} else {
+			if (yych <= '`') goto yy139;
+			if (yych <= 'z') goto yy210;
+			if (yych <= '~') goto yy139;
+			goto yy210;
+		}
+yy166:
+		YYDEBUG(166, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy139;
+yy167:
+		YYDEBUG(167, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '>') goto yy206;
+		goto yy139;
+yy168:
+		YYDEBUG(168, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(169, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1478 "Zend/zend_language_scanner.l"
+		{
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
+	return '{';
+}
+#line 2913 "Zend/zend_language_scanner.c"
+yy170:
+		YYDEBUG(170, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(171, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1490 "Zend/zend_language_scanner.l"
+		{
+	RESET_DOC_COMMENT();
+	if (!zend_stack_is_empty(&SCNG(state_stack))) {
+		yy_pop_state(TSRMLS_C);
+	}
+	return '}';
+}
+#line 2927 "Zend/zend_language_scanner.c"
+yy172:
+		YYDEBUG(172, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 'E') {
+			if (yych <= '9') {
+				if (yych == '.') goto yy188;
+				if (yych >= '0') goto yy191;
+			} else {
+				if (yych == 'B') goto yy199;
+				if (yych >= 'E') goto yy193;
+			}
+		} else {
+			if (yych <= 'b') {
+				if (yych == 'X') goto yy198;
+				if (yych >= 'b') goto yy199;
+			} else {
+				if (yych <= 'e') {
+					if (yych >= 'e') goto yy193;
+				} else {
+					if (yych == 'x') goto yy198;
+				}
+			}
+		}
+yy173:
+		YYDEBUG(173, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1538 "Zend/zend_language_scanner.l"
+		{
+	if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
+		ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
+	} else {
+		errno = 0;
+		ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
+		if (errno == ERANGE) { /* Overflow */
+			if (yytext[0] == '0') { /* octal overflow */
+				ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL));
+			} else {
+				ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
+			}
+			return T_DNUMBER;
+		}
+	}
+	return T_LNUMBER;
+}
+#line 2973 "Zend/zend_language_scanner.c"
+yy174:
+		YYDEBUG(174, *YYCURSOR);
+		yyaccept = 2;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '9') {
+			if (yych == '.') goto yy188;
+			if (yych <= '/') goto yy173;
+			goto yy191;
+		} else {
+			if (yych <= 'E') {
+				if (yych <= 'D') goto yy173;
+				goto yy193;
+			} else {
+				if (yych == 'e') goto yy193;
+				goto yy173;
+			}
+		}
+yy175:
+		YYDEBUG(175, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy187;
+yy176:
+		YYDEBUG(176, *YYCURSOR);
+		++YYCURSOR;
+yy177:
+		YYDEBUG(177, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1889 "Zend/zend_language_scanner.l"
+		{
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '\r':
+				if (*YYCURSOR == '\n') {
+					YYCURSOR++;
+				}
+				/* fall through */
+			case '\n':
+				CG(zend_lineno)++;
+				break;
+			case '%':
+				if (!CG(asp_tags)) {
+					continue;
+				}
+				/* fall through */
+			case '?':
+				if (*YYCURSOR == '>') {
+					YYCURSOR--;
+					break;
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+
+		break;
+	}
+
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	return T_COMMENT;
+}
+#line 3035 "Zend/zend_language_scanner.c"
+yy178:
+		YYDEBUG(178, *YYCURSOR);
+		++YYCURSOR;
+yy179:
+		YYDEBUG(179, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1975 "Zend/zend_language_scanner.l"
+		{
+	register char *s, *t;
+	char *end;
+	int bprefix = (yytext[0] != '\'') ? 1 : 0;
+
+	while (1) {
+		if (YYCURSOR < YYLIMIT) {
+			if (*YYCURSOR == '\'') {
+				YYCURSOR++;
+				yyleng = YYCURSOR - SCNG(yy_text);
+
+				break;
+			} else if (*YYCURSOR++ == '\\' && YYCURSOR < YYLIMIT) {
+				YYCURSOR++;
+			}
+		} else {
+			yyleng = YYLIMIT - SCNG(yy_text);
+
+			/* Unclosed single quotes; treat similar to double quotes, but without a separate token
+			 * for ' (unrecognized by parser), instead of old flex fallback to "Unexpected character..."
+			 * rule, which continued in ST_IN_SCRIPTING state after the quote */
+			return T_ENCAPSED_AND_WHITESPACE;
+		}
+	}
+
+	ZVAL_STRINGL(zendlval, yytext+bprefix+1, yyleng-bprefix-2);
+
+	/* convert escape sequences */
+	s = t = Z_STRVAL_P(zendlval);
+	end = s+Z_STRLEN_P(zendlval);
+	while (s<end) {
+		if (*s=='\\') {
+			s++;
+
+			switch(*s) {
+				case '\\':
+				case '\'':
+					*t++ = *s;
+					Z_STRLEN_P(zendlval)--;
+					break;
+				default:
+					*t++ = '\\';
+					*t++ = *s;
+					break;
+			}
+		} else {
+			*t++ = *s;
+		}
+
+		if (*s == '\n' || (*s == '\r' && (*(s+1) != '\n'))) {
+			CG(zend_lineno)++;
+		}
+		s++;
+	}
+	*t = 0;
+
+	if (SCNG(output_filter)) {
+		size_t sz = 0;
+		char *str = NULL;
+		s = Z_STRVAL_P(zendlval);
+		// TODO: avoid reallocation ???
+		SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);
+		ZVAL_STRINGL(zendlval, str, sz);
+		efree(s);
+	}
+	return T_CONSTANT_ENCAPSED_STRING;
+}
+#line 3110 "Zend/zend_language_scanner.c"
+yy180:
+		YYDEBUG(180, *YYCURSOR);
+		++YYCURSOR;
+yy181:
+		YYDEBUG(181, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2044 "Zend/zend_language_scanner.l"
+		{
+	int bprefix = (yytext[0] != '"') ? 1 : 0;
+
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '"':
+				yyleng = YYCURSOR - SCNG(yy_text);
+				zend_scan_escape_string(zendlval, yytext+bprefix+1, yyleng-bprefix-2, '"' TSRMLS_CC);
+				return T_CONSTANT_ENCAPSED_STRING;
+			case '$':
+				if (IS_LABEL_START(*YYCURSOR) || *YYCURSOR == '{') {
+					break;
+				}
+				continue;
+			case '{':
+				if (*YYCURSOR == '$') {
+					break;
+				}
+				continue;
+			case '\\':
+				if (YYCURSOR < YYLIMIT) {
+					YYCURSOR++;
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+
+		YYCURSOR--;
+		break;
+	}
+
+	/* Remember how much was scanned to save rescanning */
+	SET_DOUBLE_QUOTES_SCANNED_LENGTH(YYCURSOR - SCNG(yy_text) - yyleng);
+
+	YYCURSOR = SCNG(yy_text) + yyleng;
+
+	BEGIN(ST_DOUBLE_QUOTES);
+	return '"';
+}
+#line 3158 "Zend/zend_language_scanner.c"
+yy182:
+		YYDEBUG(182, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(183, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2134 "Zend/zend_language_scanner.l"
+		{
+	BEGIN(ST_BACKQUOTE);
+	return '`';
+}
+#line 3169 "Zend/zend_language_scanner.c"
+yy184:
+		YYDEBUG(184, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(185, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2396 "Zend/zend_language_scanner.l"
+		{
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+
+	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
+	goto restart;
+}
+#line 3184 "Zend/zend_language_scanner.c"
+yy186:
+		YYDEBUG(186, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy187:
+		YYDEBUG(187, *YYCURSOR);
+		if (yybm[0+yych] & 4) {
+			goto yy186;
+		}
+		goto yy124;
+yy188:
+		YYDEBUG(188, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(189, *YYCURSOR);
+		if (yybm[0+yych] & 8) {
+			goto yy188;
+		}
+		if (yych == 'E') goto yy193;
+		if (yych == 'e') goto yy193;
+yy190:
+		YYDEBUG(190, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1593 "Zend/zend_language_scanner.l"
+		{
+	ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
+	return T_DNUMBER;
+}
+#line 3216 "Zend/zend_language_scanner.c"
+yy191:
+		YYDEBUG(191, *YYCURSOR);
+		yyaccept = 2;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(192, *YYCURSOR);
+		if (yych <= '9') {
+			if (yych == '.') goto yy188;
+			if (yych <= '/') goto yy173;
+			goto yy191;
+		} else {
+			if (yych <= 'E') {
+				if (yych <= 'D') goto yy173;
+			} else {
+				if (yych != 'e') goto yy173;
+			}
+		}
+yy193:
+		YYDEBUG(193, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= ',') {
+			if (yych == '+') goto yy195;
+		} else {
+			if (yych <= '-') goto yy195;
+			if (yych <= '/') goto yy194;
+			if (yych <= '9') goto yy196;
+		}
+yy194:
+		YYDEBUG(194, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		if (yyaccept <= 2) {
+			if (yyaccept <= 1) {
+				if (yyaccept <= 0) {
+					goto yy124;
+				} else {
+					goto yy139;
+				}
+			} else {
+				goto yy173;
+			}
+		} else {
+			if (yyaccept <= 4) {
+				if (yyaccept <= 3) {
+					goto yy190;
+				} else {
+					goto yy235;
+				}
+			} else {
+				goto yy255;
+			}
+		}
+yy195:
+		YYDEBUG(195, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= '/') goto yy194;
+		if (yych >= ':') goto yy194;
+yy196:
+		YYDEBUG(196, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(197, *YYCURSOR);
+		if (yych <= '/') goto yy190;
+		if (yych <= '9') goto yy196;
+		goto yy190;
+yy198:
+		YYDEBUG(198, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yybm[0+yych] & 32) {
+			goto yy203;
+		}
+		goto yy194;
+yy199:
+		YYDEBUG(199, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yybm[0+yych] & 16) {
+			goto yy200;
+		}
+		goto yy194;
+yy200:
+		YYDEBUG(200, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(201, *YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy200;
+		}
+		YYDEBUG(202, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1515 "Zend/zend_language_scanner.l"
+		{
+	char *bin = yytext + 2; /* Skip "0b" */
+	int len = yyleng - 2;
+
+	/* Skip any leading 0s */
+	while (*bin == '0') {
+		++bin;
+		--len;
+	}
+
+	if (len < SIZEOF_LONG * 8) {
+		if (len == 0) {
+			ZVAL_LONG(zendlval, 0);
+		} else {
+			ZVAL_LONG(zendlval, strtol(bin, NULL, 2));
+		}
+		return T_LNUMBER;
+	} else {
+		ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, NULL));
+		return T_DNUMBER;
+	}
+}
+#line 3331 "Zend/zend_language_scanner.c"
+yy203:
+		YYDEBUG(203, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(204, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy203;
+		}
+		YYDEBUG(205, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1556 "Zend/zend_language_scanner.l"
+		{
+	char *hex = yytext + 2; /* Skip "0x" */
+	int len = yyleng - 2;
+
+	/* Skip any leading 0s */
+	while (*hex == '0') {
+		hex++;
+		len--;
+	}
+
+	if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
+		if (len == 0) {
+			ZVAL_LONG(zendlval, 0);
+		} else {
+			ZVAL_LONG(zendlval, strtol(hex, NULL, 16));
+		}
+		return T_LNUMBER;
+	} else {
+		ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, NULL));
+		return T_DNUMBER;
+	}
+}
+#line 3366 "Zend/zend_language_scanner.c"
+yy206:
+		YYDEBUG(206, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '\n') goto yy208;
+		if (yych == '\r') goto yy209;
+yy207:
+		YYDEBUG(207, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1956 "Zend/zend_language_scanner.l"
+		{
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
+	BEGIN(INITIAL);
+	return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
+}
+#line 3381 "Zend/zend_language_scanner.c"
+yy208:
+		YYDEBUG(208, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy207;
+yy209:
+		YYDEBUG(209, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy208;
+		goto yy207;
+yy210:
+		YYDEBUG(210, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(211, *YYCURSOR);
+		if (yych <= '^') {
+			if (yych <= '9') {
+				if (yych >= '0') goto yy210;
+			} else {
+				if (yych <= '@') goto yy212;
+				if (yych <= 'Z') goto yy210;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= '_') goto yy210;
+			} else {
+				if (yych <= 'z') goto yy210;
+				if (yych >= 0x7F) goto yy210;
+			}
+		}
+yy212:
+		YYDEBUG(212, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1861 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 3420 "Zend/zend_language_scanner.c"
+yy213:
+		YYDEBUG(213, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy214;
+		if (yych != 'r') goto yy187;
+yy214:
+		YYDEBUG(214, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(215, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1461 "Zend/zend_language_scanner.l"
+		{
+	return T_LOGICAL_XOR;
+}
+#line 3438 "Zend/zend_language_scanner.c"
+yy216:
+		YYDEBUG(216, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(217, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1453 "Zend/zend_language_scanner.l"
+		{
+	return T_LOGICAL_OR;
+}
+#line 3451 "Zend/zend_language_scanner.c"
+yy218:
+		YYDEBUG(218, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(219, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1441 "Zend/zend_language_scanner.l"
+		{
+	return T_XOR_EQUAL;
+}
+#line 3461 "Zend/zend_language_scanner.c"
+yy220:
+		YYDEBUG(220, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(221, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1445 "Zend/zend_language_scanner.l"
+		{
+	return T_BOOLEAN_OR;
+}
+#line 3471 "Zend/zend_language_scanner.c"
+yy222:
+		YYDEBUG(222, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(223, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1437 "Zend/zend_language_scanner.l"
+		{
+	return T_OR_EQUAL;
+}
+#line 3481 "Zend/zend_language_scanner.c"
+yy224:
+		YYDEBUG(224, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(225, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1449 "Zend/zend_language_scanner.l"
+		{
+	return T_BOOLEAN_AND;
+}
+#line 3491 "Zend/zend_language_scanner.c"
+yy226:
+		YYDEBUG(226, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(227, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1433 "Zend/zend_language_scanner.l"
+		{
+	return T_AND_EQUAL;
+}
+#line 3501 "Zend/zend_language_scanner.c"
+yy228:
+		YYDEBUG(228, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '\n') goto yy232;
+		if (yych == '\r') goto yy233;
+yy229:
+		YYDEBUG(229, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1963 "Zend/zend_language_scanner.l"
+		{
+	if (CG(asp_tags)) {
+		BEGIN(INITIAL);
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
+		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
+	} else {
+		yyless(1);
+		return yytext[0];
+	}
+}
+#line 3521 "Zend/zend_language_scanner.c"
+yy230:
+		YYDEBUG(230, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(231, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1421 "Zend/zend_language_scanner.l"
+		{
+	return T_MOD_EQUAL;
+}
+#line 3531 "Zend/zend_language_scanner.c"
+yy232:
+		YYDEBUG(232, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy229;
+yy233:
+		YYDEBUG(233, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy232;
+		goto yy229;
+yy234:
+		YYDEBUG(234, *YYCURSOR);
+		yyaccept = 4;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych == '*') goto yy239;
+yy235:
+		YYDEBUG(235, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1923 "Zend/zend_language_scanner.l"
+		{
+	int doc_com;
+
+	if (yyleng > 2) {
+		doc_com = 1;
+		RESET_DOC_COMMENT();
+	} else {
+		doc_com = 0;
+	}
+
+	while (YYCURSOR < YYLIMIT) {
+		if (*YYCURSOR++ == '*' && *YYCURSOR == '/') {
+			break;
+		}
+	}
+
+	if (YYCURSOR < YYLIMIT) {
+		YYCURSOR++;
+	} else {
+		zend_error(E_COMPILE_WARNING, "Unterminated comment starting line %d", CG(zend_lineno));
+	}
+
+	yyleng = YYCURSOR - SCNG(yy_text);
+	HANDLE_NEWLINES(yytext, yyleng);
+
+	if (doc_com) {
+		CG(doc_comment) = STR_INIT(yytext, yyleng, 0);
+		return T_DOC_COMMENT;
+	}
+
+	return T_COMMENT;
+}
+#line 3582 "Zend/zend_language_scanner.c"
+yy236:
+		YYDEBUG(236, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy177;
+yy237:
+		YYDEBUG(237, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(238, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1413 "Zend/zend_language_scanner.l"
+		{
+	return T_DIV_EQUAL;
+}
+#line 3596 "Zend/zend_language_scanner.c"
+yy239:
+		YYDEBUG(239, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yybm[0+yych] & 64) {
+			goto yy240;
+		}
+		goto yy194;
+yy240:
+		YYDEBUG(240, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(241, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy240;
+		}
+		goto yy235;
+yy242:
+		YYDEBUG(242, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '=') goto yy246;
+		YYDEBUG(243, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1405 "Zend/zend_language_scanner.l"
+		{
+	return T_POW;
+}
+#line 3624 "Zend/zend_language_scanner.c"
+yy244:
+		YYDEBUG(244, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(245, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1401 "Zend/zend_language_scanner.l"
+		{
+	return T_MUL_EQUAL;
+}
+#line 3634 "Zend/zend_language_scanner.c"
+yy246:
+		YYDEBUG(246, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(247, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1409 "Zend/zend_language_scanner.l"
+		{
+	return T_POW_EQUAL;
+}
+#line 3644 "Zend/zend_language_scanner.c"
+yy248:
+		YYDEBUG(248, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '=') goto yy252;
+		YYDEBUG(249, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1469 "Zend/zend_language_scanner.l"
+		{
+	return T_SR;
+}
+#line 3655 "Zend/zend_language_scanner.c"
+yy250:
+		YYDEBUG(250, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(251, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1389 "Zend/zend_language_scanner.l"
+		{
+	return T_IS_GREATER_OR_EQUAL;
+}
+#line 3665 "Zend/zend_language_scanner.c"
+yy252:
+		YYDEBUG(252, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(253, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1429 "Zend/zend_language_scanner.l"
+		{
+	return T_SR_EQUAL;
+}
+#line 3675 "Zend/zend_language_scanner.c"
+yy254:
+		YYDEBUG(254, *YYCURSOR);
+		yyaccept = 5;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= ';') goto yy255;
+		if (yych <= '<') goto yy270;
+		if (yych <= '=') goto yy268;
+yy255:
+		YYDEBUG(255, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1465 "Zend/zend_language_scanner.l"
+		{
+	return T_SL;
+}
+#line 3690 "Zend/zend_language_scanner.c"
+yy256:
+		YYDEBUG(256, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy261;
+		if (yych == 's') goto yy261;
+		goto yy194;
+yy257:
+		YYDEBUG(257, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(258, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1385 "Zend/zend_language_scanner.l"
+		{
+	return T_IS_SMALLER_OR_EQUAL;
+}
+#line 3706 "Zend/zend_language_scanner.c"
+yy259:
+		YYDEBUG(259, *YYCURSOR);
+		++YYCURSOR;
+yy260:
+		YYDEBUG(260, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1381 "Zend/zend_language_scanner.l"
+		{
+	return T_IS_NOT_EQUAL;
+}
+#line 3717 "Zend/zend_language_scanner.c"
+yy261:
+		YYDEBUG(261, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy262;
+		if (yych != 'c') goto yy194;
+yy262:
+		YYDEBUG(262, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy263;
+		if (yych != 'r') goto yy194;
+yy263:
+		YYDEBUG(263, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy264;
+		if (yych != 'i') goto yy194;
+yy264:
+		YYDEBUG(264, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy265;
+		if (yych != 'p') goto yy194;
+yy265:
+		YYDEBUG(265, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy266;
+		if (yych != 't') goto yy194;
+yy266:
+		YYDEBUG(266, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(267, *YYCURSOR);
+		if (yych <= '\r') {
+			if (yych <= 0x08) goto yy194;
+			if (yych <= '\n') goto yy266;
+			if (yych <= '\f') goto yy194;
+			goto yy266;
+		} else {
+			if (yych <= ' ') {
+				if (yych <= 0x1F) goto yy194;
+				goto yy266;
+			} else {
+				if (yych == '>') goto yy206;
+				goto yy194;
+			}
+		}
+yy268:
+		YYDEBUG(268, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(269, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1425 "Zend/zend_language_scanner.l"
+		{
+	return T_SL_EQUAL;
+}
+#line 3772 "Zend/zend_language_scanner.c"
+yy270:
+		YYDEBUG(270, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+		YYDEBUG(271, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy270;
+		}
+		if (yych <= 'Z') {
+			if (yych <= '&') {
+				if (yych == '"') goto yy275;
+				goto yy194;
+			} else {
+				if (yych <= '\'') goto yy274;
+				if (yych <= '@') goto yy194;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych != '_') goto yy194;
+			} else {
+				if (yych <= 'z') goto yy272;
+				if (yych <= '~') goto yy194;
+			}
+		}
+yy272:
+		YYDEBUG(272, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(2);
+		yych = *YYCURSOR;
+		YYDEBUG(273, *YYCURSOR);
+		if (yych <= '@') {
+			if (yych <= '\f') {
+				if (yych == '\n') goto yy279;
+				goto yy194;
+			} else {
+				if (yych <= '\r') goto yy281;
+				if (yych <= '/') goto yy194;
+				if (yych <= '9') goto yy272;
+				goto yy194;
+			}
+		} else {
+			if (yych <= '_') {
+				if (yych <= 'Z') goto yy272;
+				if (yych <= '^') goto yy194;
+				goto yy272;
+			} else {
+				if (yych <= '`') goto yy194;
+				if (yych <= 'z') goto yy272;
+				if (yych <= '~') goto yy194;
+				goto yy272;
+			}
+		}
+yy274:
+		YYDEBUG(274, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\'') goto yy194;
+		if (yych <= '/') goto yy283;
+		if (yych <= '9') goto yy194;
+		goto yy283;
+yy275:
+		YYDEBUG(275, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '"') goto yy194;
+		if (yych <= '/') goto yy277;
+		if (yych <= '9') goto yy194;
+		goto yy277;
+yy276:
+		YYDEBUG(276, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+yy277:
+		YYDEBUG(277, *YYCURSOR);
+		if (yych <= 'Z') {
+			if (yych <= '/') {
+				if (yych != '"') goto yy194;
+			} else {
+				if (yych <= '9') goto yy276;
+				if (yych <= '@') goto yy194;
+				goto yy276;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych == '_') goto yy276;
+				goto yy194;
+			} else {
+				if (yych <= 'z') goto yy276;
+				if (yych <= '~') goto yy194;
+				goto yy276;
+			}
+		}
+yy278:
+		YYDEBUG(278, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy279;
+		if (yych == '\r') goto yy281;
+		goto yy194;
+yy279:
+		YYDEBUG(279, *YYCURSOR);
+		++YYCURSOR;
+yy280:
+		YYDEBUG(280, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2086 "Zend/zend_language_scanner.l"
+		{
+	char *s;
+	int bprefix = (yytext[0] != '<') ? 1 : 0;
+	zend_heredoc_label *heredoc_label = emalloc(sizeof(zend_heredoc_label));
+
+	CG(zend_lineno)++;
+	heredoc_label->length = yyleng-bprefix-3-1-(yytext[yyleng-2]=='\r'?1:0);
+	s = yytext+bprefix+3;
+	while ((*s == ' ') || (*s == '\t')) {
+		s++;
+		heredoc_label->length--;
+	}
+
+	if (*s == '\'') {
+		s++;
+		heredoc_label->length -= 2;
+
+		BEGIN(ST_NOWDOC);
+	} else {
+		if (*s == '"') {
+			s++;
+			heredoc_label->length -= 2;
+		}
+
+		BEGIN(ST_HEREDOC);
+	}
+
+	heredoc_label->label = estrndup(s, heredoc_label->length);
+
+	/* Check for ending label on the next line */
+	if (heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, s, heredoc_label->length)) {
+		YYCTYPE *end = YYCURSOR + heredoc_label->length;
+
+		if (*end == ';') {
+			end++;
+		}
+
+		if (*end == '\n' || *end == '\r') {
+			BEGIN(ST_END_HEREDOC);
+		}
+	}
+
+	zend_ptr_stack_push(&SCNG(heredoc_label_stack), (void *) heredoc_label);
+
+	return T_START_HEREDOC;
+}
+#line 3924 "Zend/zend_language_scanner.c"
+yy281:
+		YYDEBUG(281, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '\n') goto yy279;
+		goto yy280;
+yy282:
+		YYDEBUG(282, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+yy283:
+		YYDEBUG(283, *YYCURSOR);
+		if (yych <= 'Z') {
+			if (yych <= '/') {
+				if (yych == '\'') goto yy278;
+				goto yy194;
+			} else {
+				if (yych <= '9') goto yy282;
+				if (yych <= '@') goto yy194;
+				goto yy282;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych == '_') goto yy282;
+				goto yy194;
+			} else {
+				if (yych <= 'z') goto yy282;
+				if (yych <= '~') goto yy194;
+				goto yy282;
+			}
+		}
+yy284:
+		YYDEBUG(284, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '=') goto yy260;
+		YYDEBUG(285, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(286, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1373 "Zend/zend_language_scanner.l"
+		{
+	return T_IS_NOT_IDENTICAL;
+}
+#line 3968 "Zend/zend_language_scanner.c"
+yy287:
+		YYDEBUG(287, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(288, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1393 "Zend/zend_language_scanner.l"
+		{
+	return T_PLUS_EQUAL;
+}
+#line 3978 "Zend/zend_language_scanner.c"
+yy289:
+		YYDEBUG(289, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(290, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1361 "Zend/zend_language_scanner.l"
+		{
+	return T_INC;
+}
+#line 3988 "Zend/zend_language_scanner.c"
+yy291:
+		YYDEBUG(291, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy292;
+		if (yych != 's') goto yy187;
+yy292:
+		YYDEBUG(292, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy293;
+		if (yych != 't') goto yy187;
+yy293:
+		YYDEBUG(293, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(294, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1349 "Zend/zend_language_scanner.l"
+		{
+	return T_LIST;
+}
+#line 4011 "Zend/zend_language_scanner.c"
+yy295:
+		YYDEBUG(295, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '=') goto yy299;
+		YYDEBUG(296, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1377 "Zend/zend_language_scanner.l"
+		{
+	return T_IS_EQUAL;
+}
+#line 4022 "Zend/zend_language_scanner.c"
+yy297:
+		YYDEBUG(297, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(298, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1345 "Zend/zend_language_scanner.l"
+		{
+	return T_DOUBLE_ARROW;
+}
+#line 4032 "Zend/zend_language_scanner.c"
+yy299:
+		YYDEBUG(299, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(300, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1369 "Zend/zend_language_scanner.l"
+		{
+	return T_IS_IDENTICAL;
+}
+#line 4042 "Zend/zend_language_scanner.c"
+yy301:
+		YYDEBUG(301, *YYCURSOR);
+		yych = *++YYCURSOR;
+		YYDEBUG(-1, yych);
+		switch (yych) {
+		case 'C':
+		case 'c':	goto yy303;
+		case 'D':
+		case 'd':	goto yy308;
+		case 'F':
+		case 'f':	goto yy305;
+		case 'H':
+		case 'h':	goto yy302;
+		case 'L':
+		case 'l':	goto yy307;
+		case 'M':
+		case 'm':	goto yy306;
+		case 'N':
+		case 'n':	goto yy309;
+		case 'T':
+		case 't':	goto yy304;
+		default:	goto yy187;
+		}
+yy302:
+		YYDEBUG(302, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy370;
+		if (yych == 'a') goto yy370;
+		goto yy187;
+yy303:
+		YYDEBUG(303, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy363;
+		if (yych == 'l') goto yy363;
+		goto yy187;
+yy304:
+		YYDEBUG(304, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy356;
+		if (yych == 'r') goto yy356;
+		goto yy187;
+yy305:
+		YYDEBUG(305, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'U') {
+			if (yych == 'I') goto yy340;
+			if (yych <= 'T') goto yy187;
+			goto yy341;
+		} else {
+			if (yych <= 'i') {
+				if (yych <= 'h') goto yy187;
+				goto yy340;
+			} else {
+				if (yych == 'u') goto yy341;
+				goto yy187;
+			}
+		}
+yy306:
+		YYDEBUG(306, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy332;
+		if (yych == 'e') goto yy332;
+		goto yy187;
+yy307:
+		YYDEBUG(307, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy326;
+		if (yych == 'i') goto yy326;
+		goto yy187;
+yy308:
+		YYDEBUG(308, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy321;
+		if (yych == 'i') goto yy321;
+		goto yy187;
+yy309:
+		YYDEBUG(309, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy310;
+		if (yych != 'a') goto yy187;
+yy310:
+		YYDEBUG(310, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'M') goto yy311;
+		if (yych != 'm') goto yy187;
+yy311:
+		YYDEBUG(311, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy312;
+		if (yych != 'e') goto yy187;
+yy312:
+		YYDEBUG(312, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy313;
+		if (yych != 's') goto yy187;
+yy313:
+		YYDEBUG(313, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy314;
+		if (yych != 'p') goto yy187;
+yy314:
+		YYDEBUG(314, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy315;
+		if (yych != 'a') goto yy187;
+yy315:
+		YYDEBUG(315, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy316;
+		if (yych != 'c') goto yy187;
+yy316:
+		YYDEBUG(316, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy317;
+		if (yych != 'e') goto yy187;
+yy317:
+		YYDEBUG(317, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(318, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(319, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(320, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1708 "Zend/zend_language_scanner.l"
+		{
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
+		ZVAL_DUP(zendlval, &CG(current_namespace));
+	} else {
+		ZVAL_EMPTY_STRING(zendlval);
+	}
+	return T_NS_C;
+}
+#line 4181 "Zend/zend_language_scanner.c"
+yy321:
+		YYDEBUG(321, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy322;
+		if (yych != 'r') goto yy187;
+yy322:
+		YYDEBUG(322, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(323, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(324, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(325, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1683 "Zend/zend_language_scanner.l"
+		{
+	zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
+	zend_string *dirname;
+
+	if (!filename) {
+		filename = STR_EMPTY_ALLOC();
+	}
+
+	dirname = STR_INIT(filename->val, filename->len, 0);
+	zend_dirname(dirname->val, dirname->len);
+
+	if (strcmp(dirname->val, ".") == 0) {
+		dirname = STR_REALLOC(dirname, MAXPATHLEN, 0);
+#if HAVE_GETCWD
+		VCWD_GETCWD(dirname->val, MAXPATHLEN);
+#elif HAVE_GETWD
+		VCWD_GETWD(dirname->val);
+#endif
+	}
+
+	dirname->len = strlen(dirname->val);
+	ZVAL_STR(zendlval, dirname);
+	return T_DIR;
+}
+#line 4226 "Zend/zend_language_scanner.c"
+yy326:
+		YYDEBUG(326, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy327;
+		if (yych != 'n') goto yy187;
+yy327:
+		YYDEBUG(327, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy328;
+		if (yych != 'e') goto yy187;
+yy328:
+		YYDEBUG(328, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(329, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(330, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(331, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1667 "Zend/zend_language_scanner.l"
+		{
+	ZVAL_LONG(zendlval, CG(zend_lineno));
+	return T_LINE;
+}
+#line 4256 "Zend/zend_language_scanner.c"
+yy332:
+		YYDEBUG(332, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy333;
+		if (yych != 't') goto yy187;
+yy333:
+		YYDEBUG(333, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy334;
+		if (yych != 'h') goto yy187;
+yy334:
+		YYDEBUG(334, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy335;
+		if (yych != 'o') goto yy187;
+yy335:
+		YYDEBUG(335, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy336;
+		if (yych != 'd') goto yy187;
+yy336:
+		YYDEBUG(336, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(337, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(338, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(339, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1635 "Zend/zend_language_scanner.l"
+		{
+	if (CG(active_class_entry)) {
+		int len = 0;
+
+		if (CG(active_class_entry)->name) {
+			len += CG(active_class_entry)->name->len;
+		}
+		if (CG(active_op_array) && CG(active_op_array)->function_name) {
+			len += sizeof("::")-1;
+			len += CG(active_op_array)->function_name->len;
+		}
+		ZVAL_NEW_STR(zendlval, STR_ALLOC(len, 0));
+		len = 0;
+		if (CG(active_class_entry)->name) {
+			memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
+			len += CG(active_class_entry)->name->len;
+		}
+		if (CG(active_op_array) && CG(active_op_array)->function_name) {
+			memcpy(Z_STRVAL_P(zendlval) + len, "::", sizeof("::")-1);
+			len += sizeof("::")-1;
+			memcpy(Z_STRVAL_P(zendlval) + len, CG(active_op_array)->function_name->val, CG(active_op_array)->function_name->len);
+			len += CG(active_op_array)->function_name->len;
+		}
+		Z_STRVAL_P(zendlval)[len] = 0;
+	} else if (CG(active_op_array) && CG(active_op_array)->function_name) {
+		ZVAL_STR(zendlval, STR_COPY(CG(active_op_array)->function_name));
+	} else {
+		ZVAL_EMPTY_STRING(zendlval);
+	}
+	return T_METHOD_C;
+}
+#line 4323 "Zend/zend_language_scanner.c"
+yy340:
+		YYDEBUG(340, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy351;
+		if (yych == 'l') goto yy351;
+		goto yy187;
+yy341:
+		YYDEBUG(341, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy342;
+		if (yych != 'n') goto yy187;
+yy342:
+		YYDEBUG(342, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy343;
+		if (yych != 'c') goto yy187;
+yy343:
+		YYDEBUG(343, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy344;
+		if (yych != 't') goto yy187;
+yy344:
+		YYDEBUG(344, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy345;
+		if (yych != 'i') goto yy187;
+yy345:
+		YYDEBUG(345, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy346;
+		if (yych != 'o') goto yy187;
+yy346:
+		YYDEBUG(346, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy347;
+		if (yych != 'n') goto yy187;
+yy347:
+		YYDEBUG(347, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(348, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(349, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(350, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1625 "Zend/zend_language_scanner.l"
+		{
+	zend_op_array *op_array = CG(active_op_array);
+	if (op_array && op_array->function_name) {
+		ZVAL_STR(zendlval, STR_COPY(op_array->function_name));
+	} else {
+		ZVAL_EMPTY_STRING(zendlval);
+	}
+	return T_FUNC_C;
+}
+#line 4384 "Zend/zend_language_scanner.c"
+yy351:
+		YYDEBUG(351, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy352;
+		if (yych != 'e') goto yy187;
+yy352:
+		YYDEBUG(352, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(353, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(354, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(355, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1672 "Zend/zend_language_scanner.l"
+		{
+	zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
+
+	if (!filename) {
+		ZVAL_EMPTY_STRING(zendlval);
+	} else {
+		ZVAL_STR(zendlval, STR_COPY(filename));
+	}
+	return T_FILE;
+}
+#line 4415 "Zend/zend_language_scanner.c"
+yy356:
+		YYDEBUG(356, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy357;
+		if (yych != 'a') goto yy187;
+yy357:
+		YYDEBUG(357, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy358;
+		if (yych != 'i') goto yy187;
+yy358:
+		YYDEBUG(358, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy359;
+		if (yych != 't') goto yy187;
+yy359:
+		YYDEBUG(359, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(360, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(361, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(362, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1615 "Zend/zend_language_scanner.l"
+		{
+	zend_class_entry *ce = CG(active_class_entry);
+	if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
+		ZVAL_STR(zendlval, STR_COPY(ce->name));
+	} else {
+		ZVAL_EMPTY_STRING(zendlval);
+	}
+	return T_TRAIT_C;
+}
+#line 4455 "Zend/zend_language_scanner.c"
+yy363:
+		YYDEBUG(363, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy364;
+		if (yych != 'a') goto yy187;
+yy364:
+		YYDEBUG(364, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy365;
+		if (yych != 's') goto yy187;
+yy365:
+		YYDEBUG(365, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy366;
+		if (yych != 's') goto yy187;
+yy366:
+		YYDEBUG(366, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(367, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(368, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(369, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1598 "Zend/zend_language_scanner.l"
+		{
+	zend_class_entry *ce = CG(active_class_entry);
+	if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
+		/* We create a special __CLASS__ constant that is going to be resolved
+		   at run-time */
+		ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1);
+		Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX;
+	} else {
+		if (ce && ce->name) {
+			ZVAL_STR(zendlval, STR_COPY(ce->name));
+		} else {
+			ZVAL_EMPTY_STRING(zendlval);
+		}
+	}
+	return T_CLASS_C;
+}
+#line 4502 "Zend/zend_language_scanner.c"
+yy370:
+		YYDEBUG(370, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy371;
+		if (yych != 'l') goto yy187;
+yy371:
+		YYDEBUG(371, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy372;
+		if (yych != 't') goto yy187;
+yy372:
+		YYDEBUG(372, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '_') goto yy187;
+		YYDEBUG(373, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy374;
+		if (yych != 'c') goto yy187;
+yy374:
+		YYDEBUG(374, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy375;
+		if (yych != 'o') goto yy187;
+yy375:
+		YYDEBUG(375, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'M') goto yy376;
+		if (yych != 'm') goto yy187;
+yy376:
+		YYDEBUG(376, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy377;
+		if (yych != 'p') goto yy187;
+yy377:
+		YYDEBUG(377, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy378;
+		if (yych != 'i') goto yy187;
+yy378:
+		YYDEBUG(378, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy379;
+		if (yych != 'l') goto yy187;
+yy379:
+		YYDEBUG(379, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy380;
+		if (yych != 'e') goto yy187;
+yy380:
+		YYDEBUG(380, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy381;
+		if (yych != 'r') goto yy187;
+yy381:
+		YYDEBUG(381, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(382, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1313 "Zend/zend_language_scanner.l"
+		{
+	return T_HALT_COMPILER;
+}
+#line 4568 "Zend/zend_language_scanner.c"
+yy383:
+		YYDEBUG(383, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy387;
+		if (yych == 's') goto yy387;
+		goto yy187;
+yy384:
+		YYDEBUG(384, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy385;
+		if (yych != 'e') goto yy187;
+yy385:
+		YYDEBUG(385, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(386, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1293 "Zend/zend_language_scanner.l"
+		{
+	return T_USE;
+}
+#line 4592 "Zend/zend_language_scanner.c"
+yy387:
+		YYDEBUG(387, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy388;
+		if (yych != 'e') goto yy187;
+yy388:
+		YYDEBUG(388, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy389;
+		if (yych != 't') goto yy187;
+yy389:
+		YYDEBUG(389, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(390, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1341 "Zend/zend_language_scanner.l"
+		{
+	return T_UNSET;
+}
+#line 4615 "Zend/zend_language_scanner.c"
+yy391:
+		YYDEBUG(391, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(7);
+		yych = *YYCURSOR;
+yy392:
+		YYDEBUG(392, *YYCURSOR);
+		if (yych <= 'S') {
+			if (yych <= 'D') {
+				if (yych <= ' ') {
+					if (yych == '\t') goto yy391;
+					if (yych <= 0x1F) goto yy194;
+					goto yy391;
+				} else {
+					if (yych <= 'A') {
+						if (yych <= '@') goto yy194;
+						goto yy396;
+					} else {
+						if (yych <= 'B') goto yy394;
+						if (yych <= 'C') goto yy194;
+						goto yy399;
+					}
+				}
+			} else {
+				if (yych <= 'I') {
+					if (yych == 'F') goto yy400;
+					if (yych <= 'H') goto yy194;
+					goto yy401;
+				} else {
+					if (yych <= 'O') {
+						if (yych <= 'N') goto yy194;
+						goto yy395;
+					} else {
+						if (yych <= 'Q') goto yy194;
+						if (yych <= 'R') goto yy398;
+						goto yy397;
+					}
+				}
+			}
+		} else {
+			if (yych <= 'f') {
+				if (yych <= 'a') {
+					if (yych == 'U') goto yy393;
+					if (yych <= '`') goto yy194;
+					goto yy396;
+				} else {
+					if (yych <= 'c') {
+						if (yych <= 'b') goto yy394;
+						goto yy194;
+					} else {
+						if (yych <= 'd') goto yy399;
+						if (yych <= 'e') goto yy194;
+						goto yy400;
+					}
+				}
+			} else {
+				if (yych <= 'q') {
+					if (yych <= 'i') {
+						if (yych <= 'h') goto yy194;
+						goto yy401;
+					} else {
+						if (yych == 'o') goto yy395;
+						goto yy194;
+					}
+				} else {
+					if (yych <= 's') {
+						if (yych <= 'r') goto yy398;
+						goto yy397;
+					} else {
+						if (yych != 'u') goto yy194;
+					}
+				}
+			}
+		}
+yy393:
+		YYDEBUG(393, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy460;
+		if (yych == 'n') goto yy460;
+		goto yy194;
+yy394:
+		YYDEBUG(394, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'O') {
+			if (yych == 'I') goto yy447;
+			if (yych <= 'N') goto yy194;
+			goto yy448;
+		} else {
+			if (yych <= 'i') {
+				if (yych <= 'h') goto yy194;
+				goto yy447;
+			} else {
+				if (yych == 'o') goto yy448;
+				goto yy194;
+			}
+		}
+yy395:
+		YYDEBUG(395, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'B') goto yy439;
+		if (yych == 'b') goto yy439;
+		goto yy194;
+yy396:
+		YYDEBUG(396, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy432;
+		if (yych == 'r') goto yy432;
+		goto yy194;
+yy397:
+		YYDEBUG(397, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy424;
+		if (yych == 't') goto yy424;
+		goto yy194;
+yy398:
+		YYDEBUG(398, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy422;
+		if (yych == 'e') goto yy422;
+		goto yy194;
+yy399:
+		YYDEBUG(399, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy418;
+		if (yych == 'o') goto yy418;
+		goto yy194;
+yy400:
+		YYDEBUG(400, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy411;
+		if (yych == 'l') goto yy411;
+		goto yy194;
+yy401:
+		YYDEBUG(401, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy402;
+		if (yych != 'n') goto yy194;
+yy402:
+		YYDEBUG(402, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy403;
+		if (yych != 't') goto yy194;
+yy403:
+		YYDEBUG(403, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy404;
+		if (yych != 'e') goto yy406;
+yy404:
+		YYDEBUG(404, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'G') goto yy409;
+		if (yych == 'g') goto yy409;
+		goto yy194;
+yy405:
+		YYDEBUG(405, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy406:
+		YYDEBUG(406, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy405;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy405;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(407, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(408, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1241 "Zend/zend_language_scanner.l"
+		{
+	return T_INT_CAST;
+}
+#line 4791 "Zend/zend_language_scanner.c"
+yy409:
+		YYDEBUG(409, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy410;
+		if (yych != 'e') goto yy194;
+yy410:
+		YYDEBUG(410, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy405;
+		if (yych == 'r') goto yy405;
+		goto yy194;
+yy411:
+		YYDEBUG(411, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy412;
+		if (yych != 'o') goto yy194;
+yy412:
+		YYDEBUG(412, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy413;
+		if (yych != 'a') goto yy194;
+yy413:
+		YYDEBUG(413, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy414;
+		if (yych != 't') goto yy194;
+yy414:
+		YYDEBUG(414, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(415, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy414;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy414;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(416, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(417, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1245 "Zend/zend_language_scanner.l"
+		{
+	return T_DOUBLE_CAST;
+}
+#line 4839 "Zend/zend_language_scanner.c"
+yy418:
+		YYDEBUG(418, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy419;
+		if (yych != 'u') goto yy194;
+yy419:
+		YYDEBUG(419, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'B') goto yy420;
+		if (yych != 'b') goto yy194;
+yy420:
+		YYDEBUG(420, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy421;
+		if (yych != 'l') goto yy194;
+yy421:
+		YYDEBUG(421, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy414;
+		if (yych == 'e') goto yy414;
+		goto yy194;
+yy422:
+		YYDEBUG(422, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy423;
+		if (yych != 'a') goto yy194;
+yy423:
+		YYDEBUG(423, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy414;
+		if (yych == 'l') goto yy414;
+		goto yy194;
+yy424:
+		YYDEBUG(424, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy425;
+		if (yych != 'r') goto yy194;
+yy425:
+		YYDEBUG(425, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy426;
+		if (yych != 'i') goto yy194;
+yy426:
+		YYDEBUG(426, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy427;
+		if (yych != 'n') goto yy194;
+yy427:
+		YYDEBUG(427, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'G') goto yy428;
+		if (yych != 'g') goto yy194;
+yy428:
+		YYDEBUG(428, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(429, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy428;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy428;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(430, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(431, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1249 "Zend/zend_language_scanner.l"
+		{
+	return T_STRING_CAST;
+}
+#line 4913 "Zend/zend_language_scanner.c"
+yy432:
+		YYDEBUG(432, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy433;
+		if (yych != 'r') goto yy194;
+yy433:
+		YYDEBUG(433, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy434;
+		if (yych != 'a') goto yy194;
+yy434:
+		YYDEBUG(434, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'Y') goto yy435;
+		if (yych != 'y') goto yy194;
+yy435:
+		YYDEBUG(435, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(436, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy435;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy435;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(437, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(438, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1253 "Zend/zend_language_scanner.l"
+		{
+	return T_ARRAY_CAST;
+}
+#line 4950 "Zend/zend_language_scanner.c"
+yy439:
+		YYDEBUG(439, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'J') goto yy440;
+		if (yych != 'j') goto yy194;
+yy440:
+		YYDEBUG(440, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy441;
+		if (yych != 'e') goto yy194;
+yy441:
+		YYDEBUG(441, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy442;
+		if (yych != 'c') goto yy194;
+yy442:
+		YYDEBUG(442, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy443;
+		if (yych != 't') goto yy194;
+yy443:
+		YYDEBUG(443, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(444, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy443;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy443;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(445, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(446, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1257 "Zend/zend_language_scanner.l"
+		{
+	return T_OBJECT_CAST;
+}
+#line 4992 "Zend/zend_language_scanner.c"
+yy447:
+		YYDEBUG(447, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy457;
+		if (yych == 'n') goto yy457;
+		goto yy194;
+yy448:
+		YYDEBUG(448, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy449;
+		if (yych != 'o') goto yy194;
+yy449:
+		YYDEBUG(449, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy450;
+		if (yych != 'l') goto yy194;
+yy450:
+		YYDEBUG(450, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy455;
+		if (yych == 'e') goto yy455;
+		goto yy452;
+yy451:
+		YYDEBUG(451, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy452:
+		YYDEBUG(452, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy451;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy451;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(453, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(454, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1261 "Zend/zend_language_scanner.l"
+		{
+	return T_BOOL_CAST;
+}
+#line 5037 "Zend/zend_language_scanner.c"
+yy455:
+		YYDEBUG(455, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy456;
+		if (yych != 'a') goto yy194;
+yy456:
+		YYDEBUG(456, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy451;
+		if (yych == 'n') goto yy451;
+		goto yy194;
+yy457:
+		YYDEBUG(457, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy458;
+		if (yych != 'a') goto yy194;
+yy458:
+		YYDEBUG(458, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy459;
+		if (yych != 'r') goto yy194;
+yy459:
+		YYDEBUG(459, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'Y') goto yy428;
+		if (yych == 'y') goto yy428;
+		goto yy194;
+yy460:
+		YYDEBUG(460, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy461;
+		if (yych != 's') goto yy194;
+yy461:
+		YYDEBUG(461, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy462;
+		if (yych != 'e') goto yy194;
+yy462:
+		YYDEBUG(462, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy463;
+		if (yych != 't') goto yy194;
+yy463:
+		YYDEBUG(463, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(464, *YYCURSOR);
+		if (yych <= 0x1F) {
+			if (yych == '\t') goto yy463;
+			goto yy194;
+		} else {
+			if (yych <= ' ') goto yy463;
+			if (yych != ')') goto yy194;
+		}
+		YYDEBUG(465, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(466, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1265 "Zend/zend_language_scanner.l"
+		{
+	return T_UNSET_CAST;
+}
+#line 5101 "Zend/zend_language_scanner.c"
+yy467:
+		YYDEBUG(467, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy468;
+		if (yych != 'r') goto yy187;
+yy468:
+		YYDEBUG(468, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(469, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1237 "Zend/zend_language_scanner.l"
+		{
+	return T_VAR;
+}
+#line 5119 "Zend/zend_language_scanner.c"
+yy470:
+		YYDEBUG(470, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'M') goto yy474;
+		if (yych == 'm') goto yy474;
+		goto yy187;
+yy471:
+		YYDEBUG(471, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'W') goto yy472;
+		if (yych != 'w') goto yy187;
+yy472:
+		YYDEBUG(472, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(473, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1229 "Zend/zend_language_scanner.l"
+		{
+	return T_NEW;
+}
+#line 5143 "Zend/zend_language_scanner.c"
+yy474:
+		YYDEBUG(474, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy475;
+		if (yych != 'e') goto yy187;
+yy475:
+		YYDEBUG(475, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy476;
+		if (yych != 's') goto yy187;
+yy476:
+		YYDEBUG(476, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy477;
+		if (yych != 'p') goto yy187;
+yy477:
+		YYDEBUG(477, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy478;
+		if (yych != 'a') goto yy187;
+yy478:
+		YYDEBUG(478, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy479;
+		if (yych != 'c') goto yy187;
+yy479:
+		YYDEBUG(479, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy480;
+		if (yych != 'e') goto yy187;
+yy480:
+		YYDEBUG(480, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(481, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1289 "Zend/zend_language_scanner.l"
+		{
+	return T_NAMESPACE;
+}
+#line 5186 "Zend/zend_language_scanner.c"
+yy482:
+		YYDEBUG(482, *YYCURSOR);
+		yyaccept = 3;
+		YYMARKER = ++YYCURSOR;
+		YYFILL(3);
+		yych = *YYCURSOR;
+		YYDEBUG(483, *YYCURSOR);
+		if (yych <= 'D') {
+			if (yych <= '/') goto yy190;
+			if (yych <= '9') goto yy482;
+			goto yy190;
+		} else {
+			if (yych <= 'E') goto yy193;
+			if (yych == 'e') goto yy193;
+			goto yy190;
+		}
+yy484:
+		YYDEBUG(484, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(485, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1417 "Zend/zend_language_scanner.l"
+		{
+	return T_CONCAT_EQUAL;
+}
+#line 5212 "Zend/zend_language_scanner.c"
+yy486:
+		YYDEBUG(486, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych != '.') goto yy194;
+		YYDEBUG(487, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(488, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1225 "Zend/zend_language_scanner.l"
+		{
+	return T_ELLIPSIS;
+}
+#line 5225 "Zend/zend_language_scanner.c"
+yy489:
+		YYDEBUG(489, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(490, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1217 "Zend/zend_language_scanner.l"
+		{
+	return T_PAAMAYIM_NEKUDOTAYIM;
+}
+#line 5235 "Zend/zend_language_scanner.c"
+yy491:
+		YYDEBUG(491, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy492:
+		YYDEBUG(492, *YYCURSOR);
+		if (yych <= '\f') {
+			if (yych <= 0x08) goto yy141;
+			if (yych <= '\n') goto yy491;
+			goto yy141;
+		} else {
+			if (yych <= '\r') goto yy491;
+			if (yych == ' ') goto yy491;
+			goto yy141;
+		}
+yy493:
+		YYDEBUG(493, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(494, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1397 "Zend/zend_language_scanner.l"
+		{
+	return T_MINUS_EQUAL;
+}
+#line 5261 "Zend/zend_language_scanner.c"
+yy495:
+		YYDEBUG(495, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(496, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1365 "Zend/zend_language_scanner.l"
+		{
+	return T_DEC;
+}
+#line 5271 "Zend/zend_language_scanner.c"
+yy497:
+		YYDEBUG(497, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(498, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1190 "Zend/zend_language_scanner.l"
+		{
+	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
+	return T_OBJECT_OPERATOR;
+}
+#line 5282 "Zend/zend_language_scanner.c"
+yy499:
+		YYDEBUG(499, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'O') {
+			if (yych == 'I') goto yy506;
+			if (yych <= 'N') goto yy187;
+			goto yy507;
+		} else {
+			if (yych <= 'i') {
+				if (yych <= 'h') goto yy187;
+				goto yy506;
+			} else {
+				if (yych == 'o') goto yy507;
+				goto yy187;
+			}
+		}
+yy500:
+		YYDEBUG(500, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'B') goto yy501;
+		if (yych != 'b') goto yy187;
+yy501:
+		YYDEBUG(501, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy502;
+		if (yych != 'l') goto yy187;
+yy502:
+		YYDEBUG(502, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy503;
+		if (yych != 'i') goto yy187;
+yy503:
+		YYDEBUG(503, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy504;
+		if (yych != 'c') goto yy187;
+yy504:
+		YYDEBUG(504, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(505, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1337 "Zend/zend_language_scanner.l"
+		{
+	return T_PUBLIC;
+}
+#line 5331 "Zend/zend_language_scanner.c"
+yy506:
+		YYDEBUG(506, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'V') {
+			if (yych == 'N') goto yy515;
+			if (yych <= 'U') goto yy187;
+			goto yy516;
+		} else {
+			if (yych <= 'n') {
+				if (yych <= 'm') goto yy187;
+				goto yy515;
+			} else {
+				if (yych == 'v') goto yy516;
+				goto yy187;
+			}
+		}
+yy507:
+		YYDEBUG(507, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy508;
+		if (yych != 't') goto yy187;
+yy508:
+		YYDEBUG(508, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy509;
+		if (yych != 'e') goto yy187;
+yy509:
+		YYDEBUG(509, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy510;
+		if (yych != 'c') goto yy187;
+yy510:
+		YYDEBUG(510, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy511;
+		if (yych != 't') goto yy187;
+yy511:
+		YYDEBUG(511, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy512;
+		if (yych != 'e') goto yy187;
+yy512:
+		YYDEBUG(512, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy513;
+		if (yych != 'd') goto yy187;
+yy513:
+		YYDEBUG(513, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(514, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1333 "Zend/zend_language_scanner.l"
+		{
+	return T_PROTECTED;
+}
+#line 5390 "Zend/zend_language_scanner.c"
+yy515:
+		YYDEBUG(515, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy521;
+		if (yych == 't') goto yy521;
+		goto yy187;
+yy516:
+		YYDEBUG(516, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy517;
+		if (yych != 'a') goto yy187;
+yy517:
+		YYDEBUG(517, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy518;
+		if (yych != 't') goto yy187;
+yy518:
+		YYDEBUG(518, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy519;
+		if (yych != 'e') goto yy187;
+yy519:
+		YYDEBUG(519, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(520, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1329 "Zend/zend_language_scanner.l"
+		{
+	return T_PRIVATE;
+}
+#line 5424 "Zend/zend_language_scanner.c"
+yy521:
+		YYDEBUG(521, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(522, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1166 "Zend/zend_language_scanner.l"
+		{
+	return T_PRINT;
+}
+#line 5437 "Zend/zend_language_scanner.c"
+yy523:
+		YYDEBUG(523, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy528;
+		if (yych == 'o') goto yy528;
+		goto yy187;
+yy524:
+		YYDEBUG(524, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy525;
+		if (yych != 't') goto yy187;
+yy525:
+		YYDEBUG(525, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy526;
+		if (yych != 'o') goto yy187;
+yy526:
+		YYDEBUG(526, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(527, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1158 "Zend/zend_language_scanner.l"
+		{
+	return T_GOTO;
+}
+#line 5466 "Zend/zend_language_scanner.c"
+yy528:
+		YYDEBUG(528, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'B') goto yy529;
+		if (yych != 'b') goto yy187;
+yy529:
+		YYDEBUG(529, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy530;
+		if (yych != 'a') goto yy187;
+yy530:
+		YYDEBUG(530, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy531;
+		if (yych != 'l') goto yy187;
+yy531:
+		YYDEBUG(531, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(532, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1301 "Zend/zend_language_scanner.l"
+		{
+	return T_GLOBAL;
+}
+#line 5494 "Zend/zend_language_scanner.c"
+yy533:
+		YYDEBUG(533, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '<') goto yy541;
+		goto yy194;
+yy534:
+		YYDEBUG(534, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy181;
+yy535:
+		YYDEBUG(535, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy179;
+yy536:
+		YYDEBUG(536, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy537;
+		if (yych != 'e') goto yy187;
+yy537:
+		YYDEBUG(537, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy538;
+		if (yych != 'a') goto yy187;
+yy538:
+		YYDEBUG(538, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'K') goto yy539;
+		if (yych != 'k') goto yy187;
+yy539:
+		YYDEBUG(539, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(540, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1150 "Zend/zend_language_scanner.l"
+		{
+	return T_BREAK;
+}
+#line 5535 "Zend/zend_language_scanner.c"
+yy541:
+		YYDEBUG(541, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == '<') goto yy270;
+		goto yy194;
+yy542:
+		YYDEBUG(542, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy549;
+		if (yych == 'a') goto yy549;
+		goto yy187;
+yy543:
+		YYDEBUG(543, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy544;
+		if (yych != 'i') goto yy187;
+yy544:
+		YYDEBUG(544, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy545;
+		if (yych != 't') goto yy187;
+yy545:
+		YYDEBUG(545, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy546;
+		if (yych != 'c') goto yy187;
+yy546:
+		YYDEBUG(546, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy547;
+		if (yych != 'h') goto yy187;
+yy547:
+		YYDEBUG(547, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(548, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1134 "Zend/zend_language_scanner.l"
+		{
+	return T_SWITCH;
+}
+#line 5579 "Zend/zend_language_scanner.c"
+yy549:
+		YYDEBUG(549, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy550;
+		if (yych != 't') goto yy187;
+yy550:
+		YYDEBUG(550, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy551;
+		if (yych != 'i') goto yy187;
+yy551:
+		YYDEBUG(551, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy552;
+		if (yych != 'c') goto yy187;
+yy552:
+		YYDEBUG(552, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(553, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1317 "Zend/zend_language_scanner.l"
+		{
+	return T_STATIC;
+}
+#line 5607 "Zend/zend_language_scanner.c"
+yy554:
+		YYDEBUG(554, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy565;
+		if (yych == 's') goto yy565;
+		goto yy187;
+yy555:
+		YYDEBUG(555, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy563;
+		if (yych == 'd') goto yy563;
+		goto yy187;
+yy556:
+		YYDEBUG(556, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy559;
+		if (yych == 'r') goto yy559;
+		goto yy187;
+yy557:
+		YYDEBUG(557, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(558, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1130 "Zend/zend_language_scanner.l"
+		{
+	return T_AS;
+}
+#line 5638 "Zend/zend_language_scanner.c"
+yy559:
+		YYDEBUG(559, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy560;
+		if (yych != 'a') goto yy187;
+yy560:
+		YYDEBUG(560, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'Y') goto yy561;
+		if (yych != 'y') goto yy187;
+yy561:
+		YYDEBUG(561, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(562, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1353 "Zend/zend_language_scanner.l"
+		{
+	return T_ARRAY;
+}
+#line 5661 "Zend/zend_language_scanner.c"
+yy563:
+		YYDEBUG(563, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(564, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1457 "Zend/zend_language_scanner.l"
+		{
+	return T_LOGICAL_AND;
+}
+#line 5674 "Zend/zend_language_scanner.c"
+yy565:
+		YYDEBUG(565, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy566;
+		if (yych != 't') goto yy187;
+yy566:
+		YYDEBUG(566, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy567;
+		if (yych != 'r') goto yy187;
+yy567:
+		YYDEBUG(567, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy568;
+		if (yych != 'a') goto yy187;
+yy568:
+		YYDEBUG(568, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy569;
+		if (yych != 'c') goto yy187;
+yy569:
+		YYDEBUG(569, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy570;
+		if (yych != 't') goto yy187;
+yy570:
+		YYDEBUG(570, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(571, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1321 "Zend/zend_language_scanner.l"
+		{
+	return T_ABSTRACT;
+}
+#line 5712 "Zend/zend_language_scanner.c"
+yy572:
+		YYDEBUG(572, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy573;
+		if (yych != 'i') goto yy187;
+yy573:
+		YYDEBUG(573, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy574;
+		if (yych != 'l') goto yy187;
+yy574:
+		YYDEBUG(574, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy575;
+		if (yych != 'e') goto yy187;
+yy575:
+		YYDEBUG(575, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(576, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1090 "Zend/zend_language_scanner.l"
+		{
+	return T_WHILE;
+}
+#line 5740 "Zend/zend_language_scanner.c"
+yy577:
+		YYDEBUG(577, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(578, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1074 "Zend/zend_language_scanner.l"
+		{
+	return T_IF;
+}
+#line 5753 "Zend/zend_language_scanner.c"
+yy579:
+		YYDEBUG(579, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy621;
+		if (yych == 'p') goto yy621;
+		goto yy187;
+yy580:
+		YYDEBUG(580, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'T') {
+			if (yych <= 'C') {
+				if (yych <= 'B') goto yy187;
+				goto yy588;
+			} else {
+				if (yych <= 'R') goto yy187;
+				if (yych <= 'S') goto yy586;
+				goto yy587;
+			}
+		} else {
+			if (yych <= 'r') {
+				if (yych == 'c') goto yy588;
+				goto yy187;
+			} else {
+				if (yych <= 's') goto yy586;
+				if (yych <= 't') goto yy587;
+				goto yy187;
+			}
+		}
+yy581:
+		YYDEBUG(581, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy582;
+		if (yych != 's') goto yy187;
+yy582:
+		YYDEBUG(582, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy583;
+		if (yych != 'e') goto yy187;
+yy583:
+		YYDEBUG(583, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy584;
+		if (yych != 't') goto yy187;
+yy584:
+		YYDEBUG(584, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(585, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1305 "Zend/zend_language_scanner.l"
+		{
+	return T_ISSET;
+}
+#line 5809 "Zend/zend_language_scanner.c"
+yy586:
+		YYDEBUG(586, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy607;
+		if (yych == 't') goto yy607;
+		goto yy187;
+yy587:
+		YYDEBUG(587, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy600;
+		if (yych == 'e') goto yy600;
+		goto yy187;
+yy588:
+		YYDEBUG(588, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy589;
+		if (yych != 'l') goto yy187;
+yy589:
+		YYDEBUG(589, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy590;
+		if (yych != 'u') goto yy187;
+yy590:
+		YYDEBUG(590, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy591;
+		if (yych != 'd') goto yy187;
+yy591:
+		YYDEBUG(591, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy592;
+		if (yych != 'e') goto yy187;
+yy592:
+		YYDEBUG(592, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '^') {
+			if (yych <= '9') {
+				if (yych >= '0') goto yy186;
+			} else {
+				if (yych <= '@') goto yy593;
+				if (yych <= 'Z') goto yy186;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= '_') goto yy594;
+			} else {
+				if (yych <= 'z') goto yy186;
+				if (yych >= 0x7F) goto yy186;
+			}
+		}
+yy593:
+		YYDEBUG(593, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1273 "Zend/zend_language_scanner.l"
+		{
+	return T_INCLUDE;
+}
+#line 5867 "Zend/zend_language_scanner.c"
+yy594:
+		YYDEBUG(594, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy595;
+		if (yych != 'o') goto yy187;
+yy595:
+		YYDEBUG(595, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy596;
+		if (yych != 'n') goto yy187;
+yy596:
+		YYDEBUG(596, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy597;
+		if (yych != 'c') goto yy187;
+yy597:
+		YYDEBUG(597, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy598;
+		if (yych != 'e') goto yy187;
+yy598:
+		YYDEBUG(598, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(599, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1277 "Zend/zend_language_scanner.l"
+		{
+	return T_INCLUDE_ONCE;
+}
+#line 5900 "Zend/zend_language_scanner.c"
+yy600:
+		YYDEBUG(600, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy601;
+		if (yych != 'r') goto yy187;
+yy601:
+		YYDEBUG(601, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'F') goto yy602;
+		if (yych != 'f') goto yy187;
+yy602:
+		YYDEBUG(602, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy603;
+		if (yych != 'a') goto yy187;
+yy603:
+		YYDEBUG(603, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy604;
+		if (yych != 'c') goto yy187;
+yy604:
+		YYDEBUG(604, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy605;
+		if (yych != 'e') goto yy187;
+yy605:
+		YYDEBUG(605, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(606, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1174 "Zend/zend_language_scanner.l"
+		{
+	return T_INTERFACE;
+}
+#line 5938 "Zend/zend_language_scanner.c"
+yy607:
+		YYDEBUG(607, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'E') {
+			if (yych == 'A') goto yy608;
+			if (yych <= 'D') goto yy187;
+			goto yy609;
+		} else {
+			if (yych <= 'a') {
+				if (yych <= '`') goto yy187;
+			} else {
+				if (yych == 'e') goto yy609;
+				goto yy187;
+			}
+		}
+yy608:
+		YYDEBUG(608, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy615;
+		if (yych == 'n') goto yy615;
+		goto yy187;
+yy609:
+		YYDEBUG(609, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy610;
+		if (yych != 'a') goto yy187;
+yy610:
+		YYDEBUG(610, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy611;
+		if (yych != 'd') goto yy187;
+yy611:
+		YYDEBUG(611, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy612;
+		if (yych != 'o') goto yy187;
+yy612:
+		YYDEBUG(612, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'F') goto yy613;
+		if (yych != 'f') goto yy187;
+yy613:
+		YYDEBUG(613, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(614, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1297 "Zend/zend_language_scanner.l"
+		{
+        return T_INSTEADOF;
+}
+#line 5992 "Zend/zend_language_scanner.c"
+yy615:
+		YYDEBUG(615, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy616;
+		if (yych != 'c') goto yy187;
+yy616:
+		YYDEBUG(616, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy617;
+		if (yych != 'e') goto yy187;
+yy617:
+		YYDEBUG(617, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy618;
+		if (yych != 'o') goto yy187;
+yy618:
+		YYDEBUG(618, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'F') goto yy619;
+		if (yych != 'f') goto yy187;
+yy619:
+		YYDEBUG(619, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(620, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1126 "Zend/zend_language_scanner.l"
+		{
+	return T_INSTANCEOF;
+}
+#line 6025 "Zend/zend_language_scanner.c"
+yy621:
+		YYDEBUG(621, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy622;
+		if (yych != 'l') goto yy187;
+yy622:
+		YYDEBUG(622, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy623;
+		if (yych != 'e') goto yy187;
+yy623:
+		YYDEBUG(623, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'M') goto yy624;
+		if (yych != 'm') goto yy187;
+yy624:
+		YYDEBUG(624, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy625;
+		if (yych != 'e') goto yy187;
+yy625:
+		YYDEBUG(625, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy626;
+		if (yych != 'n') goto yy187;
+yy626:
+		YYDEBUG(626, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy627;
+		if (yych != 't') goto yy187;
+yy627:
+		YYDEBUG(627, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy628;
+		if (yych != 's') goto yy187;
+yy628:
+		YYDEBUG(628, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(629, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1186 "Zend/zend_language_scanner.l"
+		{
+	return T_IMPLEMENTS;
+}
+#line 6073 "Zend/zend_language_scanner.c"
+yy630:
+		YYDEBUG(630, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy638;
+		if (yych == 'r') goto yy638;
+		goto yy187;
+yy631:
+		YYDEBUG(631, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'Y') {
+			if (yych == 'A') goto yy634;
+			if (yych <= 'X') goto yy187;
+		} else {
+			if (yych <= 'a') {
+				if (yych <= '`') goto yy187;
+				goto yy634;
+			} else {
+				if (yych != 'y') goto yy187;
+			}
+		}
+		YYDEBUG(632, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(633, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1058 "Zend/zend_language_scanner.l"
+		{
+	return T_TRY;
+}
+#line 6105 "Zend/zend_language_scanner.c"
+yy634:
+		YYDEBUG(634, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy635;
+		if (yych != 'i') goto yy187;
+yy635:
+		YYDEBUG(635, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy636;
+		if (yych != 't') goto yy187;
+yy636:
+		YYDEBUG(636, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(637, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1178 "Zend/zend_language_scanner.l"
+		{
+	return T_TRAIT;
+}
+#line 6128 "Zend/zend_language_scanner.c"
+yy638:
+		YYDEBUG(638, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy639;
+		if (yych != 'o') goto yy187;
+yy639:
+		YYDEBUG(639, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'W') goto yy640;
+		if (yych != 'w') goto yy187;
+yy640:
+		YYDEBUG(640, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(641, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1070 "Zend/zend_language_scanner.l"
+		{
+	return T_THROW;
+}
+#line 6151 "Zend/zend_language_scanner.c"
+yy642:
+		YYDEBUG(642, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy643;
+		if (yych != 'e') goto yy187;
+yy643:
+		YYDEBUG(643, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy644;
+		if (yych != 'l') goto yy187;
+yy644:
+		YYDEBUG(644, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy645;
+		if (yych != 'd') goto yy187;
+yy645:
+		YYDEBUG(645, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(646, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1054 "Zend/zend_language_scanner.l"
+		{
+	return T_YIELD;
+}
+#line 6179 "Zend/zend_language_scanner.c"
+yy647:
+		YYDEBUG(647, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'T') {
+			if (yych == 'Q') goto yy649;
+			if (yych <= 'S') goto yy187;
+		} else {
+			if (yych <= 'q') {
+				if (yych <= 'p') goto yy187;
+				goto yy649;
+			} else {
+				if (yych != 't') goto yy187;
+			}
+		}
+		YYDEBUG(648, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy661;
+		if (yych == 'u') goto yy661;
+		goto yy187;
+yy649:
+		YYDEBUG(649, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy650;
+		if (yych != 'u') goto yy187;
+yy650:
+		YYDEBUG(650, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy651;
+		if (yych != 'i') goto yy187;
+yy651:
+		YYDEBUG(651, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy652;
+		if (yych != 'r') goto yy187;
+yy652:
+		YYDEBUG(652, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy653;
+		if (yych != 'e') goto yy187;
+yy653:
+		YYDEBUG(653, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '^') {
+			if (yych <= '9') {
+				if (yych >= '0') goto yy186;
+			} else {
+				if (yych <= '@') goto yy654;
+				if (yych <= 'Z') goto yy186;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= '_') goto yy655;
+			} else {
+				if (yych <= 'z') goto yy186;
+				if (yych >= 0x7F) goto yy186;
+			}
+		}
+yy654:
+		YYDEBUG(654, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1281 "Zend/zend_language_scanner.l"
+		{
+	return T_REQUIRE;
+}
+#line 6244 "Zend/zend_language_scanner.c"
+yy655:
+		YYDEBUG(655, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy656;
+		if (yych != 'o') goto yy187;
+yy656:
+		YYDEBUG(656, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy657;
+		if (yych != 'n') goto yy187;
+yy657:
+		YYDEBUG(657, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy658;
+		if (yych != 'c') goto yy187;
+yy658:
+		YYDEBUG(658, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy659;
+		if (yych != 'e') goto yy187;
+yy659:
+		YYDEBUG(659, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(660, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1285 "Zend/zend_language_scanner.l"
+		{
+	return T_REQUIRE_ONCE;
+}
+#line 6277 "Zend/zend_language_scanner.c"
+yy661:
+		YYDEBUG(661, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy662;
+		if (yych != 'r') goto yy187;
+yy662:
+		YYDEBUG(662, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy663;
+		if (yych != 'n') goto yy187;
+yy663:
+		YYDEBUG(663, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(664, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1050 "Zend/zend_language_scanner.l"
+		{
+	return T_RETURN;
+}
+#line 6300 "Zend/zend_language_scanner.c"
+yy665:
+		YYDEBUG(665, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'T') {
+			if (yych <= 'L') {
+				if (yych <= 'K') goto yy187;
+				goto yy688;
+			} else {
+				if (yych <= 'R') goto yy187;
+				if (yych <= 'S') goto yy687;
+				goto yy686;
+			}
+		} else {
+			if (yych <= 'r') {
+				if (yych == 'l') goto yy688;
+				goto yy187;
+			} else {
+				if (yych <= 's') goto yy687;
+				if (yych <= 't') goto yy686;
+				goto yy187;
+			}
+		}
+yy666:
+		YYDEBUG(666, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'O') {
+			if (yych == 'A') goto yy678;
+			if (yych <= 'N') goto yy187;
+			goto yy679;
+		} else {
+			if (yych <= 'a') {
+				if (yych <= '`') goto yy187;
+				goto yy678;
+			} else {
+				if (yych == 'o') goto yy679;
+				goto yy187;
+			}
+		}
+yy667:
+		YYDEBUG(667, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy668;
+		if (yych != 'n') goto yy187;
+yy668:
+		YYDEBUG(668, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'T') {
+			if (yych <= 'R') goto yy187;
+			if (yych >= 'T') goto yy670;
+		} else {
+			if (yych <= 'r') goto yy187;
+			if (yych <= 's') goto yy669;
+			if (yych <= 't') goto yy670;
+			goto yy187;
+		}
+yy669:
+		YYDEBUG(669, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy676;
+		if (yych == 't') goto yy676;
+		goto yy187;
+yy670:
+		YYDEBUG(670, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy671;
+		if (yych != 'i') goto yy187;
+yy671:
+		YYDEBUG(671, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy672;
+		if (yych != 'n') goto yy187;
+yy672:
+		YYDEBUG(672, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy673;
+		if (yych != 'u') goto yy187;
+yy673:
+		YYDEBUG(673, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy674;
+		if (yych != 'e') goto yy187;
+yy674:
+		YYDEBUG(674, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(675, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1154 "Zend/zend_language_scanner.l"
+		{
+	return T_CONTINUE;
+}
+#line 6394 "Zend/zend_language_scanner.c"
+yy676:
+		YYDEBUG(676, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(677, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1046 "Zend/zend_language_scanner.l"
+		{
+	return T_CONST;
+}
+#line 6407 "Zend/zend_language_scanner.c"
+yy678:
+		YYDEBUG(678, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy683;
+		if (yych == 's') goto yy683;
+		goto yy187;
+yy679:
+		YYDEBUG(679, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy680;
+		if (yych != 'n') goto yy187;
+yy680:
+		YYDEBUG(680, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy681;
+		if (yych != 'e') goto yy187;
+yy681:
+		YYDEBUG(681, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(682, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1233 "Zend/zend_language_scanner.l"
+		{
+	return T_CLONE;
+}
+#line 6436 "Zend/zend_language_scanner.c"
+yy683:
+		YYDEBUG(683, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy684;
+		if (yych != 's') goto yy187;
+yy684:
+		YYDEBUG(684, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(685, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1170 "Zend/zend_language_scanner.l"
+		{
+	return T_CLASS;
+}
+#line 6454 "Zend/zend_language_scanner.c"
+yy686:
+		YYDEBUG(686, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy697;
+		if (yych == 'c') goto yy697;
+		goto yy187;
+yy687:
+		YYDEBUG(687, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy695;
+		if (yych == 'e') goto yy695;
+		goto yy187;
+yy688:
+		YYDEBUG(688, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy689;
+		if (yych != 'l') goto yy187;
+yy689:
+		YYDEBUG(689, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy690;
+		if (yych != 'a') goto yy187;
+yy690:
+		YYDEBUG(690, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'B') goto yy691;
+		if (yych != 'b') goto yy187;
+yy691:
+		YYDEBUG(691, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy692;
+		if (yych != 'l') goto yy187;
+yy692:
+		YYDEBUG(692, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy693;
+		if (yych != 'e') goto yy187;
+yy693:
+		YYDEBUG(693, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(694, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1357 "Zend/zend_language_scanner.l"
+		{
+ return T_CALLABLE;
+}
+#line 6504 "Zend/zend_language_scanner.c"
+yy695:
+		YYDEBUG(695, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(696, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1142 "Zend/zend_language_scanner.l"
+		{
+	return T_CASE;
+}
+#line 6517 "Zend/zend_language_scanner.c"
+yy697:
+		YYDEBUG(697, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy698;
+		if (yych != 'h') goto yy187;
+yy698:
+		YYDEBUG(698, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(699, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1062 "Zend/zend_language_scanner.l"
+		{
+	return T_CATCH;
+}
+#line 6535 "Zend/zend_language_scanner.c"
+yy700:
+		YYDEBUG(700, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy717;
+		if (yych == 'n') goto yy717;
+		goto yy187;
+yy701:
+		YYDEBUG(701, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy710;
+		if (yych == 'r') goto yy710;
+		goto yy187;
+yy702:
+		YYDEBUG(702, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy703;
+		if (yych != 'n') goto yy187;
+yy703:
+		YYDEBUG(703, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy704;
+		if (yych != 'c') goto yy187;
+yy704:
+		YYDEBUG(704, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy705;
+		if (yych != 't') goto yy187;
+yy705:
+		YYDEBUG(705, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy706;
+		if (yych != 'i') goto yy187;
+yy706:
+		YYDEBUG(706, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy707;
+		if (yych != 'o') goto yy187;
+yy707:
+		YYDEBUG(707, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy708;
+		if (yych != 'n') goto yy187;
+yy708:
+		YYDEBUG(708, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(709, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1042 "Zend/zend_language_scanner.l"
+		{
+	return T_FUNCTION;
+}
+#line 6590 "Zend/zend_language_scanner.c"
+yy710:
+		YYDEBUG(710, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '^') {
+			if (yych <= '@') {
+				if (yych <= '/') goto yy711;
+				if (yych <= '9') goto yy186;
+			} else {
+				if (yych == 'E') goto yy712;
+				if (yych <= 'Z') goto yy186;
+			}
+		} else {
+			if (yych <= 'd') {
+				if (yych != '`') goto yy186;
+			} else {
+				if (yych <= 'e') goto yy712;
+				if (yych <= 'z') goto yy186;
+				if (yych >= 0x7F) goto yy186;
+			}
+		}
+yy711:
+		YYDEBUG(711, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1102 "Zend/zend_language_scanner.l"
+		{
+	return T_FOR;
+}
+#line 6618 "Zend/zend_language_scanner.c"
+yy712:
+		YYDEBUG(712, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy713;
+		if (yych != 'a') goto yy187;
+yy713:
+		YYDEBUG(713, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy714;
+		if (yych != 'c') goto yy187;
+yy714:
+		YYDEBUG(714, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy715;
+		if (yych != 'h') goto yy187;
+yy715:
+		YYDEBUG(715, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(716, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1110 "Zend/zend_language_scanner.l"
+		{
+	return T_FOREACH;
+}
+#line 6646 "Zend/zend_language_scanner.c"
+yy717:
+		YYDEBUG(717, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy718;
+		if (yych != 'a') goto yy187;
+yy718:
+		YYDEBUG(718, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy719;
+		if (yych != 'l') goto yy187;
+yy719:
+		YYDEBUG(719, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '^') {
+			if (yych <= '@') {
+				if (yych <= '/') goto yy720;
+				if (yych <= '9') goto yy186;
+			} else {
+				if (yych == 'L') goto yy721;
+				if (yych <= 'Z') goto yy186;
+			}
+		} else {
+			if (yych <= 'k') {
+				if (yych != '`') goto yy186;
+			} else {
+				if (yych <= 'l') goto yy721;
+				if (yych <= 'z') goto yy186;
+				if (yych >= 0x7F) goto yy186;
+			}
+		}
+yy720:
+		YYDEBUG(720, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1325 "Zend/zend_language_scanner.l"
+		{
+	return T_FINAL;
+}
+#line 6684 "Zend/zend_language_scanner.c"
+yy721:
+		YYDEBUG(721, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'Y') goto yy722;
+		if (yych != 'y') goto yy187;
+yy722:
+		YYDEBUG(722, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(723, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1066 "Zend/zend_language_scanner.l"
+		{
+	return T_FINALLY;
+}
+#line 6702 "Zend/zend_language_scanner.c"
+yy724:
+		YYDEBUG(724, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'F') {
+			if (yych == 'C') goto yy730;
+			if (yych <= 'E') goto yy187;
+			goto yy731;
+		} else {
+			if (yych <= 'c') {
+				if (yych <= 'b') goto yy187;
+				goto yy730;
+			} else {
+				if (yych == 'f') goto yy731;
+				goto yy187;
+			}
+		}
+yy725:
+		YYDEBUG(725, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy728;
+		if (yych == 'e') goto yy728;
+		goto yy187;
+yy726:
+		YYDEBUG(726, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(727, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1098 "Zend/zend_language_scanner.l"
+		{
+	return T_DO;
+}
+#line 6737 "Zend/zend_language_scanner.c"
+yy728:
+		YYDEBUG(728, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(729, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1038 "Zend/zend_language_scanner.l"
+		{
+	return T_EXIT;
+}
+#line 6750 "Zend/zend_language_scanner.c"
+yy730:
+		YYDEBUG(730, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy737;
+		if (yych == 'l') goto yy737;
+		goto yy187;
+yy731:
+		YYDEBUG(731, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy732;
+		if (yych != 'a') goto yy187;
+yy732:
+		YYDEBUG(732, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'U') goto yy733;
+		if (yych != 'u') goto yy187;
+yy733:
+		YYDEBUG(733, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy734;
+		if (yych != 'l') goto yy187;
+yy734:
+		YYDEBUG(734, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy735;
+		if (yych != 't') goto yy187;
+yy735:
+		YYDEBUG(735, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(736, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1146 "Zend/zend_language_scanner.l"
+		{
+	return T_DEFAULT;
+}
+#line 6789 "Zend/zend_language_scanner.c"
+yy737:
+		YYDEBUG(737, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy738;
+		if (yych != 'a') goto yy187;
+yy738:
+		YYDEBUG(738, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy739;
+		if (yych != 'r') goto yy187;
+yy739:
+		YYDEBUG(739, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy740;
+		if (yych != 'e') goto yy187;
+yy740:
+		YYDEBUG(740, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(741, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1118 "Zend/zend_language_scanner.l"
+		{
+	return T_DECLARE;
+}
+#line 6817 "Zend/zend_language_scanner.c"
+yy742:
+		YYDEBUG(742, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy804;
+		if (yych == 'h') goto yy804;
+		goto yy187;
+yy743:
+		YYDEBUG(743, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy798;
+		if (yych == 's') goto yy798;
+		goto yy187;
+yy744:
+		YYDEBUG(744, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'P') goto yy794;
+		if (yych == 'p') goto yy794;
+		goto yy187;
+yy745:
+		YYDEBUG(745, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy760;
+		if (yych == 'd') goto yy760;
+		goto yy187;
+yy746:
+		YYDEBUG(746, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy757;
+		if (yych == 'a') goto yy757;
+		goto yy187;
+yy747:
+		YYDEBUG(747, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych <= 'T') {
+			if (yych == 'I') goto yy748;
+			if (yych <= 'S') goto yy187;
+			goto yy749;
+		} else {
+			if (yych <= 'i') {
+				if (yych <= 'h') goto yy187;
+			} else {
+				if (yych == 't') goto yy749;
+				goto yy187;
+			}
+		}
+yy748:
+		YYDEBUG(748, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy755;
+		if (yych == 't') goto yy755;
+		goto yy187;
+yy749:
+		YYDEBUG(749, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy750;
+		if (yych != 'e') goto yy187;
+yy750:
+		YYDEBUG(750, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'N') goto yy751;
+		if (yych != 'n') goto yy187;
+yy751:
+		YYDEBUG(751, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'D') goto yy752;
+		if (yych != 'd') goto yy187;
+yy752:
+		YYDEBUG(752, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'S') goto yy753;
+		if (yych != 's') goto yy187;
+yy753:
+		YYDEBUG(753, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(754, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1182 "Zend/zend_language_scanner.l"
+		{
+	return T_EXTENDS;
+}
+#line 6901 "Zend/zend_language_scanner.c"
+yy755:
+		YYDEBUG(755, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(756, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1034 "Zend/zend_language_scanner.l"
+		{
+	return T_EXIT;
+}
+#line 6914 "Zend/zend_language_scanner.c"
+yy757:
+		YYDEBUG(757, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy758;
+		if (yych != 'l') goto yy187;
+yy758:
+		YYDEBUG(758, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(759, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1269 "Zend/zend_language_scanner.l"
+		{
+	return T_EVAL;
+}
+#line 6932 "Zend/zend_language_scanner.c"
+yy760:
+		YYDEBUG(760, *YYCURSOR);
+		yych = *++YYCURSOR;
+		YYDEBUG(-1, yych);
+		switch (yych) {
+		case 'D':
+		case 'd':	goto yy761;
+		case 'F':
+		case 'f':	goto yy762;
+		case 'I':
+		case 'i':	goto yy763;
+		case 'S':
+		case 's':	goto yy764;
+		case 'W':
+		case 'w':	goto yy765;
+		default:	goto yy187;
+		}
+yy761:
+		YYDEBUG(761, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy787;
+		if (yych == 'e') goto yy787;
+		goto yy187;
+yy762:
+		YYDEBUG(762, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy779;
+		if (yych == 'o') goto yy779;
+		goto yy187;
+yy763:
+		YYDEBUG(763, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'F') goto yy777;
+		if (yych == 'f') goto yy777;
+		goto yy187;
+yy764:
+		YYDEBUG(764, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'W') goto yy771;
+		if (yych == 'w') goto yy771;
+		goto yy187;
+yy765:
+		YYDEBUG(765, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy766;
+		if (yych != 'h') goto yy187;
+yy766:
+		YYDEBUG(766, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy767;
+		if (yych != 'i') goto yy187;
+yy767:
+		YYDEBUG(767, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy768;
+		if (yych != 'l') goto yy187;
+yy768:
+		YYDEBUG(768, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy769;
+		if (yych != 'e') goto yy187;
+yy769:
+		YYDEBUG(769, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(770, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1094 "Zend/zend_language_scanner.l"
+		{
+	return T_ENDWHILE;
+}
+#line 7006 "Zend/zend_language_scanner.c"
+yy771:
+		YYDEBUG(771, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'I') goto yy772;
+		if (yych != 'i') goto yy187;
+yy772:
+		YYDEBUG(772, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy773;
+		if (yych != 't') goto yy187;
+yy773:
+		YYDEBUG(773, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy774;
+		if (yych != 'c') goto yy187;
+yy774:
+		YYDEBUG(774, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy775;
+		if (yych != 'h') goto yy187;
+yy775:
+		YYDEBUG(775, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(776, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1138 "Zend/zend_language_scanner.l"
+		{
+	return T_ENDSWITCH;
+}
+#line 7039 "Zend/zend_language_scanner.c"
+yy777:
+		YYDEBUG(777, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(778, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1082 "Zend/zend_language_scanner.l"
+		{
+	return T_ENDIF;
+}
+#line 7052 "Zend/zend_language_scanner.c"
+yy779:
+		YYDEBUG(779, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy780;
+		if (yych != 'r') goto yy187;
+yy780:
+		YYDEBUG(780, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '^') {
+			if (yych <= '@') {
+				if (yych <= '/') goto yy781;
+				if (yych <= '9') goto yy186;
+			} else {
+				if (yych == 'E') goto yy782;
+				if (yych <= 'Z') goto yy186;
+			}
+		} else {
+			if (yych <= 'd') {
+				if (yych != '`') goto yy186;
+			} else {
+				if (yych <= 'e') goto yy782;
+				if (yych <= 'z') goto yy186;
+				if (yych >= 0x7F) goto yy186;
+			}
+		}
+yy781:
+		YYDEBUG(781, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1106 "Zend/zend_language_scanner.l"
+		{
+	return T_ENDFOR;
+}
+#line 7085 "Zend/zend_language_scanner.c"
+yy782:
+		YYDEBUG(782, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy783;
+		if (yych != 'a') goto yy187;
+yy783:
+		YYDEBUG(783, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy784;
+		if (yych != 'c') goto yy187;
+yy784:
+		YYDEBUG(784, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'H') goto yy785;
+		if (yych != 'h') goto yy187;
+yy785:
+		YYDEBUG(785, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(786, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1114 "Zend/zend_language_scanner.l"
+		{
+	return T_ENDFOREACH;
+}
+#line 7113 "Zend/zend_language_scanner.c"
+yy787:
+		YYDEBUG(787, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'C') goto yy788;
+		if (yych != 'c') goto yy187;
+yy788:
+		YYDEBUG(788, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'L') goto yy789;
+		if (yych != 'l') goto yy187;
+yy789:
+		YYDEBUG(789, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'A') goto yy790;
+		if (yych != 'a') goto yy187;
+yy790:
+		YYDEBUG(790, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'R') goto yy791;
+		if (yych != 'r') goto yy187;
+yy791:
+		YYDEBUG(791, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy792;
+		if (yych != 'e') goto yy187;
+yy792:
+		YYDEBUG(792, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(793, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1122 "Zend/zend_language_scanner.l"
+		{
+	return T_ENDDECLARE;
+}
+#line 7151 "Zend/zend_language_scanner.c"
+yy794:
+		YYDEBUG(794, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'T') goto yy795;
+		if (yych != 't') goto yy187;
+yy795:
+		YYDEBUG(795, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'Y') goto yy796;
+		if (yych != 'y') goto yy187;
+yy796:
+		YYDEBUG(796, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(797, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1309 "Zend/zend_language_scanner.l"
+		{
+	return T_EMPTY;
+}
+#line 7174 "Zend/zend_language_scanner.c"
+yy798:
+		YYDEBUG(798, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'E') goto yy799;
+		if (yych != 'e') goto yy187;
+yy799:
+		YYDEBUG(799, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '^') {
+			if (yych <= '@') {
+				if (yych <= '/') goto yy800;
+				if (yych <= '9') goto yy186;
+			} else {
+				if (yych == 'I') goto yy801;
+				if (yych <= 'Z') goto yy186;
+			}
+		} else {
+			if (yych <= 'h') {
+				if (yych != '`') goto yy186;
+			} else {
+				if (yych <= 'i') goto yy801;
+				if (yych <= 'z') goto yy186;
+				if (yych >= 0x7F) goto yy186;
+			}
+		}
+yy800:
+		YYDEBUG(800, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1086 "Zend/zend_language_scanner.l"
+		{
+	return T_ELSE;
+}
+#line 7207 "Zend/zend_language_scanner.c"
+yy801:
+		YYDEBUG(801, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'F') goto yy802;
+		if (yych != 'f') goto yy187;
+yy802:
+		YYDEBUG(802, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(803, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1078 "Zend/zend_language_scanner.l"
+		{
+	return T_ELSEIF;
+}
+#line 7225 "Zend/zend_language_scanner.c"
+yy804:
+		YYDEBUG(804, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yych == 'O') goto yy805;
+		if (yych != 'o') goto yy187;
+yy805:
+		YYDEBUG(805, *YYCURSOR);
+		++YYCURSOR;
+		if (yybm[0+(yych = *YYCURSOR)] & 4) {
+			goto yy186;
+		}
+		YYDEBUG(806, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1162 "Zend/zend_language_scanner.l"
+		{
+	return T_ECHO;
+}
+#line 7243 "Zend/zend_language_scanner.c"
+	}
+/* *********************************** */
+yyc_ST_LOOKING_FOR_PROPERTY:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0, 128, 128,   0,   0, 128,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,   0,   0,   0,   0,   0,   0, 
+			  0,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,   0,   0,   0,   0,  64, 
+			  0,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,   0,   0,   0,   0,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+			 64,  64,  64,  64,  64,  64,  64,  64, 
+		};
+		YYDEBUG(807, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych <= '-') {
+			if (yych <= '\r') {
+				if (yych <= 0x08) goto yy815;
+				if (yych <= '\n') goto yy809;
+				if (yych <= '\f') goto yy815;
+			} else {
+				if (yych == ' ') goto yy809;
+				if (yych <= ',') goto yy815;
+				goto yy811;
+			}
+		} else {
+			if (yych <= '_') {
+				if (yych <= '@') goto yy815;
+				if (yych <= 'Z') goto yy813;
+				if (yych <= '^') goto yy815;
+				goto yy813;
+			} else {
+				if (yych <= '`') goto yy815;
+				if (yych <= 'z') goto yy813;
+				if (yych <= '~') goto yy815;
+				goto yy813;
+			}
+		}
+yy809:
+		YYDEBUG(809, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy821;
+yy810:
+		YYDEBUG(810, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1195 "Zend/zend_language_scanner.l"
+		{
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
+	HANDLE_NEWLINES(yytext, yyleng);
+	return T_WHITESPACE;
+}
+#line 7322 "Zend/zend_language_scanner.c"
+yy811:
+		YYDEBUG(811, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) == '>') goto yy818;
+yy812:
+		YYDEBUG(812, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1211 "Zend/zend_language_scanner.l"
+		{
+	yyless(0);
+	yy_pop_state(TSRMLS_C);
+	goto restart;
+}
+#line 7336 "Zend/zend_language_scanner.c"
+yy813:
+		YYDEBUG(813, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy817;
+yy814:
+		YYDEBUG(814, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1205 "Zend/zend_language_scanner.l"
+		{
+	yy_pop_state(TSRMLS_C);
+	zend_copy_value(zendlval, yytext, yyleng);
+	return T_STRING;
+}
+#line 7351 "Zend/zend_language_scanner.c"
+yy815:
+		YYDEBUG(815, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy812;
+yy816:
+		YYDEBUG(816, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy817:
+		YYDEBUG(817, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy816;
+		}
+		goto yy814;
+yy818:
+		YYDEBUG(818, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(819, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1201 "Zend/zend_language_scanner.l"
+		{
+	return T_OBJECT_OPERATOR;
+}
+#line 7376 "Zend/zend_language_scanner.c"
+yy820:
+		YYDEBUG(820, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy821:
+		YYDEBUG(821, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy820;
+		}
+		goto yy810;
+	}
+/* *********************************** */
+yyc_ST_LOOKING_FOR_VARNAME:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128,   0,   0,   0,   0,   0,   0, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			  0, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128,   0,   0,   0,   0, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+			128, 128, 128, 128, 128, 128, 128, 128, 
+		};
+		YYDEBUG(822, *YYCURSOR);
+		YYFILL(2);
+		yych = *YYCURSOR;
+		if (yych <= '_') {
+			if (yych <= '@') goto yy826;
+			if (yych <= 'Z') goto yy824;
+			if (yych <= '^') goto yy826;
+		} else {
+			if (yych <= '`') goto yy826;
+			if (yych <= 'z') goto yy824;
+			if (yych <= '~') goto yy826;
+		}
+yy824:
+		YYDEBUG(824, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= '_') {
+			if (yych <= '@') {
+				if (yych <= '/') goto yy825;
+				if (yych <= '9') goto yy828;
+			} else {
+				if (yych <= '[') goto yy828;
+				if (yych >= '_') goto yy828;
+			}
+		} else {
+			if (yych <= '|') {
+				if (yych <= '`') goto yy825;
+				if (yych <= 'z') goto yy828;
+			} else {
+				if (yych != '~') goto yy828;
+			}
+		}
+yy825:
+		YYDEBUG(825, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1508 "Zend/zend_language_scanner.l"
+		{
+	yyless(0);
+	yy_pop_state(TSRMLS_C);
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
+	goto restart;
+}
+#line 7468 "Zend/zend_language_scanner.c"
+yy826:
+		YYDEBUG(826, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy825;
+yy827:
+		YYDEBUG(827, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy828:
+		YYDEBUG(828, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy827;
+		}
+		if (yych == '[') goto yy830;
+		if (yych == '}') goto yy830;
+		YYDEBUG(829, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		goto yy825;
+yy830:
+		YYDEBUG(830, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(831, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1499 "Zend/zend_language_scanner.l"
+		{
+	yyless(yyleng - 1);
+	zend_copy_value(zendlval, yytext, yyleng);
+	yy_pop_state(TSRMLS_C);
+	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
+	return T_STRING_VARNAME;
+}
+#line 7501 "Zend/zend_language_scanner.c"
+	}
+/* *********************************** */
+yyc_ST_NOWDOC:
+	YYDEBUG(832, *YYCURSOR);
+	YYFILL(1);
+	yych = *YYCURSOR;
+	YYDEBUG(834, *YYCURSOR);
+	++YYCURSOR;
+	YYDEBUG(835, *YYCURSOR);
+	yyleng = YYCURSOR - SCNG(yy_text);
+#line 2339 "Zend/zend_language_scanner.l"
+	{
+	int newline = 0;
+
+	zend_heredoc_label *heredoc_label = zend_ptr_stack_top(&SCNG(heredoc_label_stack));
+
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+
+	YYCURSOR--;
+
+	while (YYCURSOR < YYLIMIT) {
+		switch (*YYCURSOR++) {
+			case '\r':
+				if (*YYCURSOR == '\n') {
+					YYCURSOR++;
+				}
+				/* fall through */
+			case '\n':
+				/* Check for ending label on the next line */
+				if (IS_LABEL_START(*YYCURSOR) && heredoc_label->length < YYLIMIT - YYCURSOR && !memcmp(YYCURSOR, heredoc_label->label, heredoc_label->length)) {
+					YYCTYPE *end = YYCURSOR + heredoc_label->length;
+
+					if (*end == ';') {
+						end++;
+					}
+
+					if (*end == '\n' || *end == '\r') {
+						/* newline before label will be subtracted from returned text, but
+						 * yyleng/yytext will include it, for zend_highlight/strip, tokenizer, etc. */
+						if (YYCURSOR[-2] == '\r' && YYCURSOR[-1] == '\n') {
+							newline = 2; /* Windows newline */
+						} else {
+							newline = 1;
+						}
+
+						CG(increment_lineno) = 1; /* For newline before label */
+						BEGIN(ST_END_HEREDOC);
+
+						goto nowdoc_scan_done;
+					}
+				}
+				/* fall through */
+			default:
+				continue;
+		}
+	}
+
+nowdoc_scan_done:
+	yyleng = YYCURSOR - SCNG(yy_text);
+
+	zend_copy_value(zendlval, yytext, yyleng - newline);
+	HANDLE_NEWLINES(yytext, yyleng - newline);
+	return T_ENCAPSED_AND_WHITESPACE;
+}
+#line 7568 "Zend/zend_language_scanner.c"
+/* *********************************** */
+yyc_ST_VAR_OFFSET:
+	{
+		static const unsigned char yybm[] = {
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			  0,   0,   0,   0,   0,   0,   0,   0, 
+			240, 240, 112, 112, 112, 112, 112, 112, 
+			112, 112,   0,   0,   0,   0,   0,   0, 
+			  0,  80,  80,  80,  80,  80,  80,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,   0,   0,   0,   0,  16, 
+			  0,  80,  80,  80,  80,  80,  80,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,   0,   0,   0,   0,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+			 16,  16,  16,  16,  16,  16,  16,  16, 
+		};
+		YYDEBUG(836, *YYCURSOR);
+		YYFILL(3);
+		yych = *YYCURSOR;
+		if (yych <= '/') {
+			if (yych <= ' ') {
+				if (yych <= '\f') {
+					if (yych <= 0x08) goto yy850;
+					if (yych <= '\n') goto yy846;
+					goto yy850;
+				} else {
+					if (yych <= '\r') goto yy846;
+					if (yych <= 0x1F) goto yy850;
+					goto yy846;
+				}
+			} else {
+				if (yych <= '$') {
+					if (yych <= '"') goto yy845;
+					if (yych <= '#') goto yy846;
+					goto yy841;
+				} else {
+					if (yych == '\'') goto yy846;
+					goto yy845;
+				}
+			}
+		} else {
+			if (yych <= '\\') {
+				if (yych <= '@') {
+					if (yych <= '0') goto yy838;
+					if (yych <= '9') goto yy840;
+					goto yy845;
+				} else {
+					if (yych <= 'Z') goto yy848;
+					if (yych <= '[') goto yy845;
+					goto yy846;
+				}
+			} else {
+				if (yych <= '_') {
+					if (yych <= ']') goto yy843;
+					if (yych <= '^') goto yy845;
+					goto yy848;
+				} else {
+					if (yych <= '`') goto yy845;
+					if (yych <= 'z') goto yy848;
+					if (yych <= '~') goto yy845;
+					goto yy848;
+				}
+			}
+		}
+yy838:
+		YYDEBUG(838, *YYCURSOR);
+		yyaccept = 0;
+		yych = *(YYMARKER = ++YYCURSOR);
+		if (yych <= 'W') {
+			if (yych <= '9') {
+				if (yych >= '0') goto yy862;
+			} else {
+				if (yych == 'B') goto yy859;
+			}
+		} else {
+			if (yych <= 'b') {
+				if (yych <= 'X') goto yy861;
+				if (yych >= 'b') goto yy859;
+			} else {
+				if (yych == 'x') goto yy861;
+			}
+		}
+yy839:
+		YYDEBUG(839, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1579 "Zend/zend_language_scanner.l"
+		{ /* Offset could be treated as a long */
+	if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
+		ZVAL_LONG(zendlval, strtol(yytext, NULL, 10));
+	} else {
+		ZVAL_STRINGL(zendlval, yytext, yyleng);
+	}
+	return T_NUM_STRING;
+}
+#line 7684 "Zend/zend_language_scanner.c"
+yy840:
+		YYDEBUG(840, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy858;
+yy841:
+		YYDEBUG(841, *YYCURSOR);
+		++YYCURSOR;
+		if ((yych = *YYCURSOR) <= '_') {
+			if (yych <= '@') goto yy842;
+			if (yych <= 'Z') goto yy854;
+			if (yych >= '_') goto yy854;
+		} else {
+			if (yych <= '`') goto yy842;
+			if (yych <= 'z') goto yy854;
+			if (yych >= 0x7F) goto yy854;
+		}
+yy842:
+		YYDEBUG(842, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1871 "Zend/zend_language_scanner.l"
+		{
+	/* Only '[' can be valid, but returning other tokens will allow a more explicit parse error */
+	return yytext[0];
+}
+#line 7709 "Zend/zend_language_scanner.c"
+yy843:
+		YYDEBUG(843, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(844, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1866 "Zend/zend_language_scanner.l"
+		{
+	yy_pop_state(TSRMLS_C);
+	return ']';
+}
+#line 7720 "Zend/zend_language_scanner.c"
+yy845:
+		YYDEBUG(845, *YYCURSOR);
+		yych = *++YYCURSOR;
+		goto yy842;
+yy846:
+		YYDEBUG(846, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(847, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1876 "Zend/zend_language_scanner.l"
+		{
+	/* Invalid rule to return a more explicit parse error with proper line number */
+	yyless(0);
+	yy_pop_state(TSRMLS_C);
+	return T_ENCAPSED_AND_WHITESPACE;
+}
+#line 7737 "Zend/zend_language_scanner.c"
+yy848:
+		YYDEBUG(848, *YYCURSOR);
+		++YYCURSOR;
+		yych = *YYCURSOR;
+		goto yy853;
+yy849:
+		YYDEBUG(849, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1883 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, yytext, yyleng);
+	return T_STRING;
+}
+#line 7751 "Zend/zend_language_scanner.c"
+yy850:
+		YYDEBUG(850, *YYCURSOR);
+		++YYCURSOR;
+		YYDEBUG(851, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 2396 "Zend/zend_language_scanner.l"
+		{
+	if (YYCURSOR > YYLIMIT) {
+		return 0;
+	}
+
+	zend_error(E_COMPILE_WARNING,"Unexpected character in input:  '%c' (ASCII=%d) state=%d", yytext[0], yytext[0], YYSTATE);
+	goto restart;
+}
+#line 7766 "Zend/zend_language_scanner.c"
+yy852:
+		YYDEBUG(852, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy853:
+		YYDEBUG(853, *YYCURSOR);
+		if (yybm[0+yych] & 16) {
+			goto yy852;
+		}
+		goto yy849;
+yy854:
+		YYDEBUG(854, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(855, *YYCURSOR);
+		if (yych <= '^') {
+			if (yych <= '9') {
+				if (yych >= '0') goto yy854;
+			} else {
+				if (yych <= '@') goto yy856;
+				if (yych <= 'Z') goto yy854;
+			}
+		} else {
+			if (yych <= '`') {
+				if (yych <= '_') goto yy854;
+			} else {
+				if (yych <= 'z') goto yy854;
+				if (yych >= 0x7F) goto yy854;
+			}
+		}
+yy856:
+		YYDEBUG(856, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1861 "Zend/zend_language_scanner.l"
+		{
+	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
+	return T_VARIABLE;
+}
+#line 7807 "Zend/zend_language_scanner.c"
+yy857:
+		YYDEBUG(857, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+yy858:
+		YYDEBUG(858, *YYCURSOR);
+		if (yybm[0+yych] & 32) {
+			goto yy857;
+		}
+		goto yy839;
+yy859:
+		YYDEBUG(859, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yybm[0+yych] & 128) {
+			goto yy867;
+		}
+yy860:
+		YYDEBUG(860, *YYCURSOR);
+		YYCURSOR = YYMARKER;
+		goto yy839;
+yy861:
+		YYDEBUG(861, *YYCURSOR);
+		yych = *++YYCURSOR;
+		if (yybm[0+yych] & 64) {
+			goto yy865;
+		}
+		goto yy860;
+yy862:
+		YYDEBUG(862, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(863, *YYCURSOR);
+		if (yych <= '/') goto yy864;
+		if (yych <= '9') goto yy862;
+yy864:
+		YYDEBUG(864, *YYCURSOR);
+		yyleng = YYCURSOR - SCNG(yy_text);
+#line 1588 "Zend/zend_language_scanner.l"
+		{ /* Offset must be treated as a string */
+	ZVAL_STRINGL(zendlval, yytext, yyleng);
+	return T_NUM_STRING;
+}
+#line 7852 "Zend/zend_language_scanner.c"
+yy865:
+		YYDEBUG(865, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(866, *YYCURSOR);
+		if (yybm[0+yych] & 64) {
+			goto yy865;
+		}
+		goto yy864;
+yy867:
+		YYDEBUG(867, *YYCURSOR);
+		++YYCURSOR;
+		YYFILL(1);
+		yych = *YYCURSOR;
+		YYDEBUG(868, *YYCURSOR);
+		if (yybm[0+yych] & 128) {
+			goto yy867;
+		}
+		goto yy864;
+	}
+}
+#line 2405 "Zend/zend_language_scanner.l"
+
+}
diff --git a/Zend/zend_language_scanner.h b/Zend/zend_language_scanner.h
index 05345b2cc3..d434107a9b 100644
--- a/Zend/zend_language_scanner.h
+++ b/Zend/zend_language_scanner.h
@@ -35,7 +35,7 @@ typedef struct _zend_lex_state {
 
 	zend_file_handle *in;
 	uint lineno;
-	char *filename;
+	zend_string *filename;
 
 	/* original (unfiltered) script */
 	unsigned char *script_org;
diff --git a/Zend/zend_language_scanner.l b/Zend/zend_language_scanner.l
index 4f50658a59..2204adf064 100644
--- a/Zend/zend_language_scanner.l
+++ b/Zend/zend_language_scanner.l
@@ -112,9 +112,9 @@ do {																			\
 	} \
 }
 
-/* To save initial string length after scanning to first variable, CG(doc_comment_len) can be reused */
-#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) CG(doc_comment_len) = (len)
-#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    CG(doc_comment_len)
+/* To save initial string length after scanning to first variable */
+#define SET_DOUBLE_QUOTES_SCANNED_LENGTH(len) SCNG(scanned_string_len) = (len)
+#define GET_DOUBLE_QUOTES_SCANNED_LENGTH()    SCNG(scanned_string_len)
 
 #define IS_LABEL_START(c) (((c) >= 'a' && (c) <= 'z') || ((c) >= 'A' && (c) <= 'Z') || (c) == '_' || (c) >= 0x7F)
 
@@ -179,7 +179,6 @@ void startup_scanner(TSRMLS_D)
 {
 	CG(parse_error) = 0;
 	CG(doc_comment) = NULL;
-	CG(doc_comment_len) = 0;
 	zend_stack_init(&SCNG(state_stack));
 	zend_ptr_stack_init(&SCNG(heredoc_label_stack));
 }
@@ -479,6 +478,7 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
 	const char *file_path = NULL;
 	char *buf;
 	size_t size, offset = 0;
+	zend_string *compiled_filename;
 
 	/* The shebang line was read, get the current position to obtain the buffer start */
 	if (CG(start_lineno) == 2 && file_handle->type == ZEND_HANDLE_FP && file_handle->handle.fp) {
@@ -534,7 +534,9 @@ ZEND_API int open_file_for_scanning(zend_file_handle *file_handle TSRMLS_DC)
 		file_path = file_handle->filename;
 	}
 
-	zend_set_compiled_filename(file_path TSRMLS_CC);
+	compiled_filename = STR_INIT(file_path, strlen(file_path), 0);
+	zend_set_compiled_filename(compiled_filename TSRMLS_CC);
+	STR_RELEASE(compiled_filename);
 
 	if (CG(start_lineno)) {
 		CG(zend_lineno) = CG(start_lineno);
@@ -562,7 +564,6 @@ ZEND_API zend_op_array *compile_file(zend_file_handle *file_handle, int type TSR
 	zend_bool original_in_compilation = CG(in_compilation);
 
 	retval_znode.op_type = IS_CONST;
-	INIT_PZVAL(&retval_znode.u.constant);
 	ZVAL_LONG(&retval_znode.u.constant, 1);
 
 	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
@@ -614,7 +615,7 @@ zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
 	zend_op_array *retval;
 	char *opened_path = NULL;
 
-	if (filename->type != IS_STRING) {
+	if (Z_TYPE_P(filename) != IS_STRING) {
 		tmp = *filename;
 		zval_copy_ctor(&tmp);
 		convert_to_string(&tmp);
@@ -628,13 +629,11 @@ zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
 
 	retval = zend_compile_file(&file_handle, type TSRMLS_CC);
 	if (retval && file_handle.handle.stream.handle) {
-		int dummy = 1;
-
 		if (!file_handle.opened_path) {
 			file_handle.opened_path = opened_path = estrndup(Z_STRVAL_P(filename), Z_STRLEN_P(filename));
 		}
 
-		zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL);
+		zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path));
 
 		if (opened_path) {
 			efree(opened_path);
@@ -651,17 +650,20 @@ zend_op_array *compile_filename(int type, zval *filename TSRMLS_DC)
 ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_DC)
 {
 	char *buf;
-	size_t size;
+	size_t size, old_len;
+	zend_string *new_compiled_filename;
 
 	/* enforce ZEND_MMAP_AHEAD trailing NULLs for flex... */
-	Z_STRVAL_P(str) = str_erealloc(Z_STRVAL_P(str), Z_STRLEN_P(str) + ZEND_MMAP_AHEAD);
-	memset(Z_STRVAL_P(str) + Z_STRLEN_P(str), 0, ZEND_MMAP_AHEAD);
+	old_len = Z_STRLEN_P(str);
+	Z_STR_P(str) = STR_REALLOC(Z_STR_P(str), old_len + ZEND_MMAP_AHEAD, 0);
+	Z_TYPE_INFO_P(str) = IS_STRING_EX;
+	memset(Z_STRVAL_P(str) + old_len, 0, ZEND_MMAP_AHEAD + 1);
 
 	SCNG(yy_in) = NULL;
 	SCNG(yy_start) = NULL;
 
 	buf = Z_STRVAL_P(str);
-	size = Z_STRLEN_P(str);
+	size = old_len;
 
 	if (CG(multibyte)) {
 		SCNG(script_org) = (unsigned char*)buf;
@@ -682,7 +684,9 @@ ZEND_API int zend_prepare_string_for_scanning(zval *str, char *filename TSRMLS_D
 
 	yy_scan_buffer(buf, size TSRMLS_CC);
 
-	zend_set_compiled_filename(filename TSRMLS_CC);
+	new_compiled_filename = STR_INIT(filename, strlen(filename), 0);
+	zend_set_compiled_filename(new_compiled_filename TSRMLS_CC);
+	STR_RELEASE(new_compiled_filename);
 	CG(zend_lineno) = 1;
 	CG(increment_lineno) = 0;
 	RESET_DOC_COMMENT();
@@ -729,8 +733,7 @@ zend_op_array *compile_string(zval *source_string, char *filename TSRMLS_DC)
 
 	CG(in_compilation) = 1;
 
-	tmp = *source_string;
-	zval_copy_ctor(&tmp);
+	ZVAL_DUP(&tmp, source_string);
 	convert_to_string(&tmp);
 	source_string = &tmp;
 
@@ -844,6 +847,9 @@ ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter
 			zend_error_noreturn(E_COMPILE_ERROR, "Could not convert the script from the detected "
 					"encoding \"%s\" to a compatible encoding", zend_multibyte_get_encoding_name(LANG_SCNG(script_encoding)));
 		}
+		if (SCNG(script_filtered)) {
+			efree(SCNG(script_filtered));
+		}
 		SCNG(script_filtered) = new_yy_start;
 		SCNG(script_filtered_size) = length;
 	}
@@ -857,22 +863,33 @@ ZEND_API void zend_multibyte_yyinput_again(zend_encoding_filter old_input_filter
 }
 
 
+// TODO: avoid reallocation ???
 # define zend_copy_value(zendlval, yytext, yyleng) \
 	if (SCNG(output_filter)) { \
 		size_t sz = 0; \
-		SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC); \
-		Z_STRLEN_P(zendlval) = sz; \
+		char *s = NULL; \
+		SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC); \
+		ZVAL_STRINGL(zendlval, s, sz); \
+		efree(s); \
 	} else { \
-		Z_STRVAL_P(zendlval) = (char *) estrndup(yytext, yyleng); \
-		Z_STRLEN_P(zendlval) = yyleng; \
+		ZVAL_STRINGL(zendlval, yytext, yyleng); \
 	}
 
+// TODO: some extensions might need content, but we don't copy it intentional ???
+#if 0
+# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
+	ZVAL_STRINGL(zendlval, yytext, yyleng)
+#else
+# define DUMMY_STRINGL(zendlval, yytext, yyleng) \
+	ZVAL_EMPTY_STRING(zendlval)
+#endif
+
 static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quote_type TSRMLS_DC)
 {
 	register char *s, *t;
 	char *end;
 
-	ZVAL_STRINGL(zendlval, str, len, 1);
+	ZVAL_STRINGL(zendlval, str, len);
 
 	/* convert escape sequences */
 	s = t = Z_STRVAL_P(zendlval);
@@ -979,10 +996,13 @@ static void zend_scan_escape_string(zval *zendlval, char *str, int len, char quo
 	*t = 0;
 	if (SCNG(output_filter)) {
 		size_t sz = 0;
+		unsigned char *str;
+		// TODO: avoid realocation ???
 		s = Z_STRVAL_P(zendlval);
-		SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);
-		Z_STRLEN_P(zendlval) = sz;
-		efree(s);
+		SCNG(output_filter)(&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);
+		zval_ptr_dtor(zendlval);
+		ZVAL_STRINGL(zendlval, str, sz);
+		efree(str);
 	}
 }
 
@@ -1173,7 +1193,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING,ST_LOOKING_FOR_PROPERTY>{WHITESPACE}+ {
-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_WHITESPACE;
 }
@@ -1185,7 +1205,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 <ST_LOOKING_FOR_PROPERTY>{LABEL} {
 	yy_pop_state(TSRMLS_C);
 	zend_copy_value(zendlval, yytext, yyleng);
-	zendlval->type = IS_STRING;
 	return T_STRING;
 }
 
@@ -1480,7 +1499,6 @@ NEWLINE ("\r"|"\n"|"\r\n")
 <ST_LOOKING_FOR_VARNAME>{LABEL}[[}] {
 	yyless(yyleng - 1);
 	zend_copy_value(zendlval, yytext, yyleng);
-	zendlval->type = IS_STRING;
 	yy_pop_state(TSRMLS_C);
 	yy_push_state(ST_IN_SCRIPTING TSRMLS_CC);
 	return T_STRING_VARNAME;
@@ -1506,11 +1524,10 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 	if (len < SIZEOF_LONG * 8) {
 		if (len == 0) {
-			Z_LVAL_P(zendlval) = 0;
+			ZVAL_LONG(zendlval, 0);
 		} else {
-			Z_LVAL_P(zendlval) = strtol(bin, NULL, 2);
+			ZVAL_LONG(zendlval, strtol(bin, NULL, 2));
 		}
-		zendlval->type = IS_LONG;
 		return T_LNUMBER;
 	} else {
 		ZVAL_DOUBLE(zendlval, zend_bin_strtod(bin, NULL));
@@ -1520,22 +1537,19 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <ST_IN_SCRIPTING>{LNUM} {
 	if (yyleng < MAX_LENGTH_OF_LONG - 1) { /* Won't overflow */
-		Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
+		ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
 	} else {
 		errno = 0;
-		Z_LVAL_P(zendlval) = strtol(yytext, NULL, 0);
+		ZVAL_LONG(zendlval, strtol(yytext, NULL, 0));
 		if (errno == ERANGE) { /* Overflow */
 			if (yytext[0] == '0') { /* octal overflow */
-				Z_DVAL_P(zendlval) = zend_oct_strtod(yytext, NULL);
+				ZVAL_DOUBLE(zendlval, zend_oct_strtod(yytext, NULL));
 			} else {
-				Z_DVAL_P(zendlval) = zend_strtod(yytext, NULL);
+				ZVAL_DOUBLE(zendlval, zend_strtod(yytext, NULL));
 			}
-			zendlval->type = IS_DOUBLE;
 			return T_DNUMBER;
 		}
 	}
-
-	zendlval->type = IS_LONG;
 	return T_LNUMBER;
 }
 
@@ -1551,11 +1565,10 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 	if (len < SIZEOF_LONG * 2 || (len == SIZEOF_LONG * 2 && *hex <= '7')) {
 		if (len == 0) {
-			Z_LVAL_P(zendlval) = 0;
+			ZVAL_LONG(zendlval, 0);
 		} else {
-			Z_LVAL_P(zendlval) = strtol(hex, NULL, 16);
+			ZVAL_LONG(zendlval, strtol(hex, NULL, 16));
 		}
-		zendlval->type = IS_LONG;
 		return T_LNUMBER;
 	} else {
 		ZVAL_DOUBLE(zendlval, zend_hex_strtod(hex, NULL));
@@ -1567,13 +1580,13 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	if (yyleng < MAX_LENGTH_OF_LONG - 1 || (yyleng == MAX_LENGTH_OF_LONG - 1 && strcmp(yytext, long_min_digits) < 0)) {
 		ZVAL_LONG(zendlval, strtol(yytext, NULL, 10));
 	} else {
-		ZVAL_STRINGL(zendlval, yytext, yyleng, 1);
+		ZVAL_STRINGL(zendlval, yytext, yyleng);
 	}
 	return T_NUM_STRING;
 }
 
 <ST_VAR_OFFSET>{LNUM}|{HNUM}|{BNUM} { /* Offset must be treated as a string */
-	ZVAL_STRINGL(zendlval, yytext, yyleng, 1);
+	ZVAL_STRINGL(zendlval, yytext, yyleng);
 	return T_NUM_STRING;
 }
 
@@ -1587,12 +1600,11 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	if (ce && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
 		/* We create a special __CLASS__ constant that is going to be resolved
 		   at run-time */
-		Z_STRLEN_P(zendlval) = sizeof("__CLASS__")-1;
-		Z_STRVAL_P(zendlval) = estrndup("__CLASS__", Z_STRLEN_P(zendlval));
-		zendlval->type = IS_CONSTANT;
+		ZVAL_STRINGL(zendlval, "__CLASS__", sizeof("__CLASS__") - 1);
+		Z_TYPE_INFO_P(zendlval) = IS_CONSTANT_EX;
 	} else {
 		if (ce && ce->name) {
-			ZVAL_STRINGL(zendlval, ce->name, ce->name_length, 1);
+			ZVAL_STR(zendlval, STR_COPY(ce->name));
 		} else {
 			ZVAL_EMPTY_STRING(zendlval);
 		}
@@ -1603,7 +1615,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 <ST_IN_SCRIPTING>"__TRAIT__" {
 	zend_class_entry *ce = CG(active_class_entry);
 	if (ce && ce->name && ZEND_ACC_TRAIT == (ce->ce_flags & ZEND_ACC_TRAIT)) {
-		ZVAL_STRINGL(zendlval, ce->name, ce->name_length, 1);
+		ZVAL_STR(zendlval, STR_COPY(ce->name));
 	} else {
 		ZVAL_EMPTY_STRING(zendlval);
 	}
@@ -1613,7 +1625,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 <ST_IN_SCRIPTING>"__FUNCTION__" {
 	zend_op_array *op_array = CG(active_op_array);
 	if (op_array && op_array->function_name) {
-		ZVAL_STRING(zendlval, op_array->function_name, 1);
+		ZVAL_STR(zendlval, STR_COPY(op_array->function_name));
 	} else {
 		ZVAL_EMPTY_STRING(zendlval);
 	}
@@ -1621,15 +1633,34 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"__METHOD__" {
-	const char *class_name = CG(active_class_entry) ? CG(active_class_entry)->name : NULL;
-	const char *func_name = CG(active_op_array)? CG(active_op_array)->function_name : NULL;
-
-	Z_STRLEN_P(zendlval) = zend_spprintf(&Z_STRVAL_P(zendlval), 0, "%s%s%s",
-		class_name ? class_name : "",
-		class_name && func_name ? "::" : "",
-		func_name ? func_name : ""
-		);
-	zendlval->type = IS_STRING;
+	if (CG(active_class_entry)) {
+		int len = 0;
+
+		if (CG(active_class_entry)->name) {
+			len += CG(active_class_entry)->name->len;
+		}
+		if (CG(active_op_array) && CG(active_op_array)->function_name) {
+			len += sizeof("::")-1;
+			len += CG(active_op_array)->function_name->len;
+		}
+		ZVAL_NEW_STR(zendlval, STR_ALLOC(len, 0));
+		len = 0;
+		if (CG(active_class_entry)->name) {
+			memcpy(Z_STRVAL_P(zendlval), CG(active_class_entry)->name->val, CG(active_class_entry)->name->len);
+			len += CG(active_class_entry)->name->len;
+		}
+		if (CG(active_op_array) && CG(active_op_array)->function_name) {
+			memcpy(Z_STRVAL_P(zendlval) + len, "::", sizeof("::")-1);
+			len += sizeof("::")-1;
+			memcpy(Z_STRVAL_P(zendlval) + len, CG(active_op_array)->function_name->val, CG(active_op_array)->function_name->len);
+			len += CG(active_op_array)->function_name->len;
+		}
+		Z_STRVAL_P(zendlval)[len] = 0;
+	} else if (CG(active_op_array) && CG(active_op_array)->function_name) {
+		ZVAL_STR(zendlval, STR_COPY(CG(active_op_array)->function_name));
+	} else {
+		ZVAL_EMPTY_STRING(zendlval);
+	}
 	return T_METHOD_C;
 }
 
@@ -1639,44 +1670,44 @@ NEWLINE ("\r"|"\n"|"\r\n")
 }
 
 <ST_IN_SCRIPTING>"__FILE__" {
-	char *filename = zend_get_compiled_filename(TSRMLS_C);
+	zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
 
 	if (!filename) {
-		filename = "";
+		ZVAL_EMPTY_STRING(zendlval);
+	} else {
+		ZVAL_STR(zendlval, STR_COPY(filename));
 	}
-	ZVAL_STRING(zendlval, filename, 1);
 	return T_FILE;
 }
 
 <ST_IN_SCRIPTING>"__DIR__" {
-	char *filename = zend_get_compiled_filename(TSRMLS_C);
-	const size_t filename_len = strlen(filename);
-	char *dirname;
+	zend_string *filename = zend_get_compiled_filename(TSRMLS_C);
+	zend_string *dirname;
 
 	if (!filename) {
-		filename = "";
+		filename = STR_EMPTY_ALLOC();
 	}
 
-	dirname = estrndup(filename, filename_len);
-	zend_dirname(dirname, filename_len);
+	dirname = STR_INIT(filename->val, filename->len, 0);
+	zend_dirname(dirname->val, dirname->len);
 
-	if (strcmp(dirname, ".") == 0) {
-		dirname = erealloc(dirname, MAXPATHLEN);
+	if (strcmp(dirname->val, ".") == 0) {
+		dirname = STR_REALLOC(dirname, MAXPATHLEN, 0);
 #if HAVE_GETCWD
-		VCWD_GETCWD(dirname, MAXPATHLEN);
+		VCWD_GETCWD(dirname->val, MAXPATHLEN);
 #elif HAVE_GETWD
-		VCWD_GETWD(dirname);
+		VCWD_GETWD(dirname->val);
 #endif
 	}
 
-	ZVAL_STRING(zendlval, dirname, 0);
+	dirname->len = strlen(dirname->val);
+	ZVAL_STR(zendlval, dirname);
 	return T_DIR;
 }
 
 <ST_IN_SCRIPTING>"__NAMESPACE__" {
-	if (CG(current_namespace)) {
-		*zendlval = *CG(current_namespace);
-		zval_copy_ctor(zendlval);
+	if (Z_TYPE(CG(current_namespace)) != IS_UNDEF) {
+		ZVAL_DUP(zendlval, &CG(current_namespace));
 	} else {
 		ZVAL_EMPTY_STRING(zendlval);
 	}
@@ -1693,7 +1724,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 	}
 
 	HANDLE_NEWLINES(yytext, yyleng);
-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
 }
@@ -1701,7 +1732,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <INITIAL>"<%=" {
 	if (CG(asp_tags)) {
-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG_WITH_ECHO;
 	} else {
@@ -1711,7 +1742,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <INITIAL>"<?=" {
-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG_WITH_ECHO;
 }
@@ -1719,7 +1750,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <INITIAL>"<%" {
 	if (CG(asp_tags)) {
-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG;
 	} else {
@@ -1729,7 +1760,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 
 <INITIAL>"<?php"([ \t]|{NEWLINE}) {
-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	HANDLE_NEWLINE(yytext[yyleng-1]);
 	BEGIN(ST_IN_SCRIPTING);
 	return T_OPEN_TAG;
@@ -1738,7 +1769,7 @@ NEWLINE ("\r"|"\n"|"\r\n")
 
 <INITIAL>"<?" {
 	if (CG(short_tags)) {
-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		BEGIN(ST_IN_SCRIPTING);
 		return T_OPEN_TAG;
 	} else {
@@ -1791,17 +1822,18 @@ inline_html:
 
 	if (SCNG(output_filter)) {
 		int readsize;
+		char *s = NULL;
 		size_t sz = 0;
-		readsize = SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC);
-		Z_STRLEN_P(zendlval) = sz;
+		// TODO: avoid reallocation ???
+		readsize = SCNG(output_filter)((unsigned char **)&s, &sz, (unsigned char *)yytext, (size_t)yyleng TSRMLS_CC);
+		ZVAL_STRINGL(zendlval, s, sz);
+		efree(s);
 		if (readsize < yyleng) {
 			yyless(readsize);
 		}
 	} else {
-	  Z_STRVAL_P(zendlval) = (char *) estrndup(yytext, yyleng);
-	  Z_STRLEN_P(zendlval) = yyleng;
+	  ZVAL_STRINGL(zendlval, yytext, yyleng);
 	}
-	zendlval->type = IS_STRING;
 	HANDLE_NEWLINES(yytext, yyleng);
 	return T_INLINE_HTML;
 }
@@ -1814,7 +1846,6 @@ inline_html:
 	yyless(yyleng - 3);
 	yy_push_state(ST_LOOKING_FOR_PROPERTY TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
-	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
 
@@ -1824,13 +1855,11 @@ inline_html:
 	yyless(yyleng - 1);
 	yy_push_state(ST_VAR_OFFSET TSRMLS_CC);
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
-	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
 
 <ST_IN_SCRIPTING,ST_DOUBLE_QUOTES,ST_HEREDOC,ST_BACKQUOTE,ST_VAR_OFFSET>"$"{LABEL} {
 	zend_copy_value(zendlval, (yytext+1), (yyleng-1));
-	zendlval->type = IS_STRING;
 	return T_VARIABLE;
 }
 
@@ -1853,7 +1882,6 @@ inline_html:
 
 <ST_IN_SCRIPTING,ST_VAR_OFFSET>{LABEL} {
 	zend_copy_value(zendlval, yytext, yyleng);
-	zendlval->type = IS_STRING;
 	return T_STRING;
 }
 
@@ -1918,8 +1946,7 @@ inline_html:
 	HANDLE_NEWLINES(yytext, yyleng);
 
 	if (doc_com) {
-		CG(doc_comment) = estrndup(yytext, yyleng);
-		CG(doc_comment_len) = yyleng;
+		CG(doc_comment) = STR_INIT(yytext, yyleng, 0);
 		return T_DOC_COMMENT;
 	}
 
@@ -1927,7 +1954,7 @@ inline_html:
 }
 
 <ST_IN_SCRIPTING>("?>"|"</script"{WHITESPACE}*">"){NEWLINE}? {
-	ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+	DUMMY_STRINGL(zendlval, yytext, yyleng);
 	BEGIN(INITIAL);
 	return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 }
@@ -1936,7 +1963,7 @@ inline_html:
 <ST_IN_SCRIPTING>"%>"{NEWLINE}? {
 	if (CG(asp_tags)) {
 		BEGIN(INITIAL);
-		ZVAL_STRINGL(zendlval, yytext, yyleng, 0); /* no copying - intentional */
+		DUMMY_STRINGL(zendlval, yytext, yyleng);
 		return T_CLOSE_TAG;  /* implicit ';' at php-end tag */
 	} else {
 		yyless(1);
@@ -1970,7 +1997,7 @@ inline_html:
 		}
 	}
 
-	ZVAL_STRINGL(zendlval, yytext+bprefix+1, yyleng-bprefix-2, 1);
+	ZVAL_STRINGL(zendlval, yytext+bprefix+1, yyleng-bprefix-2);
 
 	/* convert escape sequences */
 	s = t = Z_STRVAL_P(zendlval);
@@ -2003,9 +2030,11 @@ inline_html:
 
 	if (SCNG(output_filter)) {
 		size_t sz = 0;
+		char *str = NULL;
 		s = Z_STRVAL_P(zendlval);
-		SCNG(output_filter)((unsigned char **)&Z_STRVAL_P(zendlval), &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);
-		Z_STRLEN_P(zendlval) = sz;
+		// TODO: avoid reallocation ???
+		SCNG(output_filter)((unsigned char **)&str, &sz, (unsigned char *)s, (size_t)Z_STRLEN_P(zendlval) TSRMLS_CC);
+		ZVAL_STRINGL(zendlval, str, sz);
 		efree(s);
 	}
 	return T_CONSTANT_ENCAPSED_STRING;
@@ -2359,7 +2388,6 @@ nowdoc_scan_done:
 	yyleng = YYCURSOR - SCNG(yy_text);
 
 	zend_copy_value(zendlval, yytext, yyleng - newline);
-	zendlval->type = IS_STRING;
 	HANDLE_NEWLINES(yytext, yyleng - newline);
 	return T_ENCAPSED_AND_WHITESPACE;
 }
diff --git a/Zend/zend_language_scanner_defs.h b/Zend/zend_language_scanner_defs.h
index f25c3f46be..5926e3c61d 100644
--- a/Zend/zend_language_scanner_defs.h
+++ b/Zend/zend_language_scanner_defs.h
@@ -1,15 +1,15 @@
-/* Generated by re2c 0.13.5 */

-#line 3 "Zend/zend_language_scanner_defs.h"

-

-enum YYCONDTYPE {

-	yycST_IN_SCRIPTING,

-	yycST_LOOKING_FOR_PROPERTY,

-	yycST_BACKQUOTE,

-	yycST_DOUBLE_QUOTES,

-	yycST_HEREDOC,

-	yycST_LOOKING_FOR_VARNAME,

-	yycST_VAR_OFFSET,

-	yycINITIAL,

-	yycST_END_HEREDOC,

-	yycST_NOWDOC,

-};

+/* Generated by re2c 0.13.5 */
+#line 3 "Zend/zend_language_scanner_defs.h"
+
+enum YYCONDTYPE {
+	yycST_IN_SCRIPTING,
+	yycST_LOOKING_FOR_PROPERTY,
+	yycST_BACKQUOTE,
+	yycST_DOUBLE_QUOTES,
+	yycST_HEREDOC,
+	yycST_LOOKING_FOR_VARNAME,
+	yycST_VAR_OFFSET,
+	yycINITIAL,
+	yycST_END_HEREDOC,
+	yycST_NOWDOC,
+};
diff --git a/Zend/zend_list.c b/Zend/zend_list.c
index 11c2c33567..c9b9ff66df 100644
--- a/Zend/zend_list.c
+++ b/Zend/zend_list.c
@@ -31,88 +31,84 @@ ZEND_API int le_index_ptr;
 /* true global */
 static HashTable list_destructors;
 
-
-ZEND_API int zend_list_insert(void *ptr, int type TSRMLS_DC)
+ZEND_API zval *zend_list_insert(void *ptr, int type TSRMLS_DC)
 {
 	int index;
-	zend_rsrc_list_entry le;
-
-	le.ptr=ptr;
-	le.type=type;
-	le.refcount=1;
+	zval zv;
 
 	index = zend_hash_next_free_element(&EG(regular_list));
-
-	zend_hash_index_update(&EG(regular_list), index, (void *) &le, sizeof(zend_rsrc_list_entry), NULL);
-	return index;
+	ZVAL_NEW_RES(&zv, index, ptr, type);
+	return zend_hash_index_update(&EG(regular_list), index, &zv);
 }
 
-ZEND_API int _zend_list_delete(int id TSRMLS_DC)
+ZEND_API int _zend_list_delete(zend_resource *res TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
-	
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
-/*		printf("del(%d): %d->%d\n", id, le->refcount, le->refcount-1); */
-		if (--le->refcount<=0) {
-			return zend_hash_index_del(&EG(regular_list), id);
-		} else {
-			return SUCCESS;
-		}
+	if (GC_REFCOUNT(res) <= 0) {
+		return zend_hash_index_del(&EG(regular_list), res->handle);
 	} else {
-		return FAILURE;
+		return SUCCESS;
 	}
 }
 
 
-ZEND_API void *_zend_list_find(int id, int *type TSRMLS_DC)
+static void zend_resource_dtor(zend_resource *res TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
-
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
-		*type = le->type;
-		return le->ptr;
+	zend_rsrc_list_dtors_entry *ld;
+	
+	ld = zend_hash_index_find_ptr(&list_destructors, res->type);
+	if (ld) {
+		switch (ld->type) {
+			case ZEND_RESOURCE_LIST_TYPE_STD:
+				if (ld->list_dtor) {
+					(ld->list_dtor)(res->ptr);
+				}
+				break;
+			case ZEND_RESOURCE_LIST_TYPE_EX:
+				if (ld->list_dtor_ex) {
+					ld->list_dtor_ex(res TSRMLS_CC);
+				}
+				break;
+			EMPTY_SWITCH_DEFAULT_CASE()
+		}
 	} else {
-		*type = -1;
-		return NULL;
+		zend_error(E_WARNING,"Unknown list entry type (%d)", res->type);
 	}
+	res->ptr = NULL;
+	res->type = -1;
 }
 
-ZEND_API int _zend_list_addref(int id TSRMLS_DC)
+
+ZEND_API int _zend_list_close(zend_resource *res TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
-	
-	if (zend_hash_index_find(&EG(regular_list), id, (void **) &le)==SUCCESS) {
-/*		printf("add(%d): %d->%d\n", id, le->refcount, le->refcount+1); */
-		le->refcount++;
-		return SUCCESS;
-	} else {
-		return FAILURE;
+	if (GC_REFCOUNT(res) <= 0) {
+		return zend_list_delete(res);
+	} else if (res->type >= 0) {
+		zend_resource_dtor(res TSRMLS_CC);
 	}
+	return SUCCESS;
 }
 
-
-ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type TSRMLS_DC)
+ZEND_API zend_resource* zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type TSRMLS_DC)
 {
-	int rsrc_id;
+	zval *zv;
 
-	rsrc_id = zend_list_insert(rsrc_pointer, rsrc_type TSRMLS_CC);
+	zv = zend_list_insert(rsrc_pointer, rsrc_type TSRMLS_CC);
 	
 	if (rsrc_result) {
-		rsrc_result->value.lval = rsrc_id;
-		rsrc_result->type = IS_RESOURCE;
+		ZVAL_COPY_VALUE(rsrc_result, zv);
+		return Z_RES_P(rsrc_result);
+	} else {
+		return Z_RES_P(zv);
 	}
-
-	return rsrc_id;
 }
 
-
-ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, const char *resource_type_name, int *found_resource_type, int num_resource_types, ...)
+ZEND_API void *zend_fetch_resource(zval *passed_id TSRMLS_DC, int default_id, const char *resource_type_name, int *found_resource_type, int num_resource_types, ...)
 {
-	int id;
 	int actual_resource_type;
-	void *resource;
+//	void *resource;
 	va_list resource_types;
 	int i;
+	zend_resource *res;
 	const char *space;
 	const char *class_name;
 
@@ -123,26 +119,25 @@ ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, c
 				zend_error(E_WARNING, "%s%s%s(): no %s resource supplied", class_name, space, get_active_function_name(TSRMLS_C), resource_type_name);
 			}
 			return NULL;
-		} else if ((*passed_id)->type != IS_RESOURCE) {
+		} else if (Z_TYPE_P(passed_id) != IS_RESOURCE) {
 			if (resource_type_name) {
 				class_name = get_active_class_name(&space TSRMLS_CC);
 				zend_error(E_WARNING, "%s%s%s(): supplied argument is not a valid %s resource", class_name, space, get_active_function_name(TSRMLS_C), resource_type_name);
 			}
 			return NULL;
 		}
-		id = (*passed_id)->value.lval;
 	} else {
-		id = default_id;
-	}
-
-	resource = zend_list_find(id, &actual_resource_type);
-	if (!resource) {
-		if (resource_type_name) {
-			class_name = get_active_class_name(&space TSRMLS_CC);
-			zend_error(E_WARNING, "%s%s%s(): %d is not a valid %s resource", class_name, space, get_active_function_name(TSRMLS_C), id, resource_type_name);
+		passed_id = zend_hash_index_find(&EG(regular_list), default_id);
+		if (!passed_id) {
+			if (resource_type_name) {
+				class_name = get_active_class_name(&space TSRMLS_CC);
+				zend_error(E_WARNING, "%s%s%s(): %d is not a valid %s resource", class_name, space, get_active_function_name(TSRMLS_C), default_id, resource_type_name);
+			}
+			return NULL;
 		}
-		return NULL;
 	}
+	res = Z_RES_P(passed_id);
+	actual_resource_type = res->type;
 
 	va_start(resource_types, num_resource_types);
 	for (i=0; i<num_resource_types; i++) {
@@ -151,7 +146,7 @@ ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, c
 			if (found_resource_type) {
 				*found_resource_type = actual_resource_type;
 			}
-			return resource;
+			return res->ptr;
 		}
 	}
 	va_end(resource_types);
@@ -164,73 +159,76 @@ ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, c
 	return NULL;
 }
 
-
-void list_entry_destructor(void *ptr)
+void list_entry_destructor(zval *zv)
 {
-	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
-	zend_rsrc_list_dtors_entry *ld;
-	TSRMLS_FETCH();
+	zend_resource *res = Z_RES_P(zv);
+
+	if (res->type >= 0) {
+		TSRMLS_FETCH();
 	
-	if (zend_hash_index_find(&list_destructors, le->type, (void **) &ld)==SUCCESS) {
-		switch (ld->type) {
-			case ZEND_RESOURCE_LIST_TYPE_STD:
-				if (ld->list_dtor) {
-					(ld->list_dtor)(le->ptr);
-				}
-				break;
-			case ZEND_RESOURCE_LIST_TYPE_EX:
-				if (ld->list_dtor_ex) {
-					ld->list_dtor_ex(le TSRMLS_CC);
-				}
-				break;
-			EMPTY_SWITCH_DEFAULT_CASE()
-		}
-	} else {
-		zend_error(E_WARNING,"Unknown list entry type in request shutdown (%d)", le->type);
+		zend_resource_dtor(res TSRMLS_CC);
 	}
+	efree(res);
 }
 
-
-void plist_entry_destructor(void *ptr)
+void plist_entry_destructor(zval *zv)
 {
-	zend_rsrc_list_entry *le = (zend_rsrc_list_entry *) ptr;
-	zend_rsrc_list_dtors_entry *ld;
-	TSRMLS_FETCH();
+	zend_resource *res = Z_RES_P(zv);
 
-	if (zend_hash_index_find(&list_destructors, le->type, (void **) &ld)==SUCCESS) {
-		switch (ld->type) {
-			case ZEND_RESOURCE_LIST_TYPE_STD:
-				if (ld->plist_dtor) {
-					(ld->plist_dtor)(le->ptr);
-				}
-				break;
-			case ZEND_RESOURCE_LIST_TYPE_EX:
-				if (ld->plist_dtor_ex) {
-					ld->plist_dtor_ex(le TSRMLS_CC);
-				}
-				break;
+	if (res->type >= 0) {
+		zend_rsrc_list_dtors_entry *ld;
+		TSRMLS_FETCH();
+	
+		ld = zend_hash_index_find_ptr(&list_destructors, res->type);
+		if (ld) {
+			switch (ld->type) {
+				case ZEND_RESOURCE_LIST_TYPE_STD:
+					if (ld->plist_dtor) {
+						(ld->plist_dtor)(res->ptr);
+					}
+					break;
+				case ZEND_RESOURCE_LIST_TYPE_EX:
+					if (ld->plist_dtor_ex) {
+						ld->plist_dtor_ex(res TSRMLS_CC);
+					}
+					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
+			}
+		} else {
+			zend_error(E_WARNING,"Unknown list entry type (%d)", res->type);
 		}
-	} else {
-		zend_error(E_WARNING,"Unknown persistent list entry type in module shutdown (%d)", le->type);
 	}
+	free(res);
 }
 
-
 int zend_init_rsrc_list(TSRMLS_D)
 {
-	if (zend_hash_init(&EG(regular_list), 0, NULL, list_entry_destructor, 0)==SUCCESS) {
-		EG(regular_list).nNextFreeElement=1;	/* we don't want resource id 0 */
-		return SUCCESS;
-	} else {
-		return FAILURE;
-	}
+	zend_hash_init(&EG(regular_list), 8, NULL, list_entry_destructor, 0);
+	return SUCCESS;
 }
 
 
 int zend_init_rsrc_plist(TSRMLS_D)
 {
-	return zend_hash_init_ex(&EG(persistent_list), 0, NULL, plist_entry_destructor, 1, 0);
+	zend_hash_init_ex(&EG(persistent_list), 8, NULL, plist_entry_destructor, 1, 0);
+	return SUCCESS;
+}
+
+
+static int zend_close_rsrc(zval *zv TSRMLS_DC)
+{
+	zend_resource *res = Z_PTR_P(zv);
+
+	if (res->type >= 0) {
+		zend_resource_dtor(res TSRMLS_CC);
+	}
+	return ZEND_HASH_APPLY_KEEP;
+}
+
+
+void zend_close_rsrc_list(HashTable *ht TSRMLS_DC)
+{
+	zend_hash_reverse_apply(ht, zend_close_rsrc TSRMLS_CC);
 }
 
 
@@ -239,9 +237,9 @@ void zend_destroy_rsrc_list(HashTable *ht TSRMLS_DC)
 	zend_hash_graceful_reverse_destroy(ht);
 }
 
-static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id TSRMLS_DC)
+static int clean_module_resource(zval *zv, int *resource_id TSRMLS_DC)
 {
-	if (le->type == *resource_id) {
+	if (Z_RES_TYPE_P(zv) == *resource_id) {
 		return 1;
 	} else {
 		return 0;
@@ -249,8 +247,9 @@ static int clean_module_resource(zend_rsrc_list_entry *le, int *resource_id TSRM
 }
 
 
-static int zend_clean_module_rsrc_dtors_cb(zend_rsrc_list_dtors_entry *ld, int *module_number TSRMLS_DC)
+static int zend_clean_module_rsrc_dtors_cb(zval *zv, int *module_number TSRMLS_DC)
 {
+	zend_rsrc_list_dtors_entry *ld = Z_PTR_P(zv);	
 	if (ld->module_number == *module_number) {
 		zend_hash_apply_with_argument(&EG(persistent_list), (apply_func_arg_t) clean_module_resource, (void *) &(ld->resource_id) TSRMLS_CC);
 		return 1;
@@ -266,23 +265,22 @@ void zend_clean_module_rsrc_dtors(int module_number TSRMLS_DC)
 }
 
 
-ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number)
+ZEND_API int zend_register_list_destructors(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, int module_number)
 {
-	zend_rsrc_list_dtors_entry lde;
-	
-#if 0
-	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
-#endif
+	zend_rsrc_list_dtors_entry *lde;
+	zval zv;
 	
-	lde.list_dtor=(void (*)(void *)) ld;
-	lde.plist_dtor=(void (*)(void *)) pld;
-	lde.list_dtor_ex = lde.plist_dtor_ex = NULL;
-	lde.module_number = module_number;
-	lde.resource_id = list_destructors.nNextFreeElement;
-	lde.type = ZEND_RESOURCE_LIST_TYPE_STD;
-	lde.type_name = NULL;
+	lde = malloc(sizeof(zend_rsrc_list_dtors_entry));
+	lde->list_dtor = ld;
+	lde->plist_dtor = pld;
+	lde->list_dtor_ex = lde->plist_dtor_ex = NULL;
+	lde->module_number = module_number;
+	lde->resource_id = list_destructors.nNextFreeElement;
+	lde->type = ZEND_RESOURCE_LIST_TYPE_STD;
+	lde->type_name = NULL;
+	ZVAL_PTR(&zv, lde);
 	
-	if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
+	if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) {
 		return FAILURE;
 	}
 	return list_destructors.nNextFreeElement-1;
@@ -291,54 +289,49 @@ ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void
 
 ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, const char *type_name, int module_number)
 {
-	zend_rsrc_list_dtors_entry lde;
+	zend_rsrc_list_dtors_entry *lde;
+	zval zv;
 	
-#if 0
-	printf("Registering destructors %d for module %d\n", list_destructors.nNextFreeElement, module_number);
-#endif
-
-	lde.list_dtor = NULL;
-	lde.plist_dtor = NULL;
-	lde.list_dtor_ex = ld;
-	lde.plist_dtor_ex = pld;
-	lde.module_number = module_number;
-	lde.resource_id = list_destructors.nNextFreeElement;
-	lde.type = ZEND_RESOURCE_LIST_TYPE_EX;
-	lde.type_name = type_name;
+	lde = malloc(sizeof(zend_rsrc_list_dtors_entry));	
+	lde->list_dtor = NULL;
+	lde->plist_dtor = NULL;
+	lde->list_dtor_ex = ld;
+	lde->plist_dtor_ex = pld;
+	lde->module_number = module_number;
+	lde->resource_id = list_destructors.nNextFreeElement;
+	lde->type = ZEND_RESOURCE_LIST_TYPE_EX;
+	lde->type_name = type_name;
+	ZVAL_PTR(&zv, lde);
 	
-	if (zend_hash_next_index_insert(&list_destructors, (void *) &lde, sizeof(zend_rsrc_list_dtors_entry), NULL)==FAILURE) {
+	if (zend_hash_next_index_insert(&list_destructors, &zv) == NULL) {
 		return FAILURE;
 	}
 	return list_destructors.nNextFreeElement-1;
 }
 
-ZEND_API int zend_fetch_list_dtor_id(char *type_name)
+ZEND_API int zend_fetch_list_dtor_id(const char *type_name)
 {
 	zend_rsrc_list_dtors_entry *lde;
-	HashPosition pos;
 
-	zend_hash_internal_pointer_reset_ex(&list_destructors, &pos);
-	while (zend_hash_get_current_data_ex(&list_destructors, (void **)&lde, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_PTR(&list_destructors, lde) {
 		if (lde->type_name && (strcmp(type_name, lde->type_name) == 0)) {
-#if 0
-			printf("Found resource id %d for resource type %s\n", (*lde).resource_id, type_name);
-#endif
 			return lde->resource_id;
 		}
-		zend_hash_move_forward_ex(&list_destructors, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	return 0;
 }
 
-int zend_init_rsrc_list_dtors(void)
+static void list_destructors_dtor(zval *zv)
 {
-	int retval;
+	free(Z_PTR_P(zv));
+}
 
-	retval = zend_hash_init(&list_destructors, 50, NULL, NULL, 1);
+int zend_init_rsrc_list_dtors(void)
+{
+	zend_hash_init(&list_destructors, 64, NULL, list_destructors_dtor, 1);
 	list_destructors.nNextFreeElement=1;	/* we don't want resource type 0 */
-
-	return retval;
+	return SUCCESS;
 }
 
 
@@ -348,15 +341,12 @@ void zend_destroy_rsrc_list_dtors(void)
 }
 
 
-const char *zend_rsrc_list_get_rsrc_type(int resource TSRMLS_DC)
+const char *zend_rsrc_list_get_rsrc_type(zend_resource *res TSRMLS_DC)
 {
 	zend_rsrc_list_dtors_entry *lde;
-	int rsrc_type;
-
-	if (!zend_list_find(resource, &rsrc_type))
-		return NULL;
 
-	if (zend_hash_index_find(&list_destructors, rsrc_type, (void **) &lde)==SUCCESS) {
+	lde = zend_hash_index_find_ptr(&list_destructors, res->type);
+	if (lde) {
 		return lde->type_name;
 	} else {
 		return NULL;
diff --git a/Zend/zend_list.h b/Zend/zend_list.h
index b7980d56f2..a9f96addb6 100644
--- a/Zend/zend_list.h
+++ b/Zend/zend_list.h
@@ -30,19 +30,13 @@ BEGIN_EXTERN_C()
 #define ZEND_RESOURCE_LIST_TYPE_STD	1
 #define ZEND_RESOURCE_LIST_TYPE_EX	2
 
-typedef struct _zend_rsrc_list_entry {
-	void *ptr;
-	int type;
-	int refcount;
-} zend_rsrc_list_entry;
-
-typedef void (*rsrc_dtor_func_t)(zend_rsrc_list_entry *rsrc TSRMLS_DC);
-#define ZEND_RSRC_DTOR_FUNC(name)		void name(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+typedef void (*rsrc_dtor_func_t)(zend_resource *res TSRMLS_DC);
+#define ZEND_RSRC_DTOR_FUNC(name) void name(zend_resource *res TSRMLS_DC)
 
 typedef struct _zend_rsrc_list_dtors_entry {
 	/* old style destructors */
-	void (*list_dtor)(void *);
-	void (*plist_dtor)(void *);
+	void (*list_dtor)(zend_resource *);
+	void (*plist_dtor)(zend_resource *);
 
 	/* new style destructors */
 	rsrc_dtor_func_t list_dtor_ex;
@@ -56,34 +50,33 @@ typedef struct _zend_rsrc_list_dtors_entry {
 } zend_rsrc_list_dtors_entry;
 
 
-#define register_list_destructors(ld, pld) zend_register_list_destructors((void (*)(void *))ld, (void (*)(void *))pld, module_number);
-ZEND_API int zend_register_list_destructors(void (*ld)(void *), void (*pld)(void *), int module_number);
+#define register_list_destructors(ld, pld) zend_register_list_destructors(ld, pld, module_number);
+ZEND_API int zend_register_list_destructors(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, int module_number);
 ZEND_API int zend_register_list_destructors_ex(rsrc_dtor_func_t ld, rsrc_dtor_func_t pld, const char *type_name, int module_number);
 
-void list_entry_destructor(void *ptr);
-void plist_entry_destructor(void *ptr);
+void list_entry_destructor(zval *ptr);
+void plist_entry_destructor(zval *ptr);
 
 void zend_clean_module_rsrc_dtors(int module_number TSRMLS_DC);
 int zend_init_rsrc_list(TSRMLS_D);
 int zend_init_rsrc_plist(TSRMLS_D);
+void zend_close_rsrc_list(HashTable *ht TSRMLS_DC);
 void zend_destroy_rsrc_list(HashTable *ht TSRMLS_DC);
 int zend_init_rsrc_list_dtors(void);
 void zend_destroy_rsrc_list_dtors(void);
 
-ZEND_API int zend_list_insert(void *ptr, int type TSRMLS_DC);
-ZEND_API int _zend_list_addref(int id TSRMLS_DC);
-ZEND_API int _zend_list_delete(int id TSRMLS_DC);
-ZEND_API void *_zend_list_find(int id, int *type TSRMLS_DC);
+ZEND_API zval *zend_list_insert(void *ptr, int type TSRMLS_DC);
+ZEND_API int _zend_list_delete(zend_resource *res TSRMLS_DC);
+ZEND_API int _zend_list_close(zend_resource *res TSRMLS_DC);
 
-#define zend_list_addref(id)		_zend_list_addref(id TSRMLS_CC)
-#define zend_list_delete(id)		_zend_list_delete(id TSRMLS_CC)
-#define zend_list_find(id, type)	_zend_list_find(id, type TSRMLS_CC)
+#define zend_list_delete(res)		_zend_list_delete(res TSRMLS_CC)
+#define zend_list_close(res)		_zend_list_close(res TSRMLS_CC)
 
-ZEND_API int zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type TSRMLS_DC);
-ZEND_API void *zend_fetch_resource(zval **passed_id TSRMLS_DC, int default_id, const char *resource_type_name, int *found_resource_type, int num_resource_types, ...);
+ZEND_API zend_resource *zend_register_resource(zval *rsrc_result, void *rsrc_pointer, int rsrc_type TSRMLS_DC);
+ZEND_API void *zend_fetch_resource(zval *passed_id TSRMLS_DC, int default_id, const char *resource_type_name, int *found_resource_type, int num_resource_types, ...);
 
-ZEND_API const char *zend_rsrc_list_get_rsrc_type(int resource TSRMLS_DC);
-ZEND_API int zend_fetch_list_dtor_id(char *type_name);
+ZEND_API const char *zend_rsrc_list_get_rsrc_type(zend_resource *res TSRMLS_DC);
+ZEND_API int zend_fetch_list_dtor_id(const char *type_name);
 
 extern ZEND_API int le_index_ptr;  /* list entry type for index pointers */
 
diff --git a/Zend/zend_modules.h b/Zend/zend_modules.h
index 55f99c4b1d..283b069f48 100644
--- a/Zend/zend_modules.h
+++ b/Zend/zend_modules.h
@@ -125,11 +125,9 @@ struct _zend_module_dep {
 extern ZEND_API HashTable module_registry;
 
 void module_destructor(zend_module_entry *module);
-int module_registry_cleanup(zend_module_entry *module TSRMLS_DC);
 int module_registry_request_startup(zend_module_entry *module TSRMLS_DC);
 int module_registry_unload_temp(const zend_module_entry *module TSRMLS_DC);
 
-#define ZEND_MODULE_DTOR (void (*)(void *)) module_destructor
 #endif
 
 /*
diff --git a/Zend/zend_multibyte.c b/Zend/zend_multibyte.c
index 75fcd638d2..08251dfa5e 100644
--- a/Zend/zend_multibyte.c
+++ b/Zend/zend_multibyte.c
@@ -114,7 +114,7 @@ ZEND_API int zend_multibyte_set_functions(const zend_multibyte_functions *functi
 	 * populated, we need to reinitialize script_encoding here.
 	 */
 	{
-		const char *value = zend_ini_string("zend.script_encoding", sizeof("zend.script_encoding"), 0);
+		const char *value = zend_ini_string("zend.script_encoding", sizeof("zend.script_encoding") - 1, 0);
 		zend_multibyte_set_script_encoding_by_string(value, strlen(value) TSRMLS_CC);
 	}
 	return SUCCESS;
diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index 7f1d3e4e86..a41452dae8 100644
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -33,19 +33,23 @@
 
 #define DEBUG_OBJECT_HANDLERS 0
 
-#define Z_OBJ_P(zval_p) \
-	((zend_object*)(EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zval_p)].bucket.obj.object))
+/* guard flags */
+#define IN_GET		(1<<0)
+#define IN_SET		(1<<1)
+#define IN_UNSET	(1<<2)
+#define IN_ISSET	(1<<3)
 
 #define Z_OBJ_PROTECT_RECURSION(zval_p) \
 	do { \
-		if (EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zval_p)].apply_count++ >= 3) { \
+		if (Z_OBJ_APPLY_COUNT_P(zval_p) >= 3) { \
 			zend_error(E_ERROR, "Nesting level too deep - recursive dependency?"); \
 		} \
+		Z_OBJ_INC_APPLY_COUNT_P(zval_p); \
 	} while (0)
 
 
 #define Z_OBJ_UNPROTECT_RECURSION(zval_p) \
-	EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zval_p)].apply_count--
+	Z_OBJ_DEC_APPLY_COUNT_P(zval_p)
 
 /*
   __X accessors explanation:
@@ -67,36 +71,37 @@
 ZEND_API void rebuild_object_properties(zend_object *zobj) /* {{{ */
 {
 	if (!zobj->properties) {
-		HashPosition pos;
 		zend_property_info *prop_info;
 		zend_class_entry *ce = zobj->ce;
 
 		ALLOC_HASHTABLE(zobj->properties);
-		zend_hash_init(zobj->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_init(zobj->properties, 8, NULL, ZVAL_PTR_DTOR, 0);
 		if (ce->default_properties_count) {
-			for (zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
-			     zend_hash_get_current_data_ex(&ce->properties_info, (void**)&prop_info, &pos) == SUCCESS;
-			     zend_hash_move_forward_ex(&ce->properties_info, &pos)) {
+			ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
 				if (/*prop_info->ce == ce &&*/
 				    (prop_info->flags & ZEND_ACC_STATIC) == 0 &&
 				    prop_info->offset >= 0 &&
-				    zobj->properties_table[prop_info->offset]) {
-					zend_hash_quick_add(zobj->properties, prop_info->name, prop_info->name_length+1, prop_info->h, (void**)&zobj->properties_table[prop_info->offset], sizeof(zval*), (void**)&zobj->properties_table[prop_info->offset]);
+				    Z_TYPE(zobj->properties_table[prop_info->offset]) != IS_UNDEF) {
+					zval zv;
+
+					ZVAL_INDIRECT(&zv, &zobj->properties_table[prop_info->offset]);
+					zend_hash_add(zobj->properties, prop_info->name, &zv);
 				}
-			}
+			} ZEND_HASH_FOREACH_END();
 			while (ce->parent && ce->parent->default_properties_count) {
 				ce = ce->parent;
-				for (zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
-				     zend_hash_get_current_data_ex(&ce->properties_info, (void**)&prop_info, &pos) == SUCCESS;
-				     zend_hash_move_forward_ex(&ce->properties_info, &pos)) {
+				ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
 					if (prop_info->ce == ce &&
 					    (prop_info->flags & ZEND_ACC_STATIC) == 0 &&
 					    (prop_info->flags & ZEND_ACC_PRIVATE) != 0 &&
 					    prop_info->offset >= 0 &&
-						zobj->properties_table[prop_info->offset]) {
-						zend_hash_quick_add(zobj->properties, prop_info->name, prop_info->name_length+1, prop_info->h, (void**)&zobj->properties_table[prop_info->offset], sizeof(zval*), (void**)&zobj->properties_table[prop_info->offset]);
+						Z_TYPE(zobj->properties_table[prop_info->offset]) != IS_UNDEF) {
+						zval zv;
+						
+						ZVAL_INDIRECT(&zv, &zobj->properties_table[prop_info->offset]);
+						zend_hash_add(zobj->properties, prop_info->name, &zv);
 					}
-				}
+				} ZEND_HASH_FOREACH_END();
 			}
 		}
 	}
@@ -114,7 +119,7 @@ ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-ZEND_API HashTable *zend_std_get_gc(zval *object, zval ***table, int *n TSRMLS_DC) /* {{{ */
+ZEND_API HashTable *zend_std_get_gc(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
 	if (Z_OBJ_HANDLER_P(object, get_properties) != zend_std_get_properties) {
 		*table = NULL;
@@ -123,15 +128,9 @@ ZEND_API HashTable *zend_std_get_gc(zval *object, zval ***table, int *n TSRMLS_D
 	} else {
 		zend_object *zobj = Z_OBJ_P(object);
 
-		if (zobj->properties) {
-			*table = NULL;
-			*n = 0;
-			return zobj->properties;
-		} else {
-			*table = zobj->properties_table;
-			*n = zobj->ce->default_properties_count;
-			return NULL;
-		}
+		*table = zobj->properties_table;
+		*n = zobj->ce->default_properties_count;
+		return zobj->properties;
 	}
 }
 /* }}} */
@@ -139,7 +138,8 @@ ZEND_API HashTable *zend_std_get_gc(zval *object, zval ***table, int *n TSRMLS_D
 ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *ce = Z_OBJCE_P(object);
-	zval *retval = NULL;
+	zval retval;
+	HashTable *ht;
 
 	if (!ce->__debugInfo) {
 		*is_temp = 0;
@@ -148,25 +148,23 @@ ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC
 			: NULL;
 	}
 
-	zend_call_method_with_0_params(&object, ce, &ce->__debugInfo, ZEND_DEBUGINFO_FUNC_NAME, &retval);
-	if (retval && Z_TYPE_P(retval) == IS_ARRAY) {
-		HashTable *ht = Z_ARRVAL_P(retval);
-		if (Z_REFCOUNT_P(retval) <= 1) {
+	zend_call_method_with_0_params(object, ce, &ce->__debugInfo, ZEND_DEBUGINFO_FUNC_NAME, &retval);
+	if (Z_TYPE(retval) == IS_ARRAY) {
+		if (Z_REFCOUNT(retval) <= 1) {
 			*is_temp = 1;
-			efree(retval);
+			ALLOC_HASHTABLE(ht);
+			*ht = *Z_ARRVAL(retval);
+			efree(Z_ARR(retval));
 			return ht;
 		} else {
 			*is_temp = 0;
 			zval_ptr_dtor(&retval);
 		}
-		return ht;
-	}
-	if (retval && Z_TYPE_P(retval) == IS_NULL) {
-		zval ret;
-		array_init(&ret);
+	} else if (Z_TYPE(retval) == IS_NULL) {
 		*is_temp = 1;
-		zval_ptr_dtor(&retval);
-		return Z_ARRVAL(ret);
+		ALLOC_HASHTABLE(ht);
+		zend_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0);
+		return ht;
 	}
 
 	zend_error_noreturn(E_ERROR, ZEND_DEBUGINFO_FUNC_NAME "() must return an array");
@@ -175,9 +173,8 @@ ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC
 }
 /* }}} */
 
-static zval *zend_std_call_getter(zval *object, zval *member TSRMLS_DC) /* {{{ */
+static void zend_std_call_getter(zval *object, zval *member, zval *retval TSRMLS_DC) /* {{{ */
 {
-	zval *retval = NULL;
 	zend_class_entry *ce = Z_OBJCE_P(object);
 
 	/* __get handler is called with one argument:
@@ -188,26 +185,21 @@ static zval *zend_std_call_getter(zval *object, zval *member TSRMLS_DC) /* {{{ *
 
 	SEPARATE_ARG_IF_REF(member);
 
-	zend_call_method_with_1_params(&object, ce, &ce->__get, ZEND_GET_FUNC_NAME, &retval, member);
-
-	zval_ptr_dtor(&member);
+	ZVAL_UNDEF(retval);
+	zend_call_method_with_1_params(object, ce, &ce->__get, ZEND_GET_FUNC_NAME, retval, member);
 
-	if (retval) {
-		Z_DELREF_P(retval);
-	}
-
-	return retval;
+	zval_ptr_dtor(member);
 }
 /* }}} */
 
 static int zend_std_call_setter(zval *object, zval *member, zval *value TSRMLS_DC) /* {{{ */
 {
-	zval *retval = NULL;
+	zval retval;
 	int result;
 	zend_class_entry *ce = Z_OBJCE_P(object);
 
 	SEPARATE_ARG_IF_REF(member);
-	Z_ADDREF_P(value);
+	if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 
 	/* __set handler is called with two arguments:
 	     property name
@@ -215,13 +207,14 @@ static int zend_std_call_setter(zval *object, zval *member, zval *value TSRMLS_D
 
 	   it should return whether the call was successfull or not
 	*/
-	zend_call_method_with_2_params(&object, ce, &ce->__set, ZEND_SET_FUNC_NAME, &retval, member, value);
+	ZVAL_UNDEF(&retval);
+	zend_call_method_with_2_params(object, ce, &ce->__set, ZEND_SET_FUNC_NAME, &retval, member, value);
 
-	zval_ptr_dtor(&member);
-	zval_ptr_dtor(&value);
+	zval_ptr_dtor(member);
+	zval_ptr_dtor(value);
 
-	if (retval) {
-		result = i_zend_is_true(retval TSRMLS_CC) ? SUCCESS : FAILURE;
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		result = i_zend_is_true(&retval TSRMLS_CC) ? SUCCESS : FAILURE;
 		zval_ptr_dtor(&retval);
 		return result;
 	} else {
@@ -240,15 +233,14 @@ static void zend_std_call_unsetter(zval *object, zval *member TSRMLS_DC) /* {{{
 
 	SEPARATE_ARG_IF_REF(member);
 
-	zend_call_method_with_1_params(&object, ce, &ce->__unset, ZEND_UNSET_FUNC_NAME, NULL, member);
+	zend_call_method_with_1_params(object, ce, &ce->__unset, ZEND_UNSET_FUNC_NAME, NULL, member);
 
-	zval_ptr_dtor(&member);
+	zval_ptr_dtor(member);
 }
 /* }}} */
 
-static zval *zend_std_call_issetter(zval *object, zval *member TSRMLS_DC) /* {{{ */
+static void zend_std_call_issetter(zval *object, zval *member, zval *retval TSRMLS_DC) /* {{{ */
 {
-	zval *retval = NULL;
 	zend_class_entry *ce = Z_OBJCE_P(object);
 
 	/* __isset handler is called with one argument:
@@ -259,11 +251,10 @@ static zval *zend_std_call_issetter(zval *object, zval *member TSRMLS_DC) /* {{{
 
 	SEPARATE_ARG_IF_REF(member);
 
-	zend_call_method_with_1_params(&object, ce, &ce->__isset, ZEND_ISSET_FUNC_NAME, &retval, member);
+	ZVAL_UNDEF(retval);
+	zend_call_method_with_1_params(object, ce, &ce->__isset, ZEND_ISSET_FUNC_NAME, retval, member);
 
-	zval_ptr_dtor(&member);
-
-	return retval;
+	zval_ptr_dtor(member);
 }
 /* }}} */
 
@@ -300,20 +291,27 @@ static zend_always_inline zend_bool is_derived_class(zend_class_entry *child_cla
 }
 /* }}} */
 
-static zend_always_inline struct _zend_property_info *zend_get_property_info_quick(zend_class_entry *ce, zval *member, int silent, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zend_always_inline struct _zend_property_info *zend_get_property_info_quick(zend_class_entry *ce, zend_string *member, int silent, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	zend_property_info *property_info;
 	zend_property_info *scope_property_info;
 	zend_bool denied_access = 0;
-	ulong h;
 
-	if (key && (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) != NULL) {
+	if (cache_slot != -1 && ce == CACHED_PTR_EX(EG(active_op_array), cache_slot)) {
+		property_info = CACHED_PTR_EX(EG(active_op_array), cache_slot + 1);
+		if (!property_info) {
+			EG(std_property_info).flags = ZEND_ACC_PUBLIC;
+			EG(std_property_info).name = member;
+			EG(std_property_info).ce = ce;
+			EG(std_property_info).offset = -1;
+			property_info = &EG(std_property_info);
+		}
 		return property_info;
 	}
 
-	if (UNEXPECTED(Z_STRVAL_P(member)[0] == '\0')) {
+	if (UNEXPECTED(member->val[0] == '\0')) {
 		if (!silent) {
-			if (Z_STRLEN_P(member) == 0) {
+			if (member->len == 0) {
 				zend_error_noreturn(E_ERROR, "Cannot access empty property");
 			} else {
 				zend_error_noreturn(E_ERROR, "Cannot access property started with '\\0'");
@@ -322,8 +320,7 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
 		return NULL;
 	}
 	property_info = NULL;
-	h = key ? key->hash_value : zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
-	if (zend_hash_quick_find(&ce->properties_info, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, h, (void **) &property_info)==SUCCESS) {
+	if ((property_info = zend_hash_find_ptr(&ce->properties_info, member)) != NULL) {
 		if (UNEXPECTED((property_info->flags & ZEND_ACC_SHADOW) != 0)) {
 			/* if it's a shadow - go to access it's private */
 			property_info = NULL;
@@ -337,10 +334,10 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
 					 */
 				} else {
 					if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) != 0) && !silent) {
-						zend_error(E_STRICT, "Accessing static property %s::$%s as non static", ce->name, Z_STRVAL_P(member));
+						zend_error(E_STRICT, "Accessing static property %s::$%s as non static", ce->name->val, member->val);
 					}
-					if (key) {
-						CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
+					if (cache_slot != -1) {
+						CACHE_POLYMORPHIC_PTR_EX(EG(active_op_array), cache_slot, ce, property_info);
 					}
 					return property_info;
 				}
@@ -353,30 +350,31 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
 	if (EG(scope) != ce
 		&& EG(scope)
 		&& is_derived_class(ce, EG(scope))
-		&& zend_hash_quick_find(&EG(scope)->properties_info, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, h, (void **) &scope_property_info)==SUCCESS
+		&& (scope_property_info = zend_hash_find_ptr(&EG(scope)->properties_info, member)) != NULL
 		&& scope_property_info->flags & ZEND_ACC_PRIVATE) {
-		if (key) {
-			CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, scope_property_info);
+		if (cache_slot != -1) {
+			CACHE_POLYMORPHIC_PTR_EX(EG(active_op_array), cache_slot, ce, scope_property_info);
 		}
 		return scope_property_info;
 	} else if (property_info) {
 		if (UNEXPECTED(denied_access != 0)) {
 			/* Information was available, but we were denied access.  Error out. */
 			if (!silent) {
-				zend_error_noreturn(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name, Z_STRVAL_P(member));
+				zend_error_noreturn(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name->val, member->val);
 			}
 			return NULL;
 		} else {
 			/* fall through, return property_info... */
-			if (key) {
-				CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
+			if (cache_slot != -1) {
+				CACHE_POLYMORPHIC_PTR_EX(EG(active_op_array), cache_slot, ce, property_info);
 			}
 		}
 	} else {
+		if (cache_slot != -1) {
+			CACHE_POLYMORPHIC_PTR_EX(EG(active_op_array), cache_slot, ce, NULL);
+		}
 		EG(std_property_info).flags = ZEND_ACC_PUBLIC;
-		EG(std_property_info).name = Z_STRVAL_P(member);
-		EG(std_property_info).name_length = Z_STRLEN_P(member);
-		EG(std_property_info).h = h;
+		EG(std_property_info).name = member;
 		EG(std_property_info).ce = ce;
 		EG(std_property_info).offset = -1;
 		property_info = &EG(std_property_info);
@@ -387,20 +385,26 @@ static zend_always_inline struct _zend_property_info *zend_get_property_info_qui
 
 ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zval *member, int silent TSRMLS_DC) /* {{{ */
 {
-	return zend_get_property_info_quick(ce, member, silent, NULL TSRMLS_CC);
+	return zend_get_property_info_quick(ce, Z_STR_P(member), silent, -1 TSRMLS_CC);
 }
 /* }}} */
 
-ZEND_API int zend_check_property_access(zend_object *zobj, const char *prop_info_name, int prop_info_name_len TSRMLS_DC) /* {{{ */
+ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_info_name TSRMLS_DC) /* {{{ */
 {
 	zend_property_info *property_info;
-	const char *class_name, *prop_name;
-	zval member;
+	const char *class_name = NULL;
+	const char *prop_name;
+	zend_string *member;
 	int prop_name_len;
 
-	zend_unmangle_property_name_ex(prop_info_name, prop_info_name_len, &class_name, &prop_name, &prop_name_len);
-	ZVAL_STRINGL(&member, prop_name, prop_name_len, 0);
-	property_info = zend_get_property_info_quick(zobj->ce, &member, 1, NULL TSRMLS_CC);
+	if (prop_info_name->val[0] == 0) {
+		zend_unmangle_property_name_ex(prop_info_name->val, prop_info_name->len, &class_name, &prop_name, &prop_name_len);
+		member = STR_INIT(prop_name, prop_name_len, 0);
+	} else {
+		member = STR_COPY(prop_info_name);
+	}
+	property_info = zend_get_property_info_quick(zobj->ce, member, 1, -1 TSRMLS_CC);
+	STR_RELEASE(member);
 	if (!property_info) {
 		return FAILURE;
 	}
@@ -408,7 +412,7 @@ ZEND_API int zend_check_property_access(zend_object *zobj, const char *prop_info
 		if (!(property_info->flags & ZEND_ACC_PRIVATE)) {
 			/* we we're looking for a private prop but found a non private one of the same name */
 			return FAILURE;
-		} else if (strcmp(prop_info_name+1, property_info->name+1)) {
+		} else if (strcmp(prop_info_name->val+1, property_info->name->val+1)) {
 			/* we we're looking for a private prop but found a private one of the same name but another class */
 			return FAILURE;
 		}
@@ -417,61 +421,60 @@ ZEND_API int zend_check_property_access(zend_object *zobj, const char *prop_info
 }
 /* }}} */
 
-static int zend_get_property_guard(zend_object *zobj, zend_property_info *property_info, zval *member, zend_guard **pguard) /* {{{ */
+static long *zend_get_property_guard(zend_object *zobj, zend_property_info *property_info, zval *member) /* {{{ */
 {
 	zend_property_info info;
-	zend_guard stub;
+	zval stub, *guard;
+	zend_string *str = NULL;
 
 	if (!property_info) {
 		property_info = &info;
-		info.name = Z_STRVAL_P(member);
-		info.name_length = Z_STRLEN_P(member);
-		info.h = zend_get_hash_value(Z_STRVAL_P(member), Z_STRLEN_P(member) + 1);
-	} else if(property_info->name[0] == '\0'){
+		info.name = Z_STR_P(member);
+	} else if(property_info->name->val[0] == '\0'){
 		const char *class_name = NULL, *prop_name = NULL;
-		zend_unmangle_property_name(property_info->name, property_info->name_length, &class_name, &prop_name);
-		if(class_name) {
+		zend_unmangle_property_name(property_info->name->val, property_info->name->len, &class_name, &prop_name);
+		if (class_name) {
 			/* use unmangled name for protected properties */
-			info.name = prop_name;
-			info.name_length = strlen(prop_name);
-			info.h = zend_get_hash_value(info.name, info.name_length+1);
+			str = info.name = STR_INIT(prop_name, strlen(prop_name), 0);
 			property_info = &info;
 		}
 	}
 	if (!zobj->guards) {
 		ALLOC_HASHTABLE(zobj->guards);
-		zend_hash_init(zobj->guards, 0, NULL, NULL, 0);
-	} else if (zend_hash_quick_find(zobj->guards, property_info->name, property_info->name_length+1, property_info->h, (void **) pguard) == SUCCESS) {
-		return SUCCESS;
-	}
-	stub.in_get = 0;
-	stub.in_set = 0;
-	stub.in_unset = 0;
-	stub.in_isset = 0;
-	return zend_hash_quick_add(zobj->guards, property_info->name, property_info->name_length+1, property_info->h, (void**)&stub, sizeof(stub), (void**) pguard);
+		zend_hash_init(zobj->guards, 8, NULL, NULL, 0);
+	} else if ((guard = zend_hash_find(zobj->guards, property_info->name)) != NULL) {
+		if (str) {
+			STR_RELEASE(str);
+		}
+		return &Z_LVAL_P(guard);
+	}
+
+	ZVAL_LONG(&stub, 0);
+	guard = zend_hash_add(zobj->guards, property_info->name, &stub);
+	if (str) {
+		STR_RELEASE(str);
+	}
+	return &Z_LVAL_P(guard);
 }
 /* }}} */
 
-zval *zend_std_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+zval *zend_std_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
 	zend_object *zobj;
-	zval *tmp_member = NULL;
-	zval **retval;
-	zval *rv = NULL;
+	zval tmp_member;
+	zval *retval;
 	zend_property_info *property_info;
 	int silent;
 
 	silent = (type == BP_VAR_IS);
 	zobj = Z_OBJ_P(object);
 
+	ZVAL_UNDEF(&tmp_member);
 	if (UNEXPECTED(Z_TYPE_P(member) != IS_STRING)) {
-		ALLOC_ZVAL(tmp_member);
-		*tmp_member = *member;
-		INIT_PZVAL(tmp_member);
-		zval_copy_ctor(tmp_member);
-		convert_to_string(tmp_member);
-		member = tmp_member;
-		key = NULL;
+		ZVAL_DUP(&tmp_member, member);
+		convert_to_string(&tmp_member);
+		member = &tmp_member;
+		cache_slot = -1;
 	}
 
 #if DEBUG_OBJECT_HANDLERS
@@ -479,175 +482,158 @@ zval *zend_std_read_property(zval *object, zval *member, int type, const zend_li
 #endif
 
 	/* make zend_get_property_info silent if we have getter - we may want to use it */
-	property_info = zend_get_property_info_quick(zobj->ce, member, silent || (zobj->ce->__get != NULL), key TSRMLS_CC);
-
-	if (UNEXPECTED(!property_info) ||
-	    ((EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-	     property_info->offset >= 0) ?
-	        (zobj->properties ?
-	            ((retval = (zval**)zobj->properties_table[property_info->offset]) == NULL) :
-	            (*(retval = &zobj->properties_table[property_info->offset]) == NULL)) :
-	        (UNEXPECTED(!zobj->properties) ||
-	          UNEXPECTED(zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &retval) == FAILURE)))) {
-		zend_guard *guard = NULL;
-
-		if (zobj->ce->__get &&
-		    zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
-		    !guard->in_get) {
-			/* have getter - try with it! */
-			Z_ADDREF_P(object);
-			if (PZVAL_IS_REF(object)) {
-				SEPARATE_ZVAL(&object);
+	property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), silent || (zobj->ce->__get != NULL), cache_slot TSRMLS_CC);
+
+	if (EXPECTED(property_info != NULL)) {
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+			retval = &zobj->properties_table[property_info->offset];
+			if (Z_TYPE_P(retval) != IS_UNDEF) {
+				goto exit;
 			}
-			guard->in_get = 1; /* prevent circular getting */
-			rv = zend_std_call_getter(object, member TSRMLS_CC);
-			guard->in_get = 0;
+		} else if (UNEXPECTED(zobj->properties != NULL)) {
+			retval = zend_hash_find(zobj->properties, property_info->name);
+			if (retval) goto exit;
+		}
+	}
 
-			if (rv) {
-				retval = &rv;
+	/* magic get */
+	if (zobj->ce->__get) {
+		long *guard = zend_get_property_guard(zobj, property_info, member);
+		if (!((*guard) & IN_GET)) {
+			zval tmp_object;
+
+			/* have getter - try with it! */
+			ZVAL_COPY(&tmp_object, object);
+			*guard |= IN_GET; /* prevent circular getting */
+			zend_std_call_getter(&tmp_object, member, rv TSRMLS_CC);
+			*guard &= ~IN_GET;
+
+			if (Z_TYPE_P(rv) != IS_UNDEF) {
+				retval = rv;
 				if (!Z_ISREF_P(rv) &&
 				    (type == BP_VAR_W || type == BP_VAR_RW  || type == BP_VAR_UNSET)) {
-					if (Z_REFCOUNT_P(rv) > 0) {
-						zval *tmp = rv;
-
-						ALLOC_ZVAL(rv);
-						*rv = *tmp;
-						zval_copy_ctor(rv);
-						Z_UNSET_ISREF_P(rv);
-						Z_SET_REFCOUNT_P(rv, 0);
-					}
+					SEPARATE_ZVAL(rv);
 					if (UNEXPECTED(Z_TYPE_P(rv) != IS_OBJECT)) {
-						zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", zobj->ce->name, Z_STRVAL_P(member));
+						zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", zobj->ce->name->val, Z_STRVAL_P(member));
 					}
 				}
 			} else {
-				retval = &EG(uninitialized_zval_ptr);
-			}
-			if (EXPECTED(*retval != object)) {
-				zval_ptr_dtor(&object);
-			} else {
-				Z_DELREF_P(object);
+				retval = &EG(uninitialized_zval);
 			}
+			zval_ptr_dtor(&tmp_object);
 		} else {
-			if (zobj->ce->__get && guard && guard->in_get == 1) {
-				if (Z_STRVAL_P(member)[0] == '\0') {
-					if (Z_STRLEN_P(member) == 0) {
-						zend_error(E_ERROR, "Cannot access empty property");
-					} else {
-						zend_error(E_ERROR, "Cannot access property started with '\\0'");
-					}
+			if (Z_STRVAL_P(member)[0] == '\0') {
+				if (Z_STRLEN_P(member) == 0) {
+					zend_error(E_ERROR, "Cannot access empty property");
+				} else {
+					zend_error(E_ERROR, "Cannot access property started with '\\0'");
 				}
 			}
 			if (!silent) {
-				zend_error(E_NOTICE,"Undefined property: %s::$%s", zobj->ce->name, Z_STRVAL_P(member));
+				zend_error(E_NOTICE,"Undefined property: %s::$%s", zobj->ce->name->val, Z_STRVAL_P(member));
 			}
-			retval = &EG(uninitialized_zval_ptr);
+			retval = &EG(uninitialized_zval);
+		}
+	} else {
+		if (!silent) {
+			zend_error(E_NOTICE,"Undefined property: %s::$%s", zobj->ce->name->val, Z_STRVAL_P(member));
 		}
+		retval = &EG(uninitialized_zval);
 	}
-	if (UNEXPECTED(tmp_member != NULL)) {
-		Z_ADDREF_PP(retval);
+
+exit:
+	if (UNEXPECTED(Z_TYPE(tmp_member) != IS_UNDEF)) {
+		if (Z_REFCOUNTED_P(retval)) Z_ADDREF_P(retval);
 		zval_ptr_dtor(&tmp_member);
-		Z_DELREF_PP(retval);
+		if (Z_REFCOUNTED_P(retval)) Z_DELREF_P(retval);
 	}
-	return *retval;
+	return retval;
 }
 /* }}} */
 
-ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	zend_object *zobj;
-	zval *tmp_member = NULL;
-	zval **variable_ptr;
+	zval tmp_member;
+	zval *variable_ptr;
 	zend_property_info *property_info;
 
 	zobj = Z_OBJ_P(object);
 
+	ZVAL_UNDEF(&tmp_member);
  	if (UNEXPECTED(Z_TYPE_P(member) != IS_STRING)) {
- 		ALLOC_ZVAL(tmp_member);
-		*tmp_member = *member;
-		INIT_PZVAL(tmp_member);
-		zval_copy_ctor(tmp_member);
-		convert_to_string(tmp_member);
-		member = tmp_member;
-		key = NULL;
-	}
-
-	property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__set != NULL), key TSRMLS_CC);
-
-	if (EXPECTED(property_info != NULL) &&
-	    ((EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-	     property_info->offset >= 0) ?
-	        (zobj->properties ?
-	            ((variable_ptr = (zval**)zobj->properties_table[property_info->offset]) != NULL) :
-	            (*(variable_ptr = &zobj->properties_table[property_info->offset]) != NULL)) :
-	        (EXPECTED(zobj->properties != NULL) &&
-	          EXPECTED(zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &variable_ptr) == SUCCESS)))) {
-		/* if we already have this value there, we don't actually need to do anything */
-		if (EXPECTED(*variable_ptr != value)) {
-			/* if we are assigning reference, we shouldn't move it, but instead assign variable
-			   to the same pointer */
-			if (PZVAL_IS_REF(*variable_ptr)) {
-				zval garbage = **variable_ptr; /* old value should be destroyed */
-
-				/* To check: can't *variable_ptr be some system variable like error_zval here? */
-				Z_TYPE_PP(variable_ptr) = Z_TYPE_P(value);
-				(*variable_ptr)->value = value->value;
-				if (Z_REFCOUNT_P(value) > 0) {
-					zval_copy_ctor(*variable_ptr);
-				} else {
-					efree(value);
-				}
-				zval_dtor(&garbage);
-			} else {
-				zval *garbage = *variable_ptr;
+		ZVAL_DUP(&tmp_member, member);
+		convert_to_string(&tmp_member);
+		member = &tmp_member;
+		cache_slot = -1;
+	}
 
-				/* if we assign referenced variable, we should separate it */
-				Z_ADDREF_P(value);
-				if (PZVAL_IS_REF(value)) {
-					SEPARATE_ZVAL(&value);
+	property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__set != NULL), cache_slot TSRMLS_CC);
+
+	if (EXPECTED(property_info != NULL)) {
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+			variable_ptr = &zobj->properties_table[property_info->offset];
+			if (Z_TYPE_P(variable_ptr) != IS_UNDEF) {
+				goto found;
+			}
+		} else if (EXPECTED(zobj->properties != NULL)) {
+			if ((variable_ptr = zend_hash_find(zobj->properties, property_info->name)) != NULL) {
+found:
+				/* if we already have this value there, we don't actually need to do anything */
+				if (EXPECTED(variable_ptr != value)) {
+					/* if we are assigning reference, we shouldn't move it, but instead assign variable
+					   to the same pointer */
+					if (Z_ISREF_P(variable_ptr)) {
+						zval garbage;
+
+						ZVAL_COPY_VALUE(&garbage, Z_REFVAL_P(variable_ptr)); /* old value should be destroyed */
+
+						/* To check: can't *variable_ptr be some system variable like error_zval here? */
+						ZVAL_COPY_VALUE(Z_REFVAL_P(variable_ptr), value);
+						if (Z_REFCOUNTED_P(value) && Z_REFCOUNT_P(value) > 0) {
+							zval_copy_ctor(Z_REFVAL_P(variable_ptr));
+						}
+						zval_dtor(&garbage);
+					} else {
+						zval garbage;
+
+						ZVAL_COPY_VALUE(&garbage, variable_ptr);
+
+						/* if we assign referenced variable, we should separate it */
+						ZVAL_COPY_VALUE(variable_ptr, value);
+						if (Z_REFCOUNTED_P(variable_ptr)) {
+							Z_ADDREF_P(variable_ptr);
+							if (Z_ISREF_P(variable_ptr)) {
+								SEPARATE_ZVAL(variable_ptr);
+							}
+						}
+						zval_ptr_dtor(&garbage);
+					}
 				}
-				*variable_ptr = value;
-				zval_ptr_dtor(&garbage);
+				goto exit;
 			}
 		}
-	} else {
-		zend_guard *guard = NULL;
-
-		if (zobj->ce->__set &&
-		    zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
-		    !guard->in_set) {
-			Z_ADDREF_P(object);
-			if (PZVAL_IS_REF(object)) {
-				SEPARATE_ZVAL(&object);
-			}
-			guard->in_set = 1; /* prevent circular setting */
-			if (zend_std_call_setter(object, member, value TSRMLS_CC) != SUCCESS) {
+	}
+
+	/* magic set */
+	if (zobj->ce->__set) {
+		long *guard = zend_get_property_guard(zobj, property_info, member);
+
+	    if (!((*guard) & IN_SET)) {
+			zval tmp_object;
+
+			ZVAL_COPY(&tmp_object, object);
+			(*guard) |= IN_SET; /* prevent circular setting */
+			if (zend_std_call_setter(&tmp_object, member, value TSRMLS_CC) != SUCCESS) {
 				/* for now, just ignore it - __set should take care of warnings, etc. */
 			}
-			guard->in_set = 0;
-			zval_ptr_dtor(&object);
+			(*guard) &= ~IN_SET;
+			zval_ptr_dtor(&tmp_object);
 		} else if (EXPECTED(property_info != NULL)) {
-			/* if we assign referenced variable, we should separate it */
-			Z_ADDREF_P(value);
-			if (PZVAL_IS_REF(value)) {
-				SEPARATE_ZVAL(&value);
-			}
-			if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-			    property_info->offset >= 0) {
-					if (!zobj->properties) {
-						zobj->properties_table[property_info->offset] = value;
-					} else if (zobj->properties_table[property_info->offset]) {
-						*(zval**)zobj->properties_table[property_info->offset] = value;
-					} else {
-						zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &value, sizeof(zval *), (void**)&zobj->properties_table[property_info->offset]);
-					}
-				} else {
-					if (!zobj->properties) {
-					rebuild_object_properties(zobj);
-				}
-				zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &value, sizeof(zval *), NULL);
-			}
-		} else if (zobj->ce->__set && guard && guard->in_set == 1) {
+			goto write_std_property;
+		} else {
 			if (Z_STRVAL_P(member)[0] == '\0') {
 				if (Z_STRLEN_P(member) == 0) {
 					zend_error(E_ERROR, "Cannot access empty property");
@@ -656,44 +642,65 @@ ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, c
 				}
 			}
 		}
+	} else if (EXPECTED(property_info != NULL)) {
+write_std_property:
+		/* if we assign referenced variable, we should separate it */
+		if (Z_REFCOUNTED_P(value)) {
+			if (Z_ISREF_P(value)) {
+				zval tmp;
+
+				ZVAL_DUP(&tmp, Z_REFVAL_P(value));
+				value = &tmp;
+			} else {
+				Z_ADDREF_P(value);
+			}
+		}
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+
+			ZVAL_COPY_VALUE(&zobj->properties_table[property_info->offset], value);
+		} else {
+			if (!zobj->properties) {
+				rebuild_object_properties(zobj);
+			}
+			zend_hash_update(zobj->properties, property_info->name, value);
+		}
 	}
 
-	if (UNEXPECTED(tmp_member != NULL)) {
+exit:
+	if (UNEXPECTED(Z_TYPE(tmp_member) != IS_UNDEF)) {
 		zval_ptr_dtor(&tmp_member);
 	}
 }
 /* }}} */
 
-zval *zend_std_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
+zval *zend_std_read_dimension(zval *object, zval *offset, int type, zval *rv TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *ce = Z_OBJCE_P(object);
-	zval *retval;
+	zval tmp;
 
 	if (EXPECTED(instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC) != 0)) {
 		if(offset == NULL) {
 			/* [] construct */
-			ALLOC_INIT_ZVAL(offset);
+			ZVAL_UNDEF(&tmp);
+			offset = &tmp;
 		} else {
 			SEPARATE_ARG_IF_REF(offset);
 		}
-		zend_call_method_with_1_params(&object, ce, NULL, "offsetget", &retval, offset);
+		zend_call_method_with_1_params(object, ce, NULL, "offsetget", rv, offset);
 
-		zval_ptr_dtor(&offset);
+		zval_ptr_dtor(offset);
 
-		if (UNEXPECTED(!retval)) {
+		if (UNEXPECTED(Z_TYPE_P(rv) == IS_UNDEF)) {
 			if (UNEXPECTED(!EG(exception))) {
-				zend_error_noreturn(E_ERROR, "Undefined offset for object of type %s used as array", ce->name);
+				zend_error_noreturn(E_ERROR, "Undefined offset for object of type %s used as array", ce->name->val);
 			}
-			return 0;
+			return NULL;
 		}
-
-		/* Undo PZVAL_LOCK() */
-		Z_DELREF_P(retval);
-
-		return retval;
+		return rv;
 	} else {
-		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name);
-		return 0;
+		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name->val);
+		return NULL;
 	}
 }
 /* }}} */
@@ -701,17 +708,19 @@ zval *zend_std_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /*
 static void zend_std_write_dimension(zval *object, zval *offset, zval *value TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *ce = Z_OBJCE_P(object);
+	zval tmp;
 
 	if (EXPECTED(instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC) != 0)) {
 		if (!offset) {
-			ALLOC_INIT_ZVAL(offset);
+			ZVAL_NULL(&tmp);
+			offset = &tmp;
 		} else {
 			SEPARATE_ARG_IF_REF(offset);
 		}
-		zend_call_method_with_2_params(&object, ce, NULL, "offsetset", NULL, offset, value);
-		zval_ptr_dtor(&offset);
+		zend_call_method_with_2_params(object, ce, NULL, "offsetset", NULL, offset, value);
+		zval_ptr_dtor(offset);
 	} else {
-		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name);
+		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name->val);
 	}
 }
 /* }}} */
@@ -719,153 +728,148 @@ static void zend_std_write_dimension(zval *object, zval *offset, zval *value TSR
 static int zend_std_has_dimension(zval *object, zval *offset, int check_empty TSRMLS_DC) /* {{{ */
 {
 	zend_class_entry *ce = Z_OBJCE_P(object);
-	zval *retval;
+	zval retval;
 	int result;
 
 	if (EXPECTED(instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC) != 0)) {
 		SEPARATE_ARG_IF_REF(offset);
-		zend_call_method_with_1_params(&object, ce, NULL, "offsetexists", &retval, offset);
-		if (EXPECTED(retval != NULL)) {
-			result = i_zend_is_true(retval TSRMLS_CC);
+		zend_call_method_with_1_params(object, ce, NULL, "offsetexists", &retval, offset);
+		if (EXPECTED(Z_TYPE(retval) != IS_UNDEF)) {
+			result = i_zend_is_true(&retval TSRMLS_CC);
 			zval_ptr_dtor(&retval);
 			if (check_empty && result && EXPECTED(!EG(exception))) {
-				zend_call_method_with_1_params(&object, ce, NULL, "offsetget", &retval, offset);
-				if (retval) {
-					result = i_zend_is_true(retval TSRMLS_CC);
+				zend_call_method_with_1_params(object, ce, NULL, "offsetget", &retval, offset);
+				if (EXPECTED(Z_TYPE(retval) != IS_UNDEF)) {
+					result = i_zend_is_true(&retval TSRMLS_CC);
 					zval_ptr_dtor(&retval);
 				}
 			}
 		} else {
 			result = 0;
 		}
-		zval_ptr_dtor(&offset);
+		zval_ptr_dtor(offset);
 	} else {
-		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name);
+		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name->val);
 		return 0;
 	}
 	return result;
 }
 /* }}} */
 
-static zval **zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	zend_object *zobj;
 	zval tmp_member;
-	zval **retval;
+	zval *retval, tmp;
 	zend_property_info *property_info;
+	long *guard;
 
 	zobj = Z_OBJ_P(object);
 
+	ZVAL_UNDEF(&tmp_member);
  	if (UNEXPECTED(Z_TYPE_P(member) != IS_STRING)) {
-		tmp_member = *member;
-		zval_copy_ctor(&tmp_member);
+		ZVAL_DUP(&tmp_member, member);
 		convert_to_string(&tmp_member);
 		member = &tmp_member;
-		key = NULL;
+		cache_slot = -1;
 	}
 
 #if DEBUG_OBJECT_HANDLERS
 	fprintf(stderr, "Ptr object #%d property: %s\n", Z_OBJ_HANDLE_P(object), Z_STRVAL_P(member));
 #endif
 
-	property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__get != NULL), key TSRMLS_CC);
-
-	if (UNEXPECTED(!property_info) ||
-	    ((EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-	     property_info->offset >= 0) ?
-	        (zobj->properties ?
-	            ((retval = (zval**)zobj->properties_table[property_info->offset]) == NULL) :
-	            (*(retval = &zobj->properties_table[property_info->offset]) == NULL)) :
-	        (UNEXPECTED(!zobj->properties) ||
-	          UNEXPECTED(zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &retval) == FAILURE)))) {
-		zval *new_zval;
-		zend_guard *guard;
-
-		if (!zobj->ce->__get ||
-			zend_get_property_guard(zobj, property_info, member, &guard) != SUCCESS ||
-			(property_info && guard->in_get)) {
-			/* we don't have access controls - will just add it */
-			new_zval = &EG(uninitialized_zval);
-
-			if(UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
-				zend_error(E_NOTICE, "Undefined property: %s::$%s", zobj->ce->name, Z_STRVAL_P(member));
-			}
-			Z_ADDREF_P(new_zval);
-			if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-			    property_info->offset >= 0) {
-				if (!zobj->properties) {
-					zobj->properties_table[property_info->offset] = new_zval;
-					retval = &zobj->properties_table[property_info->offset];
-				} else if (zobj->properties_table[property_info->offset]) {
-					*(zval**)zobj->properties_table[property_info->offset] = new_zval;
-					retval = (zval**)zobj->properties_table[property_info->offset];
-				} else {
-					zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &new_zval, sizeof(zval *), (void**)&zobj->properties_table[property_info->offset]);
-					retval = (zval**)zobj->properties_table[property_info->offset];
-				}
-			} else {
-				if (!zobj->properties) {
-					rebuild_object_properties(zobj);
-				}
-				zend_hash_quick_update(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, &new_zval, sizeof(zval *), (void **) &retval);
+	property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__get != NULL), cache_slot TSRMLS_CC);
+
+	if (EXPECTED(property_info != NULL)) {
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+			retval = &zobj->properties_table[property_info->offset];
+			if (Z_TYPE_P(retval) != IS_UNDEF) {
+				goto exit;
 			}
+		} else if (UNEXPECTED(zobj->properties != NULL)) {
+			retval = zend_hash_find(zobj->properties, property_info->name);
+			if (retval) goto exit;
+		}
+	}
+
+	if (!zobj->ce->__get ||
+		(guard = zend_get_property_guard(zobj, property_info, member)) == NULL ||
+		(property_info && ((*guard) & IN_GET))) {
+
+		/* we don't have access controls - will just add it */
+		if(UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
+			zend_error(E_NOTICE, "Undefined property: %s::$%s", zobj->ce->name->val, Z_STRVAL_P(member));
+		}
+		ZVAL_NULL(&tmp);
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+			retval = &zobj->properties_table[property_info->offset];
+			ZVAL_NULL(retval);
 		} else {
-			/* we do have getter - fail and let it try again with usual get/set */
-			retval = NULL;
+			if (!zobj->properties) {
+				rebuild_object_properties(zobj);
+			}
+			retval = zend_hash_update(zobj->properties, property_info->name, &tmp);
 		}
+	} else {
+		/* we do have getter - fail and let it try again with usual get/set */
+		retval = NULL;
 	}
-	if (UNEXPECTED(member == &tmp_member)) {
-		zval_dtor(member);
+
+exit:
+	if (UNEXPECTED(Z_TYPE(tmp_member) != IS_UNDEF)) {
+		zval_dtor(&tmp_member);
 	}
 	return retval;
 }
 /* }}} */
 
-static void zend_std_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void zend_std_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	zend_object *zobj;
-	zval *tmp_member = NULL;
+	zval tmp_member;
 	zend_property_info *property_info;
 
 	zobj = Z_OBJ_P(object);
 
+	ZVAL_UNDEF(&tmp_member);
  	if (UNEXPECTED(Z_TYPE_P(member) != IS_STRING)) {
- 		ALLOC_ZVAL(tmp_member);
-		*tmp_member = *member;
-		INIT_PZVAL(tmp_member);
-		zval_copy_ctor(tmp_member);
-		convert_to_string(tmp_member);
-		member = tmp_member;
-		key = NULL;
-	}
-
-	property_info = zend_get_property_info_quick(zobj->ce, member, (zobj->ce->__unset != NULL), key TSRMLS_CC);
-
-	if (EXPECTED(property_info != NULL) &&
-	    EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-	    !zobj->properties &&
-	    property_info->offset >= 0 &&
-	    EXPECTED(zobj->properties_table[property_info->offset] != NULL)) {
-		zval_ptr_dtor(&zobj->properties_table[property_info->offset]);
-		zobj->properties_table[property_info->offset] = NULL;
-	} else if (UNEXPECTED(!property_info) ||
-	           !zobj->properties ||
-	           UNEXPECTED(zend_hash_quick_del(zobj->properties, property_info->name, property_info->name_length+1, property_info->h) == FAILURE)) {
-		zend_guard *guard = NULL;
-
-		if (zobj->ce->__unset &&
-		    zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
-		    !guard->in_unset) {
-			/* have unseter - try with it! */
-			Z_ADDREF_P(object);
-			if (PZVAL_IS_REF(object)) {
-				SEPARATE_ZVAL(&object);
+		ZVAL_DUP(&tmp_member, member);
+		convert_to_string(&tmp_member);
+		member = &tmp_member;
+		cache_slot = -1;
+	}
+
+	property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), (zobj->ce->__unset != NULL), cache_slot TSRMLS_CC);
+
+	if (EXPECTED(property_info != NULL)) {
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+			if (Z_TYPE(zobj->properties_table[property_info->offset]) != IS_UNDEF) {
+				zval_ptr_dtor(&zobj->properties_table[property_info->offset]);
+				ZVAL_UNDEF(&zobj->properties_table[property_info->offset]);
+				goto exit;
 			}
-			guard->in_unset = 1; /* prevent circular unsetting */
-			zend_std_call_unsetter(object, member TSRMLS_CC);
-			guard->in_unset = 0;
-			zval_ptr_dtor(&object);
-		} else if (zobj->ce->__unset && guard && guard->in_unset == 1) {
+		} else if (zobj->properties &&
+        	UNEXPECTED(zend_hash_del(zobj->properties, property_info->name) != FAILURE)) {
+			goto exit;
+		}
+	}
+	
+	/* magic unset */
+	if (zobj->ce->__unset) {
+		long *guard = zend_get_property_guard(zobj, property_info, member);
+		if (!((*guard) & IN_UNSET)) {
+			zval tmp_object;
+
+			/* have unseter - try with it! */
+			ZVAL_COPY(&tmp_object, object);
+			(*guard) |= IN_UNSET; /* prevent circular unsetting */
+			zend_std_call_unsetter(&tmp_object, member TSRMLS_CC);
+			(*guard) &= ~IN_UNSET;
+			zval_ptr_dtor(&tmp_object);
+		} else {
 			if (Z_STRVAL_P(member)[0] == '\0') {
 				if (Z_STRLEN_P(member) == 0) {
 					zend_error(E_ERROR, "Cannot access empty property");
@@ -874,13 +878,10 @@ static void zend_std_unset_property(zval *object, zval *member, const zend_liter
 				}
 			}
 		}
-	} else if (EXPECTED(property_info != NULL) &&
-	           EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-	           property_info->offset >= 0) {
-		zobj->properties_table[property_info->offset] = NULL;
 	}
 
-	if (UNEXPECTED(tmp_member != NULL)) {
+exit:
+	if (UNEXPECTED(Z_TYPE(tmp_member) != IS_NULL)) {
 		zval_ptr_dtor(&tmp_member);
 	}
 }
@@ -892,10 +893,10 @@ static void zend_std_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* {{
 
 	if (instanceof_function_ex(ce, zend_ce_arrayaccess, 1 TSRMLS_CC)) {
 		SEPARATE_ARG_IF_REF(offset);
-		zend_call_method_with_1_params(&object, ce, NULL, "offsetunset", NULL, offset);
-		zval_ptr_dtor(&offset);
+		zend_call_method_with_1_params(object, ce, NULL, "offsetunset", NULL, offset);
+		zval_ptr_dtor(offset);
 	} else {
-		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name);
+		zend_error_noreturn(E_ERROR, "Cannot use object of type %s as array", ce->name->val);
 	}
 }
 /* }}} */
@@ -903,39 +904,36 @@ static void zend_std_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* {{
 ZEND_API void zend_std_call_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
 {
 	zend_internal_function *func = (zend_internal_function *)EG(current_execute_data)->function_state.function;
-	zval *method_name_ptr, *method_args_ptr;
-	zval *method_result_ptr = NULL;
-	zend_class_entry *ce = Z_OBJCE_P(this_ptr);
+	zval method_name, method_args;
+	zval method_result;
+	zend_class_entry *ce = Z_OBJCE_P(getThis());
 
-	ALLOC_ZVAL(method_args_ptr);
-	INIT_PZVAL(method_args_ptr);
-	array_init_size(method_args_ptr, ZEND_NUM_ARGS());
+	array_init_size(&method_args, ZEND_NUM_ARGS());
 
-	if (UNEXPECTED(zend_copy_parameters_array(ZEND_NUM_ARGS(), method_args_ptr TSRMLS_CC) == FAILURE)) {
-		zval_dtor(method_args_ptr);
+	if (UNEXPECTED(zend_copy_parameters_array(ZEND_NUM_ARGS(), &method_args TSRMLS_CC) == FAILURE)) {
+		zval_dtor(&method_args);
 		zend_error_noreturn(E_ERROR, "Cannot get arguments for __call");
 		RETURN_FALSE;
 	}
 
-	ALLOC_ZVAL(method_name_ptr);
-	INIT_PZVAL(method_name_ptr);
-	ZVAL_STRING(method_name_ptr, func->function_name, 0); /* no dup - it's a copy */
+	ZVAL_STR(&method_name, func->function_name); /* no dup - it's a copy */
 
 	/* __call handler is called with two arguments:
 	   method name
 	   array of method parameters
 
 	*/
-	zend_call_method_with_2_params(&this_ptr, ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
+	ZVAL_UNDEF(&method_result);
+	zend_call_method_with_2_params(getThis(), ce, &ce->__call, ZEND_CALL_FUNC_NAME, &method_result, &method_name, &method_args);
 
-	if (method_result_ptr) {
-		RETVAL_ZVAL_FAST(method_result_ptr);
-		zval_ptr_dtor(&method_result_ptr);
+	if (Z_TYPE(method_result) != IS_UNDEF) {
+		RETVAL_ZVAL_FAST(&method_result);
+		zval_ptr_dtor(&method_result);
 	}
 
 	/* now destruct all auxiliaries */
-	zval_ptr_dtor(&method_args_ptr);
-	zval_ptr_dtor(&method_name_ptr);
+	zval_ptr_dtor(&method_args);
+	zval_ptr_dtor(&method_name);
 
 	/* destruct the function also, then - we have allocated it in get_method */
 	efree(func);
@@ -946,8 +944,10 @@ ZEND_API void zend_std_call_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
  * Returns the function address that should be called, or NULL
  * if no such function exists.
  */
-static inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, char *function_name_strval, int function_name_strlen, ulong hash_value TSRMLS_DC) /* {{{ */
+static inline zend_function *zend_check_private_int(zend_function *fbc, zend_class_entry *ce, zend_string *function_name TSRMLS_DC) /* {{{ */
 {
+    zval *func;
+
 	if (!ce) {
 		return 0;
 	}
@@ -968,10 +968,12 @@ static inline zend_function *zend_check_private_int(zend_function *fbc, zend_cla
 	ce = ce->parent;
 	while (ce) {
 		if (ce == EG(scope)) {
-			if (zend_hash_quick_find(&ce->function_table, function_name_strval, function_name_strlen+1, hash_value, (void **) &fbc)==SUCCESS
-				&& fbc->op_array.fn_flags & ZEND_ACC_PRIVATE
-				&& fbc->common.scope == EG(scope)) {
-				return fbc;
+			if ((func = zend_hash_find(&ce->function_table, function_name))) {
+				fbc = Z_FUNC_P(func);
+				if (fbc->common.fn_flags & ZEND_ACC_PRIVATE
+					&& fbc->common.scope == EG(scope)) {
+					return fbc;
+				}
 			}
 			break;
 		}
@@ -981,9 +983,9 @@ static inline zend_function *zend_check_private_int(zend_function *fbc, zend_cla
 }
 /* }}} */
 
-ZEND_API int zend_check_private(zend_function *fbc, zend_class_entry *ce, char *function_name_strval, int function_name_strlen TSRMLS_DC) /* {{{ */
+ZEND_API int zend_check_private(zend_function *fbc, zend_class_entry *ce, zend_string *function_name TSRMLS_DC) /* {{{ */
 {
-	return zend_check_private_int(fbc, ce, function_name_strval, function_name_strlen, zend_hash_func(function_name_strval, function_name_strlen+1) TSRMLS_CC) != NULL;
+	return zend_check_private_int(fbc, ce, function_name TSRMLS_CC) != NULL;
 }
 /* }}} */
 
@@ -1016,7 +1018,7 @@ ZEND_API int zend_check_protected(zend_class_entry *ce, zend_class_entry *scope)
 }
 /* }}} */
 
-static inline union _zend_function *zend_get_user_call_function(zend_class_entry *ce, const char *method_name, int method_len) /* {{{ */
+static inline union _zend_function *zend_get_user_call_function(zend_class_entry *ce, zend_string *method_name) /* {{{ */
 {
 	zend_internal_function *call_user_call = emalloc(sizeof(zend_internal_function));
 	call_user_call->type = ZEND_INTERNAL_FUNCTION;
@@ -1026,42 +1028,44 @@ static inline union _zend_function *zend_get_user_call_function(zend_class_entry
 	call_user_call->num_args = 0;
 	call_user_call->scope = ce;
 	call_user_call->fn_flags = ZEND_ACC_CALL_VIA_HANDLER;
-	call_user_call->function_name = estrndup(method_name, method_len);
+	//??? keep compatibility for "\0" characters
+	//??? see: Zend/tests/bug46238.phpt
+	if (UNEXPECTED(strlen(method_name->val) != method_name->len)) {
+		call_user_call->function_name = STR_INIT(method_name->val, strlen(method_name->val), 0);
+	} else {
+		call_user_call->function_name = STR_COPY(method_name);
+	}
 
 	return (union _zend_function *)call_user_call;
 }
 /* }}} */
 
-static union _zend_function *zend_std_get_method(zval **object_ptr, char *method_name, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
+static union _zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *method_name, const zval *key TSRMLS_DC) /* {{{ */
 {
+	zend_object *zobj = *obj_ptr;
+	zval *func;
 	zend_function *fbc;
-	zval *object = *object_ptr;
-	zend_object *zobj = Z_OBJ_P(object);
-	ulong hash_value;
-	char *lc_method_name;
-	ALLOCA_FLAG(use_heap)
+	zend_string *lc_method_name;
 
 	if (EXPECTED(key != NULL)) {
-		lc_method_name = Z_STRVAL(key->constant);
-		hash_value = key->hash_value;
+		lc_method_name = Z_STR_P(key);
 	} else {
-		lc_method_name = do_alloca(method_len+1, use_heap);
-		/* Create a zend_copy_str_tolower(dest, src, src_length); */
-		zend_str_tolower_copy(lc_method_name, method_name, method_len);
-		hash_value = zend_hash_func(lc_method_name, method_len+1);
+		lc_method_name = STR_ALLOC(method_name->len, 0);
+		zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len);
 	}
 
-	if (UNEXPECTED(zend_hash_quick_find(&zobj->ce->function_table, lc_method_name, method_len+1, hash_value, (void **)&fbc) == FAILURE)) {
+	if (UNEXPECTED((func = zend_hash_find(&zobj->ce->function_table, lc_method_name)) == NULL)) {
 		if (UNEXPECTED(!key)) {
-			free_alloca(lc_method_name, use_heap);
+			STR_FREE(lc_method_name);
 		}
 		if (zobj->ce->__call) {
-			return zend_get_user_call_function(zobj->ce, method_name, method_len);
+			return zend_get_user_call_function(zobj->ce, method_name);
 		} else {
 			return NULL;
 		}
 	}
 
+	fbc = Z_FUNC_P(func);
 	/* Check access level */
 	if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
 		zend_function *updated_fbc;
@@ -1069,14 +1073,14 @@ static union _zend_function *zend_std_get_method(zval **object_ptr, char *method
 		/* Ensure that if we're calling a private function, we're allowed to do so.
 		 * If we're not and __call() handler exists, invoke it, otherwise error out.
 		 */
-		updated_fbc = zend_check_private_int(fbc, Z_OBJ_HANDLER_P(object, get_class_entry)(object TSRMLS_CC), lc_method_name, method_len, hash_value TSRMLS_CC);
+		updated_fbc = zend_check_private_int(fbc, zobj->handlers->get_class_entry(zobj TSRMLS_CC), lc_method_name TSRMLS_CC);
 		if (EXPECTED(updated_fbc != NULL)) {
 			fbc = updated_fbc;
 		} else {
 			if (zobj->ce->__call) {
-				fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
+				fbc = zend_get_user_call_function(zobj->ce, method_name);
 			} else {
-				zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	} else {
@@ -1086,12 +1090,12 @@ static union _zend_function *zend_std_get_method(zval **object_ptr, char *method
 		if (EG(scope) &&
 		    is_derived_class(fbc->common.scope, EG(scope)) &&
 		    fbc->op_array.fn_flags & ZEND_ACC_CHANGED) {
-			zend_function *priv_fbc;
-
-			if (zend_hash_quick_find(&EG(scope)->function_table, lc_method_name, method_len+1, hash_value, (void **) &priv_fbc)==SUCCESS
-				&& priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE
-				&& priv_fbc->common.scope == EG(scope)) {
-				fbc = priv_fbc;
+			if ((func = zend_hash_find(&EG(scope)->function_table, lc_method_name)) != SUCCESS) {
+				zend_function *priv_fbc = Z_FUNC_P(func);
+				if (priv_fbc->common.fn_flags & ZEND_ACC_PRIVATE
+					&& priv_fbc->common.scope == EG(scope)) {
+					fbc = priv_fbc;
+				}
 			}
 		}
 		if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
@@ -1100,16 +1104,16 @@ static union _zend_function *zend_std_get_method(zval **object_ptr, char *method
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), EG(scope)))) {
 				if (zobj->ce->__call) {
-					fbc = zend_get_user_call_function(zobj->ce, method_name, method_len);
+					fbc = zend_get_user_call_function(zobj->ce, method_name);
 				} else {
-					zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name, EG(scope) ? EG(scope)->name : "");
+					zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), method_name->val, EG(scope) ? EG(scope)->name->val : "");
 				}
 			}
 		}
 	}
 
 	if (UNEXPECTED(!key)) {
-		free_alloca(lc_method_name, use_heap);
+		STR_FREE(lc_method_name);
 	}
 	return fbc;
 }
@@ -1118,45 +1122,42 @@ static union _zend_function *zend_std_get_method(zval **object_ptr, char *method
 ZEND_API void zend_std_callstatic_user_call(INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
 {
 	zend_internal_function *func = (zend_internal_function *)EG(current_execute_data)->function_state.function;
-	zval *method_name_ptr, *method_args_ptr;
-	zval *method_result_ptr = NULL;
+	zval method_name, method_args;
+	zval method_result;
 	zend_class_entry *ce = EG(scope);
 
-	ALLOC_ZVAL(method_args_ptr);
-	INIT_PZVAL(method_args_ptr);
-	array_init_size(method_args_ptr, ZEND_NUM_ARGS());
+	array_init_size(&method_args, ZEND_NUM_ARGS());
 
-	if (UNEXPECTED(zend_copy_parameters_array(ZEND_NUM_ARGS(), method_args_ptr TSRMLS_CC) == FAILURE)) {
-		zval_dtor(method_args_ptr);
+	if (UNEXPECTED(zend_copy_parameters_array(ZEND_NUM_ARGS(), &method_args TSRMLS_CC) == FAILURE)) {
+		zval_dtor(&method_args);
 		zend_error_noreturn(E_ERROR, "Cannot get arguments for " ZEND_CALLSTATIC_FUNC_NAME);
 		RETURN_FALSE;
 	}
 
-	ALLOC_ZVAL(method_name_ptr);
-	INIT_PZVAL(method_name_ptr);
-	ZVAL_STRING(method_name_ptr, func->function_name, 0); /* no dup - it's a copy */
+	ZVAL_STR(&method_name, func->function_name); /* no dup - it's a copy */
 
 	/* __callStatic handler is called with two arguments:
 	   method name
 	   array of method parameters
 	*/
-	zend_call_method_with_2_params(NULL, ce, &ce->__callstatic, ZEND_CALLSTATIC_FUNC_NAME, &method_result_ptr, method_name_ptr, method_args_ptr);
+	ZVAL_UNDEF(&method_result);
+	zend_call_method_with_2_params(NULL, ce, &ce->__callstatic, ZEND_CALLSTATIC_FUNC_NAME, &method_result, &method_name, &method_args);
 
-	if (method_result_ptr) {
-		RETVAL_ZVAL_FAST(method_result_ptr);
-		zval_ptr_dtor(&method_result_ptr);
+	if (Z_TYPE(method_result) != IS_UNDEF) {
+		RETVAL_ZVAL_FAST(&method_result);
+		zval_ptr_dtor(&method_result);
 	}
 
 	/* now destruct all auxiliaries */
-	zval_ptr_dtor(&method_args_ptr);
-	zval_ptr_dtor(&method_name_ptr);
+	zval_ptr_dtor(&method_args);
+	zval_ptr_dtor(&method_name);
 
 	/* destruct the function also, then - we have allocated it in get_method */
 	efree(func);
 }
 /* }}} */
 
-static inline union _zend_function *zend_get_user_callstatic_function(zend_class_entry *ce, const char *method_name, int method_len) /* {{{ */
+static inline union _zend_function *zend_get_user_callstatic_function(zend_class_entry *ce, zend_string *method_name) /* {{{ */
 {
 	zend_internal_function *callstatic_user_call = emalloc(sizeof(zend_internal_function));
 	callstatic_user_call->type     = ZEND_INTERNAL_FUNCTION;
@@ -1166,7 +1167,13 @@ static inline union _zend_function *zend_get_user_callstatic_function(zend_class
 	callstatic_user_call->num_args = 0;
 	callstatic_user_call->scope    = ce;
 	callstatic_user_call->fn_flags = ZEND_ACC_STATIC | ZEND_ACC_PUBLIC | ZEND_ACC_CALL_VIA_HANDLER;
-	callstatic_user_call->function_name = estrndup(method_name, method_len);
+	//??? keep compatibility for "\0" characters
+	//??? see: Zend/tests/bug46238.phpt
+	if (UNEXPECTED(strlen(method_name->val) != method_name->len)) {
+		callstatic_user_call->function_name = STR_INIT(method_name->val, strlen(method_name->val), 0);
+	} else {
+		callstatic_user_call->function_name = STR_COPY(method_name);
+	}
 
 	return (zend_function *)callstatic_user_call;
 }
@@ -1174,48 +1181,48 @@ static inline union _zend_function *zend_get_user_callstatic_function(zend_class
 
 /* This is not (yet?) in the API, but it belongs in the built-in objects callbacks */
 
-ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, const char *function_name_strval, int function_name_strlen, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name, const zval *key TSRMLS_DC) /* {{{ */
 {
 	zend_function *fbc = NULL;
-	char *lc_class_name, *lc_function_name = NULL;
-	ulong hash_value;
-	ALLOCA_FLAG(use_heap)
+	char *lc_class_name;
+	zend_string *lc_function_name;
 
 	if (EXPECTED(key != NULL)) {
-		lc_function_name = Z_STRVAL(key->constant);
-		hash_value = key->hash_value;
+		lc_function_name = Z_STR_P(key);
 	} else {
-		lc_function_name = do_alloca(function_name_strlen+1, use_heap);
-		/* Create a zend_copy_str_tolower(dest, src, src_length); */
-		zend_str_tolower_copy(lc_function_name, function_name_strval, function_name_strlen);
-		hash_value = zend_hash_func(lc_function_name, function_name_strlen+1);
+		lc_function_name = STR_ALLOC(function_name->len, 0);
+		zend_str_tolower_copy(lc_function_name->val, function_name->val, function_name->len);
 	}
 
-	if (function_name_strlen == ce->name_length && ce->constructor) {
-		lc_class_name = zend_str_tolower_dup(ce->name, ce->name_length);
+	if (function_name->len == ce->name->len && ce->constructor) {
+		lc_class_name = zend_str_tolower_dup(ce->name->val, ce->name->len);
 		/* Only change the method to the constructor if the constructor isn't called __construct
 		 * we check for __ so we can be binary safe for lowering, we should use ZEND_CONSTRUCTOR_FUNC_NAME
 		 */
-		if (!memcmp(lc_class_name, lc_function_name, function_name_strlen) && memcmp(ce->constructor->common.function_name, "__", sizeof("__") - 1)) {
+		if (!memcmp(lc_class_name, lc_function_name->val, function_name->len) && memcmp(ce->constructor->common.function_name->val, "__", sizeof("__") - 1)) {
 			fbc = ce->constructor;
 		}
 		efree(lc_class_name);
 	}
-	if (EXPECTED(!fbc) &&
-	    UNEXPECTED(zend_hash_quick_find(&ce->function_table, lc_function_name, function_name_strlen+1, hash_value, (void **) &fbc)==FAILURE)) {
-		if (UNEXPECTED(!key)) {
-			free_alloca(lc_function_name, use_heap);
-		}
 
-		if (ce->__call &&
-		    EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
-			return zend_get_user_call_function(ce, function_name_strval, function_name_strlen);
-		} else if (ce->__callstatic) {
-			return zend_get_user_callstatic_function(ce, function_name_strval, function_name_strlen);
+	if (EXPECTED(!fbc)) {
+		zval *func = zend_hash_find(&ce->function_table, lc_function_name);
+		if (EXPECTED(func != NULL)) {
+			fbc = Z_FUNC_P(func);
 		} else {
-	   		return NULL;
+			if (UNEXPECTED(!key)) {
+				STR_FREE(lc_function_name);
+			}
+			if (ce->__call &&
+			    Z_OBJ(EG(This)) &&
+			    Z_OBJ_HT(EG(This))->get_class_entry &&
+			    instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
+				return zend_get_user_call_function(ce, function_name);
+			} else if (ce->__callstatic) {
+				return zend_get_user_callstatic_function(ce, function_name);
+			} else {
+	   			return NULL;
+			}
 		}
 	}
 
@@ -1223,7 +1230,7 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, const c
 	/* right now this function is used for non static method lookup too */
 	/* Is the function static */
 	if (UNEXPECTED(!(fbc->common.fn_flags & ZEND_ACC_STATIC))) {
-		zend_error_noreturn(E_ERROR, "Cannot call non static method %s::%s() without object", ZEND_FN_SCOPE_NAME(fbc), fbc->common.function_name);
+		zend_error_noreturn(E_ERROR, "Cannot call non static method %s::%s() without object", ZEND_FN_SCOPE_NAME(fbc), fbc->common.function_name->val);
 	}
 #endif
 	if (fbc->op_array.fn_flags & ZEND_ACC_PUBLIC) {
@@ -1233,14 +1240,14 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, const c
 
 		/* Ensure that if we're calling a private function, we're allowed to do so.
 		 */
-		updated_fbc = zend_check_private_int(fbc, EG(scope), lc_function_name, function_name_strlen, hash_value TSRMLS_CC);
+		updated_fbc = zend_check_private_int(fbc, EG(scope), lc_function_name TSRMLS_CC);
 		if (EXPECTED(updated_fbc != NULL)) {
 			fbc = updated_fbc;
 		} else {
 			if (ce->__callstatic) {
-				fbc = zend_get_user_callstatic_function(ce, function_name_strval, function_name_strlen);
+				fbc = zend_get_user_callstatic_function(ce, function_name);
 			} else {
-				zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), function_name_strval, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), function_name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	} else if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
@@ -1248,70 +1255,60 @@ ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, const c
 		 */
 		if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), EG(scope)))) {
 			if (ce->__callstatic) {
-				fbc = zend_get_user_callstatic_function(ce, function_name_strval, function_name_strlen);
+				fbc = zend_get_user_callstatic_function(ce, function_name);
 			} else {
-				zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), function_name_strval, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), function_name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (UNEXPECTED(!key)) {
-		free_alloca(lc_function_name, use_heap);
+		STR_FREE(lc_function_name);
 	}
 
 	return fbc;
 }
 /* }}} */
 
-ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, zend_bool silent, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	zend_property_info *property_info;
-	ulong hash_value;
 
-	if (UNEXPECTED(!key) ||
-	    (property_info = CACHED_POLYMORPHIC_PTR(key->cache_slot, ce)) == NULL) {
-		if (EXPECTED(key != NULL)) {
-			hash_value = key->hash_value;
-		} else {
-			hash_value = zend_hash_func(property_name, property_name_len+1);
-		}
+	if (UNEXPECTED(cache_slot == -1) ||
+	    (property_info = CACHED_POLYMORPHIC_PTR_EX(EG(active_op_array), cache_slot, ce)) == NULL) {
 
-		if (UNEXPECTED(zend_hash_quick_find(&ce->properties_info, property_name, property_name_len+1, hash_value, (void **) &property_info)==FAILURE)) {
+		if (UNEXPECTED((property_info = zend_hash_find_ptr(&ce->properties_info, property_name)) == NULL)) {
 			if (!silent) {
-				zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name, property_name);
+				zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, property_name->val);
 			}
 			return NULL;
 		}
 
-#if DEBUG_OBJECT_HANDLERS
-		zend_printf("Access type for %s::%s is %s\n", ce->name, property_name, zend_visibility_string(property_info->flags));
-#endif
-
 		if (UNEXPECTED(!zend_verify_property_access(property_info, ce TSRMLS_CC))) {
 			if (!silent) {
-				zend_error_noreturn(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name, property_name);
+				zend_error_noreturn(E_ERROR, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ce->name->val, property_name->val);
 			}
 			return NULL;
 		}
 
 		if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0)) {
 			if (!silent) {
-				zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name, property_name);
+				zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, property_name->val);
 			}
 			return NULL;
 		}
 
 		zend_update_class_constants(ce TSRMLS_CC);
 
-		if (EXPECTED(key != NULL)) {
-			CACHE_POLYMORPHIC_PTR(key->cache_slot, ce, property_info);
+		if (EXPECTED(cache_slot != -1)) {
+			CACHE_POLYMORPHIC_PTR_EX(EG(active_op_array), cache_slot, ce, property_info);
 		}
 	}
 
 	if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL) ||
-	    UNEXPECTED(CE_STATIC_MEMBERS(ce)[property_info->offset] == NULL)) {
+	    UNEXPECTED(Z_TYPE(CE_STATIC_MEMBERS(ce)[property_info->offset]) == IS_UNDEF)) {
 		if (!silent) {
-			zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name, property_name);
+			zend_error_noreturn(E_ERROR, "Access to undeclared static property: %s::$%s", ce->name->val, property_name->val);
 		}
 		return NULL;
 	}
@@ -1320,16 +1317,15 @@ ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, const char *p
 }
 /* }}} */
 
-ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, const zend_literal *key TSRMLS_DC) /* {{{ */
+ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
-	zend_error_noreturn(E_ERROR, "Attempt to unset static property %s::$%s", ce->name, property_name);
+	zend_error_noreturn(E_ERROR, "Attempt to unset static property %s::$%s", ce->name->val, property_name->val);
 	return 0;
 }
 /* }}} */
 
-ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC) /* {{{ */
+ZEND_API union _zend_function *zend_std_get_constructor(zend_object *zobj TSRMLS_DC) /* {{{ */
 {
-	zend_object *zobj = Z_OBJ_P(object);
 	zend_function *constructor = zobj->ce->constructor;
 
 	if (constructor) {
@@ -1340,9 +1336,9 @@ ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC)
 			 */
 			if (UNEXPECTED(constructor->common.scope != EG(scope))) {
 				if (EG(scope)) {
-					zend_error_noreturn(E_ERROR, "Call to private %s::%s() from context '%s'", constructor->common.scope->name, constructor->common.function_name, EG(scope)->name);
+					zend_error_noreturn(E_ERROR, "Call to private %s::%s() from context '%s'", constructor->common.scope->name->val, constructor->common.function_name->val, EG(scope)->name->val);
 				} else {
-					zend_error_noreturn(E_ERROR, "Call to private %s::%s() from invalid context", constructor->common.scope->name, constructor->common.function_name);
+					zend_error_noreturn(E_ERROR, "Call to private %s::%s() from invalid context", constructor->common.scope->name->val, constructor->common.function_name->val);
 				}
 			}
 		} else if ((constructor->common.fn_flags & ZEND_ACC_PROTECTED)) {
@@ -1352,9 +1348,9 @@ ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC)
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(constructor), EG(scope)))) {
 				if (EG(scope)) {
-					zend_error_noreturn(E_ERROR, "Call to protected %s::%s() from context '%s'", constructor->common.scope->name, constructor->common.function_name, EG(scope)->name);
+					zend_error_noreturn(E_ERROR, "Call to protected %s::%s() from context '%s'", constructor->common.scope->name->val, constructor->common.function_name->val, EG(scope)->name->val);
 				} else {
-					zend_error_noreturn(E_ERROR, "Call to protected %s::%s() from invalid context", constructor->common.scope->name, constructor->common.function_name);
+					zend_error_noreturn(E_ERROR, "Call to protected %s::%s() from invalid context", constructor->common.scope->name->val, constructor->common.function_name->val);
 				}
 			}
 		}
@@ -1382,11 +1378,13 @@ static int zend_std_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 		Z_OBJ_PROTECT_RECURSION(o1);
 		Z_OBJ_PROTECT_RECURSION(o2);
 		for (i = 0; i < zobj1->ce->default_properties_count; i++) {
-			if (zobj1->properties_table[i]) {
-				if (zobj2->properties_table[i]) {
+			if (Z_TYPE(zobj1->properties_table[i]) != IS_UNDEF) {
+				if (Z_TYPE(zobj2->properties_table[i]) != IS_UNDEF) {
 					zval result;
+					zval *p1 = &zobj1->properties_table[i];
+					zval *p2 = &zobj2->properties_table[i];
 
-					if (compare_function(&result, zobj1->properties_table[i], zobj2->properties_table[i] TSRMLS_CC)==FAILURE) {
+					if (compare_function(&result, p1, p2 TSRMLS_CC)==FAILURE) {
 						Z_OBJ_UNPROTECT_RECURSION(o1);
 						Z_OBJ_UNPROTECT_RECURSION(o2);
 						return 1;
@@ -1402,7 +1400,7 @@ static int zend_std_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 					return 1;
 				}
 			} else {
-				if (zobj2->properties_table[i]) {
+				if (Z_TYPE(zobj2->properties_table[i]) != IS_UNDEF) {
 					Z_OBJ_UNPROTECT_RECURSION(o1);
 					Z_OBJ_UNPROTECT_RECURSION(o2);
 					return 1;
@@ -1424,67 +1422,75 @@ static int zend_std_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int zend_std_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int zend_std_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	zend_object *zobj;
 	int result;
-	zval **value = NULL;
-	zval *tmp_member = NULL;
+	zval *value = NULL;
+	zval tmp_member;
 	zend_property_info *property_info;
 
 	zobj = Z_OBJ_P(object);
 
+	ZVAL_UNDEF(&tmp_member);
 	if (UNEXPECTED(Z_TYPE_P(member) != IS_STRING)) {
-		ALLOC_ZVAL(tmp_member);
-		*tmp_member = *member;
-		INIT_PZVAL(tmp_member);
-		zval_copy_ctor(tmp_member);
-		convert_to_string(tmp_member);
-		member = tmp_member;
-		key = NULL;
+		ZVAL_DUP(&tmp_member, member);
+		convert_to_string(&tmp_member);
+		member = &tmp_member;
+		cache_slot = -1;
 	}
 
-#if DEBUG_OBJECT_HANDLERS
-	fprintf(stderr, "Read object #%d property: %s\n", Z_OBJ_HANDLE_P(object), Z_STRVAL_P(member));
-#endif
+	property_info = zend_get_property_info_quick(zobj->ce, Z_STR_P(member), 1, cache_slot TSRMLS_CC);
+
+	if (EXPECTED(property_info != NULL)) {
+		if (EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
+		    property_info->offset >= 0) {
+			value = &zobj->properties_table[property_info->offset];
+			if (Z_TYPE_P(value) != IS_UNDEF) {
+				goto found;
+			}
+		} else if (UNEXPECTED(zobj->properties != NULL) &&
+		           (value = zend_hash_find(zobj->properties, property_info->name)) != NULL) {
+found:
+			switch (has_set_exists) {
+				case 0:
+					result = (Z_TYPE_P(value) != IS_NULL);
+					break;
+				default:
+					result = zend_is_true(value TSRMLS_CC);
+					break;
+				case 2:
+					result = 1;
+					break;
+			}
+			goto exit;
+		}
+	}
+
+	result = 0;
+	if ((has_set_exists != 2) && zobj->ce->__isset) {
+		long *guard = zend_get_property_guard(zobj, property_info, member);
 
-	property_info = zend_get_property_info_quick(zobj->ce, member, 1, key TSRMLS_CC);
-
-	if (UNEXPECTED(!property_info) ||
-	    ((EXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0) &&
-	     property_info->offset >= 0) ?
-	        (zobj->properties ?
-	            ((value = (zval**)zobj->properties_table[property_info->offset]) == NULL) :
-	            (*(value = &zobj->properties_table[property_info->offset]) == NULL)) :
-	        (UNEXPECTED(!zobj->properties) ||
-	          UNEXPECTED(zend_hash_quick_find(zobj->properties, property_info->name, property_info->name_length+1, property_info->h, (void **) &value) == FAILURE)))) {
-		zend_guard *guard;
-
-		result = 0;
-		if ((has_set_exists != 2) &&
-		    zobj->ce->__isset &&
-		    zend_get_property_guard(zobj, property_info, member, &guard) == SUCCESS &&
-		    !guard->in_isset) {
-			zval *rv;
+		if (!((*guard) & IN_ISSET)) {
+			zval rv;
+			zval tmp_object;
 
 			/* have issetter - try with it! */
-			Z_ADDREF_P(object);
-			if (PZVAL_IS_REF(object)) {
-				SEPARATE_ZVAL(&object);
-			}
-			guard->in_isset = 1; /* prevent circular getting */
-			rv = zend_std_call_issetter(object, member TSRMLS_CC);
-			if (rv) {
-				result = zend_is_true(rv TSRMLS_CC);
+			ZVAL_COPY(&tmp_object, object);
+			(*guard) |= IN_ISSET; /* prevent circular getting */
+			ZVAL_UNDEF(&rv);
+			zend_std_call_issetter(&tmp_object, member, &rv TSRMLS_CC);
+			if (Z_TYPE(rv) != IS_UNDEF) {
+				result = zend_is_true(&rv TSRMLS_CC);
 				zval_ptr_dtor(&rv);
 				if (has_set_exists && result) {
-					if (EXPECTED(!EG(exception)) && zobj->ce->__get && !guard->in_get) {
-						guard->in_get = 1;
-						rv = zend_std_call_getter(object, member TSRMLS_CC);
-						guard->in_get = 0;
-						if (rv) {
-							Z_ADDREF_P(rv);
-							result = i_zend_is_true(rv TSRMLS_CC);
+					if (EXPECTED(!EG(exception)) && zobj->ce->__get && !((*guard) & IN_GET)) {
+						(*guard) |= IN_GET;
+						ZVAL_UNDEF(&rv);
+						zend_std_call_getter(&tmp_object, member, &rv TSRMLS_CC);
+						(*guard) &= ~IN_GET;
+						if (Z_TYPE(rv) != IS_UNDEF) {
+							result = i_zend_is_true(&rv TSRMLS_CC);
 							zval_ptr_dtor(&rv);
 						} else {
 							result = 0;
@@ -1494,108 +1500,82 @@ static int zend_std_has_property(zval *object, zval *member, int has_set_exists,
 					}
 				}
 			}
-			guard->in_isset = 0;
-			zval_ptr_dtor(&object);
-		}
-	} else {
-		switch (has_set_exists) {
-		case 0:
-			result = (Z_TYPE_PP(value) != IS_NULL);
-			break;
-		default:
-			result = zend_is_true(*value TSRMLS_CC);
-			break;
-		case 2:
-			result = 1;
-			break;
+			(*guard) &= ~IN_ISSET;
+			zval_ptr_dtor(&tmp_object);
 		}
 	}
 
-	if (UNEXPECTED(tmp_member != NULL)) {
+exit:
+	if (UNEXPECTED(Z_TYPE(tmp_member) != IS_UNDEF)) {
 		zval_ptr_dtor(&tmp_member);
 	}
 	return result;
 }
 /* }}} */
 
-zend_class_entry *zend_std_object_get_class(const zval *object TSRMLS_DC) /* {{{ */
+zend_class_entry *zend_std_object_get_class(const zend_object *object TSRMLS_DC) /* {{{ */
 {
-	zend_object *zobj;
-	zobj = Z_OBJ_P(object);
-
-	return zobj->ce;
+	return object->ce;
 }
 /* }}} */
 
-int zend_std_object_get_class_name(const zval *object, const char **class_name, zend_uint *class_name_len, int parent TSRMLS_DC) /* {{{ */
+zend_string* zend_std_object_get_class_name(const zend_object *zobj, int parent TSRMLS_DC) /* {{{ */
 {
-	zend_object *zobj;
 	zend_class_entry *ce;
-	zobj = Z_OBJ_P(object);
 
 	if (parent) {
 		if (!zobj->ce->parent) {
-			return FAILURE;
+			return NULL;
 		}
 		ce = zobj->ce->parent;
 	} else {
 		ce = zobj->ce;
 	}
 
-	*class_name_len = ce->name_length;
-	*class_name = estrndup(ce->name, ce->name_length);
-	return SUCCESS;
+	return STR_COPY(ce->name);
 }
 /* }}} */
 
 ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type TSRMLS_DC) /* {{{ */
 {
-	zval *retval;
+	zval retval;
 	zend_class_entry *ce;
 
 	switch (type) {
 		case IS_STRING:
+			ZVAL_UNDEF(&retval);
 			ce = Z_OBJCE_P(readobj);
 			if (ce->__tostring &&
-				(zend_call_method_with_0_params(&readobj, ce, &ce->__tostring, "__tostring", &retval) || EG(exception))) {
+				(zend_call_method_with_0_params(readobj, ce, &ce->__tostring, "__tostring", &retval) || EG(exception))) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (retval) {
-						zval_ptr_dtor(&retval);
-					}
+					zval_ptr_dtor(&retval);
 					EG(exception) = NULL;
-					zend_error_noreturn(E_ERROR, "Method %s::__toString() must not throw an exception", ce->name);
+					zend_error_noreturn(E_ERROR, "Method %s::__toString() must not throw an exception", ce->name->val);
 					return FAILURE;
 				}
-				if (EXPECTED(Z_TYPE_P(retval) == IS_STRING)) {
-					INIT_PZVAL(writeobj);
+				if (EXPECTED(Z_TYPE(retval) == IS_STRING)) {
 					if (readobj == writeobj) {
-						zval_dtor(readobj);
-					}
-					ZVAL_ZVAL(writeobj, retval, 1, 1);
-					if (Z_TYPE_P(writeobj) != type) {
-						convert_to_explicit_type(writeobj, type);
+						zval_ptr_dtor(readobj);
 					}
+					ZVAL_COPY_VALUE(writeobj, &retval);
 					return SUCCESS;
 				} else {
 					zval_ptr_dtor(&retval);
-					INIT_PZVAL(writeobj);
 					if (readobj == writeobj) {
-						zval_dtor(readobj);
+						zval_ptr_dtor(readobj);
 					}
 					ZVAL_EMPTY_STRING(writeobj);
-					zend_error(E_RECOVERABLE_ERROR, "Method %s::__toString() must return a string value", ce->name);
+					zend_error(E_RECOVERABLE_ERROR, "Method %s::__toString() must return a string value", ce->name->val);
 					return SUCCESS;
 				}
 			}
 			return FAILURE;
 		case IS_BOOL:
-			INIT_PZVAL(writeobj);
 			ZVAL_BOOL(writeobj, 1);
 			return SUCCESS;
 		case IS_LONG:
 			ce = Z_OBJCE_P(readobj);
-			zend_error(E_NOTICE, "Object of class %s could not be converted to int", ce->name);
-			INIT_PZVAL(writeobj);
+			zend_error(E_NOTICE, "Object of class %s could not be converted to int", ce->name->val);
 			if (readobj == writeobj) {
 				zval_dtor(readobj);
 			}
@@ -1603,43 +1583,44 @@ ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int ty
 			return SUCCESS;
 		case IS_DOUBLE:
 			ce = Z_OBJCE_P(readobj);
-			zend_error(E_NOTICE, "Object of class %s could not be converted to double", ce->name);
-			INIT_PZVAL(writeobj);
+			zend_error(E_NOTICE, "Object of class %s could not be converted to double", ce->name->val);
 			if (readobj == writeobj) {
 				zval_dtor(readobj);
 			}
 			ZVAL_DOUBLE(writeobj, 1);
 			return SUCCESS;
 		default:
-			INIT_PZVAL(writeobj);
-			Z_TYPE_P(writeobj) = IS_NULL;
+			ZVAL_NULL(writeobj);
 			break;
 	}
 	return FAILURE;
 }
 /* }}} */
 
-int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC) /* {{{ */
+int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC) /* {{{ */
 {
+	zval *func;
 	zend_class_entry *ce;
+
 	if (Z_TYPE_P(obj) != IS_OBJECT) {
 		return FAILURE;
 	}
 
 	ce = Z_OBJCE_P(obj);
 
-	if (zend_hash_find(&ce->function_table, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME), (void**)fptr_ptr) == FAILURE) {
+	if ((func = zend_hash_str_find(&ce->function_table, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1)) == NULL) {
 		return FAILURE;
 	}
+	*fptr_ptr = Z_FUNC_P(func);
 
 	*ce_ptr = ce;
 	if ((*fptr_ptr)->common.fn_flags & ZEND_ACC_STATIC) {
-		if (zobj_ptr) {
-			*zobj_ptr = NULL;
+		if (obj_ptr) {
+			*obj_ptr = NULL;
 		}
 	} else {
-		if (zobj_ptr) {
-			*zobj_ptr = obj;
+		if (obj_ptr) {
+			*obj_ptr = Z_OBJ_P(obj);
 		}
 	}
 	return SUCCESS;
@@ -1647,8 +1628,10 @@ int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **f
 /* }}} */
 
 ZEND_API zend_object_handlers std_object_handlers = {
-	zend_objects_store_add_ref,				/* add_ref */
-	zend_objects_store_del_ref,				/* del_ref */
+	0,										/* offset */
+
+	zend_object_std_dtor,					/* free_obj */
+	zend_objects_destroy_object,			/* dtor_obj */
 	zend_objects_clone_obj,					/* clone_obj */
 
 	zend_std_read_property,					/* read_property */
diff --git a/Zend/zend_object_handlers.h b/Zend/zend_object_handlers.h
index 14418b9bf2..1b6c85b8c5 100644
--- a/Zend/zend_object_handlers.h
+++ b/Zend/zend_object_handlers.h
@@ -24,17 +24,16 @@
 
 union _zend_function;
 struct _zend_property_info;
-struct _zend_literal;
 
 /* The following rule applies to read_property() and read_dimension() implementations:
    If you return a zval which is not otherwise referenced by the extension or the engine's
    symbol table, its reference count should be 0.
 */
 /* Used to fetch property from the object, read-only */
-typedef zval *(*zend_object_read_property_t)(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC);
+typedef zval *(*zend_object_read_property_t)(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC);
 
 /* Used to fetch dimension from the object, read-only */
-typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int type TSRMLS_DC);
+typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int type, zval *rv TSRMLS_DC);
 
 
 /* The following rule applies to write_property() and write_dimension() implementations:
@@ -43,23 +42,23 @@ typedef zval *(*zend_object_read_dimension_t)(zval *object, zval *offset, int ty
    any changes.  You should NOT modify the reference count of the value passed to you.
 */
 /* Used to set property of the object */
-typedef void (*zend_object_write_property_t)(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC);
+typedef void (*zend_object_write_property_t)(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to set dimension of the object */
 typedef void (*zend_object_write_dimension_t)(zval *object, zval *offset, zval *value TSRMLS_DC);
 
 
 /* Used to create pointer to the property of the object, for future direct r/w access */
-typedef zval **(*zend_object_get_property_ptr_ptr_t)(zval *object, zval *member, int type, const struct _zend_literal *key TSRMLS_DC);
+typedef zval *(*zend_object_get_property_ptr_ptr_t)(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to set object value. Can be used to override assignments and scalar
    write ops (like ++, +=) on the object */
-typedef void (*zend_object_set_t)(zval **object, zval *value TSRMLS_DC);
+typedef void (*zend_object_set_t)(zval *object, zval *value TSRMLS_DC);
 
 /* Used to get object value. Can be used when converting object value to
  * one of the basic types and when using scalar ops (like ++, +=) on the object
  */
-typedef zval* (*zend_object_get_t)(zval *object TSRMLS_DC);
+typedef zval* (*zend_object_get_t)(zval *object, zval *rv TSRMLS_DC);
 
 /* Used to check if a property of the object exists */
 /* param has_set_exists:
@@ -67,13 +66,13 @@ typedef zval* (*zend_object_get_t)(zval *object TSRMLS_DC);
  * 1 (set) whether property exists and is true
  * 2 (exists) whether property exists
  */
-typedef int (*zend_object_has_property_t)(zval *object, zval *member, int has_set_exists, const struct _zend_literal *key TSRMLS_DC);
+typedef int (*zend_object_has_property_t)(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to check if a dimension of the object exists */
 typedef int (*zend_object_has_dimension_t)(zval *object, zval *member, int check_empty TSRMLS_DC);
 
 /* Used to remove a property of the object */
-typedef void (*zend_object_unset_property_t)(zval *object, zval *member, const struct _zend_literal *key TSRMLS_DC);
+typedef void (*zend_object_unset_property_t)(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC);
 
 /* Used to remove a dimension of the object */
 typedef void (*zend_object_unset_dimension_t)(zval *object, zval *offset TSRMLS_DC);
@@ -87,18 +86,17 @@ typedef HashTable *(*zend_object_get_debug_info_t)(zval *object, int *is_temp TS
 /* args on stack! */
 /* Andi - EX(fbc) (function being called) needs to be initialized already in the INIT fcall opcode so that the parameters can be parsed the right way. We need to add another callback for this.
  */
-typedef int (*zend_object_call_method_t)(const char *method, INTERNAL_FUNCTION_PARAMETERS);
-typedef union _zend_function *(*zend_object_get_method_t)(zval **object_ptr, char *method, int method_len, const struct _zend_literal *key TSRMLS_DC);
-typedef union _zend_function *(*zend_object_get_constructor_t)(zval *object TSRMLS_DC);
+typedef int (*zend_object_call_method_t)(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS);
+typedef union _zend_function *(*zend_object_get_method_t)(zend_object **object, zend_string *method, const zval *key TSRMLS_DC);
+typedef union _zend_function *(*zend_object_get_constructor_t)(zend_object *object TSRMLS_DC);
 
 /* Object maintenance/destruction */
-typedef void (*zend_object_add_ref_t)(zval *object TSRMLS_DC);
-typedef void (*zend_object_del_ref_t)(zval *object TSRMLS_DC);
-typedef void (*zend_object_delete_obj_t)(zval *object TSRMLS_DC);
-typedef zend_object_value (*zend_object_clone_obj_t)(zval *object TSRMLS_DC);
+typedef void (*zend_object_dtor_obj_t)(zend_object *object TSRMLS_DC);
+typedef void (*zend_object_free_obj_t)(zend_object *object TSRMLS_DC);
+typedef zend_object* (*zend_object_clone_obj_t)(zval *object TSRMLS_DC);
 
-typedef zend_class_entry *(*zend_object_get_class_entry_t)(const zval *object TSRMLS_DC);
-typedef int (*zend_object_get_class_name_t)(const zval *object, const char **class_name, zend_uint *class_name_len, int parent TSRMLS_DC);
+typedef zend_class_entry *(*zend_object_get_class_entry_t)(const zend_object *object TSRMLS_DC);
+typedef zend_string *(*zend_object_get_class_name_t)(const zend_object *object, int parent TSRMLS_DC);
 typedef int (*zend_object_compare_t)(zval *object1, zval *object2 TSRMLS_DC);
 typedef int (*zend_object_compare_zvals_t)(zval *resul, zval *op1, zval *op2 TSRMLS_DC);
 
@@ -110,16 +108,18 @@ typedef int (*zend_object_cast_t)(zval *readobj, zval *retval, int type TSRMLS_D
  * Returns FAILURE if the object does not have any sense of overloaded dimensions */
 typedef int (*zend_object_count_elements_t)(zval *object, long *count TSRMLS_DC);
 
-typedef int (*zend_object_get_closure_t)(zval *obj, zend_class_entry **ce_ptr, union _zend_function **fptr_ptr, zval **zobj_ptr TSRMLS_DC);
+typedef int (*zend_object_get_closure_t)(zval *obj, zend_class_entry **ce_ptr, union _zend_function **fptr_ptr, zend_object **obj_ptr TSRMLS_DC);
 
-typedef HashTable *(*zend_object_get_gc_t)(zval *object, zval ***table, int *n TSRMLS_DC);
+typedef HashTable *(*zend_object_get_gc_t)(zval *object, zval **table, int *n TSRMLS_DC);
 
 typedef int (*zend_object_do_operation_t)(zend_uchar opcode, zval *result, zval *op1, zval *op2 TSRMLS_DC);
 
 struct _zend_object_handlers {
+	/* offset of real object header (usually zero) */
+	int										offset;
 	/* general object functions */
-	zend_object_add_ref_t					add_ref;
-	zend_object_del_ref_t					del_ref;
+	zend_object_free_obj_t					free_obj;
+	zend_object_dtor_obj_t					dtor_obj;
 	zend_object_clone_obj_t					clone_obj;
 	/* individual object functions */
 	zend_object_read_property_t				read_property;
@@ -155,26 +155,26 @@ extern ZEND_API zend_object_handlers std_object_handlers;
 	((fbc)->common.prototype ? (fbc)->common.prototype->common.scope : (fbc)->common.scope)
 
 BEGIN_EXTERN_C()
-ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, const char *function_name_strval, int function_name_strlen, const struct _zend_literal *key TSRMLS_DC);
-ZEND_API zval **zend_std_get_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, zend_bool silent, const struct _zend_literal *key TSRMLS_DC);
-ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, const char *property_name, int property_name_len, const struct _zend_literal *key TSRMLS_DC);
-ZEND_API union _zend_function *zend_std_get_constructor(zval *object TSRMLS_DC);
+ZEND_API union _zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name_strval, const zval *key TSRMLS_DC);
+ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent, zend_uint cache_slot TSRMLS_DC);
+ZEND_API zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name, zend_uint cache_slot TSRMLS_DC);
+ZEND_API union _zend_function *zend_std_get_constructor(zend_object *object TSRMLS_DC);
 ZEND_API struct _zend_property_info *zend_get_property_info(zend_class_entry *ce, zval *member, int silent TSRMLS_DC);
 ZEND_API HashTable *zend_std_get_properties(zval *object TSRMLS_DC);
 ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp TSRMLS_DC);
 ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type TSRMLS_DC);
-ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, const struct _zend_literal *key TSRMLS_DC);
+ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
 ZEND_API void rebuild_object_properties(zend_object *zobj);
 
 
 #define IS_ZEND_STD_OBJECT(z)  (Z_TYPE(z) == IS_OBJECT && (Z_OBJ_HT((z))->get_class_entry != NULL))
 #define HAS_CLASS_ENTRY(z) (Z_OBJ_HT(z)->get_class_entry != NULL)
 
-ZEND_API int zend_check_private(union _zend_function *fbc, zend_class_entry *ce, char *function_name_strval, int function_name_strlen TSRMLS_DC);
+ZEND_API int zend_check_private(union _zend_function *fbc, zend_class_entry *ce, zend_string *function_name TSRMLS_DC);
 
 ZEND_API int zend_check_protected(zend_class_entry *ce, zend_class_entry *scope);
 
-ZEND_API int zend_check_property_access(zend_object *zobj, const char *prop_info_name, int prop_info_name_len TSRMLS_DC);
+ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_info_name TSRMLS_DC);
 
 ZEND_API void zend_std_call_user_call(INTERNAL_FUNCTION_PARAMETERS);
 END_EXTERN_C()
diff --git a/Zend/zend_objects.c b/Zend/zend_objects.c
index da3aab551d..1ef0e1d7e7 100644
--- a/Zend/zend_objects.c
+++ b/Zend/zend_objects.c
@@ -28,14 +28,27 @@
 
 ZEND_API void zend_object_std_init(zend_object *object, zend_class_entry *ce TSRMLS_DC)
 {
+	GC_REFCOUNT(object) = 1;
+	GC_TYPE_INFO(object) = IS_OBJECT;
 	object->ce = ce;
 	object->properties = NULL;
-	object->properties_table = NULL;
 	object->guards = NULL;
+	zend_objects_store_put(object TSRMLS_CC);
+	if (EXPECTED(ce->default_properties_count != 0)) {
+		zval *p = object->properties_table;
+		zval *end = p + ce->default_properties_count;
+
+		do {
+			ZVAL_UNDEF(p);
+			p++;
+		} while (p != end);
+	}
 }
 
 ZEND_API void zend_object_std_dtor(zend_object *object TSRMLS_DC)
 {
+	int i;
+
 	if (object->guards) {
 		zend_hash_destroy(object->guards);
 		FREE_HASHTABLE(object->guards);
@@ -43,29 +56,19 @@ ZEND_API void zend_object_std_dtor(zend_object *object TSRMLS_DC)
 	if (object->properties) {
 		zend_hash_destroy(object->properties);
 		FREE_HASHTABLE(object->properties);
-		if (object->properties_table) {
-			efree(object->properties_table);
-		}
-	} else if (object->properties_table) {
-		int i;
-
-		for (i = 0; i < object->ce->default_properties_count; i++) {
-			if (object->properties_table[i]) {
-				zval_ptr_dtor(&object->properties_table[i]);
-			}
-		}
-		efree(object->properties_table);
+	}
+	for (i = 0; i < object->ce->default_properties_count; i++) {
+		zval_ptr_dtor(&object->properties_table[i]);
 	}
 }
 
-ZEND_API void zend_objects_destroy_object(zend_object *object, zend_object_handle handle TSRMLS_DC)
+ZEND_API void zend_objects_destroy_object(zend_object *object TSRMLS_DC)
 {
 	zend_function *destructor = object ? object->ce->destructor : NULL;
 
 	if (destructor) {
-		zval *old_exception;
-		zval *obj;
-		zend_object_store_bucket *obj_bucket;
+		zend_object *old_exception;
+		zval obj;
 
 		if (destructor->op_array.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED)) {
 			if (destructor->op_array.fn_flags & ZEND_ACC_PRIVATE) {
@@ -76,8 +79,8 @@ ZEND_API void zend_objects_destroy_object(zend_object *object, zend_object_handl
 
 					zend_error(EG(in_execution) ? E_ERROR : E_WARNING,
 						"Call to private %s::__destruct() from context '%s'%s",
-						ce->name,
-						EG(scope) ? EG(scope)->name : "",
+						ce->name->val,
+						EG(scope) ? EG(scope)->name->val : "",
 						EG(in_execution) ? "" : " during shutdown ignored");
 					return;
 				}
@@ -89,23 +92,16 @@ ZEND_API void zend_objects_destroy_object(zend_object *object, zend_object_handl
 
 					zend_error(EG(in_execution) ? E_ERROR : E_WARNING,
 						"Call to protected %s::__destruct() from context '%s'%s",
-						ce->name,
-						EG(scope) ? EG(scope)->name : "",
+						ce->name->val,
+						EG(scope) ? EG(scope)->name->val : "",
 						EG(in_execution) ? "" : " during shutdown ignored");
 					return;
 				}
 			}
 		}
 
-		MAKE_STD_ZVAL(obj);
-		Z_TYPE_P(obj) = IS_OBJECT;
-		Z_OBJ_HANDLE_P(obj) = handle;
-		obj_bucket = &EG(objects_store).object_buckets[handle];
-		if (!obj_bucket->bucket.obj.handlers) {
-			obj_bucket->bucket.obj.handlers = &std_object_handlers;
-		}
-		Z_OBJ_HT_P(obj) = obj_bucket->bucket.obj.handlers;
-		zval_copy_ctor(obj);
+		ZVAL_OBJ(&obj, object);
+		Z_ADDREF(obj);
 
 		/* Make sure that destructors are protected from previously thrown exceptions.
 		 * For example, if an exception was thrown in a function and when the function's
@@ -113,7 +109,7 @@ ZEND_API void zend_objects_destroy_object(zend_object *object, zend_object_handl
 		 */
 		old_exception = NULL;
 		if (EG(exception)) {
-			if (Z_OBJ_HANDLE_P(EG(exception)) == handle) {
+			if (EG(exception) == object) {
 				zend_error(E_ERROR, "Attempt to destruct pending exception");
 			} else {
 				old_exception = EG(exception);
@@ -132,104 +128,73 @@ ZEND_API void zend_objects_destroy_object(zend_object *object, zend_object_handl
 	}
 }
 
-ZEND_API void zend_objects_free_object_storage(zend_object *object TSRMLS_DC)
+ZEND_API zend_object *zend_objects_new(zend_class_entry *ce TSRMLS_DC)
 {
-	zend_object_std_dtor(object TSRMLS_CC);
-	efree(object);
-}
+	zend_object *object = emalloc(sizeof(zend_object) + sizeof(zval) * (ce->default_properties_count - 1));
 
-ZEND_API zend_object_value zend_objects_new(zend_object **object, zend_class_entry *class_type TSRMLS_DC)
-{
-	zend_object_value retval;
-
-	*object = emalloc(sizeof(zend_object));
-	(*object)->ce = class_type;
-	(*object)->properties = NULL;
-	(*object)->properties_table = NULL;
-	(*object)->guards = NULL;
-	retval.handle = zend_objects_store_put(*object, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t) zend_objects_free_object_storage, NULL TSRMLS_CC);
-	retval.handlers = &std_object_handlers;
-	return retval;
-}
-
-ZEND_API zend_object *zend_objects_get_address(const zval *zobject TSRMLS_DC)
-{
-	return (zend_object *)zend_object_store_get_object(zobject TSRMLS_CC);
+	zend_object_std_init(object, ce TSRMLS_CC);
+	object->handlers = &std_object_handlers;
+	return object;
 }
 
-ZEND_API void zend_objects_clone_members(zend_object *new_object, zend_object_value new_obj_val, zend_object *old_object, zend_object_handle handle TSRMLS_DC)
+ZEND_API void zend_objects_clone_members(zend_object *new_object, zend_object *old_object TSRMLS_DC)
 {
 	int i;
 
-	if (old_object->properties_table) {
-		if (!new_object->properties_table) {
-			new_object->properties_table = emalloc(sizeof(zval*) * old_object->ce->default_properties_count);
-			memset(new_object->properties_table, 0, sizeof(zval*) * old_object->ce->default_properties_count);
-		}
+	if (old_object->ce->default_properties_count) {
 		for (i = 0; i < old_object->ce->default_properties_count; i++) {
-			if (!new_object->properties) {
-				if (new_object->properties_table[i]) {
-					zval_ptr_dtor(&new_object->properties_table[i]);
-				}
-			}
-			if (!old_object->properties) {
-				new_object->properties_table[i] = old_object->properties_table[i];
-				if (new_object->properties_table[i]) {
-					Z_ADDREF_P(new_object->properties_table[i]);
-				}
-			}
+			zval_ptr_dtor(&new_object->properties_table[i]);
+			ZVAL_COPY(&new_object->properties_table[i], &old_object->properties_table[i]);
 		}
 	}
 	if (old_object->properties) {
+		zval *prop, new_prop;
+		ulong num_key;
+		zend_string *key;
+
 		if (!new_object->properties) {
 			ALLOC_HASHTABLE(new_object->properties);
-			zend_hash_init(new_object->properties, 0, NULL, ZVAL_PTR_DTOR, 0);
+			zend_hash_init(new_object->properties, 8, NULL, ZVAL_PTR_DTOR, 0);
 		}
-		zend_hash_copy(new_object->properties, old_object->properties, (copy_ctor_func_t) zval_add_ref, (void *) NULL /* Not used anymore */, sizeof(zval *));
-		if (old_object->properties_table) {
-			HashPosition pos;
-			zend_property_info *prop_info;
-			for (zend_hash_internal_pointer_reset_ex(&old_object->ce->properties_info, &pos);
-			     zend_hash_get_current_data_ex(&old_object->ce->properties_info, (void**)&prop_info, &pos) == SUCCESS;
-			     zend_hash_move_forward_ex(&old_object->ce->properties_info, &pos)) {
-				if ((prop_info->flags & ZEND_ACC_STATIC) == 0) {
-					if (zend_hash_quick_find(new_object->properties, prop_info->name, prop_info->name_length+1, prop_info->h, (void**)&new_object->properties_table[prop_info->offset]) == FAILURE) {
-						new_object->properties_table[prop_info->offset] = NULL;
-					}
-				}
+
+		ZEND_HASH_FOREACH_KEY_VAL(old_object->properties, num_key, key, prop) {
+			if (Z_TYPE_P(prop) == IS_INDIRECT) {
+				ZVAL_INDIRECT(&new_prop, new_object->properties_table + (Z_INDIRECT_P(prop) - old_object->properties_table));
+			} else {
+				ZVAL_COPY_VALUE(&new_prop, prop);
+				zval_add_ref(&new_prop);
 			}
-		}
+			if (key) {
+				zend_hash_update(new_object->properties, key, &new_prop);
+			} else {
+				zend_hash_index_update(new_object->properties, num_key, &new_prop);
+			}
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	if (old_object->ce->clone) {
-		zval *new_obj;
-
-		MAKE_STD_ZVAL(new_obj);
-		new_obj->type = IS_OBJECT;
-		new_obj->value.obj = new_obj_val;
-		zval_copy_ctor(new_obj);
+		zval new_obj;
 
+		ZVAL_OBJ(&new_obj, new_object);
+		zval_copy_ctor(&new_obj);
 		zend_call_method_with_0_params(&new_obj, old_object->ce, &old_object->ce->clone, ZEND_CLONE_FUNC_NAME, NULL);
-
 		zval_ptr_dtor(&new_obj);
 	}
 }
 
-ZEND_API zend_object_value zend_objects_clone_obj(zval *zobject TSRMLS_DC)
+ZEND_API zend_object *zend_objects_clone_obj(zval *zobject TSRMLS_DC)
 {
-	zend_object_value new_obj_val;
 	zend_object *old_object;
 	zend_object *new_object;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
 
 	/* assume that create isn't overwritten, so when clone depends on the
 	 * overwritten one then it must itself be overwritten */
-	old_object = zend_objects_get_address(zobject TSRMLS_CC);
-	new_obj_val = zend_objects_new(&new_object, old_object->ce TSRMLS_CC);
+	old_object = Z_OBJ_P(zobject);
+	new_object = zend_objects_new(old_object->ce TSRMLS_CC);
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
-	return new_obj_val;
+	return new_object;
 }
 
 /*
diff --git a/Zend/zend_objects.h b/Zend/zend_objects.h
index d00c65a368..1521d9756b 100644
--- a/Zend/zend_objects.h
+++ b/Zend/zend_objects.h
@@ -27,12 +27,10 @@
 BEGIN_EXTERN_C()
 ZEND_API void zend_object_std_init(zend_object *object, zend_class_entry *ce TSRMLS_DC);
 ZEND_API void zend_object_std_dtor(zend_object *object TSRMLS_DC);
-ZEND_API zend_object_value zend_objects_new(zend_object **object, zend_class_entry *class_type TSRMLS_DC);
-ZEND_API void zend_objects_destroy_object(zend_object *object, zend_object_handle handle TSRMLS_DC);
-ZEND_API zend_object *zend_objects_get_address(const zval *object TSRMLS_DC);
-ZEND_API void zend_objects_clone_members(zend_object *new_object, zend_object_value new_obj_val, zend_object *old_object, zend_object_handle handle TSRMLS_DC);
-ZEND_API zend_object_value zend_objects_clone_obj(zval *object TSRMLS_DC);
-ZEND_API void zend_objects_free_object_storage(zend_object *object TSRMLS_DC);
+ZEND_API zend_object *zend_objects_new(zend_class_entry *ce TSRMLS_DC);
+ZEND_API void zend_objects_destroy_object(zend_object *object TSRMLS_DC);
+ZEND_API void zend_objects_clone_members(zend_object *new_object, zend_object *old_object TSRMLS_DC);
+ZEND_API zend_object *zend_objects_clone_obj(zval *object TSRMLS_DC);
 END_EXTERN_C()
 
 #endif /* ZEND_OBJECTS_H */
diff --git a/Zend/zend_objects_API.c b/Zend/zend_objects_API.c
index f7a6b0b4c3..bd6673c0bb 100644
--- a/Zend/zend_objects_API.c
+++ b/Zend/zend_objects_API.c
@@ -23,17 +23,15 @@
 #include "zend_globals.h"
 #include "zend_variables.h"
 #include "zend_API.h"
-#include "zend_objects_API.h"
-
-#define ZEND_DEBUG_OBJECTS 0
+#include "zend_objects_API.h"	
 
 ZEND_API void zend_objects_store_init(zend_objects_store *objects, zend_uint init_size)
 {
-	objects->object_buckets = (zend_object_store_bucket *) emalloc(init_size * sizeof(zend_object_store_bucket));
+	objects->object_buckets = (zend_object **) emalloc(init_size * sizeof(zend_object*));
 	objects->top = 1; /* Skip 0 so that handles are true */
 	objects->size = init_size;
 	objects->free_list_head = -1;
-	memset(&objects->object_buckets[0], 0, sizeof(zend_object_store_bucket));
+	memset(&objects->object_buckets[0], 0, sizeof(zend_object*));
 }
 
 ZEND_API void zend_objects_store_destroy(zend_objects_store *objects)
@@ -44,25 +42,17 @@ ZEND_API void zend_objects_store_destroy(zend_objects_store *objects)
 
 ZEND_API void zend_objects_store_call_destructors(zend_objects_store *objects TSRMLS_DC)
 {
-	zend_uint i = 1;
+	zend_uint i;
 
 	for (i = 1; i < objects->top ; i++) {
-		if (objects->object_buckets[i].valid) {
-			struct _store_object *obj = &objects->object_buckets[i].bucket.obj;
-
-			if (!objects->object_buckets[i].destructor_called) {
-				objects->object_buckets[i].destructor_called = 1;
-				if (obj->dtor && obj->object) {
-					obj->refcount++;
-					obj->dtor(obj->object, i TSRMLS_CC);
-					obj = &objects->object_buckets[i].bucket.obj;
-					obj->refcount--;
-
-					if (obj->refcount == 0) {
-						/* in case gc_collect_cycle is triggered before free_storage */
-						GC_REMOVE_ZOBJ_FROM_BUFFER(obj);
-					}
-				}
+		zend_object *obj = objects->object_buckets[i];
+
+		if (IS_OBJ_VALID(obj)) {
+			if (!(GC_FLAGS(obj) & IS_OBJ_DESTRUCTOR_CALLED)) {
+				GC_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
+				GC_REFCOUNT(obj)++;
+				obj->handlers->dtor_obj(obj TSRMLS_CC);
+				GC_REFCOUNT(obj)--;
 			}
 		}
 	}
@@ -76,27 +66,43 @@ ZEND_API void zend_objects_store_mark_destructed(zend_objects_store *objects TSR
 		return;
 	}
 	for (i = 1; i < objects->top ; i++) {
-		if (objects->object_buckets[i].valid) {
-			objects->object_buckets[i].destructor_called = 1;
+		zend_object *obj = objects->object_buckets[i];
+
+		if (IS_OBJ_VALID(obj)) {
+			GC_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
 		}
 	}
 }
 
 ZEND_API void zend_objects_store_free_object_storage(zend_objects_store *objects TSRMLS_DC)
 {
-	zend_uint i = 1;
+	zend_uint i;
 
+	/* Free object properties but don't free object their selves */
 	for (i = 1; i < objects->top ; i++) {
-		if (objects->object_buckets[i].valid) {
-			struct _store_object *obj = &objects->object_buckets[i].bucket.obj;
+		zend_object *obj = objects->object_buckets[i];
+
+		if (IS_OBJ_VALID(obj)) {
+			if (!(GC_FLAGS(obj) & IS_OBJ_FREE_CALLED)) {
+				GC_FLAGS(obj) |= IS_OBJ_FREE_CALLED;
+				if (obj->handlers->free_obj) {
+					GC_REFCOUNT(obj)++;
+					obj->handlers->free_obj(obj TSRMLS_CC);
+					GC_REFCOUNT(obj)--;
+				}
+			}
+		}
+	}
 
-			GC_REMOVE_ZOBJ_FROM_BUFFER(obj);
+	/* Now free objects theirselves */
+	for (i = 1; i < objects->top ; i++) {
+		zend_object *obj = objects->object_buckets[i];
 
-			objects->object_buckets[i].valid = 0;
-			if (obj->free_storage) {
-				obj->free_storage(obj->object TSRMLS_CC);
-			}
+		if (IS_OBJ_VALID(obj)) {
 			/* Not adding to free list as we are shutting down anyway */
+			void *ptr = ((char*)obj) - obj->handlers->offset;
+			GC_REMOVE_FROM_BUFFER(obj);
+			efree(ptr);
 		}
 	}
 }
@@ -104,188 +110,97 @@ ZEND_API void zend_objects_store_free_object_storage(zend_objects_store *objects
 
 /* Store objects API */
 
-ZEND_API zend_object_handle zend_objects_store_put(void *object, zend_objects_store_dtor_t dtor, zend_objects_free_object_storage_t free_storage, zend_objects_store_clone_t clone TSRMLS_DC)
+ZEND_API void zend_objects_store_put(zend_object *object TSRMLS_DC)
 {
-	zend_object_handle handle;
-	struct _store_object *obj;
+	int handle;
 
 	if (EG(objects_store).free_list_head != -1) {
 		handle = EG(objects_store).free_list_head;
-		EG(objects_store).free_list_head = EG(objects_store).object_buckets[handle].bucket.free_list.next;
+		EG(objects_store).free_list_head = GET_OBJ_BUCKET_NUMBER(EG(objects_store).object_buckets[handle]);
 	} else {
 		if (EG(objects_store).top == EG(objects_store).size) {
 			EG(objects_store).size <<= 1;
-			EG(objects_store).object_buckets = (zend_object_store_bucket *) erealloc(EG(objects_store).object_buckets, EG(objects_store).size * sizeof(zend_object_store_bucket));
+			EG(objects_store).object_buckets = (zend_object **) erealloc(EG(objects_store).object_buckets, EG(objects_store).size * sizeof(zend_object*));
 		}
 		handle = EG(objects_store).top++;
 	}
-	obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-	EG(objects_store).object_buckets[handle].destructor_called = 0;
-	EG(objects_store).object_buckets[handle].valid = 1;
-	EG(objects_store).object_buckets[handle].apply_count = 0;
-
-	obj->refcount = 1;
-	GC_OBJ_INIT(obj);
-	obj->object = object;
-	obj->dtor = dtor?dtor:(zend_objects_store_dtor_t)zend_objects_destroy_object;
-	obj->free_storage = free_storage;
-	obj->clone = clone;
-	obj->handlers = NULL;
-
-#if ZEND_DEBUG_OBJECTS
-	fprintf(stderr, "Allocated object id #%d\n", handle);
-#endif
-	return handle;
-}
-
-ZEND_API zend_uint zend_objects_store_get_refcount(zval *object TSRMLS_DC)
-{
-	zend_object_handle handle = Z_OBJ_HANDLE_P(object);
-
-	return EG(objects_store).object_buckets[handle].bucket.obj.refcount;
-}
-
-ZEND_API void zend_objects_store_add_ref(zval *object TSRMLS_DC)
-{
-	zend_object_handle handle = Z_OBJ_HANDLE_P(object);
-
-	EG(objects_store).object_buckets[handle].bucket.obj.refcount++;
-#if ZEND_DEBUG_OBJECTS
-	fprintf(stderr, "Increased refcount of object id #%d\n", handle);
-#endif
-}
-
-/*
- * Add a reference to an objects store entry given the object handle.
- */
-ZEND_API void zend_objects_store_add_ref_by_handle(zend_object_handle handle TSRMLS_DC)
-{
-	EG(objects_store).object_buckets[handle].bucket.obj.refcount++;
+	object->handle = handle;
+	EG(objects_store).object_buckets[handle] = object;
 }
 
-#define ZEND_OBJECTS_STORE_ADD_TO_FREE_LIST()																	\
-			EG(objects_store).object_buckets[handle].bucket.free_list.next = EG(objects_store).free_list_head;	\
-			EG(objects_store).free_list_head = handle;															\
-			EG(objects_store).object_buckets[handle].valid = 0;
+#define ZEND_OBJECTS_STORE_ADD_TO_FREE_LIST(handle)															\
+            SET_OBJ_BUCKET_NUMBER(EG(objects_store).object_buckets[handle], EG(objects_store).free_list_head);	\
+			EG(objects_store).free_list_head = handle;
 
-ZEND_API void zend_objects_store_del_ref(zval *zobject TSRMLS_DC)
+ZEND_API void zend_objects_store_free(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	zend_object_handle handle;
-
-	handle = Z_OBJ_HANDLE_P(zobject);
-
-	Z_ADDREF_P(zobject);
-	zend_objects_store_del_ref_by_handle_ex(handle, Z_OBJ_HT_P(zobject) TSRMLS_CC);
-	Z_DELREF_P(zobject);
+	zend_uint handle = object->handle;
+	void *ptr = ((char*)object) - object->handlers->offset;
 
-	GC_ZOBJ_CHECK_POSSIBLE_ROOT(zobject);
+	GC_REMOVE_FROM_BUFFER(object);
+	efree(ptr);
+	ZEND_OBJECTS_STORE_ADD_TO_FREE_LIST(handle);
 }
+/* }}} */
 
-/*
- * Delete a reference to an objects store entry given the object handle.
- */
-ZEND_API void zend_objects_store_del_ref_by_handle_ex(zend_object_handle handle, const zend_object_handlers *handlers TSRMLS_DC) /* {{{ */
+ZEND_API void zend_objects_store_del(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	struct _store_object *obj;
-	int failure = 0;
-
-	if (!EG(objects_store).object_buckets) {
-		return;
-	}
-
-	obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-
 	/*	Make sure we hold a reference count during the destructor call
 		otherwise, when the destructor ends the storage might be freed
 		when the refcount reaches 0 a second time
 	 */
-	if (EG(objects_store).object_buckets[handle].valid) {
-		if (obj->refcount == 1) {
-			if (!EG(objects_store).object_buckets[handle].destructor_called) {
-				EG(objects_store).object_buckets[handle].destructor_called = 1;
-
-				if (obj->dtor) {
-					if (handlers && !obj->handlers) {
-						obj->handlers = handlers;
-					}
+	if (EG(objects_store).object_buckets &&
+	    IS_OBJ_VALID(EG(objects_store).object_buckets[object->handle])) {
+		if (GC_REFCOUNT(object) == 0) {
+			int failure = 0;
+
+			if (!(GC_FLAGS(object) & IS_OBJ_DESTRUCTOR_CALLED)) {
+				GC_FLAGS(object) |= IS_OBJ_DESTRUCTOR_CALLED;
+
+				if (object->handlers->dtor_obj) {
+					GC_REFCOUNT(object)++;
 					zend_try {
-						obj->dtor(obj->object, handle TSRMLS_CC);
+						object->handlers->dtor_obj(object TSRMLS_CC);
 					} zend_catch {
 						failure = 1;
 					} zend_end_try();
+					GC_REFCOUNT(object)--;
 				}
 			}
 			
-			/* re-read the object from the object store as the store might have been reallocated in the dtor */
-			obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-
-			if (obj->refcount == 1) {
-				GC_REMOVE_ZOBJ_FROM_BUFFER(obj);
-				if (obj->free_storage) {
-					zend_try {
-						obj->free_storage(obj->object TSRMLS_CC);
-					} zend_catch {
-						failure = 1;
-					} zend_end_try();
+			if (GC_REFCOUNT(object) == 0) {
+				zend_uint handle = object->handle;
+				void *ptr;
+
+				EG(objects_store).object_buckets[handle] = SET_OBJ_INVALID(object);
+				if (!(GC_FLAGS(object) & IS_OBJ_FREE_CALLED)) {
+					GC_FLAGS(object) |= IS_OBJ_FREE_CALLED;
+					if (object->handlers->free_obj) {
+						zend_try {
+							GC_REFCOUNT(object)++;
+							object->handlers->free_obj(object TSRMLS_CC);
+							GC_REFCOUNT(object)--;
+						} zend_catch {
+							failure = 1;
+						} zend_end_try();
+					}
 				}
-				ZEND_OBJECTS_STORE_ADD_TO_FREE_LIST();
+				ptr = ((char*)object) - object->handlers->offset;
+				GC_REMOVE_FROM_BUFFER(object);
+				efree(ptr);
+				ZEND_OBJECTS_STORE_ADD_TO_FREE_LIST(handle);
+			}
+			
+			if (failure) {
+				zend_bailout();
 			}
+		} else {
+			GC_REFCOUNT(object)--;
 		}
 	}
-
-	obj->refcount--;
-
-#if ZEND_DEBUG_OBJECTS
-	if (obj->refcount == 0) {
-		fprintf(stderr, "Deallocated object id #%d\n", handle);
-	} else {
-		fprintf(stderr, "Decreased refcount of object id #%d\n", handle);
-	}
-#endif
-	if (failure) {
-		zend_bailout();
-	}
 }
 /* }}} */
 
-ZEND_API zend_object_value zend_objects_store_clone_obj(zval *zobject TSRMLS_DC)
-{
-	zend_object_value retval;
-	void *new_object;
-	struct _store_object *obj;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-
-	obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-
-	if (obj->clone == NULL) {
-		zend_error(E_CORE_ERROR, "Trying to clone uncloneable object of class %s", Z_OBJCE_P(zobject)->name);
-	}
-
-	obj->clone(obj->object, &new_object TSRMLS_CC);
-	obj = &EG(objects_store).object_buckets[handle].bucket.obj;
-
-	retval.handle = zend_objects_store_put(new_object, obj->dtor, obj->free_storage, obj->clone TSRMLS_CC);
-	retval.handlers = Z_OBJ_HT_P(zobject);
-	EG(objects_store).object_buckets[handle].bucket.obj.handlers = retval.handlers;
-
-	return retval;
-}
-
-ZEND_API void *zend_object_store_get_object(const zval *zobject TSRMLS_DC)
-{
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-
-	return EG(objects_store).object_buckets[handle].bucket.obj.object;
-}
-
-/*
- * Retrieve an entry from the objects store given the object handle.
- */
-ZEND_API void *zend_object_store_get_object_by_handle(zend_object_handle handle TSRMLS_DC)
-{
-	return EG(objects_store).object_buckets[handle].bucket.obj.object;
-}
-
 /* zend_object_store_set_object:
  * It is ONLY valid to call this function from within the constructor of an
  * overloaded object.  Its purpose is to set the object pointer for the object
@@ -293,34 +208,27 @@ ZEND_API void *zend_object_store_get_object_by_handle(zend_object_handle handle
  * from the constructor function.  You MUST NOT use this function for any other
  * weird games, or call it at any other time after the object is constructed.
  * */
-ZEND_API void zend_object_store_set_object(zval *zobject, void *object TSRMLS_DC)
+ZEND_API void zend_object_store_set_object(zval *zobject, zend_object *object TSRMLS_DC)
 {
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-
-	EG(objects_store).object_buckets[handle].bucket.obj.object = object;
+	EG(objects_store).object_buckets[Z_OBJ_HANDLE_P(zobject)] = object;
 }
 
-
 /* Called when the ctor was terminated by an exception */
-ZEND_API void zend_object_store_ctor_failed(zval *zobject TSRMLS_DC)
+ZEND_API void zend_object_store_ctor_failed(zend_object *obj TSRMLS_DC)
 {
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-	zend_object_store_bucket *obj_bucket = &EG(objects_store).object_buckets[handle];
-	
-	obj_bucket->bucket.obj.handlers = Z_OBJ_HT_P(zobject);;
-	obj_bucket->destructor_called = 1;
+	GC_FLAGS(obj) |= IS_OBJ_DESTRUCTOR_CALLED;
 }
 
-
 /* Proxy objects workings */
 typedef struct _zend_proxy_object {
-	zval *object;
-	zval *property;
+	zend_object std;
+	zval object;
+	zval property;
 } zend_proxy_object;
 
 static zend_object_handlers zend_object_proxy_handlers;
 
-ZEND_API void zend_objects_proxy_destroy(zend_object *object, zend_object_handle handle TSRMLS_DC)
+ZEND_API void zend_objects_proxy_destroy(zend_object *object TSRMLS_DC)
 {
 }
 
@@ -336,46 +244,44 @@ ZEND_API void zend_objects_proxy_clone(zend_proxy_object *object, zend_proxy_obj
 	*object_clone = emalloc(sizeof(zend_proxy_object));
 	(*object_clone)->object = object->object;
 	(*object_clone)->property = object->property;
-	zval_add_ref(&(*object_clone)->property);
-	zval_add_ref(&(*object_clone)->object);
+	Z_ADDREF_P(&(*object_clone)->property);
+	Z_ADDREF_P(&(*object_clone)->object);
 }
 
-ZEND_API zval *zend_object_create_proxy(zval *object, zval *member TSRMLS_DC)
+ZEND_API zend_object *zend_object_create_proxy(zval *object, zval *member TSRMLS_DC)
 {
-	zend_proxy_object *pobj = emalloc(sizeof(zend_proxy_object));
-	zval *retval;
-
-	pobj->object = object;
-	zval_add_ref(&pobj->object);
-	ALLOC_ZVAL(pobj->property);
-	INIT_PZVAL_COPY(pobj->property, member);
-	zval_copy_ctor(pobj->property);
-
-	MAKE_STD_ZVAL(retval);
-	Z_TYPE_P(retval) = IS_OBJECT;
-	Z_OBJ_HANDLE_P(retval) = zend_objects_store_put(pobj, (zend_objects_store_dtor_t)zend_objects_proxy_destroy, (zend_objects_free_object_storage_t) zend_objects_proxy_free_storage, (zend_objects_store_clone_t) zend_objects_proxy_clone TSRMLS_CC);
-	Z_OBJ_HT_P(retval) = &zend_object_proxy_handlers;
+	zend_proxy_object *obj = emalloc(sizeof(zend_proxy_object));
+
+	GC_REFCOUNT(obj) = 1;
+	GC_TYPE_INFO(obj) = IS_OBJECT;
+	obj->std.ce = NULL;
+	obj->std.properties = NULL;
+	obj->std.guards = NULL;
+	obj->std.handlers = &zend_object_proxy_handlers;
+	
+	ZVAL_COPY(&obj->object, object);
+	ZVAL_DUP(&obj->property, member);
 
-	return retval;
+	return (zend_object*)obj;
 }
 
-ZEND_API void zend_object_proxy_set(zval **property, zval *value TSRMLS_DC)
+ZEND_API void zend_object_proxy_set(zval *property, zval *value TSRMLS_DC)
 {
-	zend_proxy_object *probj = zend_object_store_get_object(*property TSRMLS_CC);
+	zend_proxy_object *probj = (zend_proxy_object*)Z_OBJ_P(property);
 
-	if (Z_OBJ_HT_P(probj->object) && Z_OBJ_HT_P(probj->object)->write_property) {
-		Z_OBJ_HT_P(probj->object)->write_property(probj->object, probj->property, value, 0 TSRMLS_CC);
+	if (Z_OBJ_HT(probj->object) && Z_OBJ_HT(probj->object)->write_property) {
+		Z_OBJ_HT(probj->object)->write_property(&probj->object, &probj->property, value, -1 TSRMLS_CC);
 	} else {
 		zend_error(E_WARNING, "Cannot write property of object - no write handler defined");
 	}
 }
 
-ZEND_API zval* zend_object_proxy_get(zval *property TSRMLS_DC)
+ZEND_API zval* zend_object_proxy_get(zval *property, zval *rv TSRMLS_DC)
 {
-	zend_proxy_object *probj = zend_object_store_get_object(property TSRMLS_CC);
+	zend_proxy_object *probj = (zend_proxy_object*)Z_OBJ_P(property);
 
-	if (Z_OBJ_HT_P(probj->object) && Z_OBJ_HT_P(probj->object)->read_property) {
-		return Z_OBJ_HT_P(probj->object)->read_property(probj->object, probj->property, BP_VAR_R, 0 TSRMLS_CC);
+	if (Z_OBJ_HT(probj->object) && Z_OBJ_HT(probj->object)->read_property) {
+		return Z_OBJ_HT(probj->object)->read_property(&probj->object, &probj->property, BP_VAR_R, -1, rv TSRMLS_CC);
 	} else {
 		zend_error(E_WARNING, "Cannot read property of object - no read handler defined");
 	}
diff --git a/Zend/zend_objects_API.h b/Zend/zend_objects_API.h
index d8f2c5e384..4d6afe6842 100644
--- a/Zend/zend_objects_API.h
+++ b/Zend/zend_objects_API.h
@@ -24,32 +24,30 @@
 
 #include "zend.h"
 
-typedef void (*zend_objects_store_dtor_t)(void *object, zend_object_handle handle TSRMLS_DC);
-typedef void (*zend_objects_free_object_storage_t)(void *object TSRMLS_DC);
-typedef void (*zend_objects_store_clone_t)(void *object, void **object_clone TSRMLS_DC);
-
-typedef struct _zend_object_store_bucket {
-	zend_bool destructor_called;
-	zend_bool valid;
-	zend_uchar apply_count;
-	union _store_bucket {
-		struct _store_object {
-			void *object;
-			zend_objects_store_dtor_t dtor;
-			zend_objects_free_object_storage_t free_storage;
-			zend_objects_store_clone_t clone;
-			const zend_object_handlers *handlers;
-			zend_uint refcount;
-			gc_root_buffer *buffered;
-		} obj;
-		struct {
-			int next;
-		} free_list;
-	} bucket;
-} zend_object_store_bucket;
+#define OBJ_BUCKET_INVALID			(1<<0)
+
+#define IS_OBJ_VALID(o)				(!(((zend_uintptr_t)(o)) & OBJ_BUCKET_INVALID))
+
+#define SET_OBJ_INVALID(o)			((zend_object*)((((zend_uintptr_t)(o)) | OBJ_BUCKET_INVALID)))
+
+#define GET_OBJ_BUCKET_NUMBER(o)	(((zend_intptr_t)(o)) >> 1)
+
+#define SET_OBJ_BUCKET_NUMBER(o, n)	do { \
+		(o) = (zend_object*)((((zend_uintptr_t)(n)) << 1) | OBJ_BUCKET_INVALID); \
+	} while (0)
+
+
+#define OBJ_RELEASE(obj) do { \
+		zend_object *_obj = (obj); \
+		if (--GC_REFCOUNT(_obj) == 0) { \
+			zend_objects_store_del(_obj TSRMLS_CC); \
+		} else { \
+			gc_possible_root(&_obj->gc TSRMLS_CC); \
+		} \
+	} while (0)
 
 typedef struct _zend_objects_store {
-	zend_object_store_bucket *object_buckets;
+	zend_object **object_buckets;
 	zend_uint top;
 	zend_uint size;
 	int free_list_head;
@@ -63,28 +61,19 @@ ZEND_API void zend_objects_store_mark_destructed(zend_objects_store *objects TSR
 ZEND_API void zend_objects_store_destroy(zend_objects_store *objects);
 
 /* Store API functions */
-ZEND_API zend_object_handle zend_objects_store_put(void *object, zend_objects_store_dtor_t dtor, zend_objects_free_object_storage_t storage, zend_objects_store_clone_t clone TSRMLS_DC);
-
-ZEND_API void zend_objects_store_add_ref(zval *object TSRMLS_DC);
-ZEND_API void zend_objects_store_del_ref(zval *object TSRMLS_DC);
-ZEND_API void zend_objects_store_add_ref_by_handle(zend_object_handle handle TSRMLS_DC);
-ZEND_API void zend_objects_store_del_ref_by_handle_ex(zend_object_handle handle, const zend_object_handlers *handlers TSRMLS_DC);
-static zend_always_inline void zend_objects_store_del_ref_by_handle(zend_object_handle handle TSRMLS_DC) {
-	zend_objects_store_del_ref_by_handle_ex(handle, NULL TSRMLS_CC);
-}
-ZEND_API zend_uint zend_objects_store_get_refcount(zval *object TSRMLS_DC);
-ZEND_API zend_object_value zend_objects_store_clone_obj(zval *object TSRMLS_DC);
-ZEND_API void *zend_object_store_get_object(const zval *object TSRMLS_DC);
-ZEND_API void *zend_object_store_get_object_by_handle(zend_object_handle handle TSRMLS_DC);
+ZEND_API void zend_objects_store_put(zend_object *object TSRMLS_DC);
+ZEND_API void zend_objects_store_del(zend_object *object TSRMLS_DC);
+ZEND_API void zend_objects_store_free(zend_object *object TSRMLS_DC);
+
 /* See comment in zend_objects_API.c before you use this */
-ZEND_API void zend_object_store_set_object(zval *zobject, void *object TSRMLS_DC);
-ZEND_API void zend_object_store_ctor_failed(zval *zobject TSRMLS_DC);
+ZEND_API void zend_object_store_set_object(zval *zobject, zend_object *object TSRMLS_DC);
+ZEND_API void zend_object_store_ctor_failed(zend_object *object TSRMLS_DC);
 
 ZEND_API void zend_objects_store_free_object_storage(zend_objects_store *objects TSRMLS_DC);
 
-#define ZEND_OBJECTS_STORE_HANDLERS zend_objects_store_add_ref, zend_objects_store_del_ref, zend_objects_store_clone_obj
+#define ZEND_OBJECTS_STORE_HANDLERS 0, zend_object_std_dtor, zend_objects_destroy_object, zend_objects_clone_obj
 
-ZEND_API zval *zend_object_create_proxy(zval *object, zval *member TSRMLS_DC);
+ZEND_API zend_object *zend_object_create_proxy(zval *object, zval *member TSRMLS_DC);
 
 ZEND_API zend_object_handlers *zend_get_std_object_handlers(void);
 END_EXTERN_C()
diff --git a/Zend/zend_opcode.c b/Zend/zend_opcode.c
index 457f08f313..e38a32a851 100644
--- a/Zend/zend_opcode.c
+++ b/Zend/zend_opcode.c
@@ -76,7 +76,6 @@ void init_op_array(zend_op_array *op_array, zend_uchar type, int initial_ops_siz
 	op_array->function_name = NULL;
 	op_array->filename = zend_get_compiled_filename(TSRMLS_C);
 	op_array->doc_comment = NULL;
-	op_array->doc_comment_len = 0;
 
 	op_array->arg_info = NULL;
 	op_array->num_args = 0;
@@ -116,66 +115,61 @@ ZEND_API void destroy_zend_function(zend_function *function TSRMLS_DC)
 			destroy_op_array((zend_op_array *) function TSRMLS_CC);
 			break;
 		case ZEND_INTERNAL_FUNCTION:
+			if (function->common.function_name) {
+				STR_RELEASE(function->common.function_name);
+			}
 			/* do nothing */
 			break;
 	}
 }
 
-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)
+ZEND_API void zend_cleanup_op_array_data(zend_op_array *op_array)
 {
 	if (op_array->static_variables) {
 		zend_hash_clean(op_array->static_variables);
 	}
 }
 
-ZEND_API int zend_cleanup_function_data(zend_function *function TSRMLS_DC)
-{
-	if (function->type == ZEND_USER_FUNCTION) {
-		zend_cleanup_op_array_data((zend_op_array *) function);
-		return ZEND_HASH_APPLY_KEEP;
-	} else {
-		return ZEND_HASH_APPLY_STOP;
-	}
-}
-
-ZEND_API int zend_cleanup_function_data_full(zend_function *function TSRMLS_DC)
-{
-	if (function->type == ZEND_USER_FUNCTION) {
-		zend_cleanup_op_array_data((zend_op_array *) function);
-	}
-	return 0;
-}
-
-static inline void cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC)
+ZEND_API void zend_cleanup_user_class_data(zend_class_entry *ce TSRMLS_DC)
 {
 	/* Clean all parts that can contain run-time data */
 	/* Note that only run-time accessed data need to be cleaned up, pre-defined data can
 	   not contain objects and thus are not probelmatic */
 	if (ce->ce_flags & ZEND_HAS_STATIC_IN_METHODS) {
-		zend_hash_apply(&ce->function_table, (apply_func_t) zend_cleanup_function_data_full TSRMLS_CC);
+		zend_function *func;
+
+		ZEND_HASH_FOREACH_PTR(&ce->function_table, func) {
+			if (func->type == ZEND_USER_FUNCTION) {
+				zend_cleanup_op_array_data((zend_op_array *) func);
+			}
+		} ZEND_HASH_FOREACH_END();
 	}
 	if (ce->static_members_table) {
 		int i;
 
 		for (i = 0; i < ce->default_static_members_count; i++) {
-			if (ce->static_members_table[i]) {
-				zval *p = ce->static_members_table[i];
-				ce->static_members_table[i] = NULL;
-				zval_ptr_dtor(&p);
+			if (Z_TYPE(ce->static_members_table[i]) != IS_UNDEF) {
+				zval tmp;
+
+				ZVAL_COPY_VALUE(&tmp, &ce->static_members_table[i]);
+				ZVAL_UNDEF(&ce->static_members_table[i]);
+				zval_ptr_dtor(&tmp);
 			}
 		}
 		ce->static_members_table = NULL;
 	}
 }
 
-static inline void cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC)
+ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC)
 {
 	if (CE_STATIC_MEMBERS(ce)) {
 		int i;
@@ -192,31 +186,6 @@ static inline void cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC)
 	}
 }
 
-ZEND_API void zend_cleanup_internal_class_data(zend_class_entry *ce TSRMLS_DC)
-{
-	cleanup_internal_class_data(ce TSRMLS_CC);
-}
-
-ZEND_API int zend_cleanup_user_class_data(zend_class_entry **pce TSRMLS_DC)
-{
-	if ((*pce)->type == ZEND_USER_CLASS) {
-		cleanup_user_class_data(*pce TSRMLS_CC);
-		return ZEND_HASH_APPLY_KEEP;
-	} else {
-		return ZEND_HASH_APPLY_STOP;
-	}
-}
-
-ZEND_API int zend_cleanup_class_data(zend_class_entry **pce TSRMLS_DC)
-{
-	if ((*pce)->type == ZEND_USER_CLASS) {
-		cleanup_user_class_data(*pce TSRMLS_CC);
-	} else {
-		cleanup_internal_class_data(*pce TSRMLS_CC);
-	}
-	return 0;
-}
-
 void _destroy_zend_class_traits_info(zend_class_entry *ce)
 {
 	if (ce->num_traits > 0 && ce->traits) {
@@ -228,16 +197,16 @@ void _destroy_zend_class_traits_info(zend_class_entry *ce)
 		while (ce->trait_aliases[i]) {
 			if (ce->trait_aliases[i]->trait_method) {
 				if (ce->trait_aliases[i]->trait_method->method_name) {
-	 				efree((char*)ce->trait_aliases[i]->trait_method->method_name);
+	 				STR_RELEASE(ce->trait_aliases[i]->trait_method->method_name);
 				}
 				if (ce->trait_aliases[i]->trait_method->class_name) {
-	 				efree((char*)ce->trait_aliases[i]->trait_method->class_name);
+	 				STR_RELEASE(ce->trait_aliases[i]->trait_method->class_name);
 				}
 				efree(ce->trait_aliases[i]->trait_method);
 			}
 			
 			if (ce->trait_aliases[i]->alias) {
-				efree((char*)ce->trait_aliases[i]->alias);
+				STR_RELEASE(ce->trait_aliases[i]->alias);
 			}
 			
 			efree(ce->trait_aliases[i]);
@@ -251,8 +220,8 @@ void _destroy_zend_class_traits_info(zend_class_entry *ce)
 		size_t i = 0;
 		
 		while (ce->trait_precedences[i]) {
-			efree((char*)ce->trait_precedences[i]->trait_method->method_name);
-			efree((char*)ce->trait_precedences[i]->trait_method->class_name);
+			STR_RELEASE(ce->trait_precedences[i]->trait_method->method_name);
+			STR_RELEASE(ce->trait_precedences[i]->trait_method->class_name);
 			efree(ce->trait_precedences[i]->trait_method);
 
 			if (ce->trait_precedences[i]->exclude_from_classes) {
@@ -266,9 +235,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;
@@ -279,7 +248,7 @@ ZEND_API void destroy_zend_class(zend_class_entry **pce)
 				int i;
 
 				for (i = 0; i < ce->default_properties_count; i++) {
-					if (ce->default_properties_table[i]) {
+					if (Z_TYPE(ce->default_properties_table[i]) != IS_UNDEF) {
 						zval_ptr_dtor(&ce->default_properties_table[i]);
 				    }
 				}
@@ -289,21 +258,21 @@ ZEND_API void destroy_zend_class(zend_class_entry **pce)
 				int i;
 
 				for (i = 0; i < ce->default_static_members_count; i++) {
-					if (ce->default_static_members_table[i]) {
+					if (Z_TYPE(ce->default_static_members_table[i]) != IS_UNDEF) {
 						zval_ptr_dtor(&ce->default_static_members_table[i]);
 					}
 				}
 				efree(ce->default_static_members_table);
 			}
 			zend_hash_destroy(&ce->properties_info);
-			str_efree(ce->name);
+			STR_RELEASE(ce->name);
 			zend_hash_destroy(&ce->function_table);
 			zend_hash_destroy(&ce->constants_table);
 			if (ce->num_interfaces > 0 && ce->interfaces) {
 				efree(ce->interfaces);
 			}
 			if (ce->info.user.doc_comment) {
-				efree((char*)ce->info.user.doc_comment);
+				STR_RELEASE(ce->info.user.doc_comment);
 			}
 			
 			_destroy_zend_class_traits_info(ce);
@@ -315,7 +284,7 @@ ZEND_API void destroy_zend_class(zend_class_entry **pce)
 				int i;
 
 				for (i = 0; i < ce->default_properties_count; i++) {
-					if (ce->default_properties_table[i]) {
+					if (Z_TYPE(ce->default_properties_table[i]) != IS_UNDEF) {
 						zval_internal_ptr_dtor(&ce->default_properties_table[i]);
 					}
 				}
@@ -330,7 +299,7 @@ ZEND_API void destroy_zend_class(zend_class_entry **pce)
 				free(ce->default_static_members_table);
 			}
 			zend_hash_destroy(&ce->properties_info);
-			str_free(ce->name);
+			STR_RELEASE(ce->name);
 			zend_hash_destroy(&ce->function_table);
 			zend_hash_destroy(&ce->constants_table);
 			if (ce->num_interfaces > 0) {
@@ -341,15 +310,17 @@ 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)
 {
-	zend_literal *literal = op_array->literals;
-	zend_literal *end;
+	zval *literal = op_array->literals;
+	zval *end;
 	zend_uint i;
 
 	if (op_array->static_variables) {
@@ -371,7 +342,7 @@ ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
 		i = op_array->last_var;
 		while (i > 0) {
 			i--;
-			str_efree(op_array->vars[i].name);
+			STR_RELEASE(op_array->vars[i]);
 		}
 		efree(op_array->vars);
 	}
@@ -379,7 +350,7 @@ ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
 	if (literal) {
 	 	end = literal + op_array->last_literal;
 	 	while (literal < end) {
-			zval_dtor(&literal->constant);
+			zval_dtor(literal);
 			literal++;
 		}
 		efree(op_array->literals);
@@ -387,10 +358,10 @@ ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
 	efree(op_array->opcodes);
 
 	if (op_array->function_name) {
-		efree((char*)op_array->function_name);
+		STR_RELEASE(op_array->function_name);
 	}
 	if (op_array->doc_comment) {
-		efree((char*)op_array->doc_comment);
+		STR_RELEASE(op_array->doc_comment);
 	}
 	if (op_array->brk_cont_array) {
 		efree(op_array->brk_cont_array);
@@ -403,9 +374,9 @@ ZEND_API void destroy_op_array(zend_op_array *op_array TSRMLS_DC)
 	}
 	if (op_array->arg_info) {
 		for (i=0; i<op_array->num_args; i++) {
-			str_efree(op_array->arg_info[i].name);
+			efree((char*)op_array->arg_info[i].name);
 			if (op_array->arg_info[i].class_name) {
-				str_efree(op_array->arg_info[i].class_name);
+				efree((char*)op_array->arg_info[i].class_name);
 			}
 		}
 		efree(op_array->arg_info);
@@ -622,7 +593,7 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC)
 				int nest_levels, array_offset;
 				zend_brk_cont_element *jmp_to;
 
-				nest_levels = Z_LVAL(op_array->literals[opline->op2.constant].constant);
+				nest_levels = Z_LVAL(op_array->literals[opline->op2.constant]);
 				array_offset = opline->op1.opline_num;
 				do {
 					jmp_to = &op_array->brk_cont_array[array_offset];
@@ -634,9 +605,9 @@ static void zend_resolve_finally_calls(zend_op_array *op_array TSRMLS_DC)
 				break;
 			}
 			case ZEND_GOTO:
-				if (Z_TYPE(op_array->literals[opline->op2.constant].constant) != IS_LONG) {
+				if (Z_TYPE(op_array->literals[opline->op2.constant]) != IS_LONG) {
 					zend_uint num = opline->op2.constant;
-					opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
+					opline->op2.zv = &op_array->literals[opline->op2.constant];
 					zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC);
 					opline->op2.constant = num;					
 				}
@@ -671,7 +642,7 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
 	}
 
 	if (!(op_array->fn_flags & ZEND_ACC_INTERACTIVE) && CG(context).vars_size != op_array->last_var) {
-		op_array->vars = (zend_compiled_variable *) erealloc(op_array->vars, sizeof(zend_compiled_variable)*op_array->last_var);
+		op_array->vars = (zend_string**) erealloc(op_array->vars, sizeof(zend_string*)*op_array->last_var);
 		CG(context).vars_size = op_array->last_var;
 	}
 	if (!(op_array->fn_flags & ZEND_ACC_INTERACTIVE) && CG(context).opcodes_size != op_array->last) {
@@ -679,20 +650,30 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
 		CG(context).opcodes_size = op_array->last;
 	}
 	if (!(op_array->fn_flags & ZEND_ACC_INTERACTIVE) && CG(context).literals_size != op_array->last_literal) {
-		op_array->literals = (zend_literal*)erealloc(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
+		op_array->literals = (zval*)erealloc(op_array->literals, sizeof(zval) * op_array->last_literal);
 		CG(context).literals_size = op_array->last_literal;
 	}
-
 	opline = op_array->opcodes;
 	end = opline + op_array->last;
 	while (opline < end) {
 		if (opline->op1_type == IS_CONST) {
-			opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
+			opline->op1.zv = &op_array->literals[opline->op1.constant];
+		} else if (opline->op1_type & (IS_VAR|IS_TMP_VAR)) {
+			opline->op1.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->op1.var);
 		}
 		if (opline->op2_type == IS_CONST) {
-			opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
+			opline->op2.zv = &op_array->literals[opline->op2.constant];
+		} else if (opline->op2_type & (IS_VAR|IS_TMP_VAR)) {
+			opline->op2.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->op2.var);
+		}
+		if (opline->result_type & (IS_VAR|IS_TMP_VAR)) {
+			opline->result.var = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->result.var);
 		}
 		switch (opline->opcode) {
+			case ZEND_DECLARE_INHERITED_CLASS:
+			case ZEND_DECLARE_INHERITED_CLASS_DELAYED:
+				opline->extended_value = (zend_uint)EX_VAR_NUM_2(NULL, op_array->last_var + opline->extended_value);
+				break;
 			case ZEND_GOTO:
 				if (Z_TYPE_P(opline->op2.zv) != IS_LONG) {
 					zend_resolve_goto_label(op_array, opline, 1 TSRMLS_CC);
@@ -732,9 +713,9 @@ ZEND_API int pass_two(zend_op_array *op_array TSRMLS_DC)
 
 int print_class(zend_class_entry *class_entry TSRMLS_DC)
 {
-	printf("Class %s:\n", class_entry->name);
+	printf("Class %s:\n", class_entry->name->val);
 	zend_hash_apply(&class_entry->function_table, (apply_func_t) pass_two TSRMLS_CC);
-	printf("End of class %s.\n\n", class_entry->name);
+	printf("End of class %s.\n\n", class_entry->name->val);
 	return 0;
 }
 
diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index f022909bc3..764396aa03 100644
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -183,24 +183,36 @@ ZEND_API double zend_string_to_double(const char *number, zend_uint length) /* {
 
 ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
 {
+try_again:
 	switch (Z_TYPE_P(op)) {
+		case IS_REFERENCE:
+			if (Z_REFCOUNT_P(op) == 1) {
+				ZVAL_UNREF(op);
+			} else {
+				Z_DELREF_P(op);
+				ZVAL_COPY_VALUE(op, Z_REFVAL_P(op));
+			}
+			goto try_again;
 		case IS_STRING:
 			{
-				char *strval;
+				zend_string *str;
 
-				strval = Z_STRVAL_P(op);
-				if ((Z_TYPE_P(op)=is_numeric_string(strval, Z_STRLEN_P(op), &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
+				str = Z_STR_P(op);
+				if ((Z_TYPE_INFO_P(op)=is_numeric_string(str->val, str->len, &Z_LVAL_P(op), &Z_DVAL_P(op), 1)) == 0) {
 					ZVAL_LONG(op, 0);
 				}
-				str_efree(strval);
+				STR_RELEASE(str);
 				break;
 			}
 		case IS_BOOL:
-			Z_TYPE_P(op) = IS_LONG;
+			Z_TYPE_INFO_P(op) = IS_LONG;
 			break;
 		case IS_RESOURCE:
-			zend_list_delete(Z_LVAL_P(op));
-			Z_TYPE_P(op) = IS_LONG;
+			{
+				long l = Z_RES_HANDLE_P(op);
+				zval_ptr_dtor(op);
+				ZVAL_LONG(op, l);
+			}
 			break;
 		case IS_OBJECT:
 			convert_to_long_base(op, 10);
@@ -222,24 +234,26 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
 		switch (Z_TYPE_P(op)) {										\
 			case IS_STRING:											\
 				{													\
-					if ((Z_TYPE(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) {	\
+					if ((Z_TYPE_INFO(holder)=is_numeric_string(Z_STRVAL_P(op), Z_STRLEN_P(op), &Z_LVAL(holder), &Z_DVAL(holder), 1)) == 0) {	\
 						ZVAL_LONG(&(holder), 0);							\
 					}														\
 					(op) = &(holder);										\
 					break;													\
 				}															\
 			case IS_BOOL:													\
-			case IS_RESOURCE:												\
 				ZVAL_LONG(&(holder), Z_LVAL_P(op));							\
 				(op) = &(holder);											\
 				break;														\
+			case IS_RESOURCE:												\
+				ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op));					\
+				(op) = &(holder);											\
+				break;														\
 			case IS_NULL:													\
 				ZVAL_LONG(&(holder), 0);									\
 				(op) = &(holder);											\
 				break;														\
 			case IS_OBJECT:													\
-				(holder) = (*(op));											\
-				zval_copy_ctor(&(holder));									\
+				ZVAL_DUP(&(holder), op);										\
 				convert_to_long_base(&(holder), 10);						\
 				if (Z_TYPE(holder) == IS_LONG) {							\
 					(op) = &(holder);										\
@@ -257,32 +271,32 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
 	} else if (Z_TYPE_P(op) != IS_LONG) {							\
 		switch (Z_TYPE_P(op)) {										\
 			case IS_NULL:											\
-				Z_LVAL(holder) = 0;									\
+				ZVAL_LONG(&holder, 0);								\
 				break;												\
 			case IS_DOUBLE:											\
-				Z_LVAL(holder) = zend_dval_to_lval(Z_DVAL_P(op));	\
+				ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\
 				break;												\
 			case IS_STRING:											\
-				Z_LVAL(holder) = strtol(Z_STRVAL_P(op), NULL, 10);	\
+				ZVAL_LONG(&holder, strtol(Z_STRVAL_P(op), NULL, 10));\
 				break;												\
 			case IS_ARRAY:											\
-				Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);	\
+				ZVAL_LONG(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);	\
 				break;												\
 			case IS_OBJECT:											\
-				(holder) = (*(op));									\
-				zval_copy_ctor(&(holder));							\
+				ZVAL_DUP(&(holder), (op));							\
 				convert_to_long_base(&(holder), 10);				\
 				break;												\
 			case IS_BOOL:											\
+				ZVAL_LONG(&(holder), Z_LVAL_P(op));					\
+				break;												\
 			case IS_RESOURCE:										\
-				Z_LVAL(holder) = Z_LVAL_P(op);						\
+				ZVAL_LONG(&holder, Z_RES_HANDLE_P(op));				\
 				break;												\
 			default:												\
 				zend_error(E_WARNING, "Cannot convert to ordinal value");	\
-				Z_LVAL(holder) = 0;									\
+				ZVAL_LONG(&holder, 0);								\
 				break;												\
 		}															\
-		Z_TYPE(holder) = IS_LONG;									\
 		(op) = &(holder);											\
 	}
 
@@ -295,36 +309,36 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
 	} else if (Z_TYPE_P(op) != IS_BOOL) {							\
 		switch (Z_TYPE_P(op)) {										\
 			case IS_NULL:											\
-				Z_LVAL(holder) = 0;									\
+				ZVAL_BOOL(&holder, 0);								\
 				break;												\
 			case IS_RESOURCE:										\
+				ZVAL_BOOL(&holder, Z_RES_HANDLE_P(op) ? 1 : 0);		\
+				break;												\
 			case IS_LONG:											\
-				Z_LVAL(holder) = (Z_LVAL_P(op) ? 1 : 0);			\
+				ZVAL_BOOL(&holder, Z_LVAL_P(op) ? 1 : 0);			\
 				break;												\
 			case IS_DOUBLE:											\
-				Z_LVAL(holder) = (Z_DVAL_P(op) ? 1 : 0);			\
+				ZVAL_BOOL(&holder, Z_DVAL_P(op) ? 1 : 0);			\
 				break;												\
 			case IS_STRING:											\
 				if (Z_STRLEN_P(op) == 0								\
 					|| (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) {	\
-					Z_LVAL(holder) = 0;								\
+					ZVAL_BOOL(&holder, 0);							\
 				} else {											\
-					Z_LVAL(holder) = 1;								\
+					ZVAL_BOOL(&holder, 1);							\
 				}													\
 				break;												\
 			case IS_ARRAY:											\
-				Z_LVAL(holder) = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);	\
+				ZVAL_BOOL(&holder, zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);	\
 				break;												\
 			case IS_OBJECT:											\
-				(holder) = (*(op));									\
-				zval_copy_ctor(&(holder));							\
+				ZVAL_DUP(&(holder), (op));							\
 				convert_to_boolean(&(holder));						\
 				break;												\
 			default:												\
-				Z_LVAL(holder) = 0;									\
+				ZVAL_BOOL(&holder, 0);								\
 				break;												\
 		}															\
-		Z_TYPE(holder) = IS_BOOL;									\
 		(op) = &(holder);											\
 	}
 
@@ -334,23 +348,23 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
 #define convert_object_to_type(op, ctype, conv_func)										\
 	if (Z_OBJ_HT_P(op)->cast_object) {														\
 		zval dst;																			\
+		ZVAL_UNDEF(&dst);																	\
 		if (Z_OBJ_HT_P(op)->cast_object(op, &dst, ctype TSRMLS_CC) == FAILURE) {			\
 			zend_error(E_RECOVERABLE_ERROR,													\
-				"Object of class %s could not be converted to %s", Z_OBJCE_P(op)->name,		\
+				"Object of class %s could not be converted to %s", Z_OBJCE_P(op)->name->val,\
 			zend_get_type_by_const(ctype));													\
 		} else {																			\
 			zval_dtor(op);																	\
-			Z_TYPE_P(op) = ctype;															\
-			op->value = dst.value;															\
+			ZVAL_COPY_VALUE(op, &dst);														\
 		}																					\
 	} else {																				\
 		if (Z_OBJ_HT_P(op)->get) {															\
-			zval *newop = Z_OBJ_HT_P(op)->get(op TSRMLS_CC);								\
+			zval rv;																		\
+			zval *newop = Z_OBJ_HT_P(op)->get(op, &rv TSRMLS_CC);							\
 			if (Z_TYPE_P(newop) != IS_OBJECT) {												\
 				/* for safety - avoid loop */												\
 				zval_dtor(op);																\
-				*op = *newop;																\
-				FREE_ZVAL(newop);															\
+				ZVAL_COPY_VALUE(op, newop);													\
 				conv_func(op);																\
 			}																				\
 		}																					\
@@ -372,32 +386,35 @@ ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
 
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
-			Z_LVAL_P(op) = 0;
+			ZVAL_LONG(op, 0);
 			break;
 		case IS_RESOURCE: {
 				TSRMLS_FETCH();
-
-				zend_list_delete(Z_LVAL_P(op));
+				long l = Z_RES_HANDLE_P(op);
+				zval_ptr_dtor(op);
+				ZVAL_LONG(op, l);
 			}
 			/* break missing intentionally */
 		case IS_BOOL:
+			Z_TYPE_INFO_P(op) = IS_LONG;
+			break;
 		case IS_LONG:
 			break;
 		case IS_DOUBLE:
-			Z_LVAL_P(op) = zend_dval_to_lval(Z_DVAL_P(op));
+			ZVAL_LONG(op, zend_dval_to_lval(Z_DVAL_P(op)));
 			break;
 		case IS_STRING:
 			{
-				char *strval = Z_STRVAL_P(op);
+				zend_string *str = Z_STR_P(op);
 
-				Z_LVAL_P(op) = strtol(strval, NULL, base);
-				str_efree(strval);
+				ZVAL_LONG(op, strtol(str->val, NULL, base));
+				STR_RELEASE(str);
 			}
 			break;
 		case IS_ARRAY:
 			tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
 			zval_dtor(op);
-			Z_LVAL_P(op) = tmp;
+			ZVAL_LONG(op, tmp);
 			break;
 		case IS_OBJECT:
 			{
@@ -409,7 +426,7 @@ ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
 				if (Z_TYPE_P(op) == IS_LONG) {
 					return;
 				}
-				zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name);
+				zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val);
 
 				zval_dtor(op);
 				ZVAL_LONG(op, retval);
@@ -418,11 +435,9 @@ ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
 		default:
 			zend_error(E_WARNING, "Cannot convert to ordinal value");
 			zval_dtor(op);
-			Z_LVAL_P(op) = 0;
+			ZVAL_LONG(op, 0);
 			break;
 	}
-
-	Z_TYPE_P(op) = IS_LONG;
 }
 /* }}} */
 
@@ -432,32 +447,33 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */
 
 	switch (Z_TYPE_P(op)) {
 		case IS_NULL:
-			Z_DVAL_P(op) = 0.0;
+			ZVAL_DOUBLE(op, 0.0);
 			break;
 		case IS_RESOURCE: {
 				TSRMLS_FETCH();
-
-				zend_list_delete(Z_LVAL_P(op));
+				double d = (double) Z_RES_HANDLE_P(op);
+				zval_ptr_dtor(op);
+				ZVAL_DOUBLE(op, d);
 			}
-			/* break missing intentionally */
+			break;
 		case IS_BOOL:
 		case IS_LONG:
-			Z_DVAL_P(op) = (double) Z_LVAL_P(op);
+			ZVAL_DOUBLE(op, (double) Z_LVAL_P(op));
 			break;
 		case IS_DOUBLE:
 			break;
 		case IS_STRING:
 			{
-				char *strval = Z_STRVAL_P(op);
+				zend_string *str = Z_STR_P(op);
 
-				Z_DVAL_P(op) = zend_strtod(strval, NULL);
-				str_efree(strval);
+				ZVAL_DOUBLE(op, zend_strtod(str->val, NULL));
+				STR_RELEASE(str);
 			}
 			break;
 		case IS_ARRAY:
 			tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
 			zval_dtor(op);
-			Z_DVAL_P(op) = tmp;
+			ZVAL_DOUBLE(op, tmp);
 			break;
 		case IS_OBJECT:
 			{
@@ -469,7 +485,7 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */
 				if (Z_TYPE_P(op) == IS_DOUBLE) {
 					return;
 				}
-				zend_error(E_NOTICE, "Object of class %s could not be converted to double", Z_OBJCE_P(op)->name);
+				zend_error(E_NOTICE, "Object of class %s could not be converted to double", Z_OBJCE_P(op)->name->val);
 
 				zval_dtor(op);
 				ZVAL_DOUBLE(op, retval);
@@ -478,10 +494,9 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */
 		default:
 			zend_error(E_WARNING, "Cannot convert to real value (type=%d)", Z_TYPE_P(op));
 			zval_dtor(op);
-			Z_DVAL_P(op) = 0;
+			ZVAL_DOUBLE(op, 0);
 			break;
 	}
-	Z_TYPE_P(op) = IS_DOUBLE;
 }
 /* }}} */
 
@@ -489,22 +504,20 @@ ZEND_API void convert_to_null(zval *op) /* {{{ */
 {
 	if (Z_TYPE_P(op) == IS_OBJECT) {
 		if (Z_OBJ_HT_P(op)->cast_object) {
-			zval *org;
+			zval org;
 			TSRMLS_FETCH();
 
-			ALLOC_ZVAL(org);
-			*org = *op;
-			if (Z_OBJ_HT_P(op)->cast_object(org, op, IS_NULL TSRMLS_CC) == SUCCESS) {
-				zval_dtor(org);
+			ZVAL_COPY_VALUE(&org, op);
+			if (Z_OBJ_HT_P(op)->cast_object(&org, op, IS_NULL TSRMLS_CC) == SUCCESS) {
+				zval_dtor(&org);
 				return;
 			}
-			*op = *org;
-			FREE_ZVAL(org);
+			ZVAL_COPY_VALUE(op, &org);
 		}
 	}
 
 	zval_dtor(op);
-	Z_TYPE_P(op) = IS_NULL;
+	ZVAL_NULL(op);
 }
 /* }}} */
 
@@ -516,37 +529,39 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
 		case IS_BOOL:
 			break;
 		case IS_NULL:
-			Z_LVAL_P(op) = 0;
+			ZVAL_BOOL(op, 0);
 			break;
 		case IS_RESOURCE: {
 				TSRMLS_FETCH();
+				long l = (Z_RES_HANDLE_P(op) ? 1 : 0);
 
-				zend_list_delete(Z_LVAL_P(op));
+				zval_ptr_dtor(op);
+				ZVAL_BOOL(op, l);
 			}
-			/* break missing intentionally */
+			break;
 		case IS_LONG:
-			Z_LVAL_P(op) = (Z_LVAL_P(op) ? 1 : 0);
+			ZVAL_BOOL(op, Z_LVAL_P(op) ? 1 : 0);
 			break;
 		case IS_DOUBLE:
-			Z_LVAL_P(op) = (Z_DVAL_P(op) ? 1 : 0);
+			ZVAL_BOOL(op, Z_DVAL_P(op) ? 1 : 0);
 			break;
 		case IS_STRING:
 			{
-				char *strval = Z_STRVAL_P(op);
+				zend_string *str = Z_STR_P(op);
 
-				if (Z_STRLEN_P(op) == 0
-					|| (Z_STRLEN_P(op)==1 && Z_STRVAL_P(op)[0]=='0')) {
-					Z_LVAL_P(op) = 0;
+				if (str->len == 0
+					|| (str->len == 1 && str->val[0] == '0')) {
+					ZVAL_BOOL(op, 0);
 				} else {
-					Z_LVAL_P(op) = 1;
+					ZVAL_BOOL(op, 1);
 				}
-				str_efree(strval);
+				STR_RELEASE(str);
 			}
 			break;
 		case IS_ARRAY:
 			tmp = (zend_hash_num_elements(Z_ARRVAL_P(op))?1:0);
 			zval_dtor(op);
-			Z_LVAL_P(op) = tmp;
+			ZVAL_BOOL(op, tmp);
 			break;
 		case IS_OBJECT:
 			{
@@ -565,28 +580,15 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
 			}
 		default:
 			zval_dtor(op);
-			Z_LVAL_P(op) = 0;
+			ZVAL_BOOL(op, 0);
 			break;
 	}
-	Z_TYPE_P(op) = IS_BOOL;
 }
 /* }}} */
 
 ZEND_API void _convert_to_cstring(zval *op ZEND_FILE_LINE_DC) /* {{{ */
 {
-	double dval;
-	switch (Z_TYPE_P(op)) {
-		case IS_DOUBLE: {
-			TSRMLS_FETCH();
-			dval = Z_DVAL_P(op);
-			Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*H", (int) EG(precision), dval);
-			/* %H already handles removing trailing zeros from the fractional part, yay */
-			break;
-		}
-		default:
-			_convert_to_string(op ZEND_FILE_LINE_CC);
-	}
-	Z_TYPE_P(op) = IS_STRING;
+	_convert_to_string(op ZEND_FILE_LINE_CC);
 }
 /* }}} */
 
@@ -596,46 +598,59 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
 	double dval;
 
 	switch (Z_TYPE_P(op)) {
-		case IS_NULL:
-			Z_STRVAL_P(op) = STR_EMPTY_ALLOC();
-			Z_STRLEN_P(op) = 0;
+		case IS_NULL: {
+			TSRMLS_FETCH();
+			ZVAL_EMPTY_STRING(op);
 			break;
+		}
 		case IS_STRING:
 			break;
 		case IS_BOOL:
 			if (Z_LVAL_P(op)) {
-				Z_STRVAL_P(op) = estrndup_rel("1", 1);
-				Z_STRLEN_P(op) = 1;
+				ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
 			} else {
-				Z_STRVAL_P(op) = STR_EMPTY_ALLOC();
-				Z_STRLEN_P(op) = 0;
+				TSRMLS_FETCH();
+				ZVAL_EMPTY_STRING(op);
 			}
 			break;
 		case IS_RESOURCE: {
-			long tmp = Z_LVAL_P(op);
+			long tmp = Z_RES_HANDLE_P(op);
+			char *str;
+			int len;
 			TSRMLS_FETCH();
 
-			zend_list_delete(Z_LVAL_P(op));
-			Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "Resource id #%ld", tmp);
+			zval_ptr_dtor(op);
+			len = zend_spprintf(&str, 0, "Resource id #%ld", tmp);
+			ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
+			efree(str);
 			break;
 		}
-		case IS_LONG:
+		case IS_LONG: {
+			char *str;
+			int len;
 			lval = Z_LVAL_P(op);
 
-			Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%ld", lval);
+			len = zend_spprintf(&str, 0, "%ld", lval);
+			ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
+			efree(str);
 			break;
+		}
 		case IS_DOUBLE: {
+			char *str;
+			int len;
 			TSRMLS_FETCH();
+
 			dval = Z_DVAL_P(op);
-			Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*G", (int) EG(precision), dval);
+			len = zend_spprintf(&str, 0, "%.*G", (int) EG(precision), dval);
 			/* %G already handles removing trailing zeros from the fractional part, yay */
+			ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
+			efree(str);
 			break;
 		}
 		case IS_ARRAY:
 			zend_error(E_NOTICE, "Array to string conversion");
 			zval_dtor(op);
-			Z_STRVAL_P(op) = estrndup_rel("Array", sizeof("Array")-1);
-			Z_STRLEN_P(op) = sizeof("Array")-1;
+			ZVAL_NEW_STR(op, STR_INIT("Array", sizeof("Array")-1, 0));
 			break;
 		case IS_OBJECT: {
 			TSRMLS_FETCH();
@@ -646,10 +661,9 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
 				return;
 			}
 
-			zend_error(E_NOTICE, "Object of class %s to string conversion", Z_OBJCE_P(op)->name);
+			zend_error(E_NOTICE, "Object of class %s to string conversion", Z_OBJCE_P(op)->name->val);
 			zval_dtor(op);
-			Z_STRVAL_P(op) = estrndup_rel("Object", sizeof("Object")-1);
-			Z_STRLEN_P(op) = sizeof("Object")-1;
+			ZVAL_NEW_STR(op, STR_INIT("Object", sizeof("Object")-1, 0));
 			break;
 		}
 		default:
@@ -657,28 +671,24 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
 			ZVAL_BOOL(op, 0);
 			break;
 	}
-	Z_TYPE_P(op) = IS_STRING;
 }
 /* }}} */
 
 static void convert_scalar_to_array(zval *op, int type TSRMLS_DC) /* {{{ */
 {
-	zval *entry;
+	zval entry;
 
-	ALLOC_ZVAL(entry);
-	*entry = *op;
-	INIT_PZVAL(entry);
+	ZVAL_COPY_VALUE(&entry, op);
 
 	switch (type) {
 		case IS_ARRAY:
-			ALLOC_HASHTABLE(Z_ARRVAL_P(op));
-			zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0);
-			zend_hash_index_update(Z_ARRVAL_P(op), 0, (void *) &entry, sizeof(zval *), NULL);
-			Z_TYPE_P(op) = IS_ARRAY;
+			ZVAL_NEW_ARR(op);
+			zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0);
+			zend_hash_index_update(Z_ARRVAL_P(op), 0, &entry);
 			break;
 		case IS_OBJECT:
 			object_init(op);
-			zend_hash_update(Z_OBJPROP_P(op), "scalar", sizeof("scalar"), (void *) &entry, sizeof(zval *), NULL);
+			zend_hash_str_update(Z_OBJPROP_P(op), "scalar", sizeof("scalar")-1, &entry);
 			break;
 	}
 }
@@ -694,41 +704,36 @@ ZEND_API void convert_to_array(zval *op) /* {{{ */
 /* OBJECTS_OPTIMIZE */
 		case IS_OBJECT:
 			{
-				zval *tmp;
-				HashTable *ht;
+				zval arr;
 
-				ALLOC_HASHTABLE(ht);
-				zend_hash_init(ht, 0, NULL, ZVAL_PTR_DTOR, 0);
+				ZVAL_NEW_ARR(&arr);
+				zend_hash_init(Z_ARRVAL(arr), 8, NULL, ZVAL_PTR_DTOR, 0);
 				if (Z_OBJCE_P(op) == zend_ce_closure) {
 					convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC);
 					if (Z_TYPE_P(op) == IS_ARRAY) {
-						zend_hash_destroy(ht);
-						FREE_HASHTABLE(ht);
+						zval_dtor(&arr);
 						return;
 					}
 				} else if (Z_OBJ_HT_P(op)->get_properties) {
 					HashTable *obj_ht = Z_OBJ_HT_P(op)->get_properties(op TSRMLS_CC);
 					if (obj_ht) {
-						zend_hash_copy(ht, obj_ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+						zend_hash_copy(Z_ARRVAL(arr), obj_ht, zval_add_ref);
 					}
 				} else {
 					convert_object_to_type(op, IS_ARRAY, convert_to_array);
 
 					if (Z_TYPE_P(op) == IS_ARRAY) {
-						zend_hash_destroy(ht);
-						FREE_HASHTABLE(ht);
+						zval_dtor(&arr);
 						return;
 					}
 				}
 				zval_dtor(op);
-				Z_TYPE_P(op) = IS_ARRAY;
-				Z_ARRVAL_P(op) = ht;
+				ZVAL_COPY_VALUE(op, &arr);
 			}
 			break;
 		case IS_NULL:
-			ALLOC_HASHTABLE(Z_ARRVAL_P(op));
-			zend_hash_init(Z_ARRVAL_P(op), 0, NULL, ZVAL_PTR_DTOR, 0);
-			Z_TYPE_P(op) = IS_ARRAY;
+			ZVAL_NEW_ARR(op);
+			zend_hash_init(Z_ARRVAL_P(op), 8, NULL, ZVAL_PTR_DTOR, 0);
 			break;
 		default:
 			convert_scalar_to_array(op, IS_ARRAY TSRMLS_CC);
@@ -744,7 +749,14 @@ ZEND_API void convert_to_object(zval *op) /* {{{ */
 	switch (Z_TYPE_P(op)) {
 		case IS_ARRAY:
 			{
-				object_and_properties_init(op, zend_standard_class_def, Z_ARRVAL_P(op));
+				HashTable *properties = emalloc(sizeof(HashTable));
+				zend_array *arr = Z_ARR_P(op);
+
+				memcpy(properties, Z_ARRVAL_P(op), sizeof(HashTable));
+				object_and_properties_init(op, zend_standard_class_def, properties);
+				if (--GC_REFCOUNT(arr) == 0) {
+					efree(arr);
+				}
 				break;
 			}
 		case IS_OBJECT:
@@ -761,13 +773,13 @@ ZEND_API void convert_to_object(zval *op) /* {{{ */
 
 ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */
 {
-	zval **arg;
+	zval *arg;
 	va_list ap;
 
 	va_start(ap, argc);
 
 	while (argc--) {
-		arg = va_arg(ap, zval **);
+		arg = va_arg(ap, zval *);
 		convert_to_long_ex(arg);
 	}
 
@@ -777,13 +789,13 @@ ZEND_API void multi_convert_to_long_ex(int argc, ...) /* {{{ */
 
 ZEND_API void multi_convert_to_double_ex(int argc, ...) /* {{{ */
 {
-	zval **arg;
+	zval *arg;
 	va_list ap;
 
 	va_start(ap, argc);
 
 	while (argc--) {
-		arg = va_arg(ap, zval **);
+		arg = va_arg(ap, zval *);
 		convert_to_double_ex(arg);
 	}
 
@@ -793,13 +805,13 @@ ZEND_API void multi_convert_to_double_ex(int argc, ...) /* {{{ */
 
 ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */
 {
-	zval **arg;
+	zval *arg;
 	va_list ap;
 
 	va_start(ap, argc);
 
 	while (argc--) {
-		arg = va_arg(ap, zval **);
+		arg = va_arg(ap, zval *);
 		convert_to_string_ex(arg);
 	}
 
@@ -807,6 +819,149 @@ ZEND_API void multi_convert_to_string_ex(int argc, ...) /* {{{ */
 }
 /* }}} */
 
+ZEND_API long zval_get_long(zval *op TSRMLS_DC) /* {{{ */
+{
+	switch (Z_TYPE_P(op)) {
+		case IS_NULL:
+			return 0;
+		case IS_RESOURCE:
+			return Z_RES_HANDLE_P(op);
+		case IS_BOOL:
+		case IS_LONG:
+			return Z_LVAL_P(op);
+		case IS_DOUBLE:
+			return zend_dval_to_lval(Z_DVAL_P(op));
+		case IS_STRING:
+			return strtol(Z_STRVAL_P(op), NULL, 10);
+		case IS_ARRAY:
+			return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1 : 0;
+		case IS_OBJECT:
+			{
+				zval tmp;
+				ZVAL_DUP(&tmp, op);
+				convert_object_to_type(&tmp, IS_LONG, convert_to_long);
+				if (Z_TYPE(tmp) == IS_LONG) {
+					return Z_LVAL(tmp);
+				} else {
+					zend_error(E_NOTICE, "Object of class %s could not be converted to int", Z_OBJCE_P(op)->name->val);
+					zval_dtor(&tmp);
+					return 1;
+				}
+			}
+		default:
+			zend_error(E_WARNING, "Cannot convert to ordinal value");
+			return 0;
+	}
+}
+/* }}} */
+
+ZEND_API double zval_get_double(zval *op TSRMLS_DC) /* {{{ */
+{
+	switch (Z_TYPE_P(op)) {
+		case IS_NULL:
+			return 0.0;
+		case IS_RESOURCE:
+			return (double) Z_RES_HANDLE_P(op);
+		case IS_BOOL:
+		case IS_LONG:
+			return (double) Z_LVAL_P(op);
+		case IS_DOUBLE:
+			return Z_DVAL_P(op);
+		case IS_STRING:
+			return zend_strtod(Z_STRVAL_P(op), NULL);
+		case IS_ARRAY:
+			return zend_hash_num_elements(Z_ARRVAL_P(op)) ? 1.0 : 0.0;
+		case IS_OBJECT:
+			{
+				zval tmp;
+				ZVAL_DUP(&tmp, op);
+				convert_object_to_type(&tmp, IS_DOUBLE, convert_to_double);
+
+				if (Z_TYPE(tmp) == IS_DOUBLE) {
+					return Z_DVAL(tmp);
+				} else {
+					zend_error(E_NOTICE, "Object of class %s could not be converted to double", Z_OBJCE_P(op)->name->val);
+
+					zval_dtor(&tmp);
+					return 1.0;
+				}
+			}
+		default:
+			zend_error(E_WARNING, "Cannot convert to real value (type=%d)", Z_TYPE_P(op));
+			return 0.0;
+	}
+}
+/* }}} */
+
+ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC) /* {{{ */
+{
+try_again:
+	switch (Z_TYPE_P(op)) {
+		case IS_NULL:
+			return STR_EMPTY_ALLOC();
+		case IS_STRING:
+			return STR_COPY(Z_STR_P(op));
+		case IS_BOOL:
+			if (Z_BVAL_P(op)) {
+				return STR_INIT("1", 1, 0);
+			} else {
+				return STR_EMPTY_ALLOC();
+			}
+		case IS_RESOURCE: {
+			char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
+			int len;
+
+			len = snprintf(buf, sizeof(buf), "Resource id #%ld", Z_RES_HANDLE_P(op));
+			return STR_INIT(buf, len, 0);
+		}
+		case IS_LONG: {
+			char buf[MAX_LENGTH_OF_LONG + 1];
+			int len;
+
+			len = snprintf(buf, sizeof(buf), "%ld", Z_LVAL_P(op));
+			return STR_INIT(buf, len, 0);
+		}
+		case IS_DOUBLE: {
+			char *str;
+			int len = zend_spprintf(&str, 0, "%.*G", (int) EG(precision), Z_DVAL_P(op));
+			zend_string *retval = STR_INIT(str, len, 0);
+			efree(str);
+			return retval;
+		}
+		case IS_ARRAY:
+			zend_error(E_NOTICE, "Array to string conversion");
+			return STR_INIT("Array", sizeof("Array")-1, 0);
+		case IS_OBJECT: {
+			zval tmp;
+			//???if (zend_std_cast_object_tostring(op, &tmp, IS_STRING TSRMLS_CC) == SUCCESS) {
+			//???	return Z_STR(tmp);
+			//???}
+			if (Z_OBJ_HT_P(op)->cast_object) {
+				if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_STRING TSRMLS_CC) == SUCCESS) {
+					return Z_STR(tmp);
+				}
+			} else if (Z_OBJ_HT_P(op)->get) {
+				zval *z = Z_OBJ_HT_P(op)->get(op, &tmp TSRMLS_CC);
+				if (Z_TYPE_P(z) != IS_OBJECT) {
+					zend_string *str = zval_get_string(z);
+					zval_ptr_dtor(z);
+					return str;
+				}
+				zval_ptr_dtor(z);
+			}
+			zend_error(EG(exception) ? E_ERROR : E_RECOVERABLE_ERROR, "Object of class %s could not be converted to string", Z_OBJCE_P(op)->name->val);
+			return STR_EMPTY_ALLOC();
+		}
+		case IS_REFERENCE:
+			op = Z_REFVAL_P(op);
+			goto try_again;
+		default:
+			//??? original code returns bool(0)
+			return STR_EMPTY_ALLOC();
+	}
+}
+/* }}} */
+
 ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
 {
 	zval op1_copy, op2_copy;
@@ -840,23 +995,23 @@ ZEND_API int add_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
 				ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
 				return SUCCESS;
 
-			case TYPE_PAIR(IS_ARRAY, IS_ARRAY): {
-				zval *tmp;
-
+			case TYPE_PAIR(IS_ARRAY, IS_ARRAY):
 				if ((result == op1) && (result == op2)) {
 					/* $a += $a */
 					return SUCCESS;
 				}
 				if (result != op1) {
-					*result = *op1;
-					zval_copy_ctor(result);
+					ZVAL_DUP(result, op1);
 				}
-				zend_hash_merge(Z_ARRVAL_P(result), Z_ARRVAL_P(op2), (void (*)(void *pData)) zval_add_ref, (void *) &tmp, sizeof(zval *), 0);
+				zend_hash_merge(Z_ARRVAL_P(result), Z_ARRVAL_P(op2), zval_add_ref, 0);
 				return SUCCESS;
-			}
 
 			default:
-				if (!converted) {
+				if (Z_ISREF_P(op1)) {
+					op1 = Z_REFVAL_P(op1);
+				} else if (Z_ISREF_P(op2)) {
+					op2 = Z_REFVAL_P(op2);
+				} else if (!converted) {
 					ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_ADD);
 
 					zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -905,7 +1060,11 @@ ZEND_API int sub_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
 				return SUCCESS;
 
 			default:
-				if (!converted) {
+				if (Z_ISREF_P(op1)) {
+					op1 = Z_REFVAL_P(op1);
+				} else if (Z_ISREF_P(op2)) {
+					op2 = Z_REFVAL_P(op2);
+				} else if (!converted) {
 					ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_SUB);
 
 					zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -931,7 +1090,7 @@ ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
 				long overflow;
 
 				ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1),Z_LVAL_P(op2), Z_LVAL_P(result),Z_DVAL_P(result),overflow);
-				Z_TYPE_P(result) = overflow ? IS_DOUBLE : IS_LONG;
+				Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
 				return SUCCESS;
 
 			}
@@ -948,7 +1107,11 @@ ZEND_API int mul_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
 				return SUCCESS;
 
 			default:
-				if (!converted) {
+				if (Z_ISREF_P(op1)) {
+					op1 = Z_REFVAL_P(op1);
+				} else if (Z_ISREF_P(op2)) {
+					op2 = Z_REFVAL_P(op2);
+				} else if (!converted) {
 					ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_MUL);
 
 					zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -1098,7 +1261,11 @@ ZEND_API int div_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ *
 				return SUCCESS;
 
 			default:
-				if (!converted) {
+				if (Z_ISREF_P(op1)) {
+					op1 = Z_REFVAL_P(op1);
+				} else if (Z_ISREF_P(op2)) {
+					op2 = Z_REFVAL_P(op2);
+				} else if (!converted) {
 					ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_DIV);
 
 					zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -1194,12 +1361,11 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
 			int i;
 			zval op1_copy = *op1;
 
-			Z_TYPE_P(result) = IS_STRING;
-			Z_STRVAL_P(result) = estrndup(Z_STRVAL(op1_copy), Z_STRLEN(op1_copy));
-			Z_STRLEN_P(result) = Z_STRLEN(op1_copy);
+			ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN(op1_copy), 0));
 			for (i = 0; i < Z_STRLEN(op1_copy); i++) {
 				Z_STRVAL_P(result)[i] = ~Z_STRVAL(op1_copy)[i];
 			}
+			Z_STRVAL_P(result)[i] = 0;
 			return SUCCESS;
 		}
 		default:
@@ -1218,8 +1384,8 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /
 
 	if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
 		zval *longer, *shorter;
-		char *result_str;
-		int i, result_len;
+		zend_string *str;
+		int i;
 
 		if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
 			longer = op1;
@@ -1229,17 +1395,15 @@ ZEND_API int bitwise_or_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /
 			shorter = op1;
 		}
 
-		Z_TYPE_P(result) = IS_STRING;
-		result_len = Z_STRLEN_P(longer);
-		result_str = estrndup(Z_STRVAL_P(longer), Z_STRLEN_P(longer));
+		str = STR_ALLOC(Z_STRLEN_P(longer), 0);
 		for (i = 0; i < Z_STRLEN_P(shorter); i++) {
-			result_str[i] |= Z_STRVAL_P(shorter)[i];
+			str->val[i] = Z_STRVAL_P(longer)[i] | Z_STRVAL_P(shorter)[i];
 		}
+		memcpy(str->val + i, Z_STRVAL_P(longer) + i, Z_STRLEN_P(longer) - i + 1);
 		if (result==op1) {
-			str_efree(Z_STRVAL_P(result));
+			STR_RELEASE(Z_STR_P(result));
 		}
-		Z_STRVAL_P(result) = result_str;
-		Z_STRLEN_P(result) = result_len;
+		ZVAL_NEW_STR(result, str);
 		return SUCCESS;
 	}
 
@@ -1265,8 +1429,8 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 
 	if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
 		zval *longer, *shorter;
-		char *result_str;
-		int i, result_len;
+		zend_string *str;
+		int i;
 
 		if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
 			longer = op1;
@@ -1276,17 +1440,15 @@ ZEND_API int bitwise_and_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 			shorter = op1;
 		}
 
-		Z_TYPE_P(result) = IS_STRING;
-		result_len = Z_STRLEN_P(shorter);
-		result_str = estrndup(Z_STRVAL_P(shorter), Z_STRLEN_P(shorter));
+		str = STR_ALLOC(Z_STRLEN_P(shorter), 0);
 		for (i = 0; i < Z_STRLEN_P(shorter); i++) {
-			result_str[i] &= Z_STRVAL_P(longer)[i];
+			str->val[i] = Z_STRVAL_P(shorter)[i] & Z_STRVAL_P(longer)[i];
 		}
+		str->val[i] = 0;
 		if (result==op1) {
-			str_efree(Z_STRVAL_P(result));
+			STR_RELEASE(Z_STR_P(result));
 		}
-		Z_STRVAL_P(result) = result_str;
-		Z_STRLEN_P(result) = result_len;
+		ZVAL_NEW_STR(result, str);
 		return SUCCESS;
 	}
 
@@ -1312,8 +1474,8 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 
 	if (Z_TYPE_P(op1) == IS_STRING && Z_TYPE_P(op2) == IS_STRING) {
 		zval *longer, *shorter;
-		char *result_str;
-		int i, result_len;
+		zend_string *str;
+		int i;
 
 		if (Z_STRLEN_P(op1) >= Z_STRLEN_P(op2)) {
 			longer = op1;
@@ -1323,17 +1485,15 @@ ZEND_API int bitwise_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 			shorter = op1;
 		}
 
-		Z_TYPE_P(result) = IS_STRING;
-		result_len = Z_STRLEN_P(shorter);
-		result_str = estrndup(Z_STRVAL_P(shorter), Z_STRLEN_P(shorter));
+		str = STR_ALLOC(Z_STRLEN_P(shorter), 0);
 		for (i = 0; i < Z_STRLEN_P(shorter); i++) {
-			result_str[i] ^= Z_STRVAL_P(longer)[i];
+			str->val[i] = Z_STRVAL_P(shorter)[i] ^ Z_STRVAL_P(longer)[i];
 		}
+		str->val[i] = 0;
 		if (result==op1) {
-			str_efree(Z_STRVAL_P(result));
+			STR_RELEASE(Z_STR_P(result));
 		}
-		Z_STRVAL_P(result) = result_str;
-		Z_STRLEN_P(result) = result_len;
+		ZVAL_NEW_STR(result, str);
 		return SUCCESS;
 	}
 
@@ -1396,11 +1556,11 @@ 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;
-	char *buf = str_erealloc(Z_STRVAL_P(op1), length + 1);
+	zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0);
 
-	buf[length - 1] = (char) Z_LVAL_P(op2);
-	buf[length] = 0;
-	ZVAL_STRINGL(result, buf, length, 0);
+	buf->val[length - 1] = (char) Z_LVAL_P(op2);
+	buf->val[length] = 0;
+	ZVAL_NEW_STR(result, buf);
 	return SUCCESS;
 }
 /* }}} */
@@ -1408,12 +1568,13 @@ ZEND_API int add_char_to_string(zval *result, const zval *op1, const zval *op2)
 /* must support result==op1 */
 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);
-	char *buf = str_erealloc(Z_STRVAL_P(op1), length + 1);
+	int op1_len = Z_STRLEN_P(op1);
+	int length = op1_len + Z_STRLEN_P(op2);
+	zend_string *buf = STR_REALLOC(Z_STR_P(op1), length, 0);
 
-	memcpy(buf + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
-	buf[length] = 0;
-	ZVAL_STRINGL(result, buf, length, 0);
+	memcpy(buf->val + op1_len, Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+	buf->val[length] = 0;
+	ZVAL_NEW_STR(result, buf);
 	return SUCCESS;
 }
 /* }}} */
@@ -1446,28 +1607,28 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{
 	if (use_copy2) {
 		op2 = &op2_copy;
 	}
-	if (result==op1 && !IS_INTERNED(Z_STRVAL_P(op1))) {	/* special case, perform operations on result */
-		uint res_len = Z_STRLEN_P(op1) + Z_STRLEN_P(op2);
+	if (result==op1 && !IS_INTERNED(Z_STR_P(op1))) {	/* special case, perform operations on result */
+		uint op1_len = Z_STRLEN_P(op1);
+		uint op2_len = Z_STRLEN_P(op2);
+		uint res_len = op1_len + op2_len;
 
-		if (Z_STRLEN_P(result) < 0 || (int) (Z_STRLEN_P(op1) + Z_STRLEN_P(op2)) < 0) {
-			efree(Z_STRVAL_P(result));
+		if (Z_STRLEN_P(result) < 0 || (int) (op1_len + op2_len) < 0) {
 			ZVAL_EMPTY_STRING(result);
 			zend_error(E_ERROR, "String size overflow");
 		}
 
-		Z_STRVAL_P(result) = erealloc(Z_STRVAL_P(result), res_len+1);
-
-		memcpy(Z_STRVAL_P(result)+Z_STRLEN_P(result), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+		Z_STR_P(result) = STR_REALLOC(Z_STR_P(result), res_len, 0 );
+		Z_TYPE_INFO_P(result) = IS_STRING_EX;
+		memcpy(Z_STRVAL_P(result) + op1_len, Z_STRVAL_P(op2), op2_len);
 		Z_STRVAL_P(result)[res_len]=0;
-		Z_STRLEN_P(result) = res_len;
 	} else {
 		int length = Z_STRLEN_P(op1) + Z_STRLEN_P(op2);
-		char *buf = (char *) emalloc(length + 1);
+		zend_string *buf = STR_ALLOC(length, 0);
 
-		memcpy(buf, Z_STRVAL_P(op1), Z_STRLEN_P(op1));
-		memcpy(buf + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
-		buf[length] = 0;
-		ZVAL_STRINGL(result, buf, length, 0);
+		memcpy(buf->val, Z_STRVAL_P(op1), Z_STRLEN_P(op1));
+		memcpy(buf->val + Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2));
+		buf->val[length] = 0;
+		ZVAL_NEW_STR(result, buf);
 	}
 	if (use_copy1) {
 		zval_dtor(op1);
@@ -1481,35 +1642,17 @@ ZEND_API int concat_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{
 
 ZEND_API int string_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC) /* {{{ */
 {
-	zval op1_copy, op2_copy;
-	int use_copy1 = 0, use_copy2 = 0;
-
-	if (Z_TYPE_P(op1) != IS_STRING) {
-		zend_make_printable_zval(op1, &op1_copy, &use_copy1);
-	}
-	if (Z_TYPE_P(op2) != IS_STRING) {
-		zend_make_printable_zval(op2, &op2_copy, &use_copy2);
-	}
-
-	if (use_copy1) {
-		op1 = &op1_copy;
-	}
-	if (use_copy2) {
-		op2 = &op2_copy;
-	}
+	zend_string *str1 = zval_get_string(op1);
+	zend_string *str2 = zval_get_string(op2);
 
 	if (case_insensitive) {
-		ZVAL_LONG(result, zend_binary_zval_strcasecmp(op1, op2));
+		ZVAL_LONG(result, zend_binary_strcasecmp_l(str1->val, str1->len, str2->val, str1->len));
 	} else {
-		ZVAL_LONG(result, zend_binary_zval_strcmp(op1, op2));
+		ZVAL_LONG(result, zend_binary_strcmp(str1->val, str1->len, str2->val, str2->len));
 	}
 
-	if (use_copy1) {
-		zval_dtor(op1);
-	}
-	if (use_copy2) {
-		zval_dtor(op2);
-	}
+	STR_RELEASE(str1);
+	STR_RELEASE(str2);
 	return SUCCESS;
 }
 /* }}} */
@@ -1529,31 +1672,13 @@ ZEND_API int string_case_compare_function(zval *result, zval *op1, zval *op2 TSR
 #if HAVE_STRCOLL
 ZEND_API int string_locale_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
 {
-	zval op1_copy, op2_copy;
-	int use_copy1 = 0, use_copy2 = 0;
+	zend_string *str1 = zval_get_string(op1);
+	zend_string *str2 = zval_get_string(op2);
 
-	if (Z_TYPE_P(op1) != IS_STRING) {
-		zend_make_printable_zval(op1, &op1_copy, &use_copy1);
-	}
-	if (Z_TYPE_P(op2) != IS_STRING) {
-		zend_make_printable_zval(op2, &op2_copy, &use_copy2);
-	}
+	ZVAL_LONG(result, strcoll(str1->val, str2->val));
 
-	if (use_copy1) {
-		op1 = &op1_copy;
-	}
-	if (use_copy2) {
-		op2 = &op2_copy;
-	}
-
-	ZVAL_LONG(result, strcoll(Z_STRVAL_P(op1), Z_STRVAL_P(op2)));
-
-	if (use_copy1) {
-		zval_dtor(op1);
-	}
-	if (use_copy2) {
-		zval_dtor(op2);
-	}
+	STR_RELEASE(str1);
+	STR_RELEASE(str2);
 	return SUCCESS;
 }
 /* }}} */
@@ -1563,11 +1688,8 @@ ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_
 {
 	zval op1_copy, op2_copy;
 
-	op1_copy = *op1;
-	zval_copy_ctor(&op1_copy);
-
-	op2_copy = *op2;
-	zval_copy_ctor(&op2_copy);
+	ZVAL_DUP_DEREF(&op1_copy, op1);
+	ZVAL_DUP_DEREF(&op2_copy, op2);
 
 	convert_to_double(&op1_copy);
 	convert_to_double(&op2_copy);
@@ -1580,12 +1702,12 @@ ZEND_API int numeric_compare_function(zval *result, zval *op1, zval *op2 TSRMLS_
 
 static inline void zend_free_obj_get_result(zval *op TSRMLS_DC) /* {{{ */
 {
-	if (Z_REFCOUNT_P(op) == 0) {
-		GC_REMOVE_ZVAL_FROM_BUFFER(op);
-		zval_dtor(op);
-		FREE_ZVAL(op);
-	} else {
-		zval_ptr_dtor(&op);
+	if (Z_REFCOUNTED_P(op)) {
+		if (Z_REFCOUNT_P(op) == 0) {
+			zval_dtor(op);
+		} else {
+			zval_ptr_dtor(op);
+		}
 	}
 }
 /* }}} */
@@ -1595,7 +1717,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 	int ret;
 	int converted = 0;
 	zval op1_copy, op2_copy;
-	zval *op_free;
+	zval *op_free, tmp_free;
 
 	while (1) {
 		switch (TYPE_PAIR(Z_TYPE_P(op1), Z_TYPE_P(op2))) {
@@ -1670,7 +1792,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 				}
 
 				if (Z_TYPE_P(op1) == IS_OBJECT && Z_TYPE_P(op2) == IS_OBJECT) {
-					if (Z_OBJ_HANDLE_P(op1) == Z_OBJ_HANDLE_P(op2)) {
+					if (Z_OBJ_P(op1) == Z_OBJ_P(op2)) {
 						/* object handles are identical, apparently this is the same object */
 						ZVAL_LONG(result, 0);
 						return SUCCESS;
@@ -1682,44 +1804,50 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 				}
 				if (Z_TYPE_P(op1) == IS_OBJECT) {
 					if (Z_OBJ_HT_P(op1)->get) {
-						op_free = Z_OBJ_HT_P(op1)->get(op1 TSRMLS_CC);
+						zval rv;
+						op_free = Z_OBJ_HT_P(op1)->get(op1, &rv TSRMLS_CC);
 						ret = compare_function(result, op_free, op2 TSRMLS_CC);
 						zend_free_obj_get_result(op_free TSRMLS_CC);
 						return ret;
 					} else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
-						ALLOC_INIT_ZVAL(op_free);
-						if (Z_OBJ_HT_P(op1)->cast_object(op1, op_free, Z_TYPE_P(op2) TSRMLS_CC) == FAILURE) {
+						ZVAL_UNDEF(&tmp_free);
+						if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, Z_TYPE_P(op2) TSRMLS_CC) == FAILURE) {
 							ZVAL_LONG(result, 1);
-							zend_free_obj_get_result(op_free TSRMLS_CC);
+							zend_free_obj_get_result(&tmp_free TSRMLS_CC);
 							return SUCCESS;
 						}
-						ret = compare_function(result, op_free, op2 TSRMLS_CC);
-						zend_free_obj_get_result(op_free TSRMLS_CC);
+						ret = compare_function(result, &tmp_free, op2 TSRMLS_CC);
+						zend_free_obj_get_result(&tmp_free TSRMLS_CC);
 						return ret;
 					}
 				}
 				if (Z_TYPE_P(op2) == IS_OBJECT) {
 					if (Z_OBJ_HT_P(op2)->get) {
-						op_free = Z_OBJ_HT_P(op2)->get(op2 TSRMLS_CC);
+						zval rv;
+						op_free = Z_OBJ_HT_P(op2)->get(op2, &rv TSRMLS_CC);
 						ret = compare_function(result, op1, op_free TSRMLS_CC);
 						zend_free_obj_get_result(op_free TSRMLS_CC);
 						return ret;
 					} else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
-						ALLOC_INIT_ZVAL(op_free);
-						if (Z_OBJ_HT_P(op2)->cast_object(op2, op_free, Z_TYPE_P(op1) TSRMLS_CC) == FAILURE) {
+						ZVAL_UNDEF(&tmp_free);
+						if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, Z_TYPE_P(op1) TSRMLS_CC) == FAILURE) {
 							ZVAL_LONG(result, -1);
-							zend_free_obj_get_result(op_free TSRMLS_CC);
+							zend_free_obj_get_result(&tmp_free TSRMLS_CC);
 							return SUCCESS;
 						}
-						ret = compare_function(result, op1, op_free TSRMLS_CC);
-						zend_free_obj_get_result(op_free TSRMLS_CC);
+						ret = compare_function(result, op1, &tmp_free TSRMLS_CC);
+						zend_free_obj_get_result(&tmp_free TSRMLS_CC);
 						return ret;
 					} else if (Z_TYPE_P(op1) == IS_OBJECT) {
 						ZVAL_LONG(result, 1);
 						return SUCCESS;
 					}
 				}
-				if (!converted) {
+				if (Z_ISREF_P(op1)) {
+					op1 = Z_REFVAL_P(op1);
+				} else if (Z_ISREF_P(op2)) {
+					op2 = Z_REFVAL_P(op2);
+				} else if (!converted) {
 					if (Z_TYPE_P(op1) == IS_NULL) {
 						zendi_convert_to_boolean(op2, op2_copy, result);
 						ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
@@ -1762,7 +1890,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
 }
 /* }}} */
 
-static int hash_zval_identical_function(const zval **z1, const zval **z2) /* {{{ */
+static int hash_zval_identical_function(zval *z1, zval *z2) /* {{{ */
 {
 	zval result;
 	TSRMLS_FETCH();
@@ -1772,7 +1900,7 @@ static int hash_zval_identical_function(const zval **z1, const zval **z2) /* {{{
 	 * whereas this comparison function is expected to return 0 on identity,
 	 * and non zero otherwise.
 	 */
-	if (is_identical_function(&result, (zval *) *z1, (zval *) *z2 TSRMLS_CC)==FAILURE) {
+	if (is_identical_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
 		return 1;
 	}
 	return !Z_LVAL(result);
@@ -1781,40 +1909,45 @@ static int hash_zval_identical_function(const zval **z1, const zval **z2) /* {{{
 
 ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {{{ */
 {
-	Z_TYPE_P(result) = IS_BOOL;
 	if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
-		Z_LVAL_P(result) = 0;
+		ZVAL_BOOL(result, 0);
 		return SUCCESS;
 	}
 	switch (Z_TYPE_P(op1)) {
 		case IS_NULL:
-			Z_LVAL_P(result) = 1;
+			ZVAL_BOOL(result, 1);
 			break;
 		case IS_BOOL:
 		case IS_LONG:
+			ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
+			break;
 		case IS_RESOURCE:
-			Z_LVAL_P(result) = (Z_LVAL_P(op1) == Z_LVAL_P(op2));
+			ZVAL_BOOL(result, Z_RES_P(op1) == Z_RES_P(op2));
 			break;
 		case IS_DOUBLE:
-			Z_LVAL_P(result) = (Z_DVAL_P(op1) == Z_DVAL_P(op2));
+			ZVAL_BOOL(result, Z_DVAL_P(op1) == Z_DVAL_P(op2));
 			break;
 		case IS_STRING:
-			Z_LVAL_P(result) = ((Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
-				&& (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1))));
+			if (Z_STR_P(op1) == Z_STR_P(op2)) {
+				ZVAL_BOOL(result, 1);
+			} else {
+				ZVAL_BOOL(result, (Z_STRLEN_P(op1) == Z_STRLEN_P(op2))
+					&& (!memcmp(Z_STRVAL_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op1))));
+			}
 			break;
 		case IS_ARRAY:
-			Z_LVAL_P(result) = (Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
+			ZVAL_BOOL(result, Z_ARRVAL_P(op1) == Z_ARRVAL_P(op2) ||
 				zend_hash_compare(Z_ARRVAL_P(op1), Z_ARRVAL_P(op2), (compare_func_t) hash_zval_identical_function, 1 TSRMLS_CC)==0);
 			break;
 		case IS_OBJECT:
 			if (Z_OBJ_HT_P(op1) == Z_OBJ_HT_P(op2)) {
-				Z_LVAL_P(result) = (Z_OBJ_HANDLE_P(op1) == Z_OBJ_HANDLE_P(op2));
+				ZVAL_BOOL(result, Z_OBJ_P(op1) == Z_OBJ_P(op2));
 			} else {
-				Z_LVAL_P(result) = 0;
+				ZVAL_BOOL(result, 0);
 			}
 			break;
 		default:
-			Z_LVAL_P(result) = 0;
+			ZVAL_BOOL(result, 0);
 			return FAILURE;
 	}
 	return SUCCESS;
@@ -1907,21 +2040,28 @@ static void increment_string(zval *str) /* {{{ */
 {
 	int carry=0;
 	int pos=Z_STRLEN_P(str)-1;
-	char *s=Z_STRVAL_P(str);
-	char *t;
+	char *s;
+	zend_string *t;
 	int last=0; /* Shut up the compiler warning */
 	int ch;
 
 	if (Z_STRLEN_P(str) == 0) {
-		str_efree(Z_STRVAL_P(str));
-		Z_STRVAL_P(str) = estrndup("1", sizeof("1")-1);
-		Z_STRLEN_P(str) = 1;
+		STR_RELEASE(Z_STR_P(str));
+		Z_STR_P(str) = STR_INIT("1", sizeof("1")-1, 0);
+		Z_TYPE_INFO_P(str) = IS_STRING_EX;
 		return;
 	}
 
-	if (IS_INTERNED(s)) {
-		Z_STRVAL_P(str) = s = estrndup(s, Z_STRLEN_P(str));
+	if (IS_INTERNED(Z_STR_P(str))) {
+		Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+		Z_TYPE_INFO_P(str) = IS_STRING_EX;
+	} else if (Z_REFCOUNT_P(str) > 1) {
+		Z_DELREF_P(str);
+		Z_STR_P(str) = STR_INIT(Z_STRVAL_P(str), Z_STRLEN_P(str), 0);
+	} else {
+		STR_FORGET_HASH_VAL(Z_STR_P(str));
 	}
+	s = Z_STRVAL_P(str);
 
 	while (pos >= 0) {
 		ch = s[pos];
@@ -1963,23 +2103,22 @@ static void increment_string(zval *str) /* {{{ */
 	}
 
 	if (carry) {
-		t = (char *) emalloc(Z_STRLEN_P(str)+1+1);
-		memcpy(t+1, Z_STRVAL_P(str), Z_STRLEN_P(str));
-		Z_STRLEN_P(str)++;
-		t[Z_STRLEN_P(str)] = '\0';
+		t = STR_ALLOC(Z_STRLEN_P(str)+1, 0);
+		memcpy(t->val + 1, Z_STRVAL_P(str), Z_STRLEN_P(str));
+		t->val[Z_STRLEN_P(str) + 1] = '\0';
 		switch (last) {
 			case NUMERIC:
-				t[0] = '1';
+				t->val[0] = '1';
 				break;
 			case UPPER_CASE:
-				t[0] = 'A';
+				t->val[0] = 'A';
 				break;
 			case LOWER_CASE:
-				t[0] = 'a';
+				t->val[0] = 'a';
 				break;
 		}
-		str_efree(Z_STRVAL_P(str));
-		Z_STRVAL_P(str) = t;
+		STR_FREE(Z_STR_P(str));
+		ZVAL_NEW_STR(str, t);
 	}
 }
 /* }}} */
@@ -2008,7 +2147,7 @@ ZEND_API int increment_function(zval *op1) /* {{{ */
 
 				switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
 					case IS_LONG:
-						str_efree(Z_STRVAL_P(op1));
+						STR_RELEASE(Z_STR_P(op1));
 						if (lval == LONG_MAX) {
 							/* switch to double */
 							double d = (double)lval;
@@ -2018,7 +2157,7 @@ ZEND_API int increment_function(zval *op1) /* {{{ */
 						}
 						break;
 					case IS_DOUBLE:
-						str_efree(Z_STRVAL_P(op1));
+						STR_RELEASE(Z_STR_P(op1));
 						ZVAL_DOUBLE(op1, dval+1);
 						break;
 					default:
@@ -2030,13 +2169,12 @@ ZEND_API int increment_function(zval *op1) /* {{{ */
 			break;
 		case IS_OBJECT:
 			if (Z_OBJ_HANDLER_P(op1, do_operation)) {
-				zval *op2;
+				zval op2;
 				int res;
 				TSRMLS_FETCH();
 
-				MAKE_STD_ZVAL(op2);
-				ZVAL_LONG(op2, 1);
-				res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, op2 TSRMLS_CC);
+				ZVAL_LONG(&op2, 1);
+				res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_ADD, op1, op1, &op2 TSRMLS_CC);
 				zval_ptr_dtor(&op2);
 
 				return res;
@@ -2068,13 +2206,13 @@ ZEND_API int decrement_function(zval *op1) /* {{{ */
 			break;
 		case IS_STRING:		/* Like perl we only support string increment */
 			if (Z_STRLEN_P(op1) == 0) { /* consider as 0 */
-				str_efree(Z_STRVAL_P(op1));
+				STR_RELEASE(Z_STR_P(op1));
 				ZVAL_LONG(op1, -1);
 				break;
 			}
 			switch (is_numeric_string(Z_STRVAL_P(op1), Z_STRLEN_P(op1), &lval, &dval, 0)) {
 				case IS_LONG:
-					str_efree(Z_STRVAL_P(op1));
+					STR_RELEASE(Z_STR_P(op1));
 					if (lval == LONG_MIN) {
 						double d = (double)lval;
 						ZVAL_DOUBLE(op1, d-1);
@@ -2083,20 +2221,19 @@ ZEND_API int decrement_function(zval *op1) /* {{{ */
 					}
 					break;
 				case IS_DOUBLE:
-					str_efree(Z_STRVAL_P(op1));
+					STR_RELEASE(Z_STR_P(op1));
 					ZVAL_DOUBLE(op1, dval - 1);
 					break;
 			}
 			break;
 		case IS_OBJECT:
 			if (Z_OBJ_HANDLER_P(op1, do_operation)) {
-				zval *op2;
+				zval op2;
 				int res;
 				TSRMLS_FETCH();
 
-				MAKE_STD_ZVAL(op2);
-				ZVAL_LONG(op2, 1);
-				res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, op2 TSRMLS_CC);
+				ZVAL_LONG(&op2, 1);
+				res = Z_OBJ_HANDLER_P(op1, do_operation)(ZEND_SUB, op1, op1, &op2 TSRMLS_CC);
 				zval_ptr_dtor(&op2);
 
 				return res;
@@ -2346,17 +2483,17 @@ ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2) /* {{{ */
 		}
 	} else {
 string_cmp:
-		Z_LVAL_P(result) = zend_binary_zval_strcmp(s1, s2);
+		Z_LVAL_P(result) = zend_binary_strcmp(Z_STRVAL_P(s1), Z_STRLEN_P(s1), Z_STRVAL_P(s2), Z_STRLEN_P(s2));
 		ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(result)));
 	}
 }
 /* }}} */
 
-static int hash_zval_compare_function(const zval **z1, const zval **z2 TSRMLS_DC) /* {{{ */
+static int hash_zval_compare_function(zval *z1, zval *z2 TSRMLS_DC) /* {{{ */
 {
 	zval result;
 
-	if (compare_function(&result, (zval *) *z1, (zval *) *z2 TSRMLS_CC)==FAILURE) {
+	if (compare_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
 		return 1;
 	}
 	return Z_LVAL(result);
@@ -2383,17 +2520,15 @@ ZEND_API void zend_compare_arrays(zval *result, zval *a1, zval *a2 TSRMLS_DC) /*
 
 ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 {
-	Z_TYPE_P(result) = IS_LONG;
-
-	if (Z_OBJ_HANDLE_P(o1) == Z_OBJ_HANDLE_P(o2)) {
-		Z_LVAL_P(result) = 0;
+	if (Z_OBJ_P(o1) == Z_OBJ_P(o2)) {
+		ZVAL_LONG(result, 0);
 		return;
 	}
 
 	if (Z_OBJ_HT_P(o1)->compare_objects == NULL) {
-		Z_LVAL_P(result) = 1;
+		ZVAL_LONG(result, 1);
 	} else {
-		Z_LVAL_P(result) = Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC);
+		ZVAL_LONG(result, Z_OBJ_HT_P(o1)->compare_objects(o1, o2 TSRMLS_CC));
 	}
 }
 /* }}} */
@@ -2401,8 +2536,12 @@ ZEND_API void zend_compare_objects(zval *result, zval *o1, zval *o2 TSRMLS_DC) /
 ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC) /* {{{ */
 {
 	TSRMLS_FETCH();
+	char *str;
+	int len;
 
-	Z_STRLEN_P(op) = zend_spprintf(&Z_STRVAL_P(op), 0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op));
+	len = zend_spprintf(&str, 0, "%.*G", (int) EG(precision), (double)Z_DVAL_P(op));
+	ZVAL_NEW_STR(op, STR_INIT(str, len, 0));
+	efree(str);
 }
 /* }}} */
 
diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 1fab481269..a727df6707 100644
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -337,10 +337,18 @@ ZEND_API void convert_to_object(zval *op);
 ZEND_API void multi_convert_to_long_ex(int argc, ...);
 ZEND_API void multi_convert_to_double_ex(int argc, ...);
 ZEND_API void multi_convert_to_string_ex(int argc, ...);
+
+ZEND_API long zval_get_long(zval *op TSRMLS_DC);
+ZEND_API double zval_get_double(zval *op TSRMLS_DC);
+ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC);
+
+#define zval_get_string(op) ((Z_TYPE_P(op) == IS_STRING) ? \
+	STR_COPY(Z_STR_P(op)) : _zval_get_string_func((op) TSRMLS_CC))
+
 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);
-#define convert_to_cstring(op) if ((op)->type != IS_STRING) { _convert_to_cstring((op) ZEND_FILE_LINE_CC); }
-#define convert_to_string(op) if ((op)->type != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
+#define convert_to_cstring(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_cstring((op) ZEND_FILE_LINE_CC); }
+#define convert_to_string(op) if (Z_TYPE_P(op) != IS_STRING) { _convert_to_string((op) ZEND_FILE_LINE_CC); }
 
 ZEND_API double zend_string_to_double(const char *number, zend_uint length);
 
@@ -366,6 +374,7 @@ ZEND_API int zend_binary_strcmp(const char *s1, uint len1, const char *s2, uint
 ZEND_API int zend_binary_strncmp(const char *s1, uint len1, const char *s2, uint len2, uint length);
 ZEND_API int zend_binary_strcasecmp(const char *s1, uint len1, const char *s2, uint len2);
 ZEND_API int zend_binary_strncasecmp(const char *s1, uint len1, const char *s2, uint len2, uint length);
+ZEND_API int zend_binary_strcasecmp_l(const char *s1, uint len1, const char *s2, uint len2);
 ZEND_API int zend_binary_strncasecmp_l(const char *s1, uint len1, const char *s2, uint len2, uint length);
 
 ZEND_API void zendi_smart_strcmp(zval *result, zval *s1, zval *s2);
@@ -379,10 +388,10 @@ ZEND_API long zend_atol(const char *str, int str_len);
 ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC);
 END_EXTERN_C()
 
-#define convert_to_ex_master(ppzv, lower_type, upper_type)	\
-	if (Z_TYPE_PP(ppzv)!=IS_##upper_type) {					\
-		SEPARATE_ZVAL_IF_NOT_REF(ppzv);						\
-		convert_to_##lower_type(*ppzv);						\
+#define convert_to_ex_master(pzv, lower_type, upper_type)	\
+	if (Z_TYPE_P(pzv)!=IS_##upper_type) {					\
+		SEPARATE_ZVAL_IF_NOT_REF(pzv);						\
+		convert_to_##lower_type(pzv);						\
 	}
 
 #define convert_to_explicit_type(pzv, type)		\
@@ -415,81 +424,26 @@ END_EXTERN_C()
 		}										\
 	} while (0);
 
-#define convert_to_explicit_type_ex(ppzv, str_type)	\
-	if (Z_TYPE_PP(ppzv) != str_type) {				\
-		SEPARATE_ZVAL_IF_NOT_REF(ppzv);				\
-		convert_to_explicit_type(*ppzv, str_type);	\
+#define convert_to_explicit_type_ex(pzv, str_type)	\
+	if (Z_TYPE_P(pzv) != str_type) {				\
+		SEPARATE_ZVAL_IF_NOT_REF(pzv);				\
+		convert_to_explicit_type(pzv, str_type);	\
 	}
 
-#define convert_to_boolean_ex(ppzv)	convert_to_ex_master(ppzv, boolean, BOOL)
-#define convert_to_long_ex(ppzv)	convert_to_ex_master(ppzv, long, LONG)
-#define convert_to_double_ex(ppzv)	convert_to_ex_master(ppzv, double, DOUBLE)
-#define convert_to_string_ex(ppzv)	convert_to_ex_master(ppzv, string, STRING)
-#define convert_to_array_ex(ppzv)	convert_to_ex_master(ppzv, array, ARRAY)
-#define convert_to_object_ex(ppzv)	convert_to_ex_master(ppzv, object, OBJECT)
-#define convert_to_null_ex(ppzv)	convert_to_ex_master(ppzv, null, NULL)
-
-#define convert_scalar_to_number_ex(ppzv)							\
-	if (Z_TYPE_PP(ppzv)!=IS_LONG && Z_TYPE_PP(ppzv)!=IS_DOUBLE) {	\
-		if (!Z_ISREF_PP(ppzv)) {									\
-			SEPARATE_ZVAL(ppzv);									\
-		}															\
-		convert_scalar_to_number(*ppzv TSRMLS_CC);					\
+#define convert_to_boolean_ex(pzv)	convert_to_ex_master(pzv, boolean, BOOL)
+#define convert_to_long_ex(pzv)		convert_to_ex_master(pzv, long, LONG)
+#define convert_to_double_ex(pzv)	convert_to_ex_master(pzv, double, DOUBLE)
+#define convert_to_string_ex(pzv)	convert_to_ex_master(pzv, string, STRING)
+#define convert_to_array_ex(pzv)	convert_to_ex_master(pzv, array, ARRAY)
+#define convert_to_object_ex(pzv)	convert_to_ex_master(pzv, object, OBJECT)
+#define convert_to_null_ex(pzv)		convert_to_ex_master(pzv, null, NULL)
+
+#define convert_scalar_to_number_ex(pzv)							\
+	if (Z_TYPE_P(pzv)!=IS_LONG && Z_TYPE_P(pzv)!=IS_DOUBLE) {		\
+		SEPARATE_ZVAL_IF_NOT_REF(pzv);								\
+		convert_scalar_to_number(pzv TSRMLS_CC);					\
 	}
 
-
-#define Z_LVAL(zval)			(zval).value.lval
-#define Z_BVAL(zval)			((zend_bool)(zval).value.lval)
-#define Z_DVAL(zval)			(zval).value.dval
-#define Z_STRVAL(zval)			(zval).value.str.val
-#define Z_STRLEN(zval)			(zval).value.str.len
-#define Z_ARRVAL(zval)			(zval).value.ht
-#define Z_AST(zval)			(zval).value.ast
-#define Z_OBJVAL(zval)			(zval).value.obj
-#define Z_OBJ_HANDLE(zval)		Z_OBJVAL(zval).handle
-#define Z_OBJ_HT(zval)			Z_OBJVAL(zval).handlers
-#define Z_OBJCE(zval)			zend_get_class_entry(&(zval) TSRMLS_CC)
-#define Z_OBJPROP(zval)			Z_OBJ_HT((zval))->get_properties(&(zval) TSRMLS_CC)
-#define Z_OBJ_HANDLER(zval, hf) Z_OBJ_HT((zval))->hf
-#define Z_RESVAL(zval)			(zval).value.lval
-#define Z_OBJDEBUG(zval,is_tmp)	(Z_OBJ_HANDLER((zval),get_debug_info)?Z_OBJ_HANDLER((zval),get_debug_info)(&(zval),&is_tmp TSRMLS_CC):(is_tmp=0,Z_OBJ_HANDLER((zval),get_properties)?Z_OBJPROP(zval):NULL))
-
-#define Z_LVAL_P(zval_p)		Z_LVAL(*zval_p)
-#define Z_BVAL_P(zval_p)		Z_BVAL(*zval_p)
-#define Z_DVAL_P(zval_p)		Z_DVAL(*zval_p)
-#define Z_STRVAL_P(zval_p)		Z_STRVAL(*zval_p)
-#define Z_STRLEN_P(zval_p)		Z_STRLEN(*zval_p)
-#define Z_ARRVAL_P(zval_p)		Z_ARRVAL(*zval_p)
-#define Z_AST_P(zval_p)			Z_AST(*zval_p)
-#define Z_OBJPROP_P(zval_p)		Z_OBJPROP(*zval_p)
-#define Z_OBJCE_P(zval_p)		Z_OBJCE(*zval_p)
-#define Z_RESVAL_P(zval_p)		Z_RESVAL(*zval_p)
-#define Z_OBJVAL_P(zval_p)		Z_OBJVAL(*zval_p)
-#define Z_OBJ_HANDLE_P(zval_p)	Z_OBJ_HANDLE(*zval_p)
-#define Z_OBJ_HT_P(zval_p)		Z_OBJ_HT(*zval_p)
-#define Z_OBJ_HANDLER_P(zval_p, h)	Z_OBJ_HANDLER(*zval_p, h)
-#define Z_OBJDEBUG_P(zval_p,is_tmp)	Z_OBJDEBUG(*zval_p,is_tmp)
-
-#define Z_LVAL_PP(zval_pp)		Z_LVAL(**zval_pp)
-#define Z_BVAL_PP(zval_pp)		Z_BVAL(**zval_pp)
-#define Z_DVAL_PP(zval_pp)		Z_DVAL(**zval_pp)
-#define Z_STRVAL_PP(zval_pp)	Z_STRVAL(**zval_pp)
-#define Z_STRLEN_PP(zval_pp)	Z_STRLEN(**zval_pp)
-#define Z_ARRVAL_PP(zval_pp)	Z_ARRVAL(**zval_pp)
-#define Z_AST_PP(zval_p)		Z_AST(**zval_p)
-#define Z_OBJPROP_PP(zval_pp)	Z_OBJPROP(**zval_pp)
-#define Z_OBJCE_PP(zval_pp)		Z_OBJCE(**zval_pp)
-#define Z_RESVAL_PP(zval_pp)	Z_RESVAL(**zval_pp)
-#define Z_OBJVAL_PP(zval_pp)	Z_OBJVAL(**zval_pp)
-#define Z_OBJ_HANDLE_PP(zval_p)	Z_OBJ_HANDLE(**zval_p)
-#define Z_OBJ_HT_PP(zval_p)		Z_OBJ_HT(**zval_p)
-#define Z_OBJ_HANDLER_PP(zval_p, h)		Z_OBJ_HANDLER(**zval_p, h)
-#define Z_OBJDEBUG_PP(zval_pp,is_tmp)	Z_OBJDEBUG(**zval_pp,is_tmp)
-
-#define Z_TYPE(zval)		(zval).type
-#define Z_TYPE_P(zval_p)	Z_TYPE(*zval_p)
-#define Z_TYPE_PP(zval_pp)	Z_TYPE(**zval_pp)
-
 #if HAVE_SETLOCALE && defined(ZEND_WIN32) && !defined(ZTS) && defined(_MSC_VER) && (_MSC_VER >= 1400)
 /* This is performance improvement of tolower() on Windows and VC2005
  * Gives 10-18% on bench.php
@@ -505,7 +459,7 @@ ZEND_API void zend_update_current_locale(void);
 
 /* The offset in bytes between the value and type fields of a zval */
 #define ZVAL_OFFSETOF_TYPE	\
-	(offsetof(zval,type) - offsetof(zval,value))
+	(offsetof(zval, u1.type_info) - offsetof(zval, value))
 
 static zend_always_inline int fast_increment_function(zval *op1)
 {
@@ -516,7 +470,7 @@ static zend_always_inline int fast_increment_function(zval *op1)
 			"jno  0f\n\t"
 			"movl $0x0, (%0)\n\t"
 			"movl $0x41e00000, 0x4(%0)\n\t"
-			"movb %1, %c2(%0)\n"
+			"movl %1, %c2(%0)\n"
 			"0:"
 			:
 			: "r"(&op1->value),
@@ -529,7 +483,7 @@ static zend_always_inline int fast_increment_function(zval *op1)
 			"jno  0f\n\t"
 			"movl $0x0, (%0)\n\t"
 			"movl $0x43e00000, 0x4(%0)\n\t"
-			"movb %1, %c2(%0)\n"
+			"movl %1, %c2(%0)\n"
 			"0:"
 			:
 			: "r"(&op1->value),
@@ -539,8 +493,7 @@ static zend_always_inline int fast_increment_function(zval *op1)
 #else
 		if (UNEXPECTED(Z_LVAL_P(op1) == LONG_MAX)) {
 			/* switch to double */
-			Z_DVAL_P(op1) = (double)LONG_MAX + 1.0;
-			Z_TYPE_P(op1) = IS_DOUBLE;
+			ZVAL_DOUBLE(op1, (double)LONG_MAX + 1.0);
 		} else {
 			Z_LVAL_P(op1)++;
 		}
@@ -559,7 +512,7 @@ static zend_always_inline int fast_decrement_function(zval *op1)
 			"jno  0f\n\t"
 			"movl $0x00200000, (%0)\n\t"
 			"movl $0xc1e00000, 0x4(%0)\n\t"
-			"movb %1,%c2(%0)\n"
+			"movl %1,%c2(%0)\n"
 			"0:"
 			:
 			: "r"(&op1->value),
@@ -572,7 +525,7 @@ static zend_always_inline int fast_decrement_function(zval *op1)
 			"jno  0f\n\t"
 			"movl $0x00000000, (%0)\n\t"
 			"movl $0xc3e00000, 0x4(%0)\n\t"
-			"movb %1,%c2(%0)\n"
+			"movl %1,%c2(%0)\n"
 			"0:"
 			:
 			: "r"(&op1->value),
@@ -582,8 +535,7 @@ static zend_always_inline int fast_decrement_function(zval *op1)
 #else
 		if (UNEXPECTED(Z_LVAL_P(op1) == LONG_MIN)) {
 			/* switch to double */
-			Z_DVAL_P(op1) = (double)LONG_MIN - 1.0;
-			Z_TYPE_P(op1) = IS_DOUBLE;
+			ZVAL_DOUBLE(op1, (double)LONG_MIN - 1.0);
 		} else {
 			Z_LVAL_P(op1)--;
 		}
@@ -603,13 +555,13 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o
 			"addl   (%2), %%eax\n\t"
 			"jo     0f\n\t"     
 			"movl   %%eax, (%0)\n\t"
-			"movb   %3, %c5(%0)\n\t"
+			"movl   %3, %c5(%0)\n\t"
 			"jmp    1f\n"
 			"0:\n\t"
 			"fildl	(%1)\n\t"
 			"fildl	(%2)\n\t"
 			"faddp	%%st, %%st(1)\n\t"
-			"movb   %4, %c5(%0)\n\t"
+			"movl   %4, %c5(%0)\n\t"
 			"fstpl	(%0)\n"
 			"1:"
 			: 
@@ -626,13 +578,13 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o
 			"addq   (%2), %%rax\n\t"
 			"jo     0f\n\t"     
 			"movq   %%rax, (%0)\n\t"
-			"movb   %3, %c5(%0)\n\t"
+			"movl   %3, %c5(%0)\n\t"
 			"jmp    1f\n"
 			"0:\n\t"
 			"fildq	(%1)\n\t"
 			"fildq	(%2)\n\t"
 			"faddp	%%st, %%st(1)\n\t"
-			"movb   %4, %c5(%0)\n\t"
+			"movl   %4, %c5(%0)\n\t"
 			"fstpl	(%0)\n"
 			"1:"
 			: 
@@ -652,27 +604,22 @@ static zend_always_inline int fast_add_function(zval *result, zval *op1, zval *o
 
 			if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) == (Z_LVAL_P(op2) & LONG_SIGN_MASK)
 				&& (Z_LVAL_P(op1) & LONG_SIGN_MASK) != ((Z_LVAL_P(op1) + Z_LVAL_P(op2)) & LONG_SIGN_MASK))) {
-				Z_DVAL_P(result) = (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2);
-				Z_TYPE_P(result) = IS_DOUBLE;
+				ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) + (double) Z_LVAL_P(op2));
 			} else {
-				Z_LVAL_P(result) = Z_LVAL_P(op1) + Z_LVAL_P(op2);
-				Z_TYPE_P(result) = IS_LONG;
+				ZVAL_LONG(result, Z_LVAL_P(op1) + Z_LVAL_P(op2));
 			}
 #endif
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) + Z_DVAL_P(op2));
 			return SUCCESS;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			Z_DVAL_P(result) = Z_DVAL_P(op1) + Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) + Z_DVAL_P(op2));
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			Z_DVAL_P(result) = Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2));
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) + ((double)Z_LVAL_P(op2)));
 			return SUCCESS;
 		}
 	}
@@ -689,7 +636,7 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o
 			"subl   (%2), %%eax\n\t"
 			"jo     0f\n\t"     
 			"movl   %%eax, (%0)\n\t"
-			"movb   %3, %c5(%0)\n\t"
+			"movl   %3, %c5(%0)\n\t"
 			"jmp    1f\n"
 			"0:\n\t"
 			"fildl	(%2)\n\t"
@@ -699,7 +646,7 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o
 #else
 			"fsubp	%%st, %%st(1)\n\t"
 #endif
-			"movb   %4, %c5(%0)\n\t"
+			"movl   %4, %c5(%0)\n\t"
 			"fstpl	(%0)\n"
 			"1:"
 			: 
@@ -716,7 +663,7 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o
 			"subq   (%2), %%rax\n\t"
 			"jo     0f\n\t"     
 			"movq   %%rax, (%0)\n\t"
-			"movb   %3, %c5(%0)\n\t"
+			"movl   %3, %c5(%0)\n\t"
 			"jmp    1f\n"
 			"0:\n\t"
 			"fildq	(%2)\n\t"
@@ -726,7 +673,7 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o
 #else
 			"fsubp	%%st, %%st(1)\n\t"
 #endif
-			"movb   %4, %c5(%0)\n\t"
+			"movl   %4, %c5(%0)\n\t"
 			"fstpl	(%0)\n"
 			"1:"
 			: 
@@ -738,30 +685,24 @@ static zend_always_inline int fast_sub_function(zval *result, zval *op1, zval *o
 			  "n"(ZVAL_OFFSETOF_TYPE)
 			: "rax","cc");
 #else
-			Z_LVAL_P(result) = Z_LVAL_P(op1) - Z_LVAL_P(op2);
+			ZVAL_LONG(result, Z_LVAL_P(op1) - Z_LVAL_P(op2));
 
 			if (UNEXPECTED((Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(op2) & LONG_SIGN_MASK)
 				&& (Z_LVAL_P(op1) & LONG_SIGN_MASK) != (Z_LVAL_P(result) & LONG_SIGN_MASK))) {
-				Z_DVAL_P(result) = (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2);
-				Z_TYPE_P(result) = IS_DOUBLE;
-			} else {
-				Z_TYPE_P(result) = IS_LONG;
+				ZVAL_DOUBLE(result, (double) Z_LVAL_P(op1) - (double) Z_LVAL_P(op2));
 			}
 #endif
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) - Z_DVAL_P(op2));
 			return SUCCESS;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			Z_DVAL_P(result) = Z_DVAL_P(op1) - Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) - Z_DVAL_P(op2));
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			Z_DVAL_P(result) = Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2));
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) - ((double)Z_LVAL_P(op2)));
 			return SUCCESS;
 		}
 	}
@@ -775,21 +716,18 @@ static zend_always_inline int fast_mul_function(zval *result, zval *op1, zval *o
 			long overflow;
 
 			ZEND_SIGNED_MULTIPLY_LONG(Z_LVAL_P(op1), Z_LVAL_P(op2), Z_LVAL_P(result), Z_DVAL_P(result), overflow);
-			Z_TYPE_P(result) = overflow ? IS_DOUBLE : IS_LONG;
+			Z_TYPE_INFO_P(result) = overflow ? IS_DOUBLE : IS_LONG;
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) * Z_DVAL_P(op2));
 			return SUCCESS;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-			Z_DVAL_P(result) = Z_DVAL_P(op1) * Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) * Z_DVAL_P(op2));
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-			Z_DVAL_P(result) = Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2));
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) * ((double)Z_LVAL_P(op2)));
 			return SUCCESS;
 		}
 	}
@@ -803,53 +741,43 @@ static zend_always_inline int fast_div_function(zval *result, zval *op1, zval *o
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
 			if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
 				zend_error(E_WARNING, "Division by zero");
-				Z_LVAL_P(result) = 0;
-				Z_TYPE_P(result) = IS_BOOL;
+				ZVAL_BOOL(result, 0);
 				return FAILURE;
 			} else if (UNEXPECTED(Z_LVAL_P(op2) == -1 && Z_LVAL_P(op1) == LONG_MIN)) {
 				/* Prevent overflow error/crash */
-				Z_DVAL_P(result) = (double) LONG_MIN / -1;
-				Z_TYPE_P(result) = IS_DOUBLE;
+				ZVAL_DOUBLE(result, (double) LONG_MIN / -1);
 			} else if (EXPECTED(Z_LVAL_P(op1) % Z_LVAL_P(op2) == 0)) {
 				/* integer */
-				Z_LVAL_P(result) = Z_LVAL_P(op1) / Z_LVAL_P(op2);
-				Z_TYPE_P(result) = IS_LONG;
+				ZVAL_LONG(result, Z_LVAL_P(op1) / Z_LVAL_P(op2));
 			} else {
-				Z_DVAL_P(result) = ((double) Z_LVAL_P(op1)) / ((double)Z_LVAL_P(op2));
-				Z_TYPE_P(result) = IS_DOUBLE;
+				ZVAL_DOUBLE(result, ((double) Z_LVAL_P(op1)) / ((double)Z_LVAL_P(op2)));
 			}
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
 			if (UNEXPECTED(Z_DVAL_P(op2) == 0)) {
 				zend_error(E_WARNING, "Division by zero");
-				Z_LVAL_P(result) = 0;
-				Z_TYPE_P(result) = IS_BOOL;
+				ZVAL_BOOL(result, 0);
 				return FAILURE;
 			}
-			Z_DVAL_P(result) = ((double)Z_LVAL_P(op1)) / Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, ((double)Z_LVAL_P(op1)) / Z_DVAL_P(op2));
 			return SUCCESS;
 		}
 	} else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE) && 0) {
 		if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
 			if (UNEXPECTED(Z_DVAL_P(op2) == 0)) {
 				zend_error(E_WARNING, "Division by zero");
-				Z_LVAL_P(result) = 0;
-				Z_TYPE_P(result) = IS_BOOL;
+				ZVAL_BOOL(result, 0);
 				return FAILURE;
 			}
-			Z_DVAL_P(result) = Z_DVAL_P(op1) / Z_DVAL_P(op2);
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) / Z_DVAL_P(op2));
 			return SUCCESS;
 		} else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
 			if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
 				zend_error(E_WARNING, "Division by zero");
-				Z_LVAL_P(result) = 0;
-				Z_TYPE_P(result) = IS_BOOL;
+				ZVAL_BOOL(result, 0);
 				return FAILURE;
 			}
-			Z_DVAL_P(result) = Z_DVAL_P(op1) / ((double)Z_LVAL_P(op2));
-			Z_TYPE_P(result) = IS_DOUBLE;
+			ZVAL_DOUBLE(result, Z_DVAL_P(op1) / ((double)Z_LVAL_P(op2)));
 			return SUCCESS;
 		}
 	}
@@ -863,17 +791,14 @@ static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *o
 		if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
 			if (UNEXPECTED(Z_LVAL_P(op2) == 0)) {
 				zend_error(E_WARNING, "Division by zero");
-				Z_LVAL_P(result) = 0;
-				Z_TYPE_P(result) = IS_BOOL;
+				ZVAL_BOOL(result, 0);
 				return FAILURE;
 			} else if (UNEXPECTED(Z_LVAL_P(op2) == -1)) {
 				/* Prevent overflow error/crash if op1==LONG_MIN */
-				Z_LVAL_P(result) = 0;
-				Z_TYPE_P(result) = IS_LONG;
+				ZVAL_LONG(result, 0);
 				return SUCCESS;
 			}
-			Z_LVAL_P(result) = Z_LVAL_P(op1) % Z_LVAL_P(op2);
-			Z_TYPE_P(result) = IS_LONG;
+			ZVAL_LONG(result, Z_LVAL_P(op1) % Z_LVAL_P(op2));
 			return SUCCESS;
 		}
 	}
diff --git a/Zend/zend_stack.c b/Zend/zend_stack.c
index cf99499e79..31bb8afec5 100644
--- a/Zend/zend_stack.c
+++ b/Zend/zend_stack.c
@@ -161,6 +161,27 @@ ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*
 	}
 }
 
+ZEND_API void zend_stack_clean(zend_stack *stack, void (*func)(void *), zend_bool free_elements)
+{
+	int i;
+
+	if (func) {
+		for (i = 0; i < stack->top; i++) {
+			func(stack->elements[i]);
+		}
+	}
+	if (free_elements) {
+		if (stack->elements) {
+			for (i = 0; i < stack->top; i++) {
+				efree(stack->elements[i]);
+			}
+			efree(stack->elements);
+			stack->elements = NULL;
+		}
+		stack->top = stack->max = 0;
+	}
+}
+
 /*
  * Local variables:
  * tab-width: 4
diff --git a/Zend/zend_stack.h b/Zend/zend_stack.h
index d484879468..851e2301aa 100644
--- a/Zend/zend_stack.h
+++ b/Zend/zend_stack.h
@@ -42,6 +42,7 @@ ZEND_API void **zend_stack_base(const zend_stack *stack);
 ZEND_API int zend_stack_count(const zend_stack *stack);
 ZEND_API void zend_stack_apply(zend_stack *stack, int type, int (*apply_function)(void *element));
 ZEND_API void zend_stack_apply_with_argument(zend_stack *stack, int type, int (*apply_function)(void *element, void *arg), void *arg);
+ZEND_API void zend_stack_clean(zend_stack *stack, void (*func)(void *), zend_bool free_elements);
 END_EXTERN_C()
 
 #define ZEND_STACK_APPLY_TOPDOWN	1
diff --git a/Zend/zend_string.c b/Zend/zend_string.c
index f1162f0b4c..80571ec390 100644
--- a/Zend/zend_string.c
+++ b/Zend/zend_string.c
@@ -21,48 +21,50 @@
 #include "zend.h"
 #include "zend_globals.h"
 
-#ifndef ZEND_DEBUG_INTERNED_STRINGS
-# define ZEND_DEBUG_INTERNED_STRINGS 0
-#endif
-
-#if ZEND_DEBUG_INTERNED_STRINGS
-# include <sys/mman.h>
-#endif
-
-ZEND_API const char *(*zend_new_interned_string)(const char *str, int len, int free_src TSRMLS_DC);
+ZEND_API zend_string *(*zend_new_interned_string)(zend_string *str TSRMLS_DC);
 ZEND_API void (*zend_interned_strings_snapshot)(TSRMLS_D);
 ZEND_API void (*zend_interned_strings_restore)(TSRMLS_D);
 
-static const char *zend_new_interned_string_int(const char *str, int len, int free_src TSRMLS_DC);
+static zend_string *zend_new_interned_string_int(zend_string *str TSRMLS_DC);
 static void zend_interned_strings_snapshot_int(TSRMLS_D);
 static void zend_interned_strings_restore_int(TSRMLS_D);
 
-void zend_interned_strings_init(TSRMLS_D)
+ZEND_API zend_ulong zend_hash_func(const char *str, uint len)
 {
-#ifndef ZTS
-	size_t size = 1024 * 1024;
+	return zend_inline_hash_func(str, len);
+}
 
-#if ZEND_DEBUG_INTERNED_STRINGS
-	CG(interned_strings_start) = valloc(size);
-#else
-	CG(interned_strings_start) = malloc(size);
-#endif
+static void _str_dtor(zval *zv)
+{
+	zend_string *str = Z_STR_P(zv);
+	GC_FLAGS(str) &= ~IS_STR_INTERNED;
+	GC_REFCOUNT(str) = 1;
+}
 
-	CG(interned_strings_top) = CG(interned_strings_start);
-	CG(interned_strings_snapshot_top) = CG(interned_strings_start);
-	CG(interned_strings_end) = CG(interned_strings_start) + size;
+void zend_interned_strings_init(TSRMLS_D)
+{
+	zend_string *str;
 
-	zend_hash_init(&CG(interned_strings), 0, NULL, NULL, 1);
+#ifndef ZTS
+	zend_hash_init(&CG(interned_strings), 1024, NULL, _str_dtor, 1);
 	
 	CG(interned_strings).nTableMask = CG(interned_strings).nTableSize - 1;
-	CG(interned_strings).arBuckets = (Bucket **) pecalloc(CG(interned_strings).nTableSize, sizeof(Bucket *), CG(interned_strings).persistent);
+	CG(interned_strings).arData = (Bucket*) pecalloc(CG(interned_strings).nTableSize, sizeof(Bucket), 1);
+	CG(interned_strings).arHash = (zend_uint*) pecalloc(CG(interned_strings).nTableSize, sizeof(zend_uint), 1);
+	memset(CG(interned_strings).arHash, INVALID_IDX, CG(interned_strings).nTableSize * sizeof(zend_uint));
 
-#if ZEND_DEBUG_INTERNED_STRINGS
-	mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_READ);
-#endif
+	/* interned empty string */
+	str = STR_ALLOC(sizeof("")-1, 1);
+	str->val[0] = '\000';
+	CG(empty_string) = zend_new_interned_string_int(str TSRMLS_CC);
 
-    /* interned empty string */
-	CG(interned_empty_string) = zend_new_interned_string_int("", sizeof(""), 0 TSRMLS_CC);
+	/* one char strings (the actual interned strings are going to be created by ext/opcache) */
+	memset(CG(one_char_string), 0, sizeof(CG(one_char_string)));
+#else
+	str = STR_ALLOC(sizeof("")-1, 1);
+	str->val[0] = '\000';
+	str->gc.u.v.flags |= IS_STR_INTERNED;
+	CG(empty_string) = str;
 #endif
 
 	zend_new_interned_string = zend_new_interned_string_int;
@@ -73,94 +75,50 @@ void zend_interned_strings_init(TSRMLS_D)
 void zend_interned_strings_dtor(TSRMLS_D)
 {
 #ifndef ZTS
-#if ZEND_DEBUG_INTERNED_STRINGS
-	mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_WRITE | PROT_READ);
-#endif
-	free(CG(interned_strings).arBuckets);
-	free(CG(interned_strings_start));
+	zend_hash_destroy(&CG(interned_strings));
+#else
+	free(CG(empty_string));
 #endif
 }
 
-static const char *zend_new_interned_string_int(const char *arKey, int nKeyLength, int free_src TSRMLS_DC)
+static zend_string *zend_new_interned_string_int(zend_string *str TSRMLS_DC)
 {
 #ifndef ZTS
 	ulong h;
 	uint nIndex;
+	uint idx;
 	Bucket *p;
 
-	if (IS_INTERNED(arKey)) {
-		return arKey;
+	if (IS_INTERNED(str)) {
+		return str;
 	}
 
-	h = zend_inline_hash_func(arKey, nKeyLength);
+	h = STR_HASH_VAL(str);
 	nIndex = h & CG(interned_strings).nTableMask;
-	p = CG(interned_strings).arBuckets[nIndex];
-	while (p != NULL) {
-		if ((p->h == h) && (p->nKeyLength == nKeyLength)) {
-			if (!memcmp(p->arKey, arKey, nKeyLength)) {
-				if (free_src) {
-					efree((void *)arKey);
-				}
-				return p->arKey;
+	idx = CG(interned_strings).arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = CG(interned_strings).arData + idx;
+		if ((p->h == h) && (p->key->len == str->len)) {
+			if (!memcmp(p->key->val, str->val, str->len)) {
+				STR_RELEASE(str);
+				return p->key;
 			}
 		}
-		p = p->pNext;
-	}
-	
-	if (CG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength) >=
-	    CG(interned_strings_end)) {
-	    /* no memory */
-		return arKey;
+		idx = Z_NEXT(p->val);
 	}
-
-	p = (Bucket *) CG(interned_strings_top);
-	CG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength);
-
-#if ZEND_DEBUG_INTERNED_STRINGS
-	mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_READ | PROT_WRITE);
-#endif
 	
-	p->arKey = (char*)(p+1);
-	memcpy((char*)p->arKey, arKey, nKeyLength);
-	if (free_src) {
-		efree((void *)arKey);
-	}
-	p->nKeyLength = nKeyLength;
-	p->h = h;
-	p->pData = &p->pDataPtr;
-	p->pDataPtr = p;
-	
-	p->pNext = CG(interned_strings).arBuckets[nIndex];
-	p->pLast = NULL;
-	if (p->pNext) {
-		p->pNext->pLast = p;
-	}
-
-	HANDLE_BLOCK_INTERRUPTIONS();
-	
-	p->pListLast = CG(interned_strings).pListTail;
-	CG(interned_strings).pListTail = p;
-	p->pListNext = NULL;
-	if (p->pListLast != NULL) {
-		p->pListLast->pListNext = p;
-	}
-	if (!CG(interned_strings).pListHead) {
-		CG(interned_strings).pListHead = p;
-	}
-
-	CG(interned_strings).arBuckets[nIndex] = p;
-
-	HANDLE_UNBLOCK_INTERRUPTIONS();
+	GC_REFCOUNT(str) = 1;
+	GC_FLAGS(str) |= IS_STR_INTERNED;
 
-	CG(interned_strings).nNumOfElements++;
-
-	if (CG(interned_strings).nNumOfElements > CG(interned_strings).nTableSize) {
+	if (CG(interned_strings).nNumUsed >= CG(interned_strings).nTableSize) {
 		if ((CG(interned_strings).nTableSize << 1) > 0) {	/* Let's double the table size */
-			Bucket **t = (Bucket **) perealloc_recoverable(CG(interned_strings).arBuckets, (CG(interned_strings).nTableSize << 1) * sizeof(Bucket *), CG(interned_strings).persistent);
+			Bucket *d = (Bucket *) perealloc_recoverable(CG(interned_strings).arData, (CG(interned_strings).nTableSize << 1) * sizeof(Bucket), 1);
+			zend_uint *h = (zend_uint *) perealloc_recoverable(CG(interned_strings).arHash, (CG(interned_strings).nTableSize << 1) * sizeof(zend_uint), 1);
 
-			if (t) {
+			if (d && h) {
 				HANDLE_BLOCK_INTERRUPTIONS();
-				CG(interned_strings).arBuckets = t;
+				CG(interned_strings).arData = d;
+				CG(interned_strings).arHash = h;
 				CG(interned_strings).nTableSize = (CG(interned_strings).nTableSize << 1);
 				CG(interned_strings).nTableMask = CG(interned_strings).nTableSize - 1;
 				zend_hash_rehash(&CG(interned_strings));
@@ -169,60 +127,73 @@ static const char *zend_new_interned_string_int(const char *arKey, int nKeyLengt
 		}
 	}
 
-#if ZEND_DEBUG_INTERNED_STRINGS
-	mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_READ);
-#endif
+	HANDLE_BLOCK_INTERRUPTIONS();
+	
+	idx = CG(interned_strings).nNumUsed++;
+	CG(interned_strings).nNumOfElements++;
+	p = CG(interned_strings).arData + idx;
+	p->h = h;
+	p->key = str;
+	Z_STR(p->val) = str;
+	Z_TYPE_INFO(p->val) = IS_INTERNED_STRING_EX;
+	nIndex = h & CG(interned_strings).nTableMask;
+	Z_NEXT(p->val) = CG(interned_strings).arHash[nIndex];
+	CG(interned_strings).arHash[nIndex] = idx;
+		
+	HANDLE_UNBLOCK_INTERRUPTIONS();
 
-	return p->arKey;
+	return str;
 #else
-	return arKey;
+	return str;
 #endif
 }
 
 static void zend_interned_strings_snapshot_int(TSRMLS_D)
 {
-	CG(interned_strings_snapshot_top) = CG(interned_strings_top);
+#ifndef ZTS
+	uint idx;
+	Bucket *p;
+
+	idx = CG(interned_strings).nNumUsed;
+	while (idx > 0) {
+		idx--;
+		p = CG(interned_strings).arData + idx;
+		ZEND_ASSERT(GC_FLAGS(p->key) & IS_STR_PERSISTENT);
+		GC_FLAGS(p->key) |= IS_STR_PERMANENT;
+	}
+#endif
 }
 
 static void zend_interned_strings_restore_int(TSRMLS_D)
 {
 #ifndef ZTS
+	uint nIndex;
+	uint idx;
 	Bucket *p;
-	int i;
-#endif
-
-	CG(interned_strings_top) = CG(interned_strings_snapshot_top);
-
-#ifndef ZTS
-#if ZEND_DEBUG_INTERNED_STRINGS
-	mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_WRITE | PROT_READ);
-#endif
 
-	for (i = 0; i < CG(interned_strings).nTableSize; i++) {
-		p = CG(interned_strings).arBuckets[i];
-		while (p && p->arKey > CG(interned_strings_top)) {
-			CG(interned_strings).nNumOfElements--;
-			if (p->pListLast != NULL) {
-				p->pListLast->pListNext = p->pListNext;
-			} else { 
-				CG(interned_strings).pListHead = p->pListNext;
-			}
-			if (p->pListNext != NULL) {
-				p->pListNext->pListLast = p->pListLast;
-			} else {
-				CG(interned_strings).pListTail = p->pListLast;
-			}
-			p = p->pNext;
-		}
-		if (p) {
-			p->pLast = NULL;
-		}
-		CG(interned_strings).arBuckets[i] = p;
-	}
-
-#if ZEND_DEBUG_INTERNED_STRINGS
-	mprotect(CG(interned_strings_start), CG(interned_strings_end) - CG(interned_strings_start), PROT_READ);
-#endif
+	idx = CG(interned_strings).nNumUsed;
+	while (idx > 0) {
+		idx--;
+		p = CG(interned_strings).arData + idx;
+		if (GC_FLAGS(p->key) & IS_STR_PERMANENT) break;
+		CG(interned_strings).nNumUsed--;
+		CG(interned_strings).nNumOfElements--;
+
+		GC_FLAGS(p->key) &= ~IS_STR_INTERNED;
+		GC_REFCOUNT(p->key) = 1;
+		STR_FREE(p->key);
+
+		nIndex = p->h & CG(interned_strings).nTableMask;
+		if (CG(interned_strings).arHash[nIndex] == idx) {
+			CG(interned_strings).arHash[nIndex] = Z_NEXT(p->val);
+		} else {
+			uint prev = CG(interned_strings).arHash[nIndex];
+			while (Z_NEXT(CG(interned_strings).arData[prev].val) != idx) {
+				prev = Z_NEXT(CG(interned_strings).arData[prev].val);
+ 			}
+			Z_NEXT(CG(interned_strings).arData[prev].val) = Z_NEXT(p->val);
+ 		}
+ 	}
 #endif
 }
 
diff --git a/Zend/zend_string.h b/Zend/zend_string.h
index 978426e7c5..af83d4d3b5 100644
--- a/Zend/zend_string.h
+++ b/Zend/zend_string.h
@@ -24,70 +24,253 @@
 #include "zend.h"
 
 BEGIN_EXTERN_C()
-ZEND_API extern const char *(*zend_new_interned_string)(const char *str, int len, int free_src TSRMLS_DC);
+
+ZEND_API extern zend_string *(*zend_new_interned_string)(zend_string *str TSRMLS_DC);
 ZEND_API extern void (*zend_interned_strings_snapshot)(TSRMLS_D);
 ZEND_API extern void (*zend_interned_strings_restore)(TSRMLS_D);
 
+ZEND_API zend_ulong zend_hash_func(const char *str, uint len);
 void zend_interned_strings_init(TSRMLS_D);
 void zend_interned_strings_dtor(TSRMLS_D);
+
 END_EXTERN_C()
 
-#ifndef ZTS
+#define IS_INTERNED(s)					(GC_FLAGS(s) & IS_STR_INTERNED)
+
+#define STR_HASH_VAL(s)					zend_str_hash_val(s)
+#define STR_FORGET_HASH_VAL(s)			zend_str_forget_hash_val(s)
+
+#define STR_REFCOUNT(s)					zend_str_refcount(s)
+#define STR_ADDREF(s)					zend_str_addref(s)
+#define STR_DELREF(s)					zend_str_delref(s)
+#define STR_ALLOC(len, persistent)		zend_str_alloc(len, persistent)
+#define STR_SAFE_ALLOC(n, m, l, p)		zend_str_safe_alloc(n, m, l, p)
+#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_REALLOC(s, len, persistent)	zend_str_realloc(s, len, persistent)
+#define STR_SAFE_REALLOC(s, n, m, l, p)	zend_str_safe_realloc(s, n, m, l, p)
+#define STR_FREE(s)						zend_str_free(s)
+#define STR_RELEASE(s)					zend_str_release(s)
+#define STR_EMPTY_ALLOC()				CG(empty_string)
+
+#define _STR_HEADER_SIZE XtOffsetOf(zend_string, val)
+
+static zend_always_inline zend_ulong zend_str_hash_val(zend_string *s)
+{
+	if (!s->h) {
+		s->h = zend_hash_func(s->val, s->len);
+	}
+	return s->h;
+}
+
+static zend_always_inline void zend_str_forget_hash_val(zend_string *s)
+{
+	s->h = 0;
+}
+
+static zend_always_inline zend_uint zend_str_refcount(zend_string *s)
+{
+	if (!IS_INTERNED(s)) {
+		return GC_REFCOUNT(s);
+	}
+	return 1;
+}
 
-#define IS_INTERNED(s) \
-	(((s) >= CG(interned_strings_start)) && ((s) < CG(interned_strings_end)))
+static zend_always_inline zend_uint zend_str_addref(zend_string *s)
+{
+	if (!IS_INTERNED(s)) {
+		return ++GC_REFCOUNT(s);
+	}
+	return 1;
+}
+
+static zend_always_inline zend_uint zend_str_delref(zend_string *s)
+{
+	if (!IS_INTERNED(s)) {
+		return --GC_REFCOUNT(s);
+	}
+	return 1;
+}
 
+static zend_always_inline zend_string *zend_str_alloc(int len, int persistent)
+{
+	zend_string *ret = pemalloc(_STR_HEADER_SIZE + len + 1, persistent);
+
+	GC_REFCOUNT(ret) = 1;
+#if 1
+	/* optimized single assignment */
+	GC_TYPE_INFO(ret) = IS_STRING | ((persistent ? IS_STR_PERSISTENT : 0) << 8);
 #else
+	GC_TYPE(ret) = IS_STRING;
+	GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
+	GC_INFO(ret) = 0;
+#endif
+	ret->h = 0;
+	ret->len = len;
+	return ret;
+}
 
-#define IS_INTERNED(s) \
-	(0)
+static zend_always_inline zend_string *zend_str_safe_alloc(size_t n, size_t m, size_t l, int persistent)
+{
+	zend_string *ret = safe_pemalloc(n, m, _STR_HEADER_SIZE + l + 1, persistent);
 
+	GC_REFCOUNT(ret) = 1;
+#if 1
+	/* optimized single assignment */
+	GC_TYPE_INFO(ret) = IS_STRING | ((persistent ? IS_STR_PERSISTENT : 0) << 8);
+#else
+	GC_TYPE(ret) = IS_STRING;
+	GC_FLAGS(ret) = (persistent ? IS_STR_PERSISTENT : 0);
+	GC_INFO(ret) = 0;
 #endif
+	ret->h = 0;
+	ret->len = (n * m) + l;
+	return ret;
+}
+
+static zend_always_inline zend_string *zend_str_init(const char *str, int len, int persistent)
+{
+	zend_string *ret = STR_ALLOC(len, persistent);
+
+	memcpy(ret->val, str, len);
+	ret->val[len] = '\0';
+	return ret;
+}
+
+static zend_always_inline zend_string *zend_str_copy(zend_string *s)
+{
+	if (!IS_INTERNED(s)) {
+		STR_ADDREF(s);
+	}
+	return s;
+}
+
+static zend_always_inline zend_string *zend_str_dup(zend_string *s, int persistent)
+{
+	if (IS_INTERNED(s)) {
+		return s;
+	} else {
+		return STR_INIT(s->val, s->len, persistent);
+	}
+}
+
+static zend_always_inline zend_string *zend_str_realloc(zend_string *s, int len, int persistent)
+{
+	zend_string *ret;
 
-#define INTERNED_LEN(s) \
-	(((Bucket*)(((char*)(s))-sizeof(Bucket)))->nKeyLength)
-
-#define INTERNED_HASH(s) \
-	(((Bucket*)(((char*)(s))-sizeof(Bucket)))->h)
-
-#define str_efree(s) do { \
-		if (!IS_INTERNED(s)) { \
-			efree((char*)s); \
-		} \
-	} while (0)
-
-#define str_efree_rel(s) do { \
-		if (!IS_INTERNED(s)) { \
-			efree_rel((char *)s); \
-		} \
-	} while (0)
-
-#define str_free(s) do { \
-		if (!IS_INTERNED(s)) { \
-			free((char*)s); \
-		} \
-	} while (0)
-
-#define str_erealloc(str, new_len) \
-	(IS_INTERNED(str) \
-	 ? _str_erealloc(str, new_len, INTERNED_LEN(str)) \
-	 : erealloc(str, new_len))
-
-static inline char *_str_erealloc(char *str, size_t new_len, size_t old_len) {
-	char *buf = (char *) emalloc(new_len);
-	memcpy(buf, str, old_len);
-	return buf;
+	if (IS_INTERNED(s)) {
+		ret = STR_ALLOC(len, persistent);
+		memcpy(ret->val, s->val, (len > s->len ? s->len : len) + 1);
+	} else if (STR_REFCOUNT(s) == 1) {
+		ret = perealloc(s, _STR_HEADER_SIZE + len + 1, persistent);
+		ret->len = len;
+		STR_FORGET_HASH_VAL(ret);
+	} else {
+		ret = STR_ALLOC(len, persistent);
+		memcpy(ret->val, s->val, (len > s->len ? s->len : len) + 1);
+		STR_DELREF(s);
+	}
+	return ret;
 }
 
-#define str_estrndup(str, len) \
-	(IS_INTERNED(str) ? (str) : estrndup((str), (len)))
+static zend_always_inline zend_string *zend_str_safe_realloc(zend_string *s, size_t n, size_t m, size_t l, int persistent)
+{
+	zend_string *ret;
 
-#define str_strndup(str, len) \
-	(IS_INTERNED(str) ? (str) : zend_strndup((str), (len)));
+	if (IS_INTERNED(s)) {
+		ret = STR_SAFE_ALLOC(n, m, l, persistent);
+		memcpy(ret->val, s->val, ((n * m) + l > s->len ? s->len : ((n * m) + l)) + 1);
+	} else if (STR_REFCOUNT(s) == 1) {
+		ret = safe_perealloc(s, n, m, _STR_HEADER_SIZE + l + 1, persistent);
+		ret->len = (n * m) + l;
+		STR_FORGET_HASH_VAL(ret);
+	} else {
+		ret = STR_SAFE_ALLOC(n, m, l, persistent);
+		memcpy(ret->val, s->val, ((n * m) + l > s->len ? s->len : ((n * m) + l)) + 1);
+		STR_DELREF(s);
+	}
+	return ret;
+}
 
-#define str_hash(str, len) \
-	(IS_INTERNED(str) ? INTERNED_HASH(str) : zend_hash_func((str), (len)+1))
+static zend_always_inline void zend_str_free(zend_string *s)
+{
+	if (!IS_INTERNED(s)) {
+		ZEND_ASSERT(STR_REFCOUNT(s) <= 1);
+		pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT);
+	}
+}
 
+static zend_always_inline void zend_str_release(zend_string *s)
+{
+	if (!IS_INTERNED(s)) {
+		if (STR_DELREF(s) == 0) {
+			pefree(s, GC_FLAGS(s) & IS_STR_PERSISTENT);
+		}
+	}
+}
+
+/*
+ * DJBX33A (Daniel J. Bernstein, Times 33 with Addition)
+ *
+ * This is Daniel J. Bernstein's popular `times 33' hash function as
+ * posted by him years ago on comp.lang.c. It basically uses a function
+ * like ``hash(i) = hash(i-1) * 33 + str[i]''. This is one of the best
+ * known hash functions for strings. Because it is both computed very
+ * fast and distributes very well.
+ *
+ * The magic of number 33, i.e. why it works better than many other
+ * constants, prime or not, has never been adequately explained by
+ * anyone. So I try an explanation: if one experimentally tests all
+ * multipliers between 1 and 256 (as RSE did now) one detects that even
+ * numbers are not useable at all. The remaining 128 odd numbers
+ * (except for the number 1) work more or less all equally well. They
+ * all distribute in an acceptable way and this way fill a hash table
+ * with an average percent of approx. 86%. 
+ *
+ * If one compares the Chi^2 values of the variants, the number 33 not
+ * even has the best value. But the number 33 and a few other equally
+ * good numbers like 17, 31, 63, 127 and 129 have nevertheless a great
+ * advantage to the remaining numbers in the large set of possible
+ * multipliers: their multiply operation can be replaced by a faster
+ * operation based on just one shift plus either a single addition
+ * or subtraction operation. And because a hash function has to both
+ * distribute good _and_ has to be very fast to compute, those few
+ * numbers should be preferred and seems to be the reason why Daniel J.
+ * Bernstein also preferred it.
+ *
+ *
+ *                  -- Ralf S. Engelschall <rse@engelschall.com>
+ */
+
+static inline ulong zend_inline_hash_func(const char *str, uint len)
+{
+	register ulong hash = 5381;
+
+	/* variant with the hash unrolled eight times */
+	for (; len >= 8; len -= 8) {
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+		hash = ((hash << 5) + hash) + *str++;
+	}
+	switch (len) {
+		case 7: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */
+		case 6: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */
+		case 5: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */
+		case 4: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */
+		case 3: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */
+		case 2: hash = ((hash << 5) + hash) + *str++; /* fallthrough... */
+		case 1: hash = ((hash << 5) + hash) + *str++; break;
+		case 0: break;
+EMPTY_SWITCH_DEFAULT_CASE()
+	}
+	return hash;
+}
 
 #endif /* ZEND_STRING_H */
 
diff --git a/Zend/zend_ts_hash.c b/Zend/zend_ts_hash.c
index 100bcf188d..92cd62128e 100644
--- a/Zend/zend_ts_hash.c
+++ b/Zend/zend_ts_hash.c
@@ -59,24 +59,24 @@ static void end_write(TsHashTable *ht)
 }
 
 /* delegates */
-ZEND_API int _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
+ZEND_API void _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC)
 {
 #ifdef ZTS
 	ht->mx_reader = tsrm_mutex_alloc();
 	ht->mx_writer = tsrm_mutex_alloc();
 	ht->reader = 0;
 #endif
-	return _zend_hash_init(TS_HASH(ht), nSize, pDestructor, persistent ZEND_FILE_LINE_RELAY_CC);
+	_zend_hash_init(TS_HASH(ht), nSize, pDestructor, persistent ZEND_FILE_LINE_RELAY_CC);
 }
 
-ZEND_API int _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
+ZEND_API void _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC)
 {
 #ifdef ZTS
 	ht->mx_reader = tsrm_mutex_alloc();
 	ht->mx_writer = tsrm_mutex_alloc();
 	ht->reader = 0;
 #endif
-	return _zend_hash_init_ex(TS_HASH(ht), nSize, pDestructor, persistent, bApplyProtection ZEND_FILE_LINE_RELAY_CC);
+	_zend_hash_init_ex(TS_HASH(ht), nSize, pDestructor, persistent, bApplyProtection ZEND_FILE_LINE_RELAY_CC);
 }
 
 ZEND_API void zend_ts_hash_destroy(TsHashTable *ht)
@@ -99,45 +99,34 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht)
 	end_write(ht);
 }
 
-ZEND_API int _zend_ts_hash_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API zval *_zend_ts_hash_add_or_update(TsHashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC)
 {
-	int retval;
+	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_add_or_update(TS_HASH(ht), arKey, nKeyLength, pData, nDataSize, pDest, flag ZEND_FILE_LINE_RELAY_CC);
+	retval = _zend_hash_add_or_update(TS_HASH(ht), key, pData, flag ZEND_FILE_LINE_RELAY_CC);
 	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API int _zend_ts_hash_quick_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API zval *_zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC)
 {
-	int retval;
+	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_quick_add_or_update(TS_HASH(ht), arKey, nKeyLength, h, pData, nDataSize, pDest, flag ZEND_FILE_LINE_RELAY_CC);
+	retval = _zend_hash_index_update_or_next_insert(TS_HASH(ht), h, pData, flag ZEND_FILE_LINE_RELAY_CC);
 	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API int _zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
+ZEND_API zval *zend_ts_hash_add_empty_element(TsHashTable *ht, zend_string *key)
 {
-	int retval;
+	zval *retval;
 
 	begin_write(ht);
-	retval = _zend_hash_index_update_or_next_insert(TS_HASH(ht), h, pData, nDataSize, pDest, flag ZEND_FILE_LINE_RELAY_CC);
-	end_write(ht);
-
-	return retval;
-}
-
-ZEND_API int zend_ts_hash_add_empty_element(TsHashTable *ht, char *arKey, uint nKeyLength)
-{
-	int retval;
-
-	begin_write(ht);
-	retval = zend_hash_add_empty_element(TS_HASH(ht), arKey, nKeyLength);
+	retval = zend_hash_add_empty_element(TS_HASH(ht), key);
 	end_write(ht);
 
 	return retval;
@@ -187,67 +176,56 @@ ZEND_API void zend_ts_hash_reverse_apply(TsHashTable *ht, apply_func_t apply_fun
 	end_write(ht);
 }
 
-ZEND_API int zend_ts_hash_del_key_or_index(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag)
+ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key)
 {
 	int retval;
 
 	begin_write(ht);
-	retval = zend_hash_del_key_or_index(TS_HASH(ht), arKey, nKeyLength, h, flag);
+	retval = zend_hash_del(TS_HASH(ht), key);
 	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API ulong zend_ts_get_hash_value(TsHashTable *ht, char *arKey, uint nKeyLength)
-{
-	ulong retval;
-
-	begin_read(ht);
-	retval = zend_get_hash_value(arKey, nKeyLength);
-	end_read(ht);
-
-	return retval;
-}
-
-ZEND_API int zend_ts_hash_find(TsHashTable *ht, char *arKey, uint nKeyLength, void **pData)
+ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, ulong h)
 {
 	int retval;
 
-	begin_read(ht);
-	retval = zend_hash_find(TS_HASH(ht), arKey, nKeyLength, pData);
-	end_read(ht);
+	begin_write(ht);
+	retval = zend_hash_index_del(TS_HASH(ht), h);
+	end_write(ht);
 
 	return retval;
 }
 
-ZEND_API int zend_ts_hash_quick_find(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData)
+ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key)
 {
-	int retval;
+	zval *retval;
 
 	begin_read(ht);
-	retval = zend_hash_quick_find(TS_HASH(ht), arKey, nKeyLength, h, pData);
+	retval = zend_hash_find(TS_HASH(ht), key);
 	end_read(ht);
 
 	return retval;
 }
 
-ZEND_API int zend_ts_hash_index_find(TsHashTable *ht, ulong h, void **pData)
+ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, ulong h)
 {
-	int retval;
+	zval *retval;
 
 	begin_read(ht);
-	retval = zend_hash_index_find(TS_HASH(ht), h, pData);
+	retval = zend_hash_index_find(TS_HASH(ht), h);
 	end_read(ht);
 
 	return retval;
 }
 
-ZEND_API int zend_ts_hash_exists(TsHashTable *ht, char *arKey, uint nKeyLength)
+ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key)
 {
 	int retval;
 
 	begin_read(ht);
-	retval = zend_hash_exists(TS_HASH(ht), arKey, nKeyLength);
+	retval = zend_hash_exists(TS_HASH(ht), key);
 	end_read(ht);
 
 	return retval;
@@ -264,36 +242,36 @@ ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, ulong h)
 	return retval;
 }
 
-ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size)
+ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor)
 {
 	begin_read(source);
 	begin_write(target);
-	zend_hash_copy(TS_HASH(target), TS_HASH(source), pCopyConstructor, tmp, size);
+	zend_hash_copy(TS_HASH(target), TS_HASH(source), pCopyConstructor);
 	end_write(target);
 	end_read(source);
 }
 
-ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size)
+ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor)
 {
 	begin_read(source);
-	zend_hash_copy(target, TS_HASH(source), pCopyConstructor, tmp, size);
+	zend_hash_copy(target, TS_HASH(source), pCopyConstructor);
 	end_read(source);
 }
 
-ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite)
+ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, int overwrite)
 {
 	begin_read(source);
 	begin_write(target);
-	zend_hash_merge(TS_HASH(target), TS_HASH(source), pCopyConstructor, tmp, size, overwrite);
+	zend_hash_merge(TS_HASH(target), TS_HASH(source), pCopyConstructor, overwrite);
 	end_write(target);
 	end_read(source);
 }
 
-ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam)
+ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam)
 {
 	begin_read(source);
 	begin_write(target);
-	zend_hash_merge_ex(TS_HASH(target), TS_HASH(source), pCopyConstructor, size, pMergeSource, pParam);
+	zend_hash_merge_ex(TS_HASH(target), TS_HASH(source), pCopyConstructor, pMergeSource, pParam);
 	end_write(target);
 	end_read(source);
 }
@@ -322,12 +300,12 @@ ZEND_API int zend_ts_hash_compare(TsHashTable *ht1, TsHashTable *ht2, compare_fu
 	return retval;
 }
 
-ZEND_API int zend_ts_hash_minmax(TsHashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC)
+ZEND_API zval *zend_ts_hash_minmax(TsHashTable *ht, compare_func_t compar, int flag TSRMLS_DC)
 {
-	int retval;
+	zval *retval;
 
 	begin_read(ht);
-	retval = zend_hash_minmax(TS_HASH(ht), compar, flag, pData TSRMLS_CC);
+	retval = zend_hash_minmax(TS_HASH(ht), compar, flag TSRMLS_CC);
 	end_read(ht);
 
 	return retval;
@@ -355,22 +333,6 @@ ZEND_API int zend_ts_hash_rehash(TsHashTable *ht)
 	return retval;
 }
 
-#if ZEND_DEBUG
-void zend_ts_hash_display_pListTail(TsHashTable *ht)
-{
-	begin_read(ht);
-	zend_hash_display_pListTail(TS_HASH(ht));
-	end_read(ht);
-}
-
-void zend_ts_hash_display(TsHashTable *ht)
-{
-	begin_read(ht);
-	zend_hash_display(TS_HASH(ht));
-	end_read(ht);
-}
-#endif
-
 /*
  * Local variables:
  * tab-width: 4
diff --git a/Zend/zend_ts_hash.h b/Zend/zend_ts_hash.h
index e46acd52bf..4b0a507368 100644
--- a/Zend/zend_ts_hash.h
+++ b/Zend/zend_ts_hash.h
@@ -37,8 +37,8 @@ BEGIN_EXTERN_C()
 #define TS_HASH(table) (&(table->hash))
 
 /* startup/shutdown */
-ZEND_API int _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC);
-ZEND_API int _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC);
+ZEND_API void _zend_ts_hash_init(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent ZEND_FILE_LINE_DC);
+ZEND_API void _zend_ts_hash_init_ex(TsHashTable *ht, uint nSize, dtor_func_t pDestructor, zend_bool persistent, zend_bool bApplyProtection ZEND_FILE_LINE_DC);
 ZEND_API void zend_ts_hash_destroy(TsHashTable *ht);
 ZEND_API void zend_ts_hash_clean(TsHashTable *ht);
 
@@ -49,25 +49,19 @@ ZEND_API void zend_ts_hash_clean(TsHashTable *ht);
 
 
 /* additions/updates/changes */
-ZEND_API int _zend_ts_hash_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
-#define zend_ts_hash_update(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-		_zend_ts_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
-#define zend_ts_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
-		_zend_ts_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
-
-ZEND_API int _zend_ts_hash_quick_add_or_update(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
-#define zend_ts_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-		_zend_ts_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
-#define zend_ts_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
-		_zend_ts_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
-
-ZEND_API int _zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
-#define zend_ts_hash_index_update(ht, h, pData, nDataSize, pDest) \
-		_zend_ts_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
-#define zend_ts_hash_next_index_insert(ht, pData, nDataSize, pDest) \
-		_zend_ts_hash_index_update_or_next_insert(ht, 0, pData, nDataSize, pDest, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
-
-ZEND_API int zend_ts_hash_add_empty_element(TsHashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API zval *_zend_ts_hash_add_or_update(TsHashTable *ht, zend_string *key, zval *pData, int flag ZEND_FILE_LINE_DC);
+#define zend_ts_hash_update(ht, key, pData) \
+		_zend_ts_hash_add_or_update(ht, key, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_ts_hash_add(ht, key, pData) \
+		_zend_ts_hash_add_or_update(ht, key, pData, HASH_ADD ZEND_FILE_LINE_CC)
+
+ZEND_API zval *_zend_ts_hash_index_update_or_next_insert(TsHashTable *ht, ulong h, zval *pData, int flag ZEND_FILE_LINE_DC);
+#define zend_ts_hash_index_update(ht, h, pData) \
+		_zend_ts_hash_index_update_or_next_insert(ht, h, pData, HASH_UPDATE ZEND_FILE_LINE_CC)
+#define zend_ts_hash_next_index_insert(ht, pData) \
+		_zend_ts_hash_index_update_or_next_insert(ht, 0, pData, HASH_NEXT_INSERT ZEND_FILE_LINE_CC)
+
+ZEND_API zval* zend_ts_hash_add_empty_element(TsHashTable *ht, zend_string *key);
 
 ZEND_API void zend_ts_hash_graceful_destroy(TsHashTable *ht);
 ZEND_API void zend_ts_hash_apply(TsHashTable *ht, apply_func_t apply_func TSRMLS_DC);
@@ -78,38 +72,30 @@ ZEND_API void zend_ts_hash_reverse_apply(TsHashTable *ht, apply_func_t apply_fun
 
 
 /* Deletes */
-ZEND_API int zend_ts_hash_del_key_or_index(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, int flag);
-#define zend_ts_hash_del(ht, arKey, nKeyLength) \
-		zend_ts_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY)
-#define zend_ts_hash_index_del(ht, h) \
-		zend_ts_hash_del_key_or_index(ht, NULL, 0, h, HASH_DEL_INDEX)
-
-ZEND_API ulong zend_ts_get_hash_value(TsHashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_ts_hash_del(TsHashTable *ht, zend_string *key);
+ZEND_API int zend_ts_hash_index_del(TsHashTable *ht, ulong h);
 
 /* Data retreival */
-ZEND_API int zend_ts_hash_find(TsHashTable *ht, char *arKey, uint nKeyLength, void **pData);
-ZEND_API int zend_ts_hash_quick_find(TsHashTable *ht, char *arKey, uint nKeyLength, ulong h, void **pData);
-ZEND_API int zend_ts_hash_index_find(TsHashTable *ht, ulong h, void **pData);
+ZEND_API zval *zend_ts_hash_find(TsHashTable *ht, zend_string *key);
+ZEND_API zval *zend_ts_hash_index_find(TsHashTable *ht, ulong);
 
 /* Misc */
-ZEND_API int zend_ts_hash_exists(TsHashTable *ht, char *arKey, uint nKeyLength);
+ZEND_API int zend_ts_hash_exists(TsHashTable *ht, zend_string *key);
 ZEND_API int zend_ts_hash_index_exists(TsHashTable *ht, ulong h);
 
 /* Copying, merging and sorting */
-ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
-ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size);
-ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, void *tmp, uint size, int overwrite);
-ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, uint size, merge_checker_func_t pMergeSource, void *pParam);
+ZEND_API void zend_ts_hash_copy(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor);
+ZEND_API void zend_ts_hash_copy_to_hash(HashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor);
+ZEND_API void zend_ts_hash_merge(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, int overwrite);
+ZEND_API void zend_ts_hash_merge_ex(TsHashTable *target, TsHashTable *source, copy_ctor_func_t pCopyConstructor, merge_checker_func_t pMergeSource, void *pParam);
 ZEND_API int zend_ts_hash_sort(TsHashTable *ht, sort_func_t sort_func, compare_func_t compare_func, int renumber TSRMLS_DC);
 ZEND_API int zend_ts_hash_compare(TsHashTable *ht1, TsHashTable *ht2, compare_func_t compar, zend_bool ordered TSRMLS_DC);
-ZEND_API int zend_ts_hash_minmax(TsHashTable *ht, compare_func_t compar, int flag, void **pData TSRMLS_DC);
+ZEND_API zval *zend_ts_hash_minmax(TsHashTable *ht, compare_func_t compar, int flag TSRMLS_DC);
 
 ZEND_API int zend_ts_hash_num_elements(TsHashTable *ht);
 
 ZEND_API int zend_ts_hash_rehash(TsHashTable *ht);
 
-ZEND_API ulong zend_ts_hash_func(char *arKey, uint nKeyLength);
-
 #if ZEND_DEBUG
 /* debug */
 void zend_ts_hash_display_pListTail(TsHashTable *ht);
diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index e5d5bbb500..2afd54f0ec 100644
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -22,6 +22,22 @@
 #ifndef ZEND_TYPES_H
 #define ZEND_TYPES_H
 
+#ifdef WORDS_BIGENDIAN
+# define ZEND_ENDIAN_LOHI(lo, hi)          hi; lo;
+# define ZEND_ENDIAN_LOHI_3(lo, mi, hi)    hi; mi; lo;
+# define ZEND_ENDIAN_LOHI_4(a, b, c, d)    d; c; b; a;
+# define ZEND_ENDIAN_LOHI_C(lo, hi)        hi, lo
+# define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi)  hi, mi, lo,
+# define ZEND_ENDIAN_LOHI_C_4(a, b, c, d)  d, c, b, a
+#else
+# define ZEND_ENDIAN_LOHI(lo, hi)          lo; hi;
+# define ZEND_ENDIAN_LOHI_3(lo, mi, hi)    lo; mi; hi;
+# define ZEND_ENDIAN_LOHI_4(a, b, c, d)    a; b; c; d;
+# define ZEND_ENDIAN_LOHI_C(lo, hi)        lo, hi
+# define ZEND_ENDIAN_LOHI_C_3(lo, mi, hi)  lo, mi, hi,
+# define ZEND_ENDIAN_LOHI_C_4(a, b, c, d)  a, b, c, d
+#endif
+
 typedef unsigned char zend_bool;
 typedef unsigned char zend_uchar;
 typedef unsigned int zend_uint;
@@ -50,14 +66,566 @@ typedef long zend_intptr_t;
 typedef unsigned long zend_uintptr_t;
 #endif
 
-typedef unsigned int zend_object_handle;
 typedef struct _zend_object_handlers zend_object_handlers;
-typedef struct _zval_struct zval;
+typedef struct _zend_class_entry     zend_class_entry;
+typedef union  _zend_function        zend_function;
+
+typedef struct _zval_struct     zval;
+
+typedef struct _zend_refcounted zend_refcounted;
+typedef struct _zend_string     zend_string;
+typedef struct _zend_array      zend_array;
+typedef struct _zend_object     zend_object;
+typedef struct _zend_resource   zend_resource;
+typedef struct _zend_reference  zend_reference;
+typedef struct _zend_ast_ref    zend_ast_ref;
+typedef struct _zend_ast        zend_ast;
+
+typedef int  (*compare_func_t)(const void *, const void * TSRMLS_DC);
+typedef void (*sort_func_t)(void *, size_t, size_t, compare_func_t TSRMLS_DC);
+typedef void (*dtor_func_t)(zval *pDest);
+typedef void (*copy_ctor_func_t)(zval *pElement);
+
+typedef union _zend_value {
+	long              lval;				/* long value */
+	double            dval;				/* double value */
+	zend_refcounted  *counted;
+	zend_string      *str;
+	zend_array       *arr;
+	zend_object      *obj;
+	zend_resource    *res;
+	zend_reference   *ref;
+	zend_ast_ref     *ast;
+	zval             *zv;
+	void             *ptr;
+	zend_class_entry *ce;
+	zend_function    *func;
+} zend_value;
 
-typedef struct _zend_object_value {
-	zend_object_handle handle;
+struct _zval_struct {
+	zend_value        value;			/* value */
+	union {
+		struct {
+			ZEND_ENDIAN_LOHI_4(
+				zend_uchar    type,			/* active type */
+				zend_uchar    type_flags,
+				zend_uchar    const_flags,
+				zend_uchar    reserved)	    /* various IS_VAR flags */
+		} v;
+		zend_uint type_info;
+	} u1;
+	union {
+		zend_uint     var_flags;
+		zend_uint     next;                 /* hash collision chain */
+		zend_uint     str_offset;           /* string offset */
+		zend_uint     cache_slot;           /* literal cache slot */
+	} u2;
+};
+
+struct _zend_refcounted {
+	zend_uint         refcount;			/* reference counter 32-bit */
+	union {
+		struct {
+			ZEND_ENDIAN_LOHI_3(
+				zend_uchar    type,
+				zend_uchar    flags,    /* used for strings & objects */
+				zend_ushort   gc_info)  /* keeps GC root number (or 0) and color */
+		} v;
+		zend_uint type_info;
+	} u;
+};
+
+struct _zend_string {
+	zend_refcounted   gc;
+	zend_ulong        h;                /* hash value */
+	int               len;
+	char              val[1];
+};
+
+typedef struct _Bucket {
+	zend_ulong        h;                /* hash value (or numeric index)   */
+	zend_string      *key;              /* string key or NULL for numerics */
+	zval              val;
+} Bucket;
+
+typedef struct _HashTable {	
+	zend_uint         nTableSize;
+	zend_uint         nTableMask;
+	zend_uint         nNumUsed;
+	zend_uint         nNumOfElements;
+	long              nNextFreeElement;
+	Bucket           *arData;
+	zend_uint        *arHash;
+	dtor_func_t       pDestructor;
+	zend_uint         nInternalPointer; 
+	union {
+		struct {
+			ZEND_ENDIAN_LOHI_3(
+				zend_uchar    flags,
+				zend_uchar    nApplyCount,
+				zend_ushort   reserve)
+		} v;
+		zend_uint flags;
+	} u;
+} HashTable;
+
+struct _zend_array {
+	zend_refcounted   gc;
+	HashTable         ht;
+};
+
+struct _zend_object {
+	zend_refcounted   gc;
+	zend_uint         handle; // TODO: may be removed ???
+	zend_class_entry *ce;
 	const zend_object_handlers *handlers;
-} zend_object_value;
+	HashTable        *properties;
+	HashTable        *guards; /* protects from __get/__set ... recursion */
+	zval              properties_table[1];
+};
+
+struct _zend_resource {
+	zend_refcounted   gc;
+	long              handle; // TODO: may be removed ???
+	int               type;
+	void             *ptr;
+};
+
+struct _zend_reference {
+	zend_refcounted   gc;
+	zval              val;
+};
+
+struct _zend_ast_ref {
+	zend_refcounted   gc;
+	zend_ast         *ast;
+};
+
+/* data types */
+#define IS_UNDEF					0
+#define IS_NULL						1
+#define IS_INDIRECT             	2
+#define IS_BOOL						3
+#define IS_LONG						4
+#define IS_DOUBLE					5
+#define IS_STRING					6
+#define IS_ARRAY					7
+#define IS_OBJECT					8
+#define IS_RESOURCE					9
+#define IS_REFERENCE				10
+
+#define IS_CONSTANT					11
+#define IS_CONSTANT_ARRAY			12
+#define IS_CONSTANT_AST				13
+#define IS_CALLABLE					14
+
+#define IS_STR_OFFSET				15
+#define IS_PTR						16
+
+static inline zend_uchar zval_get_type(const zval* pz) {
+	return pz->u1.v.type;
+}
+
+/* we should never set just Z_TYPE, we should set Z_TYPE_INFO */
+#define Z_TYPE(zval)				zval_get_type(&(zval))
+#define Z_TYPE_P(zval_p)			Z_TYPE(*(zval_p))
+
+#define Z_TYPE_FLAGS(zval)			(zval).u1.v.type_flags
+#define Z_TYPE_FLAGS_P(zval_p)		Z_TYPE_FLAGS(*(zval_p))
+
+#define Z_CONST_FLAGS(zval)			(zval).u1.v.const_flags
+#define Z_CONST_FLAGS_P(zval_p)		Z_CONST_FLAGS(*(zval_p))
+
+#define Z_VAR_FLAGS(zval)			(zval).u2.var_flags
+#define Z_VAR_FLAGS_P(zval_p)		Z_VAR_FLAGS(*(zval_p))
+
+#define Z_TYPE_INFO(zval)			(zval).u1.type_info
+#define Z_TYPE_INFO_P(zval_p)		Z_TYPE_INFO(*(zval_p))
+
+#define Z_NEXT(zval)				(zval).u2.next
+#define Z_NEXT_P(zval_p)			Z_NEXT(*(zval_p))
+
+#define Z_CACHE_SLOT(zval)			(zval).u2.cache_slot
+#define Z_CACHE_SLOT_P(zval_p)		Z_CACHE_SLOT(*(zval_p))
+
+#define Z_COUNTED(zval)				(zval).value.counted
+#define Z_COUNTED_P(zval_p)			Z_COUNTED(*(zval_p))
+
+#define Z_TYPE_FLAGS_SHIFT			8
+#define Z_CONST_FLAGS_SHIFT			8
+
+#define GC_REFCOUNT(p)				((zend_refcounted*)(p))->refcount
+#define GC_TYPE(p)					((zend_refcounted*)(p))->u.v.type
+#define GC_FLAGS(p)					((zend_refcounted*)(p))->u.v.flags
+#define GC_INFO(p)					((zend_refcounted*)(p))->u.v.gc_info
+#define GC_TYPE_INFO(p)				((zend_refcounted*)(p))->u.type_info
+
+#define Z_GC_TYPE(zval)				GC_TYPE(Z_COUNTED(zval))
+#define Z_GC_TYPE_P(zval_p)			Z_GC_TYPE(*(zval_p))
+
+#define Z_GC_FLAGS(zval)			GC_FLAGS(Z_COUNTED(zval))
+#define Z_GC_FLAGS_P(zval_p)		Z_GC_TYPE(*(zval_p))
+
+#define Z_GC_INFO(zval)				GC_INFO(Z_COUNTED(zval))
+#define Z_GC_INFO_P(zval_p)			Z_GC_INFO(*(zval_p))
+
+#define Z_GC_TYPE_INFO(zval)		GC_TYPE_INFO(Z_COUNTED(zval))
+#define Z_GC_TYPE_INFO_P(zval_p)	Z_GC_TYPE_INFO(*(zval_p))
+
+/* zval.u1.v.type_flags */
+#define IS_TYPE_CONSTANT			(1<<0)
+#define IS_TYPE_REFCOUNTED			(1<<1)
+#define IS_TYPE_COLLECTABLE			(1<<2)
+#define IS_TYPE_COPYABLE			(1<<3)
+
+/* extended types */
+#define IS_INTERNED_STRING_EX		IS_STRING
+
+#define IS_STRING_EX				(IS_STRING         | ((                   IS_TYPE_REFCOUNTED |                       IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT))
+#define IS_ARRAY_EX					(IS_ARRAY          | ((                   IS_TYPE_REFCOUNTED | IS_TYPE_COLLECTABLE | IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT))
+#define IS_OBJECT_EX				(IS_OBJECT         | ((                   IS_TYPE_REFCOUNTED | IS_TYPE_COLLECTABLE                   ) << Z_TYPE_FLAGS_SHIFT))
+#define IS_RESOURCE_EX				(IS_RESOURCE       | ((                   IS_TYPE_REFCOUNTED                                         ) << Z_TYPE_FLAGS_SHIFT))
+#define IS_REFERENCE_EX				(IS_REFERENCE      | ((                   IS_TYPE_REFCOUNTED                                         ) << Z_TYPE_FLAGS_SHIFT))
+
+#define IS_CONSTANT_EX				(IS_CONSTANT       | ((IS_TYPE_CONSTANT | IS_TYPE_REFCOUNTED |                       IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT))
+#define IS_CONSTANT_ARRAY_EX		(IS_CONSTANT_ARRAY | ((IS_TYPE_CONSTANT | IS_TYPE_REFCOUNTED |                       IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT))
+#define IS_CONSTANT_AST_EX			(IS_CONSTANT_AST   | ((IS_TYPE_CONSTANT | IS_TYPE_REFCOUNTED |                       IS_TYPE_COPYABLE) << Z_TYPE_FLAGS_SHIFT))
+
+/* zval.u1.v.const_flags */
+#define IS_CONSTANT_UNQUALIFIED		0x010
+#define IS_LEXICAL_VAR				0x020
+#define IS_LEXICAL_REF				0x040
+#define IS_CONSTANT_IN_NAMESPACE	0x100  /* used only in opline->extended_value */
+
+/* zval.u2.var_flags */
+#define IS_VAR_RET_REF				(1<<0) /* return by by reference */
+
+/* string flags (zval.value->gc.u.flags) */
+#define IS_STR_PERSISTENT			(1<<0) /* allocated using malloc   */
+#define IS_STR_INTERNED				(1<<1) /* interned string          */
+#define IS_STR_PERMANENT        	(1<<2) /* relives request boundary */
+
+#define IS_STR_CONSTANT             (1<<3) /* constant index */
+#define IS_STR_CONSTANT_UNQUALIFIED (1<<4) /* the same as IS_CONSTANT_UNQUALIFIED */
+#define IS_STR_AST                  (1<<5) /* constant expression index */
+
+/* object flags (zval.value->gc.u.flags) */
+#define IS_OBJ_APPLY_COUNT			0x07
+#define IS_OBJ_DESTRUCTOR_CALLED	(1<<3)
+#define IS_OBJ_FREE_CALLED			(1<<4)
+
+#define Z_OBJ_APPLY_COUNT(zval) \
+	(Z_GC_FLAGS(zval) & IS_OBJ_APPLY_COUNT)
+
+#define Z_OBJ_INC_APPLY_COUNT(zval) do { \
+		Z_GC_FLAGS(zval) = \
+			(Z_GC_FLAGS(zval) & ~IS_OBJ_APPLY_COUNT) | \
+			((Z_GC_FLAGS(zval) & IS_OBJ_APPLY_COUNT) + 1); \
+	} while (0)
+	
+#define Z_OBJ_DEC_APPLY_COUNT(zval) do { \
+		Z_GC_FLAGS(zval) = \
+			(Z_GC_FLAGS(zval) & ~IS_OBJ_APPLY_COUNT) | \
+			((Z_GC_FLAGS(zval) & IS_OBJ_APPLY_COUNT) - 1); \
+	} while (0)
+
+#define Z_OBJ_APPLY_COUNT_P(zv)     Z_OBJ_APPLY_COUNT(*(zv))
+#define Z_OBJ_INC_APPLY_COUNT_P(zv) Z_OBJ_INC_APPLY_COUNT(*(zv))
+#define Z_OBJ_DEC_APPLY_COUNT_P(zv) Z_OBJ_DEC_APPLY_COUNT(*(zv))
+
+/* All data types < IS_STRING have their constructor/destructors skipped */
+#define Z_CONSTANT(zval)			((Z_TYPE_FLAGS(zval) & IS_TYPE_CONSTANT) != 0)
+#define Z_CONSTANT_P(zval_p)		Z_CONSTANT(*(zval_p))
+
+#define Z_REFCOUNTED(zval)			((Z_TYPE_FLAGS(zval) & IS_TYPE_REFCOUNTED) != 0)
+#define Z_REFCOUNTED_P(zval_p)		Z_REFCOUNTED(*(zval_p))
+
+#define Z_COLLECTABLE(zval)			((Z_TYPE_FLAGS(zval) & IS_TYPE_COLLECTABLE) != 0)
+#define Z_COLLECTABLE_P(zval_p)		Z_COLLECTABLE(*(zval_p))
+
+#define Z_COPYABLE(zval)			((Z_TYPE_FLAGS(zval) & IS_TYPE_COPYABLE) != 0)
+#define Z_COPYABLE_P(zval_p)		Z_COPYABLE(*(zval_p))
+
+/* the following Z_OPT_* macros make better code when Z_TYPE_INFO accessed before */
+#define Z_OPT_TYPE(zval)			(Z_TYPE_INFO(zval) & 0xff)
+#define Z_OPT_TYPE_P(zval_p)		Z_OPT_TYPE(*(zval_p))
+
+#define Z_OPT_CONSTANT(zval)		((Z_TYPE_INFO(zval) & (IS_TYPE_CONSTANT << Z_TYPE_FLAGS_SHIFT)) != 0)
+#define Z_OPT_CONSTANT_P(zval_p)	Z_OPT_CONSTANT(*(zval_p))
+
+#define Z_OPT_REFCOUNTED(zval)		((Z_TYPE_INFO(zval) & (IS_TYPE_REFCOUNTED << Z_TYPE_FLAGS_SHIFT)) != 0)
+#define Z_OPT_REFCOUNTED_P(zval_p)	Z_OPT_REFCOUNTED(*(zval_p))
+
+#define Z_OPT_COLLECTABLE(zval)		((Z_TYPE_INFO(zval) & (IS_TYPE_COLLECTABLE << Z_TYPE_FLAGS_SHIFT)) != 0)
+#define Z_OPT_COLLECTABLE_P(zval_p)	Z_OPT_COLLECTABLE(*(zval_p))
+
+#define Z_OPT_COPYABLE(zval)		((Z_TYPE_INFO(zval) & (IS_TYPE_COPYABLE << Z_TYPE_FLAGS_SHIFT)) != 0)
+#define Z_OPT_COPYABLE_P(zval_p)	Z_OPT_COPYABLE(*(zval_p))
+
+#define Z_ISREF(zval)				(Z_TYPE(zval) == IS_REFERENCE)
+#define Z_ISREF_P(zval_p)			Z_ISREF(*(zval_p))
+
+#define Z_BVAL(zval)				(zend_bool)(zval).value.lval
+#define Z_BVAL_P(zval_p)			Z_LVAL(*(zval_p))
+
+#define Z_LVAL(zval)				(zval).value.lval
+#define Z_LVAL_P(zval_p)			Z_LVAL(*(zval_p))
+
+#define Z_DVAL(zval)				(zval).value.dval
+#define Z_DVAL_P(zval_p)			Z_DVAL(*(zval_p))
+
+#define Z_STR(zval)					(zval).value.str
+#define Z_STR_P(zval_p)				Z_STR(*(zval_p))
+
+#define Z_STRVAL(zval)				Z_STR(zval)->val
+#define Z_STRVAL_P(zval_p)			Z_STRVAL(*(zval_p))
+
+#define Z_STRLEN(zval)				Z_STR(zval)->len
+#define Z_STRLEN_P(zval_p)			Z_STRLEN(*(zval_p))
+
+#define Z_STRHASH(zval)				Z_STR(zval)->h
+#define Z_STRHASH_P(zval_p)			Z_STRHASH(*(zval_p))
+
+#define Z_ARR(zval)					(zval).value.arr
+#define Z_ARR_P(zval_p)				Z_ARR(*(zval_p))
+
+#define Z_ARRVAL(zval)				(&Z_ARR(zval)->ht)
+#define Z_ARRVAL_P(zval_p)			Z_ARRVAL(*(zval_p))
+
+#define Z_OBJ(zval)					(zval).value.obj
+#define Z_OBJ_P(zval_p)				Z_OBJ(*(zval_p))
+
+#define Z_OBJ_HT(zval)				Z_OBJ(zval)->handlers
+#define Z_OBJ_HT_P(zval_p)			Z_OBJ_HT(*(zval_p))
+
+#define Z_OBJ_HANDLER(zval, hf)		Z_OBJ_HT((zval))->hf
+#define Z_OBJ_HANDLER_P(zv_p, hf)	Z_OBJ_HANDLER(*(zv_p), hf)
+
+#define Z_OBJ_HANDLE(zval)          (Z_OBJ((zval)))->handle
+#define Z_OBJ_HANDLE_P(zval_p)      Z_OBJ_HANDLE(*(zval_p))
+
+#define Z_OBJCE(zval)				zend_get_class_entry(Z_OBJ(zval) TSRMLS_CC)
+#define Z_OBJCE_P(zval_p)			Z_OBJCE(*(zval_p))
+
+#define Z_OBJPROP(zval)				Z_OBJ_HT((zval))->get_properties(&(zval) TSRMLS_CC)
+#define Z_OBJPROP_P(zval_p)			Z_OBJPROP(*(zval_p))
+
+#define Z_OBJDEBUG(zval,tmp)		(Z_OBJ_HANDLER((zval),get_debug_info)?Z_OBJ_HANDLER((zval),get_debug_info)(&(zval),&tmp TSRMLS_CC):(tmp=0,Z_OBJ_HANDLER((zval),get_properties)?Z_OBJPROP(zval):NULL))
+#define Z_OBJDEBUG_P(zval_p,tmp)	Z_OBJDEBUG(*(zval_p), tmp)
+
+#define Z_RES(zval)					(zval).value.res
+#define Z_RES_P(zval_p)				Z_RES(*zval_p)
+
+#define Z_RES_HANDLE(zval)			Z_RES(zval)->handle
+#define Z_RES_HANDLE_P(zval_p)		Z_RES_HANDLE(*zval_p)
+
+#define Z_RES_TYPE(zval)			Z_RES(zval)->type
+#define Z_RES_TYPE_P(zval_p)		Z_RES_TYPE(*zval_p)
+
+#define Z_RES_VAL(zval)				Z_RES(zval)->ptr
+#define Z_RES_VAL_P(zval_p)			Z_RES_VAL(*zval_p)
+
+#define Z_REF(zval)					(zval).value.ref
+#define Z_REF_P(zval_p)				Z_REF(*(zval_p))
+
+#define Z_REFVAL(zval)				&Z_REF(zval)->val
+#define Z_REFVAL_P(zval_p)			Z_REFVAL(*(zval_p))
+
+#define Z_AST(zval)					(zval).value.ast
+#define Z_AST_P(zval_p)				Z_AST(*(zval_p))
+
+#define Z_ASTVAL(zval)				(zval).value.ast->ast
+#define Z_ASTVAL_P(zval_p)			Z_ASTVAL(*(zval_p))
+
+#define Z_INDIRECT(zval)			(zval).value.zv
+#define Z_INDIRECT_P(zval_p)		Z_INDIRECT(*(zval_p))
+
+#define Z_CE(zval)					(zval).value.ce
+#define Z_CE_P(zval_p)				Z_CE(*(zval_p))
+
+#define Z_FUNC(zval)				(zval).value.func
+#define Z_FUNC_P(zval_p)			Z_FUNC(*(zval_p))
+
+#define Z_PTR(zval)					(zval).value.ptr
+#define Z_PTR_P(zval_p)				Z_PTR(*(zval_p))
+
+#define ZVAL_UNDEF(z) do {				\
+		Z_TYPE_INFO_P(z) = IS_UNDEF;	\
+	} while (0)
+
+#define ZVAL_NULL(z) do {				\
+		Z_TYPE_INFO_P(z) = IS_NULL;		\
+	} while (0)
+
+#define ZVAL_BOOL(z, b) do {			\
+		zval *__z = (z);				\
+		Z_LVAL_P(__z) = ((b) != 0);		\
+		Z_TYPE_INFO_P(__z) = IS_BOOL;	\
+	} while (0)
+
+#define ZVAL_LONG(z, l) {				\
+		zval *__z = (z);				\
+		Z_LVAL_P(__z) = l;				\
+		Z_TYPE_INFO_P(__z) = IS_LONG;	\
+	}
+
+#define ZVAL_DOUBLE(z, d) {				\
+		zval *__z = (z);				\
+		Z_DVAL_P(__z) = d;				\
+		Z_TYPE_INFO_P(__z) = IS_DOUBLE;	\
+	}
+
+#define ZVAL_STR(z, s) do {						\
+		zval *__z = (z);						\
+		zend_string *__s = (s);					\
+		Z_STR_P(__z) = __s;						\
+		/* interned strings support */			\
+		Z_TYPE_INFO_P(__z) = IS_INTERNED(__s) ? \
+			IS_INTERNED_STRING_EX : 			\
+			IS_STRING_EX;						\
+	} while (0)
+
+#define ZVAL_INT_STR(z, s) do {					\
+		zval *__z = (z);						\
+		zend_string *__s = (s);					\
+		Z_STR_P(__z) = __s;						\
+		Z_TYPE_INFO_P(__z) = IS_INTERNED_STRING_EX;	\
+	} while (0)
+
+#define ZVAL_NEW_STR(z, s) do {					\
+		zval *__z = (z);						\
+		zend_string *__s = (s);					\
+		Z_STR_P(__z) = __s;						\
+		/* interned strings support */			\
+		Z_TYPE_INFO_P(__z) = IS_STRING_EX;		\
+	} while (0)
+
+#define ZVAL_ARR(z, a) do {						\
+		zval *__z = (z);						\
+		Z_ARR_P(__z) = (a);						\
+		Z_TYPE_INFO_P(__z) = IS_ARRAY_EX;		\
+	} while (0)
+
+#define ZVAL_NEW_ARR(z) do {									\
+		zval *__z = (z);										\
+		zend_array *_arr = emalloc(sizeof(zend_array));			\
+		GC_REFCOUNT(_arr) = 1;									\
+		GC_TYPE_INFO(_arr) = IS_ARRAY;							\
+		Z_ARR_P(__z) = _arr;									\
+		Z_TYPE_INFO_P(__z) = IS_ARRAY_EX;						\
+	} while (0)
+
+#define ZVAL_NEW_PERSISTENT_ARR(z) do {							\
+		zval *__z = (z);										\
+		zend_array *_arr = malloc(sizeof(zend_array));			\
+		GC_REFCOUNT(_arr) = 1;									\
+		GC_TYPE_INFO(_arr) = IS_ARRAY;							\
+		Z_ARR_P(__z) = _arr;									\
+		Z_TYPE_INFO_P(__z) = IS_ARRAY_EX;						\
+	} while (0)
+
+#define ZVAL_OBJ(z, o) do {						\
+		zval *__z = (z);						\
+		Z_OBJ_P(__z) = (o);						\
+		Z_TYPE_INFO_P(__z) = IS_OBJECT_EX;		\
+	} while (0)
+
+#define ZVAL_RES(z, r) do {						\
+		zval *__z = (z);						\
+		Z_RES_P(__z) = (r);						\
+		Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX;	\
+	} while (0)
+
+#define ZVAL_NEW_RES(z, h, p, t) do {							\
+		zend_resource *_res = emalloc(sizeof(zend_resource));	\
+		GC_REFCOUNT(_res) = 1;									\
+		GC_TYPE_INFO(_res) = IS_RESOURCE;						\
+		_res->handle = (h);										\
+		_res->type = (t);										\
+		_res->ptr = (p);										\
+		zval *__z = (z);										\
+		Z_RES_P(__z) = _res;									\
+		Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX;					\
+	} while (0)
+
+#define ZVAL_NEW_PERSISTENT_RES(z, h, p, t) do {				\
+		zend_resource *_res = malloc(sizeof(zend_resource));	\
+		GC_REFCOUNT(_res) = 1;									\
+		GC_TYPE_INFO(_res) = IS_RESOURCE;						\
+		_res->handle = (h);										\
+		_res->type = (t);										\
+		_res->ptr = (p);										\
+		zval *__z = (z);										\
+		Z_RES_P(__z) = _res;									\
+		Z_TYPE_INFO_P(__z) = IS_RESOURCE_EX;					\
+	} while (0)
+
+#define ZVAL_REF(z, r) do {										\
+		zval *__z = (z);										\
+		Z_REF_P(__z) = (r);										\
+		Z_TYPE_INFO_P(__z) = IS_REFERENCE_EX;					\
+	} while (0)
+
+#define ZVAL_NEW_REF(z, r) do {									\
+		zend_reference *_ref = emalloc(sizeof(zend_reference));	\
+		GC_REFCOUNT(_ref) = 1;									\
+		GC_TYPE_INFO(_ref) = IS_REFERENCE;						\
+		ZVAL_COPY_VALUE(&_ref->val, r);							\
+		Z_REF_P(z) = _ref;										\
+		Z_TYPE_INFO_P(z) = IS_REFERENCE_EX;						\
+	} while (0)
+
+#define ZVAL_NEW_PERSISTENT_REF(z, r) do {						\
+		zend_reference *_ref = malloc(sizeof(zend_reference));	\
+		GC_REFCOUNT(_ref) = 1;									\
+		GC_TYPE_INFO(_ref) = IS_REFERENCE;						\
+		ZVAL_COPY_VALUE(&_ref->val, r);							\
+		Z_REF_P(z) = _ref;										\
+		Z_TYPE_INFO_P(z) = IS_REFERENCE_EX;						\
+	} while (0)
+
+#define ZVAL_NEW_AST(z, a) do {									\
+		zval *__z = (z);										\
+		zend_ast_ref *_ast = emalloc(sizeof(zend_ast_ref));		\
+		GC_REFCOUNT(_ast) = 1;									\
+		GC_TYPE_INFO(_ast) = IS_CONSTANT_AST;					\
+		_ast->ast = (a);										\
+		Z_AST_P(__z) = _ast;									\
+		Z_TYPE_INFO_P(__z) = IS_CONSTANT_AST_EX;				\
+	} while (0)
+
+#define ZVAL_INDIRECT(z, v) do {								\
+		Z_INDIRECT_P(z) = (v);									\
+		Z_TYPE_INFO_P(z) = IS_INDIRECT;							\
+	} while (0)
+
+#define ZVAL_PTR(z, p) do {										\
+		Z_PTR_P(z) = (p);										\
+		Z_TYPE_INFO_P(z) = IS_PTR;								\
+	} while (0)
+
+#define ZVAL_FUNC(z, f) do {									\
+		Z_FUNC_P(z) = (f);										\
+		Z_TYPE_INFO_P(z) = IS_PTR;								\
+	} while (0)
+
+#define ZVAL_CE(z, c) do {										\
+		Z_CE_P(z) = (c);										\
+		Z_TYPE_INFO_P(z) = IS_PTR;								\
+	} while (0)
+
+
+#define Z_STR_OFFSET_STR(zval)		Z_INDIRECT(zval)
+#define Z_STR_OFFSET_STR_P(zval_p)	Z_STR_OFFSET_STR(*(zval_p))
+
+#define Z_STR_OFFSET_IDX(zval)		(zval).u2.str_offset
+#define Z_STR_OFFSET_IDX_P(zval_p)	Z_STR_OFFSET_IDX(*(zval_p))
+
+#define ZVAL_STR_OFFSET(z, s, i) do {							\
+		Z_STR_OFFSET_STR_P(z) = (s);							\
+		Z_STR_OFFSET_IDX_P(z) = (i);							\
+		Z_TYPE_INFO_P(z) = IS_STR_OFFSET;						\
+	} while (0)
 
 #endif /* ZEND_TYPES_H */
 
diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 0f9e184b7e..5557c7beea 100644
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -27,69 +27,178 @@
 #include "zend_constants.h"
 #include "zend_list.h"
 
-
-ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC)
+ZEND_API void _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC)
 {
-	switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+	switch (GC_TYPE(p)) {
 		case IS_STRING:
-		case IS_CONSTANT:
-			CHECK_ZVAL_STRING_REL(zvalue);
-			str_efree_rel(zvalue->value.str.val);
-			break;
-		case IS_ARRAY: {
+		case IS_CONSTANT: {
+				zend_string *str = (zend_string*)p;
+				CHECK_ZVAL_STRING_REL(str);
+				STR_RELEASE(str);
+				break;
+			}
+		case IS_ARRAY:
+		case IS_CONSTANT_ARRAY: {
+				zend_array *arr =(zend_array*)p;
 				TSRMLS_FETCH();
 
-				if (zvalue->value.ht && (zvalue->value.ht != &EG(symbol_table))) {
+				if (arr != &EG(symbol_table)) {
 					/* break possible cycles */
-					Z_TYPE_P(zvalue) = IS_NULL;
-					zend_hash_destroy(zvalue->value.ht);
-					FREE_HASHTABLE(zvalue->value.ht);
+					GC_TYPE(arr) = IS_NULL;
+					zend_hash_destroy(&arr->ht);
+					GC_REMOVE_FROM_BUFFER(arr);
+					efree(arr);
 				}
+				break;
 			}
-			break;
-		case IS_CONSTANT_AST:
-			zend_ast_destroy(Z_AST_P(zvalue));
-			break;
-		case IS_OBJECT:
-			{
+		case IS_CONSTANT_AST: {
+				zend_ast_ref *ast =(zend_ast_ref*)p;
+		
+				zend_ast_destroy(ast->ast);
+				efree(ast);
+				break;
+			}
+		case IS_OBJECT: {
+				zend_object *obj = (zend_object*)p;
+				TSRMLS_FETCH();
+
+				OBJ_RELEASE(obj);
+				break;
+			}
+		case IS_RESOURCE: {
+				zend_resource *res = (zend_resource*)p;
 				TSRMLS_FETCH();
 
-				Z_OBJ_HT_P(zvalue)->del_ref(zvalue TSRMLS_CC);
+				if (--GC_REFCOUNT(res) == 0) {
+					/* destroy resource */
+					zend_list_delete(res);
+				}
+				break;
 			}
+		case IS_REFERENCE: {
+				zend_reference *ref = (zend_reference*)p;
+				if (--GC_REFCOUNT(ref) == 0) {
+					zval_ptr_dtor(&ref->val);
+					efree(ref);
+				}
+				break;
+			}
+		default:
 			break;
-		case IS_RESOURCE:
-			{
+	}
+}
+
+ZEND_API void _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC)
+{
+	switch (GC_TYPE(p)) {
+		case IS_STRING:
+		case IS_CONSTANT: {
+				zend_string *str = (zend_string*)p;
+				CHECK_ZVAL_STRING_REL(str);
+				STR_FREE(str);
+				break;
+			}
+		case IS_ARRAY:
+		case IS_CONSTANT_ARRAY: {
+				zend_array *arr =(zend_array*)p;
+				TSRMLS_FETCH();
+
+				if (arr != &EG(symbol_table)) {
+					/* break possible cycles */
+					GC_TYPE(arr) = IS_NULL;
+					zend_hash_destroy(&arr->ht);
+					GC_REMOVE_FROM_BUFFER(arr);
+					efree(arr);
+				}
+				break;
+			}
+		case IS_CONSTANT_AST: {
+				zend_ast_ref *ast =(zend_ast_ref*)p;
+
+				zend_ast_destroy(ast->ast);
+				efree(ast);
+				break;
+			}
+		case IS_OBJECT: {
+				zend_object *obj = (zend_object*)p;
+				TSRMLS_FETCH();
+
+				zend_objects_store_del(obj TSRMLS_CC);
+				break;
+			}
+		case IS_RESOURCE: {
+				zend_resource *res = (zend_resource*)p;
 				TSRMLS_FETCH();
 
 				/* destroy resource */
-				zend_list_delete(zvalue->value.lval);
+				zend_list_delete(res);
+				break;
+			}
+		case IS_REFERENCE: {
+				zend_reference *ref = (zend_reference*)p;
+
+				zval_ptr_dtor(&ref->val);
+				efree(ref);
+				break;
 			}
+		default:
 			break;
+	}
+}
+
+ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
+{
+	switch (Z_TYPE_P(zvalue)) {
+		case IS_STRING:
+		case IS_CONSTANT:
+			CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+			STR_RELEASE(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_REFERENCE: {
+				zend_reference *ref = (zend_reference*)Z_REF_P(zvalue);
+
+				zval_internal_ptr_dtor(&ref->val);
+				free(ref);
+				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)
+ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC)
 {
-	switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+	switch (Z_TYPE_P(zvalue)) {
 		case IS_STRING:
 		case IS_CONSTANT:
-			CHECK_ZVAL_STRING_REL(zvalue);
-			str_free(zvalue->value.str.val);
+			CHECK_ZVAL_STRING_REL(Z_STR_P(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_REFERENCE: {
+				zend_reference *ref = (zend_reference*)Z_REF_P(zvalue);
+
+				zval_internal_ptr_dtor(&ref->val);
+				free(ref);
+				break;
+			}
 		case IS_LONG:
 		case IS_DOUBLE:
 		case IS_BOOL:
@@ -99,72 +208,76 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
 	}
 }
 
-
-ZEND_API void zval_add_ref(zval **p)
+ZEND_API void zval_add_ref(zval *p)
 {
-	Z_ADDREF_PP(p);
+	if (Z_REFCOUNTED_P(p)) {
+		if (Z_ISREF_P(p) && Z_REFCOUNT_P(p) == 1) {
+			ZVAL_DUP(p, Z_REFVAL_P(p));
+		} else {
+			Z_ADDREF_P(p);
+		}
+	}
 }
 
+ZEND_API void zval_add_ref_unref(zval *p)
+{
+	if (Z_REFCOUNTED_P(p)) {
+		if (Z_ISREF_P(p)) {
+			ZVAL_DUP(p, Z_REFVAL_P(p));
+		} else {
+			Z_ADDREF_P(p);
+		}
+	}
+}
 
 ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC)
 {
-	switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
-		case IS_RESOURCE: {
-				TSRMLS_FETCH();
-
-				zend_list_addref(zvalue->value.lval);
-			}
-			break;
-		case IS_BOOL:
-		case IS_LONG:
-		case IS_NULL:
-			break;
+	switch (Z_TYPE_P(zvalue)) {
 		case IS_CONSTANT:
 		case IS_STRING:
-			CHECK_ZVAL_STRING_REL(zvalue);
-			if (!IS_INTERNED(zvalue->value.str.val)) {
-				zvalue->value.str.val = (char *) estrndup_rel(zvalue->value.str.val, zvalue->value.str.len);
-			}
+			CHECK_ZVAL_STRING_REL(Z_STR_P(zvalue));
+			Z_STR_P(zvalue) = STR_DUP(Z_STR_P(zvalue), 0);
 			break;
-		case IS_ARRAY: {
-				zval *tmp;
-				HashTable *original_ht = zvalue->value.ht;
-				HashTable *tmp_ht = NULL;
+		case IS_ARRAY:
+		case IS_CONSTANT_ARRAY: {
+				HashTable *ht;
 				TSRMLS_FETCH();
 
-				if (zvalue->value.ht == &EG(symbol_table)) {
+				if (Z_ARR_P(zvalue) == &EG(symbol_table)) {
 					return; /* do nothing */
 				}
-				ALLOC_HASHTABLE_REL(tmp_ht);
-				zend_hash_init(tmp_ht, zend_hash_num_elements(original_ht), NULL, ZVAL_PTR_DTOR, 0);
-				zend_hash_copy(tmp_ht, original_ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
-				zvalue->value.ht = tmp_ht;
+				ht = Z_ARRVAL_P(zvalue);
+				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, zval_add_ref);
 			}
 			break;
-		case IS_CONSTANT_AST:
-			Z_AST_P(zvalue) = zend_ast_copy(Z_AST_P(zvalue));
+		case IS_CONSTANT_AST: {
+				zend_ast_ref *ast = emalloc(sizeof(zend_ast_ref));
+
+				GC_REFCOUNT(ast) = 1;
+				GC_TYPE_INFO(ast) = IS_CONSTANT_AST;
+				ast->ast = zend_ast_copy(Z_ASTVAL_P(zvalue));
+				Z_AST_P(zvalue) = ast;
+			}
 			break;
 		case IS_OBJECT:
-			{
-				TSRMLS_FETCH();
-				Z_OBJ_HT_P(zvalue)->add_ref(zvalue TSRMLS_CC);
-			}
+		case IS_RESOURCE:
+		case IS_REFERENCE:
+			Z_ADDREF_P(zvalue);
 			break;
 	}
 }
 
 
-ZEND_API int zend_print_variable(zval *var) 
+ZEND_API int zend_print_variable(zval *var TSRMLS_DC) 
 {
-	return zend_print_zval(var, 0);
+	return zend_print_zval(var, 0 TSRMLS_CC);
 }
 
 
 ZEND_API void _zval_dtor_wrapper(zval *zvalue)
 {
-	TSRMLS_FETCH();
-
-	GC_REMOVE_ZVAL_FROM_BUFFER(zvalue);
 	zval_dtor(zvalue);
 }
 
@@ -182,59 +295,68 @@ ZEND_API void _zval_internal_dtor_wrapper(zval *zvalue)
 }
 
 
-ZEND_API void _zval_ptr_dtor_wrapper(zval **zval_ptr)
+ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr)
 {
 	zval_ptr_dtor(zval_ptr);
 }
 
 
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval **zval_ptr)
+ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zval_ptr)
 {
 	zval_internal_ptr_dtor(zval_ptr);
 }
 #endif
 
-ZEND_API int zval_copy_static_var(zval **p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
+ZEND_API int zval_copy_static_var(zval *p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
 {
 	HashTable *target = va_arg(args, HashTable*);
 	zend_bool is_ref;
-	zval *tmp;
+	zval tmp;
   
-	if (Z_TYPE_PP(p) & (IS_LEXICAL_VAR|IS_LEXICAL_REF)) {
-		is_ref = Z_TYPE_PP(p) & IS_LEXICAL_REF;
+	if (Z_CONST_FLAGS_P(p) & (IS_LEXICAL_VAR|IS_LEXICAL_REF)) {
+		is_ref = Z_CONST_FLAGS_P(p) & IS_LEXICAL_REF;
     
 		if (!EG(active_symbol_table)) {
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
-		if (zend_hash_quick_find(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, (void **) &p) == FAILURE) {
-			if (is_ref) {        
-				ALLOC_INIT_ZVAL(tmp);
-				Z_SET_ISREF_P(tmp);
-				zend_hash_quick_add(EG(active_symbol_table), key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), (void**)&p);
+		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)->ht, key->key, &tmp);
+				Z_ADDREF_P(p);
 			} else {
-				tmp = EG(uninitialized_zval_ptr);
-				zend_error(E_NOTICE,"Undefined variable: %s", key->arKey);
+				zend_error(E_NOTICE,"Undefined variable: %s", key->key->val);
 			}
 		} else {
+			if (Z_TYPE_P(p) == IS_INDIRECT) {
+				p = Z_INDIRECT_P(p);
+				if (Z_TYPE_P(p) == IS_UNDEF) {
+					if (!is_ref) {
+						zend_error(E_NOTICE,"Undefined variable: %s", key->key->val);
+						p = &tmp;
+						ZVAL_NULL(&tmp);
+					} else {
+						ZVAL_NULL(p);
+					}
+				}
+			}
 			if (is_ref) {
 				SEPARATE_ZVAL_TO_MAKE_IS_REF(p);
-				tmp = *p;
-			} else if (Z_ISREF_PP(p)) {
-				ALLOC_INIT_ZVAL(tmp);
-				ZVAL_COPY_VALUE(tmp, *p);
-				zval_copy_ctor(tmp);
-				Z_SET_REFCOUNT_P(tmp, 0);
-				Z_UNSET_ISREF_P(tmp);
-			} else {
-				tmp = *p;
+				Z_ADDREF_P(p);
+			} else if (Z_ISREF_P(p)) {
+				ZVAL_DUP(&tmp, Z_REFVAL_P(p));
+				p = &tmp;
+			} else if (Z_REFCOUNTED_P(p)) {
+				Z_ADDREF_P(p);
 			}
 		}
-	} else {
-		tmp = *p;
-	}
-	if (zend_hash_quick_add(target, key->arKey, key->nKeyLength, key->h, &tmp, sizeof(zval*), NULL) == SUCCESS) {
-		Z_ADDREF_P(tmp);
-	}
+	} else if (Z_REFCOUNTED_P(p)) {
+		Z_ADDREF_P(p);
+	} 
+	zend_hash_add(target, key->key, p);
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
diff --git a/Zend/zend_variables.h b/Zend/zend_variables.h
index 30f170bfbe..b85ef435ca 100644
--- a/Zend/zend_variables.h
+++ b/Zend/zend_variables.h
@@ -25,34 +25,53 @@
 
 BEGIN_EXTERN_C()
 
-ZEND_API void _zval_dtor_func(zval *zvalue ZEND_FILE_LINE_DC);
+ZEND_API void _zval_dtor_func(zend_refcounted *p ZEND_FILE_LINE_DC);
+ZEND_API void _zval_dtor_func_for_ptr(zend_refcounted *p ZEND_FILE_LINE_DC);
 
 static zend_always_inline void _zval_dtor(zval *zvalue ZEND_FILE_LINE_DC)
 {
-	if (zvalue->type <= IS_BOOL) {
+	if (!Z_REFCOUNTED_P(zvalue)) {
 		return;
 	}
-	_zval_dtor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
+	_zval_dtor_func(Z_COUNTED_P(zvalue) ZEND_FILE_LINE_RELAY_CC);
 }
 
 ZEND_API void _zval_copy_ctor_func(zval *zvalue ZEND_FILE_LINE_DC);
 
+#define zval_copy_ctor_func(zv) _zval_copy_ctor_func(zv ZEND_FILE_LINE_CC)
+
 static zend_always_inline void _zval_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
 {
-	if (zvalue->type <= IS_BOOL) {
-		return;
+	if (Z_REFCOUNTED_P(zvalue)) {
+		if (Z_COPYABLE_P(zvalue)) {
+			_zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
+		} else {
+			Z_ADDREF_P(zvalue);
+		}
+	}
+}
+
+static zend_always_inline void _zval_opt_copy_ctor(zval *zvalue ZEND_FILE_LINE_DC)
+{
+	if (Z_OPT_REFCOUNTED_P(zvalue)) {
+		if (Z_OPT_COPYABLE_P(zvalue)) {
+			_zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
+		} else {
+			Z_ADDREF_P(zvalue);
+		}
 	}
-	_zval_copy_ctor_func(zvalue ZEND_FILE_LINE_RELAY_CC);
 }
 
-ZEND_API int zval_copy_static_var(zval **p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key);
+ZEND_API int zval_copy_static_var(zval *p TSRMLS_DC, int num_args, va_list args, zend_hash_key *key);
 
-ZEND_API int zend_print_variable(zval *var);
-ZEND_API void _zval_ptr_dtor(zval **zval_ptr ZEND_FILE_LINE_DC);
+ZEND_API int zend_print_variable(zval *var TSRMLS_DC);
+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_internal_ptr_dtor(zval *zvalue ZEND_FILE_LINE_DC);
 ZEND_API void _zval_dtor_wrapper(zval *zvalue);
 #define zval_copy_ctor(zvalue) _zval_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
+#define zval_opt_copy_ctor(zvalue) _zval_opt_copy_ctor((zvalue) ZEND_FILE_LINE_CC)
 #define zval_dtor(zvalue) _zval_dtor((zvalue) ZEND_FILE_LINE_CC)
 #define zval_ptr_dtor(zval_ptr) _zval_ptr_dtor((zval_ptr) ZEND_FILE_LINE_CC)
 #define zval_internal_dtor(zvalue) _zval_internal_dtor((zvalue) ZEND_FILE_LINE_CC)
@@ -61,9 +80,9 @@ ZEND_API void _zval_dtor_wrapper(zval *zvalue);
 
 #if ZEND_DEBUG
 ZEND_API void _zval_copy_ctor_wrapper(zval *zvalue);
-ZEND_API void _zval_ptr_dtor_wrapper(zval **zval_ptr);
+ZEND_API void _zval_ptr_dtor_wrapper(zval *zval_ptr);
 ZEND_API void _zval_internal_dtor_wrapper(zval *zvalue);
-ZEND_API void _zval_internal_ptr_dtor_wrapper(zval **zvalue);
+ZEND_API void _zval_internal_ptr_dtor_wrapper(zval *zvalue);
 #define zval_copy_ctor_wrapper _zval_copy_ctor_wrapper
 #define zval_ptr_dtor_wrapper _zval_ptr_dtor_wrapper
 #define zval_internal_dtor_wrapper _zval_internal_dtor_wrapper
@@ -75,15 +94,16 @@ ZEND_API void _zval_internal_ptr_dtor_wrapper(zval **zvalue);
 #define zval_internal_ptr_dtor_wrapper _zval_internal_ptr_dtor
 #endif
 
-ZEND_API void zval_add_ref(zval **p);
+ZEND_API void zval_add_ref(zval *p);
+ZEND_API void zval_add_ref_unref(zval *p);
 
 END_EXTERN_C()
 
-#define ZVAL_DESTRUCTOR (void (*)(void *)) zval_dtor_wrapper
-#define ZVAL_PTR_DTOR (void (*)(void *)) zval_ptr_dtor_wrapper
-#define ZVAL_INTERNAL_DTOR (void (*)(void *)) zval_internal_dtor_wrapper
-#define ZVAL_INTERNAL_PTR_DTOR (void (*)(void *)) zval_internal_ptr_dtor_wrapper
-#define ZVAL_COPY_CTOR (void (*)(void *)) zval_copy_ctor_wrapper
+#define ZVAL_DESTRUCTOR zval_dtor_wrapper
+#define ZVAL_PTR_DTOR zval_ptr_dtor_wrapper
+#define ZVAL_INTERNAL_DTOR zval_internal_dtor_wrapper
+#define ZVAL_INTERNAL_PTR_DTOR zval_internal_ptr_dtor_wrapper
+#define ZVAL_COPY_CTOR zval_copy_ctor_wrapper
 
 #endif
 
diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 195772a395..812a2acaf9 100644
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -31,7 +31,7 @@ ZEND_VM_HANDLER(1, ZEND_ADD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -46,7 +46,7 @@ ZEND_VM_HANDLER(2, ZEND_SUB, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -61,7 +61,7 @@ ZEND_VM_HANDLER(3, ZEND_MUL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -76,7 +76,7 @@ ZEND_VM_HANDLER(4, ZEND_DIV, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		GET_OP1_ZVAL_PTR(BP_VAR_R),
 		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
@@ -91,9 +91,9 @@ ZEND_VM_HANDLER(5, ZEND_MOD, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	fast_mod_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -106,9 +106,9 @@ ZEND_VM_HANDLER(6, ZEND_SL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	shift_left_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -121,9 +121,9 @@ ZEND_VM_HANDLER(7, ZEND_SR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	shift_right_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -136,9 +136,9 @@ ZEND_VM_HANDLER(8, ZEND_CONCAT, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	concat_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -151,9 +151,9 @@ ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	is_identical_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -164,12 +164,12 @@ ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	FREE_OP1();
 	FREE_OP2();
@@ -181,7 +181,7 @@ ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -197,7 +197,7 @@ ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -213,7 +213,7 @@ ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -229,7 +229,7 @@ ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -247,9 +247,9 @@ ZEND_VM_HANDLER(9, ZEND_BW_OR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	bitwise_or_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -262,9 +262,9 @@ ZEND_VM_HANDLER(10, ZEND_BW_AND, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	bitwise_and_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -277,9 +277,9 @@ ZEND_VM_HANDLER(11, ZEND_BW_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -292,9 +292,9 @@ ZEND_VM_HANDLER(14, ZEND_BOOL_XOR, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	boolean_xor_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -307,8 +307,8 @@ ZEND_VM_HANDLER(12, ZEND_BW_NOT, CONST|TMP|VAR|CV, ANY)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_not_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	bitwise_not_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -320,8 +320,8 @@ ZEND_VM_HANDLER(13, ZEND_BOOL_NOT, CONST|TMP|VAR|CV, ANY)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_not_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	boolean_not_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -331,18 +331,18 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2, free_op_data1;
-	zval **object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
-	zval *object;
+	zval *object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
 	zval *property = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -350,81 +350,68 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (IS_OP2_TMP_FREE()) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (IS_OP2_TMP_FREE()) {
-			zval_ptr_dtor(&property);
-		} else {
-			FREE_OP2();
-		}
+		FREE_OP2();
 		FREE_OP(free_op_data1);
 	}
 
@@ -435,179 +422,288 @@ ZEND_VM_HELPER_EX(zend_binary_assign_op_obj_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
+ZEND_VM_HELPER_EX(zend_binary_assign_op_dim_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
-
-				if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (OP1_TYPE == IS_VAR && !OP1_FREE) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
-				} else {
-					zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
+	container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (OP1_TYPE == IS_VAR && !OP1_FREE) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, binary_op);
+	} else {
+		zval *dim = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, OP2_TYPE, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = GET_OP2_ZVAL_PTR(BP_VAR_R);
-			var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, OP2_TYPE TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		FREE_OP2();
-		FREE_OP1_VAR_PTR();
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
-		}
-		ZEND_VM_NEXT_OPCODE();
+		ZEND_VM_C_GOTO(assign_op_dim_exit);
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+ZEND_VM_C_LABEL(assign_op_dim_exit):
 	FREE_OP2();
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+	FREE_OP1_VAR_PTR();
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
-		FREE_OP1_VAR_PTR();
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+ZEND_VM_HELPER_EX(zend_binary_assign_op_helper, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV, int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC))
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = GET_OP2_ZVAL_PTR(BP_VAR_R);
+	var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
+
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		ZEND_VM_C_GOTO(assign_op_exit);
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		FREE_OP1_VAR_PTR();
-		CHECK_EXCEPTION();
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+ZEND_VM_C_LABEL(assign_op_exit):
+	FREE_OP2();
+	FREE_OP1_VAR_PTR();
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(23, ZEND_ASSIGN_ADD, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, add_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, add_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, add_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, add_function);
+	}
 }
 
 ZEND_VM_HANDLER(24, ZEND_ASSIGN_SUB, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, sub_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, sub_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, sub_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, sub_function);
+	}
 }
 
 ZEND_VM_HANDLER(25, ZEND_ASSIGN_MUL, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mul_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mul_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mul_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, mul_function);
+	}
 }
 
 ZEND_VM_HANDLER(26, ZEND_ASSIGN_DIV, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, div_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, div_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, div_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, div_function);
+	}
 }
 
 ZEND_VM_HANDLER(27, ZEND_ASSIGN_MOD, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mod_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, mod_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, mod_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, mod_function);
+	}
 }
 
 ZEND_VM_HANDLER(28, ZEND_ASSIGN_SL, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_left_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_left_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_left_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, shift_left_function);
+	}
 }
 
 ZEND_VM_HANDLER(29, ZEND_ASSIGN_SR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_right_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, shift_right_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, shift_right_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, shift_right_function);
+	}
 }
 
 ZEND_VM_HANDLER(30, ZEND_ASSIGN_CONCAT, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, concat_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, concat_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, concat_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, concat_function);
+	}
 }
 
 ZEND_VM_HANDLER(31, ZEND_ASSIGN_BW_OR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_or_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_or_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_or_function);
+	}
 }
 
 ZEND_VM_HANDLER(32, ZEND_ASSIGN_BW_AND, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_and_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_and_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_and_function);
+	}
 }
 
 ZEND_VM_HANDLER(33, ZEND_ASSIGN_BW_XOR, VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_helper, binary_op, bitwise_xor_function);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_dim_helper, binary_op, bitwise_xor_function);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_binary_assign_op_obj_helper, binary_op, bitwise_xor_function);
+	}
 }
 
 ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV, incdec_t incdec_op)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
+	object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		FREE_OP2();
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 		FREE_OP1_VAR_PTR();
 		CHECK_EXCEPTION();
@@ -616,59 +712,50 @@ ZEND_VM_HELPER_EX(zend_pre_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR|
 
 	/* here we are sure we are dealing with an object */
 
-	if (IS_OP2_TMP_FREE()) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (IS_OP2_TMP_FREE()) {
-		zval_ptr_dtor(&property);
-	} else {
-		FREE_OP2();
-	}
+	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -688,23 +775,21 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
+	object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -717,60 +802,48 @@ ZEND_VM_HELPER_EX(zend_post_incdec_property_helper, VAR|UNUSED|CV, CONST|TMP|VAR
 
 	/* here we are sure we are dealing with an object */
 
-	if (IS_OP2_TMP_FREE()) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (IS_OP2_TMP_FREE()) {
-		zval_ptr_dtor(&property);
-	} else {
-		FREE_OP2();
-	}
+	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -790,42 +863,53 @@ ZEND_VM_HANDLER(34, ZEND_PRE_INC, VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
 	var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_increment_function(var_ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		}
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 		FREE_OP1_VAR_PTR();
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+	} else {
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_increment_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_increment_function(*var_ptr);
+		increment_function(var_ptr);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -837,42 +921,53 @@ ZEND_VM_HANDLER(35, ZEND_PRE_DEC, VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
 	var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_decrement_function(var_ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		}
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 		FREE_OP1_VAR_PTR();
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+	} else {
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_decrement_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_decrement_function(*var_ptr);
+		decrement_function(var_ptr);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -884,38 +979,49 @@ ZEND_VM_HANDLER(36, ZEND_POST_INC, VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr, *retval;
+	zval *var_ptr, *retval;
 
 	SAVE_OPLINE();
 	var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		fast_increment_function(var_ptr);
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
 		FREE_OP1_VAR_PTR();
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	retval = &EX_T(opline->result.var).tmp_var;
-	ZVAL_COPY_VALUE(retval, *var_ptr);
-	zendi_zval_copy_ctor(*retval);
+	retval = EX_VAR(opline->result.var);
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+		ZVAL_DUP(retval, var_ptr);
+	} else {
+		ZVAL_DUP(retval, var_ptr);
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_increment_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_increment_function(*var_ptr);
+		increment_function(var_ptr);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -927,38 +1033,49 @@ ZEND_VM_HANDLER(37, ZEND_POST_DEC, VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr, *retval;
+	zval *var_ptr, *retval;
 
 	SAVE_OPLINE();
 	var_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		fast_decrement_function(var_ptr);
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
 		FREE_OP1_VAR_PTR();
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	retval = &EX_T(opline->result.var).tmp_var;
-	ZVAL_COPY_VALUE(retval, *var_ptr);
-	zendi_zval_copy_ctor(*retval);
+	retval = EX_VAR(opline->result.var);
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+		ZVAL_DUP(retval, var_ptr);
+	} else {
+		ZVAL_DUP(retval, var_ptr);
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_decrement_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_decrement_function(*var_ptr);
+		decrement_function(var_ptr);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -973,12 +1090,9 @@ ZEND_VM_HANDLER(40, ZEND_ECHO, CONST|TMP|VAR|CV, ANY)
 	zval *z;
 
 	SAVE_OPLINE();
-	z = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	z = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-	if (OP1_TYPE == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
-		INIT_PZVAL(z);
-	}
-	zend_print_variable(z);
+	zend_print_variable(z TSRMLS_CC);
 
 	FREE_OP1();
 	CHECK_EXCEPTION();
@@ -989,7 +1103,7 @@ ZEND_VM_HANDLER(41, ZEND_PRINT, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 
-	ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
+	ZVAL_LONG(EX_VAR(opline->result.var), 1);
 	ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ECHO);
 }
 
@@ -998,19 +1112,16 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (OP1_TYPE != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -1019,105 +1130,88 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
 		zend_class_entry *ce;
 
 		if (OP2_TYPE == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (OP1_TYPE != IS_CONST && varname == &tmp_varname) {
+					if (OP1_TYPE != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 					FREE_OP1();
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((OP1_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 		FREE_OP1();
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (OP1_TYPE == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));	
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (OP1_TYPE != IS_TMP_VAR) {
-					FREE_OP1();
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				FREE_OP1();
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (OP1_TYPE == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			FREE_OP1();
 		}
 	}
 
-
-	if (OP1_TYPE != IS_CONST && varname == &tmp_varname) {
+	if (OP1_TYPE != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -1142,8 +1236,11 @@ ZEND_VM_HANDLER(92, ZEND_FETCH_FUNC_ARG, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
 	USE_OPLINE
 
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type,
-		zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_W);
+	} else {
+		ZEND_VM_DISPATCH_TO_HELPER_EX(zend_fetch_var_address_helper, type, BP_VAR_R);
+	}
 }
 
 ZEND_VM_HANDLER(95, ZEND_FETCH_UNSET, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
@@ -1164,7 +1261,7 @@ ZEND_VM_HANDLER(81, ZEND_FETCH_DIM_R, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 
 	SAVE_OPLINE();
 	container = GET_OP1_ZVAL_PTR(BP_VAR_R);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
 	FREE_OP2();
 	if (OP1_TYPE != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 		FREE_OP1();
@@ -1177,32 +1274,24 @@ ZEND_VM_HANDLER(84, ZEND_FETCH_DIM_W, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_W TSRMLS_CC);
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
+	}
 	FREE_OP2();
 	if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_VAR_PTR();
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
-	}
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -1211,18 +1300,18 @@ ZEND_VM_HANDLER(87, ZEND_FETCH_DIM_RW, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
 	FREE_OP2();
 	if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_VAR_PTR();
 	CHECK_EXCEPTION();
@@ -1237,7 +1326,7 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
 
 	SAVE_OPLINE();
 	container = GET_OP1_ZVAL_PTR(BP_VAR_IS);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
 	FREE_OP2();
 	FREE_OP1();
 	CHECK_EXCEPTION();
@@ -1247,29 +1336,28 @@ ZEND_VM_HANDLER(90, ZEND_FETCH_DIM_IS, VAR|CV, CONST|TMP|VAR|CV)
 ZEND_VM_HANDLER(93, ZEND_FETCH_DIM_FUNC_ARG, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+		container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 		if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
 		if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 		FREE_OP2();
 		FREE_OP1_VAR_PTR();
 	} else {
-		zval *container;
-
 		if (OP2_TYPE == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = GET_OP1_ZVAL_PTR(BP_VAR_R);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
 		FREE_OP2();
 		FREE_OP1();
 	}
@@ -1281,41 +1369,22 @@ ZEND_VM_HANDLER(96, ZEND_FETCH_DIM_UNSET, VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = GET_OP1_ZVAL_PTR_PTR(BP_VAR_UNSET);
 
-	if (OP1_TYPE == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE TSRMLS_CC);
 	FREE_OP2();
 	if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_VAR_PTR();
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
-	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
@@ -1327,35 +1396,25 @@ ZEND_VM_HELPER(zend_fetch_property_address_read_helper, VAR|UNUSED|CV, CONST|TMP
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
+	container = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_R);
 	offset  = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		FREE_OP2();
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (IS_OP2_TMP_FREE()) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (IS_OP2_TMP_FREE()) {
-			zval_ptr_dtor(&offset);
-		} else {
-			FREE_OP2();
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	FREE_OP2();
 	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -1371,41 +1430,22 @@ ZEND_VM_HANDLER(85, ZEND_FETCH_OBJ_W, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (IS_OP2_TMP_FREE()) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
 	container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (IS_OP2_TMP_FREE()) {
-		zval_ptr_dtor(&property);
-	} else {
-		FREE_OP2();
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	FREE_OP2();
 	if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_VAR_PTR();
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	}
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -1415,26 +1455,19 @@ ZEND_VM_HANDLER(88, ZEND_FETCH_OBJ_RW, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 	container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_RW);
 
-	if (IS_OP2_TMP_FREE()) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (IS_OP2_TMP_FREE()) {
-		zval_ptr_dtor(&property);
-	} else {
-		FREE_OP2();
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	FREE_OP2();
 	if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_VAR_PTR();
 	CHECK_EXCEPTION();
@@ -1450,34 +1483,24 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
+	container = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_IS);
 	offset  = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		FREE_OP2();
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (IS_OP2_TMP_FREE()) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		if (IS_OP2_TMP_FREE()) {
-			zval_ptr_dtor(&offset);
-		} else {
-			FREE_OP2();
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	FREE_OP2();
 	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -1486,31 +1509,24 @@ ZEND_VM_HANDLER(91, ZEND_FETCH_OBJ_IS, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 		container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
 
-		if (IS_OP2_TMP_FREE()) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (IS_OP2_TMP_FREE()) {
-			zval_ptr_dtor(&property);
-		} else {
-			FREE_OP2();
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		FREE_OP2();
 		if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 		FREE_OP1_VAR_PTR();
 		CHECK_EXCEPTION();
@@ -1523,42 +1539,22 @@ ZEND_VM_HANDLER(94, ZEND_FETCH_OBJ_FUNC_ARG, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 ZEND_VM_HANDLER(97, ZEND_FETCH_OBJ_UNSET, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
 	container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
 	property = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_OP2_TMP_FREE()) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (IS_OP2_TMP_FREE()) {
-		zval_ptr_dtor(&property);
-	} else {
-		FREE_OP2();
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	FREE_OP2();
 	if (OP1_TYPE == IS_VAR && OP1_FREE && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_VAR_PTR();
-
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -1573,14 +1569,12 @@ ZEND_VM_HANDLER(98, ZEND_FETCH_DIM_TMP_VAR, CONST|TMP, CONST)
 	container = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zend_free_op free_op2;
-		zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), GET_OP2_ZVAL_PTR(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
+		zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R), OP2_TYPE, BP_VAR_R TSRMLS_CC);
 
-		PZVAL_LOCK(value);
-		EX_T(opline->result.var).var.ptr = value;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
 		FREE_OP2();
 	}
 	CHECK_EXCEPTION();
@@ -1591,25 +1585,18 @@ ZEND_VM_HANDLER(136, ZEND_ASSIGN_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
+	object = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_W);
 	property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (IS_OP2_TMP_FREE()) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (IS_OP2_TMP_FREE()) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		FREE_OP2();
-	}
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	FREE_OP2();
 	FREE_OP1_VAR_PTR();
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -1621,74 +1608,57 @@ ZEND_VM_HANDLER(147, ZEND_ASSIGN_DIM, VAR|CV, CONST|TMP|VAR|UNUSED|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
 	object_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 		zend_free_op free_op2;
 		zval *property_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-		if (IS_OP2_TMP_FREE()) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (IS_OP2_TMP_FREE()) {
-			zval_ptr_dtor(&property_name);
-		} else {
-			FREE_OP2();
-		}
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+		FREE_OP2();
 	} else {
 		zend_free_op free_op2, free_op_data1, free_op_data2;
 		zval *value;
-		zval *dim = GET_OP2_ZVAL_PTR(BP_VAR_R);
-		zval **variable_ptr_ptr;
+		zval *dim = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, OP2_TYPE, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, OP2_TYPE TSRMLS_CC);
 		FREE_OP2();
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
  	FREE_OP1_VAR_PTR();
@@ -1703,50 +1673,35 @@ ZEND_VM_HANDLER(38, ZEND_ASSIGN, VAR|CV, CONST|TMP|VAR|CV)
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = GET_OP2_ZVAL_PTR(BP_VAR_R);
-	variable_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
-
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, OP2_TYPE TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
+	variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
 
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (OP1_TYPE == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, OP2_TYPE, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (IS_OP2_TMP_FREE()) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (OP2_TYPE == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (OP2_TYPE == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+		FREE_OP1_VAR_PTR();
 	}
 
-	FREE_OP1_VAR_PTR();
-
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
  	FREE_OP2_IF_VAR();
 
@@ -1758,19 +1713,18 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **variable_ptr_ptr;
-	zval **value_ptr_ptr;
+	zval *variable_ptr;
+	zval *value_ptr;
 
 	SAVE_OPLINE();
-	value_ptr_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
+	value_ptr = GET_OP2_ZVAL_PTR_PTR(BP_VAR_W);
 
 	if (OP2_TYPE == IS_VAR &&
-	    value_ptr_ptr &&
-	    !Z_ISREF_PP(value_ptr_ptr) &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION &&
-	    !EX_T(opline->op2.var).var.fcall_returned_reference) {
-		if (free_op2.var == NULL) {
-			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
+	    !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) &&
+	    !Z_ISREF_P(value_ptr)) {
+		if (!OP2_FREE) {
+			PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -1779,26 +1733,36 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
 		}
 		ZEND_VM_DISPATCH_TO_HANDLER(ZEND_ASSIGN);
 	} else if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		PZVAL_LOCK(*value_ptr_ptr);
+		if (!OP2_FREE) {
+			PZVAL_LOCK(value_ptr);
+		}
 	}
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
+
+	variable_ptr = GET_OP1_ZVAL_PTR_PTR_UNDEF(BP_VAR_W);
+	if (OP1_TYPE == IS_VAR &&
+	    UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
+	    UNEXPECTED(!Z_ISREF_P(variable_ptr))) {
 		zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
-
-	variable_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
-	if ((OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
-	    (OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
+	if ((OP2_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) ||
+	    (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) {
 		zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
 	}
-	zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
+	if ((OP1_TYPE == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
+	    (OP2_TYPE == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+		variable_ptr = &EG(uninitialized_zval);
+	} else {
+		zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC);
+	}
 
 	if (OP2_TYPE == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		Z_DELREF_PP(variable_ptr_ptr);
+		if (!OP2_FREE) {
+			Z_DELREF_P(variable_ptr);
+		}
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*variable_ptr_ptr);
-		EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
 	}
 
 	FREE_OP1_VAR_PTR();
@@ -1810,110 +1774,129 @@ ZEND_VM_HANDLER(39, ZEND_ASSIGN_REF, VAR|CV, VAR|CV)
 
 ZEND_VM_HELPER(zend_leave_helper, ANY, ANY)
 {
-	zend_bool nested = EX(nested);
-	zend_op_array *op_array = EX(op_array);
+	vm_frame_kind frame_kind = EX(frame_kind);
 
 	EG(current_execute_data) = EX(prev_execute_data);
-	EG(opline_ptr) = NULL;
-	if (!EG(active_symbol_table)) {
-		i_free_compiled_variables(execute_data TSRMLS_CC);
-	}
-
-	zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T) TSRMLS_CC);
 
-	if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
-		zval_ptr_dtor((zval**)&op_array->prototype);
-	}
+	if (frame_kind == VM_FRAME_NESTED_FUNCTION) {
+		i_free_compiled_variables(execute_data TSRMLS_CC);
+		if (UNEXPECTED(EX(symbol_table) != NULL)) {
+			zend_clean_and_cache_symbol_table(EX(symbol_table) TSRMLS_CC);
+		}
+		if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_CLOSURE) != 0) && EX(op_array)->prototype) {
+			zval_ptr_dtor((zval*)EX(op_array)->prototype);
+		}
+		zend_vm_stack_free((char*)execute_data TSRMLS_CC);
 
-	if (nested) {
 		execute_data = EG(current_execute_data);
-	}
-	if (nested) {
-		USE_OPLINE
-
-		LOAD_REGS();
-		LOAD_OPLINE();
-		if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
+		EG(opline_ptr) = &EX(opline);
+		EG(active_op_array) = EX(op_array);
+		EG(active_symbol_table) = EX(symbol_table);
 
-			EX(function_state).function = (zend_function *) EX(op_array);
-			EX(function_state).arguments = NULL;
+		EX(function_state).function = (zend_function *) EX(op_array);
+		EX(function_state).arguments = NULL;
 
-			EG(opline_ptr) = &EX(opline);
-			EG(active_op_array) = EX(op_array);
-			EG(return_value_ptr_ptr) = EX(original_return_value);
-			destroy_op_array(op_array TSRMLS_CC);
-			efree(op_array);
-			if (UNEXPECTED(EG(exception) != NULL)) {
-				zend_throw_exception_internal(NULL TSRMLS_CC);
-				HANDLE_EXCEPTION_LEAVE();
+		if (Z_OBJ(EG(This))) {
+			if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
+				if (EX(call)->is_ctor_result_used) {
+					Z_DELREF(EG(This));
+				}
+				if (Z_REFCOUNT(EG(This)) == 1) {
+					zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
+				}
 			}
-
-			ZEND_VM_INC_OPCODE();
-			ZEND_VM_LEAVE();
-		} else {
-			EG(opline_ptr) = &EX(opline);
-			EG(active_op_array) = EX(op_array);
-			EG(return_value_ptr_ptr) = EX(original_return_value);
-			if (EG(active_symbol_table)) {
-				zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
+			if (!Z_DELREF(EG(This))) {
+				_zval_dtor_func_for_ptr(Z_COUNTED(EG(This)) ZEND_FILE_LINE_CC);
+			} else if (UNEXPECTED(!Z_GC_INFO(EG(This)))) {
+				gc_possible_root(Z_COUNTED(EG(This)) TSRMLS_CC);
 			}
-			EG(active_symbol_table) = EX(symbol_table);
+		}
+		Z_OBJ(EG(This)) = EX(object);
+		EG(scope) = EX(scope);
+		EG(called_scope) = EX(called_scope);
 
-			EX(function_state).function = (zend_function *) EX(op_array);
-			EX(function_state).arguments = NULL;
+		EX(call)--;
 
-			if (EG(This)) {
-				if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
-					if (EX(call)->is_ctor_result_used) {
-						Z_DELREF_P(EG(This));
-					}
-					if (Z_REFCOUNT_P(EG(This)) == 1) {
-						zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
-					}
-				}
-				zval_ptr_dtor(&EG(This));
+		zend_vm_stack_clear_multiple(1 TSRMLS_CC);
+
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_op *opline = EX(opline);
+			zend_throw_exception_internal(NULL TSRMLS_CC);
+			if (RETURN_VALUE_USED(opline)) {
+				zval_ptr_dtor(EX_VAR(opline->result.var));
 			}
-			EG(This) = EX(current_this);
-			EG(scope) = EX(current_scope);
-			EG(called_scope) = EX(current_called_scope);
+			HANDLE_EXCEPTION_LEAVE();
+		}
 
-			EX(call)--;
+		LOAD_OPLINE();
+		ZEND_VM_INC_OPCODE();
+		ZEND_VM_LEAVE();
+	} else if (frame_kind == VM_FRAME_NESTED_CODE) {
+		zend_detach_symbol_table(execute_data);
+		destroy_op_array(EX(op_array) TSRMLS_CC);
+		efree(EX(op_array));
+		zend_vm_stack_free((char*)execute_data TSRMLS_CC);
 
-			zend_vm_stack_clear_multiple(1 TSRMLS_CC);
+		execute_data = EG(current_execute_data);
+		zend_attach_symbol_table(execute_data);
+		EX(function_state).function = (zend_function *) EX(op_array);
+		EX(function_state).arguments = NULL;
+		EG(opline_ptr) = &EX(opline);
+		EG(active_op_array) = EX(op_array);
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_throw_exception_internal(NULL TSRMLS_CC);
+			HANDLE_EXCEPTION_LEAVE();
+		}
 
-			if (UNEXPECTED(EG(exception) != NULL)) {
-				zend_throw_exception_internal(NULL TSRMLS_CC);
-				if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
-					zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
+		LOAD_OPLINE();
+		ZEND_VM_INC_OPCODE();
+		ZEND_VM_LEAVE();
+	} else {
+		if (frame_kind == VM_FRAME_TOP_FUNCTION) {
+			i_free_compiled_variables(execute_data TSRMLS_CC);
+		} else /* if (frame_kind == VM_FRAME_TOP_CODE) */ {
+			zend_array *symbol_table = EX(symbol_table);
+			zend_execute_data *old_execute_data;
+
+			zend_detach_symbol_table(execute_data);
+			old_execute_data = EX(prev_execute_data);
+			while (old_execute_data) {
+				if (old_execute_data->op_array) {
+					if (old_execute_data->symbol_table == symbol_table) {
+						zend_attach_symbol_table(old_execute_data);
+					}
+					break;
 				}
-				HANDLE_EXCEPTION_LEAVE();
+				old_execute_data = old_execute_data->prev_execute_data;
 			}
-
-			ZEND_VM_INC_OPCODE();
-			ZEND_VM_LEAVE();
 		}
-	}
-	ZEND_VM_RETURN();
+		if ((EX(op_array)->fn_flags & ZEND_ACC_CLOSURE) && EX(op_array)->prototype) {
+			zval_ptr_dtor((zval*)EX(op_array)->prototype);
+		}
+		zend_vm_stack_free((char*)execute_data TSRMLS_CC);
+		EG(opline_ptr) = NULL;
+		ZEND_VM_RETURN();
+	}		
 }
 
 ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
 {
 	USE_OPLINE
-	zend_bool should_change_scope = 0;
 	zend_function *fbc = EX(function_state).function;
+	zend_object *object;
 	zend_uint num_args;
 
 	SAVE_OPLINE();
-	EX(object) = EX(call)->object;
+	object = EX(call)->object;
 	if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
 		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
-			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name);
+			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name->val, fbc->common.function_name->val);
 		}
 		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
 			zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
-				fbc->common.scope ? fbc->common.scope->name : "",
+				fbc->common.scope ? fbc->common.scope->name->val : "",
 				fbc->common.scope ? "::" : "",
-				fbc->common.function_name);
+				fbc->common.function_name->val);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
@@ -1921,158 +1904,181 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
 	}
 	if (fbc->common.scope &&
 		!(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
-		!EX(object)) {
+		!object) {
 
 		if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
 			/* FIXME: output identifiers properly */
-			zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name);
+			zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name->val, fbc->common.function_name->val);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 		} else {
 			/* FIXME: output identifiers properly */
 			/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-			zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name);
+			zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name->val, fbc->common.function_name->val);
 		}
 	}
 
-	if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
-		should_change_scope = 1;
-		EX(current_this) = EG(This);
-		EX(current_scope) = EG(scope);
-		EX(current_called_scope) = EG(called_scope);
-		EG(This) = EX(object);
-		EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
-		EG(called_scope) = EX(call)->called_scope;
-	}
-
-	num_args = opline->extended_value + EX(call)->num_additional_args;
-	if (EX(call)->num_additional_args) {
+	if (UNEXPECTED(EX(call)->num_additional_args != 0)) {
+		num_args = opline->extended_value + EX(call)->num_additional_args;
 		EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
 	} else {
+		zval tmp;
+
+		num_args = opline->extended_value;
+		ZVAL_LONG(&tmp, num_args);
 		EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
-		zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
+		zend_vm_stack_push(&tmp TSRMLS_CC);
 	}
 	LOAD_OPLINE();
 
 	if (fbc->type == ZEND_INTERNAL_FUNCTION) {
+		int should_change_scope = 0;
+		zval *ret;
+
+		if (fbc->common.scope) {
+			should_change_scope = 1;
+			Z_OBJ(EG(This)) = object;
+//???			EG(scope) = (object) ? NULL : fbc->common.scope;
+			EG(scope) = fbc->common.scope;
+			EG(called_scope) = EX(call)->called_scope;
+		}
+
 		if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
 			zend_uint i;
-			void **p = EX(function_state).arguments - num_args;
+			zval *p = EX(function_state).arguments - num_args;
 
 			for (i = 0; i < num_args; ++i, ++p) {
-				zend_verify_arg_type(fbc, i + 1, (zval *) *p, 0 TSRMLS_CC);
+				zend_verify_arg_type(fbc, i + 1, p, 0 TSRMLS_CC);
+			}
+			if (UNEXPECTED(EG(exception) != NULL)) {
+				if (RETURN_VALUE_USED(opline)) {
+					ZVAL_UNDEF(EX_VAR(opline->result.var));
+				}
+				if (UNEXPECTED(should_change_scope)) {
+					ZEND_VM_C_GOTO(fcall_end_change_scope);
+				} else {
+					ZEND_VM_C_GOTO(fcall_end);
+				}
 			}
 		}
 
-		if (EXPECTED(EG(exception) == NULL)) {
-			temp_variable *ret = &EX_T(opline->result.var);
+		ret = EX_VAR(opline->result.var);
+		ZVAL_NULL(ret);
+		Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
 
-			MAKE_STD_ZVAL(ret->var.ptr);
-			ZVAL_NULL(ret->var.ptr);
-			ret->var.ptr_ptr = &ret->var.ptr;
-			ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+		if (!zend_execute_internal) {
+			/* saves one function call if zend_execute_internal is not used */
+			fbc->internal_function.handler(num_args, ret TSRMLS_CC);
+		} else {
+			zend_execute_internal(execute_data, NULL TSRMLS_CC);
+		}
 
-			if (!zend_execute_internal) {
-				/* saves one function call if zend_execute_internal is not used */
-				fbc->internal_function.handler(num_args, ret->var.ptr, &ret->var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
-			} else {
-				zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
-			}
+		if (!RETURN_VALUE_USED(opline)) {
+			zval_ptr_dtor(ret);
+		}
 
-			if (!RETURN_VALUE_USED(opline)) {
-				zval_ptr_dtor(&ret->var.ptr);
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr = NULL;
+		if (UNEXPECTED(should_change_scope)) {
+			ZEND_VM_C_GOTO(fcall_end_change_scope);
+		} else {
+			ZEND_VM_C_GOTO(fcall_end);
 		}
 	} else if (fbc->type == ZEND_USER_FUNCTION) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
+		Z_OBJ(EG(This)) = object;
+		EG(scope) = fbc->common.scope;
+		EG(called_scope) = EX(call)->called_scope;
 		EG(active_symbol_table) = NULL;
 		EG(active_op_array) = &fbc->op_array;
-		EG(return_value_ptr_ptr) = NULL;
 		if (RETURN_VALUE_USED(opline)) {
-			temp_variable *ret = &EX_T(opline->result.var);
+			return_value = EX_VAR(opline->result.var);
 
-			ret->var.ptr = NULL;
-			EG(return_value_ptr_ptr) = &ret->var.ptr;
-			ret->var.ptr_ptr = &ret->var.ptr;
-			ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+			ZVAL_NULL(return_value);
+			Z_VAR_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
 		}
 
 		if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
 			if (RETURN_VALUE_USED(opline)) {
-				EX_T(opline->result.var).var.ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC);
+				zend_generator_create_zval(EG(active_op_array), EX_VAR(opline->result.var) TSRMLS_CC);
 			}
 		} else if (EXPECTED(zend_execute_ex == execute_ex)) {
 			if (EXPECTED(EG(exception) == NULL)) {
+				i_create_execute_data_from_op_array(EG(active_op_array), return_value, VM_FRAME_NESTED_FUNCTION TSRMLS_CC);
 				ZEND_VM_ENTER();
 			}
 		} else {
-			zend_execute(EG(active_op_array) TSRMLS_CC);
+			zend_execute(EG(active_op_array), return_value TSRMLS_CC);
 		}
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
-		if (EG(active_symbol_table)) {
+		if (UNEXPECTED(EG(active_symbol_table) != NULL)) {
 			zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
 		}
 		EG(active_symbol_table) = EX(symbol_table);
 	} else { /* ZEND_OVERLOADED_FUNCTION */
-		MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr);
-		ZVAL_NULL(EX_T(opline->result.var).var.ptr);
+		Z_OBJ(EG(This)) = object;
+//???		EG(scope) = NULL;
+		EG(scope) = fbc->common.scope;
+		EG(called_scope) = EX(call)->called_scope;
+
+		ZVAL_NULL(EX_VAR(opline->result.var));
 
 		/* Not sure what should be done here if it's a static method */
-		if (EXPECTED(EX(object) != NULL)) {
-			Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, num_args, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
+		if (EXPECTED(object != NULL)) {
+			object->handlers->call_method(fbc->common.function_name, object, num_args, EX_VAR(opline->result.var) TSRMLS_CC);
 		} else {
 			zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
 		}
 
 		if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
-			efree((char*)fbc->common.function_name);
+			STR_RELEASE(fbc->common.function_name);
 		}
 		efree(fbc);
 
 		if (!RETURN_VALUE_USED(opline)) {
-			zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		} else {
-			Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
-			Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
-			EX_T(opline->result.var).var.fcall_returned_reference = 0;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+//???			Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
+//???			Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
+			Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0;
 		}
 	}
 
-	EX(function_state).function = (zend_function *) EX(op_array);
-	EX(function_state).arguments = NULL;
-
-	if (should_change_scope) {
-		if (EG(This)) {
-			if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
-				if (EX(call)->is_ctor_result_used) {
-					Z_DELREF_P(EG(This));
-				}
-				if (Z_REFCOUNT_P(EG(This)) == 1) {
-					zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
-				}
+ZEND_VM_C_LABEL(fcall_end_change_scope):
+	if (Z_OBJ(EG(This))) {
+		if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
+			if (EX(call)->is_ctor_result_used) {
+				Z_DELREF(EG(This));
+			}
+			if (Z_REFCOUNT(EG(This)) == 1) {
+				zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
 			}
-			zval_ptr_dtor(&EG(This));
 		}
-		EG(This) = EX(current_this);
-		EG(scope) = EX(current_scope);
-		EG(called_scope) = EX(current_called_scope);
+		if (!Z_DELREF(EG(This))) {
+			EX(function_state).function = (zend_function *) EX(op_array);
+			EX(function_state).arguments = NULL;
+			_zval_dtor_func_for_ptr(Z_COUNTED(EG(This)) ZEND_FILE_LINE_CC);
+		} else if (UNEXPECTED(!Z_GC_INFO(EG(This)))) {
+			gc_possible_root(Z_COUNTED(EG(This)) TSRMLS_CC);
+		}
 	}
+	Z_OBJ(EG(This)) = EX(object);
+	EG(scope) = EX(scope);
+	EG(called_scope) = EX(called_scope);
 
+ZEND_VM_C_LABEL(fcall_end):
+	EX(function_state).function = (zend_function *) EX(op_array);
+	EX(function_state).arguments = NULL;
 	EX(call)--;
 
 	zend_vm_stack_clear_multiple(1 TSRMLS_CC);
 
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		zend_throw_exception_internal(NULL TSRMLS_CC);
-		if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
-			zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 		HANDLE_EXCEPTION();
 	}
@@ -2099,7 +2105,7 @@ ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
 	int ret;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
 	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		ret = Z_LVAL_P(val);
@@ -2129,7 +2135,7 @@ ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
 	int ret;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
 	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		ret = Z_LVAL_P(val);
@@ -2159,7 +2165,7 @@ ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
 	int retval;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
 	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
@@ -2193,7 +2199,7 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
 	int retval;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
 	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
@@ -2204,8 +2210,7 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -2224,7 +2229,7 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
 	int retval;
 
 	SAVE_OPLINE();
-	val = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
 	if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
@@ -2235,8 +2240,7 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -2253,9 +2257,9 @@ ZEND_VM_HANDLER(70, ZEND_FREE, TMP|VAR, ANY)
 
 	SAVE_OPLINE();
 	if (OP1_TYPE == IS_TMP_VAR) {
-		zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+		zval_dtor(EX_VAR(opline->op1.var));
 	} else {
-		zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+		zval_ptr_dtor(EX_VAR(opline->op1.var));
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -2264,15 +2268,10 @@ ZEND_VM_HANDLER(70, ZEND_FREE, TMP|VAR, ANY)
 ZEND_VM_HANDLER(53, ZEND_INIT_STRING, ANY, ANY)
 {
 	USE_OPLINE
-	zval *tmp = &EX_T(opline->result.var).tmp_var;
+	zval *tmp = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	tmp->value.str.val = emalloc(1);
-	tmp->value.str.val[0] = 0;
-	tmp->value.str.len = 0;
-	Z_SET_REFCOUNT_P(tmp, 1);
-	tmp->type = IS_STRING;
-	Z_UNSET_ISREF_P(tmp);
+	ZVAL_EMPTY_STRING(tmp);
 	/*CHECK_EXCEPTION();*/
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -2280,17 +2279,13 @@ ZEND_VM_HANDLER(53, ZEND_INIT_STRING, ANY, ANY)
 ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP|UNUSED, CONST)
 {
 	USE_OPLINE
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 
 	if (OP1_TYPE == IS_UNUSED) {
 		/* Initialize for erealloc in add_char_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	add_char_to_string(str, str, opline->op2.zv);
@@ -2303,17 +2298,13 @@ ZEND_VM_HANDLER(54, ZEND_ADD_CHAR, TMP|UNUSED, CONST)
 ZEND_VM_HANDLER(55, ZEND_ADD_STRING, TMP|UNUSED, CONST)
 {
 	USE_OPLINE
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 
 	if (OP1_TYPE == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	add_string_to_string(str, str, opline->op2.zv);
@@ -2327,7 +2318,7 @@ ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP|UNUSED, TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -2337,18 +2328,17 @@ ZEND_VM_HANDLER(56, ZEND_ADD_VAR, TMP|UNUSED, TMP|VAR|CV)
 
 	if (OP1_TYPE == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -2377,24 +2367,24 @@ ZEND_VM_HANDLER(109, ZEND_FETCH_CLASS, ANY, CONST|TMP|VAR|UNUSED|CV)
 		zend_exception_save(TSRMLS_C);
 	}
 	if (OP2_TYPE == IS_UNUSED) {
-		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
 		zend_free_op free_op2;
-		zval *class_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
+		zval *class_name = GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R);
 
 		if (OP2_TYPE == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
+				Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 			} else {
-				EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-				CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
+				Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+				CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
 			}
 		} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-			EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
+			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
-			EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC);
 		} else {
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
@@ -2412,10 +2402,9 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1, free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -2429,33 +2418,30 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
+	object = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_R);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	call->object = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_R);
-
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (OP2_TYPE != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (OP2_TYPE == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -2463,21 +2449,13 @@ ZEND_VM_HANDLER(112, ZEND_INIT_METHOD_CALL, TMP|VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 			FREE_OP2();
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -2502,21 +2480,21 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 
 	if (OP1_TYPE == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -2527,51 +2505,40 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 
 	if (OP1_TYPE == IS_CONST &&
 	    OP2_TYPE == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (OP1_TYPE != IS_CONST &&
 	           OP2_TYPE == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (OP2_TYPE != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 		zend_free_op free_op2;
 
-		if (OP2_TYPE == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
-
+		function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
+		if (OP2_TYPE != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((OP2_TYPE == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (OP2_TYPE == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (OP1_TYPE == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((OP2_TYPE == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (OP2_TYPE == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (OP1_TYPE == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (OP2_TYPE != IS_CONST) {
@@ -2581,8 +2548,8 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -2590,21 +2557,21 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -2619,18 +2586,19 @@ ZEND_VM_HANDLER(113, ZEND_INIT_STATIC_METHOD_CALL, CONST|VAR, CONST|TMP|VAR|UNUS
 ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
-	zval *function_name;
+	zval *function_name_ptr, *function_name, *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
 	if (OP2_TYPE == IS_CONST) {
-		function_name = (zval*)(opline->op2.literal+1);
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
+		function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 
 		call->object = NULL;
@@ -2642,28 +2610,28 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 		/*CHECK_EXCEPTION();*/
 		ZEND_VM_NEXT_OPCODE();
 	} else {
-		char *function_name_strval, *lcname;
-		int function_name_strlen;
+		zend_string *lcname;
 		zend_free_op free_op2;
 
 		SAVE_OPLINE();
-		function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
+		function_name_ptr = function_name = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
+		ZVAL_DEREF(function_name);
 		if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
-			function_name_strval = Z_STRVAL_P(function_name);
-			function_name_strlen = Z_STRLEN_P(function_name);
-			if (function_name_strval[0] == '\\') {
-			    function_name_strlen -= 1;
-				lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
+			if (Z_STRVAL_P(function_name)[0] == '\\') {
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
 			} else {
-				lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
 			}
-			if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
+			if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
+				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
 			}
-			efree(lcname);
+			STR_FREE(lcname);
 			FREE_OP2();
 
+			call->fbc = Z_FUNC_P(func);
 			call->object = NULL;
 			call->called_scope = NULL;
 			call->num_additional_args = 0;
@@ -2677,12 +2645,12 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
 			if (call->object) {
-				Z_ADDREF_P(call->object);
+				GC_REFCOUNT(call->object)++;
 			}
 			if (OP2_TYPE == IS_VAR && OP2_FREE && Z_REFCOUNT_P(function_name) == 1 &&
 			    call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
-				call->fbc->common.prototype = (zend_function*)function_name;
+				call->fbc->common.prototype = (zend_function*)function_name_ptr;
 			} else {
 				FREE_OP2();
 			}
@@ -2696,67 +2664,56 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 		} else if (OP2_TYPE != IS_CONST &&
 				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
-			zend_class_entry *ce;
-			zval **method = NULL;
-			zval **obj = NULL;
+			zval *obj;
+			zval *method;
 
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
+			obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
+			method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
 
 			if (!obj || !method) {
 				zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
 			}
 
-			if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
+			if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
 				zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
 			}
 
-			if (Z_TYPE_PP(method) != IS_STRING) {
+			if (Z_TYPE_P(method) != IS_STRING) {
 				zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
 			}
 
-			if (Z_TYPE_PP(obj) == IS_STRING) {
-				ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
-				if (UNEXPECTED(ce == NULL)) {
+			if (Z_TYPE_P(obj) == IS_STRING) {
+				call->object = NULL;
+				call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
+				if (UNEXPECTED(call->called_scope == NULL)) {
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				call->called_scope = ce;
-				call->object = NULL;
 
-				if (ce->get_static_method) {
-					call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
+				if (call->called_scope->get_static_method) {
+					call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC);
 				} else {
-					call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+					call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC);
+				}
+				if (UNEXPECTED(call->fbc == NULL)) {
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method));
 				}
 			} else {
-				call->object = *obj;
-				ce = call->called_scope = Z_OBJCE_PP(obj);
+				call->called_scope = Z_OBJCE_P(obj);
+				call->object = Z_OBJ_P(obj);
 
-				call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+				call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
 				if (UNEXPECTED(call->fbc == NULL)) {
-					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
 				}
 
 				if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 					call->object = NULL;
 				} else {
-					if (!PZVAL_IS_REF(call->object)) {
-						Z_ADDREF_P(call->object); /* For $this pointer */
-					} else {
-						zval *this_ptr;
-						ALLOC_ZVAL(this_ptr);
-						INIT_PZVAL_COPY(this_ptr, call->object);
-						zval_copy_ctor(this_ptr);
-						call->object = this_ptr;
-					}
+					GC_REFCOUNT(call->object)++; /* For $this pointer */
 				}
 			}
 
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
-			}
-
 			call->num_additional_args = 0;
 			call->is_ctor_call = 0;
 			EX(call) = call;
@@ -2778,30 +2735,33 @@ ZEND_VM_HANDLER(59, ZEND_INIT_FCALL_BY_NAME, ANY, CONST|TMP|VAR|CV)
 ZEND_VM_HANDLER(69, ZEND_INIT_NS_FCALL_BY_NAME, ANY, CONST)
 {
 	USE_OPLINE
-	zend_literal *func_name;
+	zval *func_name;
+	zval *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
-	func_name = opline->op2.literal + 1;
-	if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-	} else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) {
+	func_name = opline->op2.zv + 1;
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+	} else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) {
 		func_name++;
-		if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) {
+		if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 	} else {
-		CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+		call->fbc = Z_FUNC_P(func);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 	}
 
 	call->object = NULL;
 	call->called_scope = NULL;
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
-
 	EX(call) = call;
+
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -2816,15 +2776,17 @@ ZEND_VM_HANDLER(60, ZEND_DO_FCALL, CONST, ANY)
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *fname = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	zval *func;
 	call_slot *call = EX(call_slots) + opline->op2.num;
 
-	if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-		EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
-	} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(fname), Z_STRLEN_P(fname)+1, Z_HASH_P(fname), (void **) &EX(function_state).function)==FAILURE)) {
+	if (CACHED_PTR(Z_CACHE_SLOT_P(fname))) {
+		EX(function_state).function = CACHED_PTR(Z_CACHE_SLOT_P(fname));
+	} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(fname))) == NULL)) {
 	    SAVE_OPLINE();
-		zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
+		zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(fname));
 	} else {
-		CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
+		EX(function_state).function = Z_FUNC_P(func);
+		CACHE_PTR(Z_CACHE_SLOT_P(fname), EX(function_state).function);
 	}
 
 	call->fbc = EX(function_state).function;
@@ -2848,34 +2810,21 @@ ZEND_VM_HANDLER(62, ZEND_RETURN, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (!EG(return_value_ptr_ptr)) {
+	if (!EX(return_value)) {
 		FREE_OP1();
 	} else {
-		if (OP1_TYPE == IS_CONST ||
-		    OP1_TYPE == IS_TMP_VAR ||
-		    PZVAL_IS_REF(retval_ptr)) {
-			zval *ret;
-
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, retval_ptr);
+		if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {		    
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (OP1_TYPE != IS_TMP_VAR) {
-				zval_copy_ctor(ret);
+				zval_opt_copy_ctor(EX(return_value));
 			}
-			*EG(return_value_ptr_ptr) = ret;
+		} else if (Z_ISREF_P(retval_ptr)) {
+			ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
 			FREE_OP1_IF_VAR();
-		} else if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
-		           retval_ptr == &EG(uninitialized_zval)) {
-			zval *ret;
-
-			if (OP1_TYPE == IS_VAR) {
-				Z_DELREF_P(retval_ptr);
-			}
-			ALLOC_INIT_ZVAL(ret);
-			*EG(return_value_ptr_ptr) = ret;
 		} else {
-			*EG(return_value_ptr_ptr) = retval_ptr;
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (OP1_TYPE == IS_CV) {
-				Z_ADDREF_P(retval_ptr);
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
 			}
 		}
 	}
@@ -2886,7 +2835,6 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zval *retval_ptr;
-	zval **retval_ptr_ptr;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
@@ -2898,55 +2846,41 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
 			retval_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
-			if (!EG(return_value_ptr_ptr)) {
+			if (!EX(return_value)) {
 				if (OP1_TYPE == IS_TMP_VAR) {
 					FREE_OP1();
 				}
 			} else if (!IS_OP1_TMP_FREE()) { /* Not a temp var */
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				zval_copy_ctor(ret);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_DUP(EX(return_value), retval_ptr);
 			} else {
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			}
 			break;
 		}
 
-		retval_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+		retval_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-		if (OP1_TYPE == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
+		if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
 		}
 
-		if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
+		if (OP1_TYPE == IS_VAR && !Z_ISREF_P(retval_ptr)) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-			    EX_T(opline->op1.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+			    (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+			} else {
 				zend_error(E_NOTICE, "Only variable references should be returned by reference");
-				if (EG(return_value_ptr_ptr)) {
-					zval *ret;
-
-					ALLOC_ZVAL(ret);
-					INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
-					zval_copy_ctor(ret);
-					*EG(return_value_ptr_ptr) = ret;
+				if (EX(return_value)) {
+					zval tmp;
+					ZVAL_DUP(&tmp, retval_ptr);
+					ZVAL_NEW_REF(EX(return_value), &tmp);
 				}
 				break;
 			}
 		}
 
-		if (EG(return_value_ptr_ptr)) {
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
-			Z_ADDREF_PP(retval_ptr_ptr);
-
-			*EG(return_value_ptr_ptr) = *retval_ptr_ptr;
+		if (EX(return_value)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
+			ZVAL_COPY(EX(return_value), retval_ptr);
 		}
 	} while (0);
 
@@ -2956,8 +2890,8 @@ ZEND_VM_HANDLER(111, ZEND_RETURN_BY_REF, CONST|TMP|VAR|CV, ANY)
 
 ZEND_VM_HANDLER(161, ZEND_GENERATOR_RETURN, ANY, ANY)
 {
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	/* Close the generator to free up resources */
 	zend_generator_close(generator, 1 TSRMLS_CC);
@@ -2970,7 +2904,7 @@ ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zval *value;
-	zval *exception;
+	zval exception;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
@@ -2984,14 +2918,14 @@ ZEND_VM_HANDLER(108, ZEND_THROW, CONST|TMP|VAR|CV, ANY)
 	}
 
 	zend_exception_save(TSRMLS_C);
-	/* Not sure if a complete copy is what we want here */
-	ALLOC_ZVAL(exception);
-	INIT_PZVAL_COPY(exception, value);
-	if (!IS_OP1_TMP_FREE()) {
-		zval_copy_ctor(exception);
+	if (OP1_TYPE == IS_CONST) {
+		ZVAL_DUP(&exception, value);
+		value = &exception;
+	} else if (OP1_TYPE != IS_TMP_VAR) {
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 	}
 
-	zend_throw_exception_object(exception TSRMLS_CC);
+	zend_throw_exception_object(value TSRMLS_CC);
 	zend_exception_restore(TSRMLS_C);
 	FREE_OP1_IF_VAR();
 	HANDLE_EXCEPTION();
@@ -3001,7 +2935,7 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
 {
 	USE_OPLINE
 	zend_class_entry *ce, *catch_ce;
-	zval *exception;
+	zend_object *exception;
 
 	SAVE_OPLINE();
 	/* Check whether an exception has been thrown, if not, jump over code */
@@ -3010,14 +2944,14 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
 		ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
 		ZEND_VM_CONTINUE(); /* CHECK_ME */
 	}
-	if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-		catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+		catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 	} else {
-		catch_ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
+		catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
 
-		CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce);
 	}
-	ce = Z_OBJCE_P(EG(exception));
+	ce = zend_get_class_entry(EG(exception) TSRMLS_CC);
 
 #ifdef HAVE_DTRACE
 	if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
@@ -3037,19 +2971,12 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
 	}
 
 	exception = EG(exception);
-	if (!EG(active_symbol_table)) {
-		if (EX_CV(opline->op2.var)) {
-			zval_ptr_dtor(EX_CV(opline->op2.var));
-		}
-		EX_CV(opline->op2.var) = (zval**)EX_CV_NUM(execute_data, EX(op_array)->last_var + opline->op2.var);
-		*EX_CV(opline->op2.var) = EG(exception);
-	} else {
-		zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var);
-		zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
-		    &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var));
+	if (Z_REFCOUNTED_P(EX_VAR(opline->op2.var))) {
+		zval_ptr_dtor(EX_VAR(opline->op2.var));
 	}
+	ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception));
 	if (UNEXPECTED(EG(exception) != exception)) {
-		Z_ADDREF_P(EG(exception));
+		GC_REFCOUNT(EG(exception))++;
 		HANDLE_EXCEPTION();
 	} else {
 		EG(exception) = NULL;
@@ -3060,6 +2987,8 @@ ZEND_VM_HANDLER(107, ZEND_CATCH, CONST, CV)
 ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP, ANY)
 {
 	USE_OPLINE
+	zval *value, *top;
+	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
@@ -3068,55 +2997,32 @@ ZEND_VM_HANDLER(65, ZEND_SEND_VAL, CONST|TMP, ANY)
 		}
 	}
 
-	{
-		zval *valptr;
-		zval *value;
-		zend_free_op free_op1;
-
-		value = GET_OP1_ZVAL_PTR(BP_VAR_R);
-
-		ALLOC_ZVAL(valptr);
-		INIT_PZVAL_COPY(valptr, value);
-		if (!IS_OP1_TMP_FREE()) {
-			zval_copy_ctor(valptr);
-		}
-		zend_vm_stack_push(valptr TSRMLS_CC);
-		FREE_OP1_IF_VAR();
+	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	ZVAL_COPY_VALUE(top, value);
+	if (OP1_TYPE == IS_CONST) {
+		zval_opt_copy_ctor(top);
 	}
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HELPER(zend_send_by_var_helper, VAR|CV, ANY)
 {
 	USE_OPLINE
-	zval *varptr;
+	zval *varptr, *top;
 	zend_free_op free_op1;
-	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (varptr == &EG(uninitialized_zval)) {
-		if (OP1_TYPE == IS_VAR) {
-			Z_DELREF_P(varptr);
-		}
-		ALLOC_INIT_ZVAL(varptr);
-	} else if (PZVAL_IS_REF(varptr)) {
-		if (OP1_TYPE == IS_CV ||
-		    (OP1_TYPE == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
-			zval *original_var = varptr;
-
-			ALLOC_ZVAL(varptr);
-			INIT_PZVAL_COPY(varptr, original_var);
-			zval_copy_ctor(varptr);
-			FREE_OP1();
-		} else {
-			Z_UNSET_ISREF_P(varptr);
+	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (Z_ISREF_P(varptr)) {
+		ZVAL_DUP(top, Z_REFVAL_P(varptr));
+		FREE_OP1();
+	} else {
+		ZVAL_COPY_VALUE(top, varptr);
+		if (OP1_TYPE == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
 		}
-	} else if (OP1_TYPE == IS_CV) {
-		Z_ADDREF_P(varptr);
 	}
-	zend_vm_stack_push(varptr TSRMLS_CC);
-
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -3124,7 +3030,7 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *varptr;
+	zval *varptr, *top;
 
 	SAVE_OPLINE();
 	if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
@@ -3139,29 +3045,29 @@ ZEND_VM_HANDLER(106, ZEND_SEND_VAR_NO_REF, VAR|CV, ANY)
 
 	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
-	     EX_T(opline->op1.var).var.fcall_returned_reference) &&
-	    varptr != &EG(uninitialized_zval) &&
-	    (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
-		Z_SET_ISREF_P(varptr);
+	     (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
+	    ((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) || 
+	     Z_ISREF_P(varptr) ||
+	     Z_TYPE_P(varptr) == IS_OBJECT ||
+	     (Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) {
+
+		if (!Z_ISREF_P(varptr)) {
+			ZVAL_NEW_REF(varptr, varptr);
+		}
 		if (OP1_TYPE == IS_CV) {
 			Z_ADDREF_P(varptr);
 		}
 		zend_vm_stack_push(varptr TSRMLS_CC);
 	} else {
-		zval *valptr;
-
 		if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
 			!(opline->extended_value & ZEND_ARG_SEND_SILENT) :
 			!ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
 			zend_error(E_STRICT, "Only variables should be passed by reference");
 		}
-		ALLOC_ZVAL(valptr);
-		INIT_PZVAL_COPY(valptr, varptr);
-		if (!IS_OP1_TMP_FREE()) {
-			zval_copy_ctor(valptr);
-		}
+		top = zend_vm_stack_top_inc(TSRMLS_C);
+		ZVAL_COPY_VALUE(top, varptr);
+		zval_opt_copy_ctor(top);
 		FREE_OP1_IF_VAR();
-		zend_vm_stack_push(valptr TSRMLS_CC);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -3171,51 +3077,62 @@ ZEND_VM_HANDLER(67, ZEND_SEND_REF, VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **varptr_ptr;
-	zval *varptr;
+	zval *varptr, *top;
 
 	SAVE_OPLINE();
-	varptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+	varptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
 	}
 
-	if (OP1_TYPE == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
-		ALLOC_INIT_ZVAL(varptr);
-		zend_vm_stack_push(varptr TSRMLS_CC);
-		CHECK_EXCEPTION();
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (OP1_TYPE == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
+		ZVAL_NEW_REF(top, &EG(uninitialized_zval));
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
-	    EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) { 
-		if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
-			ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
-		}
+	if (Z_ISREF_P(varptr)) {
+		Z_ADDREF_P(varptr);
+		ZVAL_COPY_VALUE(top, varptr);
+	} else if (OP1_TYPE == IS_VAR &&
+		UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
+		ZVAL_COPY_VALUE(top, varptr);
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(top);
+	} else {
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr);
+		Z_ADDREF_P(varptr);
+		ZVAL_COPY_VALUE(top, varptr);
 	}
 
-	SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
-	varptr = *varptr_ptr;
-	Z_ADDREF_P(varptr);
-	zend_vm_stack_push(varptr TSRMLS_CC);
-
 	FREE_OP1_VAR_PTR();
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(66, ZEND_SEND_VAR, VAR|CV, ANY)
 {
 	USE_OPLINE
+	zval *varptr, *top;
+	zend_free_op free_op1;
 
 	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
 		if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
 			ZEND_VM_DISPATCH_TO_HANDLER(ZEND_SEND_REF);
 		}
 	}
-	SAVE_OPLINE();
-	ZEND_VM_DISPATCH_TO_HELPER(zend_send_by_var_helper);
+
+	varptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (Z_ISREF_P(varptr)) {
+		ZVAL_DUP(top, Z_REFVAL_P(varptr));
+		FREE_OP1();
+	} else {
+		ZVAL_COPY_VALUE(top, varptr);
+		if (OP1_TYPE == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
+		}
+	}
+	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
@@ -3229,23 +3146,17 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
 	args = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
 
+ZEND_VM_C_LABEL(send_again):
 	switch (Z_TYPE_P(args)) {
 		case IS_ARRAY: {
 			HashTable *ht = Z_ARRVAL_P(args);
-			HashPosition pos;
-			zval **arg_ptr, *arg;
+			zval *arg;
+			zend_string *name;
 
 			ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
 
-			for (zend_hash_internal_pointer_reset_ex(ht, &pos);
-			     zend_hash_get_current_data_ex(ht, (void **) &arg_ptr, &pos) == SUCCESS;
-			     zend_hash_move_forward_ex(ht, &pos), ++arg_num
-			) {
-				char *name;
-				zend_uint name_len;
-				zend_ulong index;
-
-				if (zend_hash_get_current_key_ex(ht, &name, &name_len, &index, 0, &pos) == HASH_KEY_IS_STRING) {
+			ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
+				if (name) {
 					zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
 					FREE_OP1();
 					CHECK_EXCEPTION();
@@ -3253,20 +3164,19 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
 				}
 
 				if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
-					SEPARATE_ZVAL_TO_MAKE_IS_REF(arg_ptr);
-					arg = *arg_ptr;
+					SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
 					Z_ADDREF_P(arg);
-				} else if (Z_ISREF_PP(arg_ptr)) {
-					ALLOC_ZVAL(arg);
-					MAKE_COPY_ZVAL(arg_ptr, arg);
+				} else if (Z_ISREF_P(arg)) {
+					ZVAL_DUP(arg, Z_REFVAL_P(arg));
 				} else {
-					arg = *arg_ptr;
-					Z_ADDREF_P(arg);
+					if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
 				}
 
 				zend_vm_stack_push(arg TSRMLS_CC);
 				EX(call)->num_additional_args++;
-			}
+				arg_num++;
+			} ZEND_HASH_FOREACH_END();
+
 			break;
 		}
 		case IS_OBJECT: {
@@ -3283,7 +3193,7 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
 				FREE_OP1();
 				if (!EG(exception)) {
 					zend_throw_exception_ex(
-						NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name
+						NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val
 					);
 				}
 				HANDLE_EXCEPTION();
@@ -3297,13 +3207,13 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
 			}
 
 			for (; iter->funcs->valid(iter TSRMLS_CC) == SUCCESS; ++arg_num) {
-				zval **arg_ptr, *arg;
+				zval *arg;
 
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					ZEND_VM_C_GOTO(unpack_iter_dtor);
 				}
 
-				iter->funcs->get_current_data(iter, &arg_ptr TSRMLS_CC);
+				arg = iter->funcs->get_current_data(iter TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					ZEND_VM_C_GOTO(unpack_iter_dtor);
 				}
@@ -3329,18 +3239,16 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
 					zend_error(
 						E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
 						" by unpacking a Traversable, passing by-value instead", arg_num,
-						EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name : "",
+						EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name->val : "",
 						EX(call)->fbc->common.scope ? "::" : "",
-						EX(call)->fbc->common.function_name
+						EX(call)->fbc->common.function_name->val
 					);
 				}
 				
-				if (Z_ISREF_PP(arg_ptr)) {
-					ALLOC_ZVAL(arg);
-					MAKE_COPY_ZVAL(arg_ptr, arg);
+				if (Z_ISREF_P(arg)) {
+					ZVAL_DUP(arg, Z_REFVAL_P(arg));
 				} else {
-					arg = *arg_ptr;
-					Z_ADDREF_P(arg);
+					if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
 				}
 
 				ZEND_VM_STACK_GROW_IF_NEEDED(1);
@@ -3354,9 +3262,13 @@ ZEND_VM_HANDLER(165, ZEND_SEND_UNPACK, ANY, ANY)
 			}
 
 ZEND_VM_C_LABEL(unpack_iter_dtor):
-			iter->funcs->dtor(iter TSRMLS_CC);
+			zend_iterator_dtor(iter TSRMLS_CC);
 			break;
 		}
+		case IS_REFERENCE:
+			args = Z_REFVAL_P(args);
+			ZEND_VM_C_GOTO(send_again);
+			break;
 		default:
 			zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
 	}
@@ -3370,37 +3282,22 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
 {
 	USE_OPLINE
 	zend_uint arg_num = opline->op1.num;
-	zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
+	zval *arguments = EX(prev_execute_data)->function_state.arguments;
+	zend_uint arg_count = Z_LVAL_P(arguments);
 
 	SAVE_OPLINE();
-	if (UNEXPECTED(param == NULL)) {
-		if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) {
-			const char *space;
-			const char *class_name;
-			zend_execute_data *ptr;
-
-			if (EG(active_op_array)->scope) {
-				class_name = EG(active_op_array)->scope->name;
-				space = "::";
-			} else {
-				class_name = space = "";
-			}
-			ptr = EX(prev_execute_data);
-
-			if(ptr && ptr->op_array) {
-				zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
-			} else {
-				zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C));
-			}
-		}
+	if (UNEXPECTED(arg_num > arg_count)) {
+		zend_verify_missing_arg(execute_data, arg_num TSRMLS_CC);
 	} else {
-		zval **var_ptr;
+		zval *var_ptr;
+		zval *param = arguments - arg_count + arg_num - 1;
 
-		zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
-		var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
-		Z_DELREF_PP(var_ptr);
-		*var_ptr = *param;
-		Z_ADDREF_PP(var_ptr);
+		if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+			zend_verify_arg_type((zend_function *) EX(op_array), arg_num, param, opline->extended_value TSRMLS_CC);
+		}
+		var_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
+		if (UNEXPECTED(Z_REFCOUNTED_P(var_ptr))) Z_DELREF_P(var_ptr);
+		ZVAL_COPY(var_ptr, param);
 	}
 
 	CHECK_EXCEPTION();
@@ -3410,31 +3307,32 @@ ZEND_VM_HANDLER(63, ZEND_RECV, ANY, ANY)
 ZEND_VM_HANDLER(64, ZEND_RECV_INIT, ANY, CONST)
 {
 	USE_OPLINE
-	zval *assignment_value;
 	zend_uint arg_num = opline->op1.num;
-	zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
-	zval **var_ptr;
+	zval *arguments = EX(prev_execute_data)->function_state.arguments;
+	zend_uint arg_count = Z_LVAL_P(arguments);
+	zval *var_ptr;
 
 	SAVE_OPLINE();
-	if (param == NULL) {
-		ALLOC_ZVAL(assignment_value);
-		*assignment_value = *opline->op2.zv;
-		if (IS_CONSTANT_TYPE(Z_TYPE_P(assignment_value))) {
-			Z_SET_REFCOUNT_P(assignment_value, 1);
-			zval_update_constant(&assignment_value, 0 TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
+	if (UNEXPECTED(Z_REFCOUNTED_P(var_ptr))) Z_DELREF_P(var_ptr);
+	if (arg_num > arg_count) {
+		ZVAL_COPY_VALUE(var_ptr, opline->op2.zv);
+		if (Z_OPT_CONSTANT_P(var_ptr)) {
+			zval_update_constant(var_ptr, 0 TSRMLS_CC);
 		} else {
-			zval_copy_ctor(assignment_value);
+			/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
+			if (UNEXPECTED(Z_OPT_COPYABLE_P(var_ptr))) {
+				_zval_copy_ctor_func(var_ptr ZEND_FILE_LINE_CC);
+			}
 		}
-		INIT_PZVAL(assignment_value);
 	} else {
-		assignment_value = *param;
-		Z_ADDREF_P(assignment_value);
+		zval *param = arguments - arg_count + arg_num - 1;
+		ZVAL_COPY(var_ptr, param);
 	}
 
-	zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC);
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
-	zval_ptr_dtor(var_ptr);
-	*var_ptr = assignment_value;
+	if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+		zend_verify_arg_type((zend_function *) EX(op_array), arg_num, var_ptr, opline->extended_value TSRMLS_CC);
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -3444,29 +3342,36 @@ ZEND_VM_HANDLER(164, ZEND_RECV_VARIADIC, ANY, ANY)
 {
 	USE_OPLINE
 	zend_uint arg_num = opline->op1.num;
-	zend_uint arg_count = zend_vm_stack_get_args_count(TSRMLS_C);
-	zval **var_ptr, *params;
+	zval *arguments = EX(prev_execute_data)->function_state.arguments;
+	zend_uint arg_count = Z_LVAL_P(arguments);
+	zval *params;
 
 	SAVE_OPLINE();
 
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
-	Z_DELREF_PP(var_ptr);
-	MAKE_STD_ZVAL(params);
-	*var_ptr = params;
+	params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
+	if (UNEXPECTED(Z_REFCOUNTED_P(params))) Z_DELREF_P(params);
 
 	if (arg_num <= arg_count) {
+		zval *param = arguments - arg_count + arg_num - 1;
 		array_init_size(params, arg_count - arg_num + 1);
+		if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+			do {
+				zend_verify_arg_type((zend_function *) EX(op_array), arg_num, param, opline->extended_value TSRMLS_CC);
+				zend_hash_next_index_insert(Z_ARRVAL_P(params), param);
+				if (Z_REFCOUNTED_P(param)) Z_ADDREF_P(param);
+				param++;
+			} while (++arg_num <= arg_count);
+		} else {
+			do {
+				zend_hash_next_index_insert(Z_ARRVAL_P(params), param);
+				if (Z_REFCOUNTED_P(param)) Z_ADDREF_P(param);
+				param++;
+			} while (++arg_num <= arg_count);
+		}
 	} else {
 		array_init(params);
 	}
 
-	for (; arg_num <= arg_count; ++arg_num) {
-		zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
-		zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
-		zend_hash_next_index_insert(Z_ARRVAL_P(params), param, sizeof(zval *), NULL);
-		Z_ADDREF_PP(param);
-	}
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -3475,7 +3380,7 @@ ZEND_VM_HANDLER(52, ZEND_BOOL, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *retval = &EX_T(opline->result.var).tmp_var;
+	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
@@ -3523,12 +3428,12 @@ ZEND_VM_HANDLER(100, ZEND_GOTO, ANY, CONST)
 	switch (brk_opline->opcode) {
 		case ZEND_SWITCH_FREE:
 			if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-				zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
+				zval_ptr_dtor(EX_VAR(brk_opline->op1.var));
 			}
 			break;
 		case ZEND_FREE:
 			if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-				zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
+				zval_dtor(EX_VAR(brk_opline->op1.var));
 			}
 			break;
 	}
@@ -3539,11 +3444,12 @@ ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 GET_OP1_ZVAL_PTR(BP_VAR_R),
-				 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+				 GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
 
 	FREE_OP2();
 	CHECK_EXCEPTION();
@@ -3555,7 +3461,7 @@ ZEND_VM_HANDLER(49, ZEND_SWITCH_FREE, VAR, ANY)
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+	zval_ptr_dtor(EX_VAR(opline->op1.var));
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -3563,28 +3469,25 @@ ZEND_VM_HANDLER(49, ZEND_SWITCH_FREE, VAR, ANY)
 ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
 {
 	USE_OPLINE
-	zval *object_zval;
+	zval object_zval;
 	zend_function *constructor;
 
 	SAVE_OPLINE();
-	if (UNEXPECTED((EX_T(opline->op1.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
-		if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
-			zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name);
-		} else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-			zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name);
+	if (UNEXPECTED((Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
+		if (Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & ZEND_ACC_INTERFACE) {
+			zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val);
+		} else if ((Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
+			zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val);
 		} else {
-			zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name);
+			zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val);
 		}
 	}
-	ALLOC_ZVAL(object_zval);
-	object_init_ex(object_zval, EX_T(opline->op1.var).class_entry);
-	INIT_PZVAL(object_zval);
-
-	constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
+	object_init_ex(&object_zval, Z_CE_P(EX_VAR(opline->op1.var)));
+	constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval) TSRMLS_CC);
 
 	if (constructor == NULL) {
 		if (RETURN_VALUE_USED(opline)) {
-			AI_SET_PTR(&EX_T(opline->result.var), object_zval);
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), &object_zval);
 		} else {
 			zval_ptr_dtor(&object_zval);
 		}
@@ -3593,14 +3496,13 @@ ZEND_VM_HANDLER(68, ZEND_NEW, ANY, ANY)
 		call_slot *call = EX(call_slots) + opline->extended_value;
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(object_zval);
-			AI_SET_PTR(&EX_T(opline->result.var), object_zval);
+			ZVAL_COPY(EX_VAR(opline->result.var), &object_zval);
 		}
 
 		/* We are not handling overloaded classes right now */
 		call->fbc = constructor;
-		call->object = object_zval;
-		call->called_scope = EX_T(opline->op1.var).class_entry;
+		call->object = Z_OBJ(object_zval);
+		call->called_scope = Z_CE_P(EX_VAR(opline->op1.var));
 		call->num_additional_args = 0;
 		call->is_ctor_call = 1;
 		call->is_ctor_result_used = RETURN_VALUE_USED(opline);
@@ -3636,7 +3538,7 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (UNEXPECTED(clone_call == NULL)) {
 		if (ce) {
-			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
+			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
 		} else {
 			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
 		}
@@ -3647,29 +3549,21 @@ ZEND_VM_HANDLER(110, ZEND_CLONE, CONST|TMP|VAR|UNUSED|CV, ANY)
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(ce != EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (EXPECTED(EG(exception) == NULL)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
-		Z_TYPE_P(retval) = IS_OBJECT;
-		Z_SET_REFCOUNT_P(retval, 1);
-		Z_SET_ISREF_P(retval);
+		ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC));
 		if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&retval);
-		} else {
-			EX_T(opline->result.var).var.ptr = retval;
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 	}
 	FREE_OP1_IF_VAR();
@@ -3686,9 +3580,9 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
 		zend_constant *c;
 		zval *retval;
 
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			c = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
 			if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
 				char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
 				if(!actual) {
@@ -3698,52 +3592,52 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
 				}
 				/* non-qualified constant - allow text substitution */
 				zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
-				ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
+				ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)));
 				CHECK_EXCEPTION();
 				ZEND_VM_NEXT_OPCODE();
 			} else {
 				zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
 			}
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, c);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
 		}
-		retval = &EX_T(opline->result.var).tmp_var;
-		ZVAL_COPY_VALUE(retval, &c->value);
-		zval_copy_ctor(retval);
+		retval = EX_VAR(opline->result.var);
+		ZVAL_DUP(retval, &c->value);
 	} else {
 		/* class constant */
 		zend_class_entry *ce;
-		zval **value;
+		zval *value;
 
 		if (OP1_TYPE == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				value = CACHED_PTR(opline->op2.literal->cache_slot);
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
-			} else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op1.literal->cache_slot);
+			} else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 				}
-				CACHE_PTR(opline->op1.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op1.var).class_entry;
-			if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ce = Z_CE_P(EX_VAR(opline->op1.var));
+			if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
 			}
 		}
 
-		if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
-			if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
+		if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
+			if (Z_ISREF_P(value)) {
+				value = Z_REFVAL_P(value);
+			}
+			if (Z_CONSTANT_P(value)) {
 				zend_class_entry *old_scope = EG(scope);
 
 				EG(scope) = ce;
@@ -3751,23 +3645,20 @@ ZEND_VM_HANDLER(99, ZEND_FETCH_CONSTANT, VAR|CONST|UNUSED, CONST)
 				EG(scope) = old_scope;
 			}
 			if (OP1_TYPE == IS_CONST) {
-				CACHE_PTR(opline->op2.literal->cache_slot, value);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
 			} else {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
 			}
-			ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-			zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ZVAL_DUP(EX_VAR(opline->result.var), value);
 		} else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
 			/* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
-			ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
+			ZVAL_STR(EX_VAR(opline->result.var), ce->name);
+			STR_ADDREF(ce->name);
 		} else {
 			zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
 		}
 	}
 constant_fetch_end:
-	if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) {
-		zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time");
-	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -3776,35 +3667,31 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
-
-		if (OP1_TYPE == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+		if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+		FREE_OP1_VAR_PTR();
 	} else {
-		expr_ptr=GET_OP1_ZVAL_PTR(BP_VAR_R);
+		expr_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
 		if (IS_OP1_TMP_FREE()) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (OP1_TYPE == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (OP1_TYPE == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 			FREE_OP1_IF_VAR();
-		} else if (OP1_TYPE == IS_CV) {
+		} else if (OP1_TYPE == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -3812,8 +3699,10 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
 	if (OP2_TYPE != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
+		zend_string *str;
 		ulong hval;
 
+ZEND_VM_C_LABEL(add_again):
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -3822,32 +3711,32 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 ZEND_VM_C_LABEL(num_index):
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (OP2_TYPE == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index));
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (OP2_TYPE != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, ZEND_VM_C_GOTO(num_index));
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+ZEND_VM_C_LABEL(str_index):				
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				ZEND_VM_C_GOTO(str_index);
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				ZEND_VM_C_GOTO(add_again);
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 		FREE_OP2();
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) && opline->extended_value) {
-		FREE_OP1_VAR_PTR();
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -3855,9 +3744,26 @@ ZEND_VM_C_LABEL(num_index):
 
 ZEND_VM_HANDLER(71, ZEND_INIT_ARRAY, CONST|TMP|VAR|UNUSED|CV, CONST|TMP|VAR|UNUSED|CV)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (OP1_TYPE != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (OP1_TYPE != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (OP1_TYPE == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if !defined(ZEND_VM_SPEC) || OP1_TYPE != IS_UNUSED
@@ -3871,18 +3777,34 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *expr, *expr_ptr;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	expr = expr_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
+		ZVAL_DEREF(expr);
+	}
+	if (Z_TYPE_P(expr) == opline->extended_value) {
+		ZVAL_COPY_VALUE(result, expr);
+		if (OP1_TYPE == IS_CONST || expr != expr_ptr) {
+			zval_opt_copy_ctor(result);
+			FREE_OP1_IF_VAR();
+		} else if (OP1_TYPE == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	}
 
 	if (opline->extended_value != IS_STRING) {
 		ZVAL_COPY_VALUE(result, expr);
 		if (!IS_OP1_TMP_FREE()) {
-			zendi_zval_copy_ctor(*result);
+			zval_opt_copy_ctor(result);
 		}
 	}
+
 	switch (opline->extended_value) {
 		case IS_NULL:
 			convert_to_null(result);
@@ -3909,7 +3831,7 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
 			} else {
 				ZVAL_COPY_VALUE(result, expr);
 				if (!IS_OP1_TMP_FREE()) {
-					zendi_zval_copy_ctor(*result);
+					zval_opt_copy_ctor(result);
 				}
 			}
 			break;
@@ -3932,18 +3854,17 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 	zend_op_array *new_op_array=NULL;
 	zend_free_op free_op1;
 	zval *inc_filename;
-	zval *tmp_inc_filename = NULL;
+	zval tmp_inc_filename;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
 	inc_filename = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	if (inc_filename->type!=IS_STRING) {
-		MAKE_STD_ZVAL(tmp_inc_filename);
-		ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
-		zval_copy_ctor(tmp_inc_filename);
-		convert_to_string(tmp_inc_filename);
-		inc_filename = tmp_inc_filename;
+	ZVAL_UNDEF(&tmp_inc_filename);
+	if (Z_TYPE_P(inc_filename) != IS_STRING) {
+		ZVAL_DUP(&tmp_inc_filename, inc_filename);
+		convert_to_string(&tmp_inc_filename);
+		inc_filename = &tmp_inc_filename;
 	}
 
 	if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
@@ -3961,7 +3882,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 
 					resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
 					if (resolved_path) {
-						failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
+						failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path));
 					} else {
 						resolved_path = Z_STRVAL_P(inc_filename);
 					}
@@ -3974,7 +3895,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 							file_handle.opened_path = estrdup(resolved_path);
 						}
 
-						if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
+						if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) {
 							new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
 							zend_destroy_file_handle(&file_handle TSRMLS_CC);
 						} else {
@@ -4007,40 +3928,37 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 			EMPTY_SWITCH_DEFAULT_CASE()
 		}
 	}
-	if (tmp_inc_filename) {
+	if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
 		zval_ptr_dtor(&tmp_inc_filename);
 	}
 	FREE_OP1();
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		HANDLE_EXCEPTION();
 	} else if (EXPECTED(new_op_array != NULL)) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
 		EG(active_op_array) = new_op_array;
 		if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-			EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
-		} else {
-			EG(return_value_ptr_ptr) = NULL;
+			return_value = EX_VAR(opline->result.var);
 		}
 
 		EX(function_state).function = (zend_function *) new_op_array;
-		EX(object) = NULL;
 
 		if (!EG(active_symbol_table)) {
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+		    i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC);
 			ZEND_VM_ENTER();
 		} else {
-			zend_execute(new_op_array TSRMLS_CC);
+			zend_execute(new_op_array, return_value TSRMLS_CC);
 		}
 
 		EX(function_state).function = (zend_function *) EX(op_array);
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
 		destroy_op_array(new_op_array TSRMLS_CC);
 		efree(new_op_array);
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -4049,12 +3967,7 @@ ZEND_VM_HANDLER(73, ZEND_INCLUDE_OR_EVAL, CONST|TMP|VAR|CV, ANY)
 		}
 
 	} else if (RETURN_VALUE_USED(opline)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		ZVAL_BOOL(retval, failure_retval);
-		INIT_PZVAL(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -4065,20 +3978,15 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (OP1_TYPE == IS_CV &&
 	    OP2_TYPE == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -4086,27 +3994,28 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 	varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 	if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (OP2_TYPE != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (OP2_TYPE == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (OP1_TYPE != IS_CONST && varname == &tmp) {
+					if (OP1_TYPE != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 					FREE_OP1();
 					HANDLE_EXCEPTION();
@@ -4114,23 +4023,21 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((OP1_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (OP1_TYPE != IS_CONST && varname == &tmp) {
+	if (OP1_TYPE != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 	FREE_OP1();
 	CHECK_EXCEPTION();
@@ -4141,94 +4048,92 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
 	container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
-	if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	if (OP1_TYPE != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (OP2_TYPE == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_dim));
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+ZEND_VM_C_LABEL(container_again):
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+ZEND_VM_C_LABEL(offset_again):
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (OP2_TYPE != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_dim));
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 ZEND_VM_C_LABEL(num_index_dim):
-						zend_hash_index_del(ht, hval);
-						if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				FREE_OP2();
-				break;
+					zend_hash_index_del(ht, hval);
+					if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					ZEND_VM_C_GOTO(offset_again);
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (IS_OP2_TMP_FREE()) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (IS_OP2_TMP_FREE()) {
-					zval_ptr_dtor(&offset);
-				} else {
-					FREE_OP2();
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				FREE_OP2();
-				break;
+			FREE_OP2();
+			break;
 		}
-	} else {
-		FREE_OP2();
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (OP2_TYPE == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			FREE_OP2();
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			ZEND_VM_C_GOTO(container_again);
+			break;
+		default:
+			FREE_OP2();
+			break;
 	}
 	FREE_OP1_VAR_PTR();
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -4237,39 +4142,26 @@ ZEND_VM_HANDLER(76, ZEND_UNSET_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
 	container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
+	if (OP1_TYPE == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (OP1_TYPE != IS_VAR || container) {
-		if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (IS_OP2_TMP_FREE()) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (IS_OP2_TMP_FREE()) {
-				zval_ptr_dtor(&offset);
-			} else {
-				FREE_OP2();
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			FREE_OP2();
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		FREE_OP2();
 	}
+	FREE_OP2();
 	FREE_OP1_VAR_PTR();
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -4278,7 +4170,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *array_ptr, **array_ptr_ptr;
+	zval *array_ptr, *array_ref, iterator;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
 	zend_class_entry *ce = NULL;
@@ -4288,71 +4180,79 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
 
 	if ((OP1_TYPE == IS_CV || OP1_TYPE == IS_VAR) &&
 	    (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
-		array_ptr_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
-		if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
-			MAKE_STD_ZVAL(array_ptr);
-			ZVAL_NULL(array_ptr);
-		} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
-			if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
+		array_ptr = array_ref = GET_OP1_ZVAL_PTR_PTR(BP_VAR_R);
+		ZVAL_DEREF(array_ptr);
+		if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
+			if (!Z_ISREF_P(array_ref)) {
+				SEPARATE_ZVAL(array_ptr);
+				array_ref = array_ptr;
+				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
+					ZVAL_NEW_REF(array_ptr, array_ptr);
+					array_ref = array_ptr;
+					array_ptr = Z_REFVAL_P(array_ptr);						
+				}
+			}
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
+		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
+			if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) {
 				zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
 
-			ce = Z_OBJCE_PP(array_ptr_ptr);
+			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || ce->get_iterator == NULL) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				Z_ADDREF_PP(array_ptr_ptr);
-			}
-			array_ptr = *array_ptr_ptr;
-		} else {
-			if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-					Z_SET_ISREF_PP(array_ptr_ptr);
+				if (!Z_ISREF_P(array_ref)) {
+					SEPARATE_ZVAL(array_ptr);
 				}
+				Z_ADDREF_P(array_ptr);
 			}
-			array_ptr = *array_ptr_ptr;
-			Z_ADDREF_P(array_ptr);
+			array_ref = array_ptr;
+		} else {
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
 		}
 	} else {
-		array_ptr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+		array_ptr = array_ref = GET_OP1_ZVAL_PTR(BP_VAR_R);
+		ZVAL_DEREF(array_ptr);
 		if (IS_OP1_TMP_FREE()) { /* IS_TMP_VAR */
-			zval *tmp;
+			zval tmp;
 
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			array_ptr = tmp;
+			ZVAL_COPY_VALUE(&tmp, array_ptr);
+			array_ptr = &tmp;
 			if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 				ce = Z_OBJCE_P(array_ptr);
 				if (ce && ce->get_iterator) {
-					Z_DELREF_P(array_ptr);
+					Z_DELREF_P(array_ref);
 				}
 			}
 		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || !ce->get_iterator) {
 				if (OP1_TYPE == IS_CV) {
-					Z_ADDREF_P(array_ptr);
+					Z_ADDREF_P(array_ref);
 				}
 			}
-		} else if (OP1_TYPE == IS_CONST ||
-		           (OP1_TYPE == IS_CV && 
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 1) ||
-		           (OP1_TYPE == IS_VAR &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 2)) {
-			zval *tmp;
-
-			if (OP1_TYPE == IS_VAR) {
-				Z_DELREF_P(array_ptr);
+		} else if (Z_REFCOUNTED_P(array_ref)) {
+			if (OP1_TYPE == IS_CONST ||
+			           (OP1_TYPE == IS_CV && 
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 1) ||
+			           (OP1_TYPE == IS_VAR &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 2)) {
+				zval tmp;
+
+				if (OP1_TYPE == IS_VAR) {
+					Z_DELREF_P(array_ref);
+				}
+				ZVAL_DUP(&tmp, array_ref);
+				array_ptr = array_ref = &tmp;
+			} else if (OP1_TYPE == IS_CV) {
+				if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) {
+					ZVAL_UNREF(array_ref);
+					array_ptr = array_ref;
+				}
+				Z_ADDREF_P(array_ref);
 			}
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			zval_copy_ctor(tmp);
-			array_ptr = tmp;
-		} else if (OP1_TYPE == IS_CV) {
-			Z_ADDREF_P(array_ptr);
 		}
 	}
 
@@ -4363,27 +4263,28 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
 			FREE_OP1_IF_VAR();
 		}
 		if (iter && EXPECTED(EG(exception) == NULL)) {
-			array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
+			ZVAL_OBJ(&iterator, &iter->std);
+			array_ptr = array_ref = &iterator;
 		} else {
 			if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 				FREE_OP1_VAR_PTR();
 			}
 			if (!EG(exception)) {
-				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
+				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val);
 			}
 			zend_throw_exception_internal(NULL TSRMLS_CC);
 			HANDLE_EXCEPTION();
 		}
 	}
 
-	EX_T(opline->result.var).fe.ptr = array_ptr;
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
 
 	if (iter) {
 		iter->index = 0;
 		if (iter->funcs->rewind) {
 			iter->funcs->rewind(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array_ptr);
+				zval_ptr_dtor(array_ref);
 				if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 					FREE_OP1_VAR_PTR();
 				}
@@ -4392,7 +4293,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
 		}
 		is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&array_ptr);
+			zval_ptr_dtor(array_ref);
 			if (OP1_TYPE == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 				FREE_OP1_VAR_PTR();
 			}
@@ -4402,24 +4303,23 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
 	} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
 		zend_hash_internal_pointer_reset(fe_ht);
 		if (ce) {
-			zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array_ptr);
 			while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
-				char *str_key;
-				uint str_key_len;
+				zend_string *str_key;
 				ulong int_key;
 				zend_uchar key_type;
 
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 				if (key_type != HASH_KEY_NON_EXISTENT &&
 					(key_type == HASH_KEY_IS_LONG ||
-				     zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
+				     zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) {
 					break;
 				}
 				zend_hash_move_forward(fe_ht);
 			}
 		}
 		is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
-		zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
+		zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var));
 	} else {
 		zend_error(E_WARNING, "Invalid argument supplied for foreach()");
 		is_empty = 1;
@@ -4440,14 +4340,16 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *array = EX_T(opline->op1.var).fe.ptr;
-	zval **value;
+	zval *array, *array_ref;
+	zval *value;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
-
 	zval *key = NULL;
+
+	array = array_ref = EX_VAR(opline->op1.var);
+	ZVAL_DEREF(array);
 	if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
-		key = &EX_T((opline+1)->result.var).tmp_var;
+		key = EX_VAR((opline+1)->result.var);
 	}
 
 	SAVE_OPLINE();
@@ -4459,24 +4361,35 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 			ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 
 		case ZEND_ITER_PLAIN_OBJECT: {
-			zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array);
 			int key_type;
-			char *str_key;
-			zend_uint str_key_len;
+			zend_string *str_key;
 			zend_ulong int_key;
 
 			fe_ht = Z_OBJPROP_P(array);
-			zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
-			do {
-				if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
+			zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
+			while (1) {
+				if ((value = zend_hash_get_current_data(fe_ht)) == NULL) {
 					/* reached end of iteration */
 					ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 				}
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+
+				if (Z_TYPE_P(value) == IS_INDIRECT) {
+					value = Z_INDIRECT_P(value);
+					if (Z_TYPE_P(value) == IS_UNDEF) {
+						zend_hash_move_forward(fe_ht);
+						continue;
+					}
+				}
+
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 
 				zend_hash_move_forward(fe_ht);
-			} while (key_type != HASH_KEY_IS_LONG &&
-			         zend_check_property_access(zobj, str_key, str_key_len - 1 TSRMLS_CC) != SUCCESS);
+				if (key_type == HASH_KEY_IS_LONG ||
+				    zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) {
+					break;
+				}
+			}
 
 			if (key) {
 				if (key_type == HASH_KEY_IS_LONG) {
@@ -4485,20 +4398,20 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 					const char *class_name, *prop_name;
 					int prop_name_len;
 					zend_unmangle_property_name_ex(
-						str_key, str_key_len - 1, &class_name, &prop_name, &prop_name_len
+						str_key->val, str_key->len, &class_name, &prop_name, &prop_name_len
 					);
-					ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
+					ZVAL_STRINGL(key, prop_name, prop_name_len);
 				}
 			}
 
-			zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
+			zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
 			break;
 		}
 
 		case ZEND_ITER_PLAIN_ARRAY:
 			fe_ht = Z_ARRVAL_P(array);
-			zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
-			if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
+			zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
+			if ((value = zend_hash_get_current_data(fe_ht)) == NULL) {
 				/* reached end of iteration */
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
@@ -4506,7 +4419,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 				zend_hash_get_current_key_zval(fe_ht, key);
 			}
 			zend_hash_move_forward(fe_ht);
-			zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
+			zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
 			break;
 
 		case ZEND_ITER_OBJECT:
@@ -4516,7 +4429,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 				 * In case that ever happens we need an additional flag. */
 				iter->funcs->move_forward(iter TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					zval_ptr_dtor(&array);
+					zval_ptr_dtor(array_ref);
 					HANDLE_EXCEPTION();
 				}
 			}
@@ -4524,14 +4437,14 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 			if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
 				/* reached end of iteration */
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					zval_ptr_dtor(&array);
+					zval_ptr_dtor(array_ref);
 					HANDLE_EXCEPTION();
 				}
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
-			iter->funcs->get_current_data(iter, &value TSRMLS_CC);
+			value = iter->funcs->get_current_data(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array);
+				zval_ptr_dtor(array_ref);
 				HANDLE_EXCEPTION();
 			}
 			if (!value) {
@@ -4542,7 +4455,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 				if (iter->funcs->get_current_key) {
 					iter->funcs->get_current_key(iter, key TSRMLS_CC);
 					if (UNEXPECTED(EG(exception) != NULL)) {
-						zval_ptr_dtor(&array);
+						zval_ptr_dtor(array_ref);
 						HANDLE_EXCEPTION();
 					}
 				} else {
@@ -4553,14 +4466,9 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 	}
 
 	if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-		SEPARATE_ZVAL_IF_NOT_REF(value);
-		Z_SET_ISREF_PP(value);
-		EX_T(opline->result.var).var.ptr_ptr = value;
-		Z_ADDREF_PP(value);
-	} else {
-		PZVAL_LOCK(*value);
-		EX_T(opline->result.var).var.ptr = *value;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(value);
 	}
+	ZVAL_COPY(EX_VAR(opline->result.var), value);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -4570,21 +4478,16 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
 ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (OP1_TYPE == IS_CV &&
 	    OP2_TYPE == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -4594,8 +4497,7 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 		zval tmp, *varname = GET_OP1_ZVAL_PTR(BP_VAR_IS);
 
 		if (OP1_TYPE != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -4604,26 +4506,26 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 			zend_class_entry *ce;
 
 			if (OP2_TYPE == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((OP1_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -4635,16 +4537,16 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -4652,26 +4554,25 @@ ZEND_VM_HANDLER(114, ZEND_ISSET_ISEMPTY_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|TMP|VAR|CV, int prop_dim)
+ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = GET_OP1_OBJ_ZVAL_PTR(BP_VAR_IS);
+	container = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_IS);
 	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+ZEND_VM_C_LABEL(isset_again):
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -4681,25 +4582,23 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 ZEND_VM_C_LABEL(num_index_prop):
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (OP2_TYPE == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_prop));
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (OP2_TYPE != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, ZEND_VM_C_GOTO(num_index_prop));
 				}
+ZEND_VM_C_LABEL(str_index_prop):
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				ZEND_VM_C_GOTO(str_index_prop);
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				ZEND_VM_C_GOTO(isset_again);
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -4707,96 +4606,87 @@ ZEND_VM_C_LABEL(num_index_prop):
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		FREE_OP2();
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (IS_OP2_TMP_FREE()) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((OP2_TYPE == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (IS_OP2_TMP_FREE()) {
-			zval_ptr_dtor(&offset);
-		} else {
-			FREE_OP2();
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
-				}
+				} 
 			}
 		}
-		FREE_OP2();
-	} else {
-		FREE_OP2();
-	}
-
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
+	FREE_OP2();
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 	FREE_OP1_IF_VAR();
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-ZEND_VM_HANDLER(115, ZEND_ISSET_ISEMPTY_DIM_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
-{
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 0);
-}
-
 ZEND_VM_HANDLER(148, ZEND_ISSET_ISEMPTY_PROP_OBJ, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 {
-	ZEND_VM_DISPATCH_TO_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, prop_dim, 1);
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = GET_OP1_OBJ_ZVAL_PTR_DEREF(BP_VAR_IS);
+	offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((OP2_TYPE == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	FREE_OP2();
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	FREE_OP1_IF_VAR();
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY)
@@ -4812,7 +4702,7 @@ ZEND_VM_HANDLER(79, ZEND_EXIT, CONST|TMP|VAR|UNUSED|CV, ANY)
 		if (Z_TYPE_P(ptr) == IS_LONG) {
 			EG(exit_status) = Z_LVAL_P(ptr);
 		} else {
-			zend_print_variable(ptr);
+			zend_print_variable(ptr TSRMLS_CC);
 		}
 		FREE_OP1();
 	}
@@ -4826,17 +4716,19 @@ ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting);
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG;  /* shouldn't be necessary */
-	if (EX(old_error_reporting) == NULL) {
-		EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var;
+	ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
+	if (Z_TYPE(EX(old_error_reporting)) == IS_UNDEF) {
+		ZVAL_LONG(&EX(old_error_reporting), EG(error_reporting));
 	}
 
 	if (EG(error_reporting)) {
 		do {
 			EG(error_reporting) = 0;
 			if (!EG(error_reporting_ini_entry)) {
-				if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) {
+				zend_ini_entry *p = zend_hash_str_find_ptr(EG(ini_directives), "error_reporting", sizeof("error_reporting")-1);
+				if (p) {
+					EG(error_reporting_ini_entry) = p;
+				} else {
 					break;
 				}
 			}
@@ -4845,7 +4737,7 @@ ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
 					ALLOC_HASHTABLE(EG(modified_ini_directives));
 					zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
 				}
-				if (EXPECTED(zend_hash_add(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting"), &EG(error_reporting_ini_entry), sizeof(zend_ini_entry*), NULL) == SUCCESS)) {
+				if (EXPECTED(zend_hash_str_add_ptr(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting")-1, EG(error_reporting_ini_entry)) != NULL)) {
 					EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
 					EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length;
 					EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
@@ -4865,7 +4757,7 @@ ZEND_VM_HANDLER(57, ZEND_BEGIN_SILENCE, ANY, ANY)
 ZEND_VM_HANDLER(142, ZEND_RAISE_ABSTRACT_ERROR, ANY, ANY)
 {
 	SAVE_OPLINE();
-	zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
+	zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name->val, EX(op_array)->function_name->val);
 	ZEND_VM_NEXT_OPCODE(); /* Never reached */
 }
 
@@ -4875,9 +4767,8 @@ ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
 	zval restored_error_reporting;
 
 	SAVE_OPLINE();
-	if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) {
-		Z_TYPE(restored_error_reporting) = IS_LONG;
-		Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var);
+	if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) {
+		ZVAL_LONG(&restored_error_reporting, Z_LVAL_P(EX_VAR(opline->op1.var)));
 		EG(error_reporting) = Z_LVAL(restored_error_reporting);
 		convert_to_string(&restored_error_reporting);
 		if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
@@ -4885,15 +4776,14 @@ ZEND_VM_HANDLER(58, ZEND_END_SILENCE, TMP, ANY)
 			    EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) {
 				efree(EG(error_reporting_ini_entry)->value);
 			}
-			EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting);
+			EG(error_reporting_ini_entry)->value = estrndup(Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting));
 			EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting);
-		} else {
-			zendi_zval_dtor(restored_error_reporting);
-		}
-	}
-	if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) {
-		EX(old_error_reporting) = NULL;
+		} 
+		zval_dtor(&restored_error_reporting);
 	}
+//???	if (EX(old_error_reporting) == EX_VAR(opline->op1.var)) {
+//???		EX(old_error_reporting) = NULL;
+//???	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -4908,9 +4798,9 @@ ZEND_VM_HANDLER(152, ZEND_JMP_SET, CONST|TMP|VAR|CV, ANY)
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
-		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!IS_OP1_TMP_FREE()) {
-			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 		FREE_OP1_IF_VAR();
 #if DEBUG_ZEND>=2
@@ -4928,23 +4818,18 @@ ZEND_VM_HANDLER(158, ZEND_JMP_SET_VAR, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
 		if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
-			Z_ADDREF_P(value);
-			EX_T(opline->result.var).var.ptr = value;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		} else {
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, value);
-			EX_T(opline->result.var).var.ptr = ret;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 			if (!IS_OP1_TMP_FREE()) {
-				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+				zval_opt_copy_ctor(EX_VAR(opline->result.var));
 			}
 		}
 		FREE_OP1_IF_VAR();
@@ -4968,9 +4853,9 @@ ZEND_VM_HANDLER(22, ZEND_QM_ASSIGN, CONST|TMP|VAR|CV, ANY)
 	SAVE_OPLINE();
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
-	ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 	if (!IS_OP1_TMP_FREE()) {
-		zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+		zval_opt_copy_ctor(EX_VAR(opline->result.var));
 	}
 	FREE_OP1_IF_VAR();
 	CHECK_EXCEPTION();
@@ -4981,22 +4866,17 @@ ZEND_VM_HANDLER(157, ZEND_QM_ASSIGN_VAR, CONST|TMP|VAR|CV, ANY)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 	if (OP1_TYPE == IS_VAR || OP1_TYPE == IS_CV) {
-		Z_ADDREF_P(value);
-		EX_T(opline->result.var).var.ptr = value;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
 	} else {
-		ALLOC_ZVAL(ret);
-		INIT_PZVAL_COPY(ret, value);
-		EX_T(opline->result.var).var.ptr = ret;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!IS_OP1_TMP_FREE()) {
-			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -5040,7 +4920,7 @@ ZEND_VM_HANDLER(139, ZEND_DECLARE_CLASS, ANY, ANY)
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
+	Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5050,7 +4930,7 @@ ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	EX_T(opline->result.var).class_entry = do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
+	Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(EX(op_array), opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5058,13 +4938,13 @@ ZEND_VM_HANDLER(140, ZEND_DECLARE_INHERITED_CLASS, ANY, ANY)
 ZEND_VM_HANDLER(145, ZEND_DECLARE_INHERITED_CLASS_DELAYED, ANY, ANY)
 {
 	USE_OPLINE
-	zend_class_entry **pce, **pce_orig;
+	zval *zce, *orig_zce;
 
 	SAVE_OPLINE();
-	if (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void**)&pce) == FAILURE ||
-	    (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void**)&pce_orig) == SUCCESS &&
-	     *pce != *pce_orig)) {
-		do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
+	if ((zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op2.zv))) == NULL ||
+	    ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op1.zv))) != NULL &&
+	     Z_CE_P(zce) != Z_CE_P(orig_zce))) {
+		do_bind_inherited_class(EX(op_array), opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5103,14 +4983,14 @@ ZEND_VM_HANDLER(138, ZEND_INSTANCEOF, TMP|VAR|CV, ANY)
 	zend_bool result;
 
 	SAVE_OPLINE();
-	expr = GET_OP1_ZVAL_PTR(BP_VAR_R);
+	expr = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
 	if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
-		result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
+		result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC);
 	} else {
 		result = 0;
 	}
-	ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 	FREE_OP1();
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5129,23 +5009,23 @@ ZEND_VM_HANDLER(0, ZEND_NOP, ANY, ANY)
 ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
 {
 	USE_OPLINE
-	zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
+	zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
 	zend_class_entry *iface;
 
 	SAVE_OPLINE();
-	if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-		iface = CACHED_PTR(opline->op2.literal->cache_slot);
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else {
-		iface = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
+		iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
 		if (UNEXPECTED(iface == NULL)) {
 			CHECK_EXCEPTION();
 			ZEND_VM_NEXT_OPCODE();
 		}
-		CACHE_PTR(opline->op2.literal->cache_slot, iface);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface);
 	}
 
 	if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
-		zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
+		zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name->val, iface->name->val);
 	}
 	zend_do_implement_interface(ce, iface TSRMLS_CC);
 
@@ -5156,25 +5036,24 @@ ZEND_VM_HANDLER(144, ZEND_ADD_INTERFACE, ANY, CONST)
 ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
 {
 	USE_OPLINE
-	zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
+	zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
 	zend_class_entry *trait;
 
 	SAVE_OPLINE();
-	if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-		trait = CACHED_PTR(opline->op2.literal->cache_slot);
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else {
-		trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv),
-		                                 Z_STRLEN_P(opline->op2.zv),
-		                                 opline->op2.literal + 1,
+		trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv),
+		                                 opline->op2.zv + 1,
 		                                 opline->extended_value TSRMLS_CC);
 		if (UNEXPECTED(trait == NULL)) {
 			CHECK_EXCEPTION();
 			ZEND_VM_NEXT_OPCODE();
 		}
 		if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
-			zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name);
+			zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val);
 		}
-		CACHE_PTR(opline->op2.literal->cache_slot, trait);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait);
 	}
 
 	zend_do_implement_trait(ce, trait TSRMLS_CC);
@@ -5186,7 +5065,7 @@ ZEND_VM_HANDLER(154, ZEND_ADD_TRAIT, ANY, ANY)
 ZEND_VM_HANDLER(155, ZEND_BIND_TRAITS, ANY, ANY)
 {
 	USE_OPLINE
-	zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
+	zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 	SAVE_OPLINE();
 	zend_do_bind_traits(ce TSRMLS_CC);
@@ -5199,7 +5078,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 	zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
 	int i;
 	zend_uint catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
-	void **stack_frame;
+	zval *stack_frame;
 
 	/* Figure out where the next stack frame (which maybe contains pushed
 	 * arguments that have to be dtor'ed) starts */
@@ -5209,7 +5088,7 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 	 * arguments pushed to the stack that have to be dtor'ed. */
 	while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
 		zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
-		zval_ptr_dtor(&stack_zval_p);
+		zval_ptr_dtor(stack_zval_p);
 	}
 
 	for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
@@ -5235,13 +5114,13 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 			if (call->object) {
 				if (call->is_ctor_call) {
 					if (call->is_ctor_result_used) {
-						Z_DELREF_P(call->object);
+						GC_REFCOUNT(call->object)--;
 					}
-					if (Z_REFCOUNT_P(call->object) == 1) {
+					if (GC_REFCOUNT(call->object) == 1) {
 						zend_object_store_ctor_failed(call->object TSRMLS_CC);
 					}
 				}
-				zval_ptr_dtor(&call->object);
+				OBJ_RELEASE(call->object);
 			}
 			call--;
 		} while (call >= EX(call_slots));
@@ -5262,12 +5141,12 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 				switch (brk_opline->opcode) {
 					case ZEND_SWITCH_FREE:
 						if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-							zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
+							zval_ptr_dtor(EX_VAR(brk_opline->op1.var));
 						}
 						break;
 					case ZEND_FREE:
 						if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-							zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
+							zval_dtor(EX_VAR(brk_opline->op1.var));
 						}
 						break;
 				}
@@ -5276,16 +5155,18 @@ ZEND_VM_HANDLER(149, ZEND_HANDLE_EXCEPTION, ANY, ANY)
 	}
 
 	/* restore previous error_reporting value */
-	if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
+	if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_LVAL(EX(old_error_reporting)) != 0) {
 		zval restored_error_reporting;
+		zend_string *key;
 
-		Z_TYPE(restored_error_reporting) = IS_LONG;
-		Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
+		ZVAL_LONG(&restored_error_reporting, Z_LVAL(EX(old_error_reporting)));
 		convert_to_string(&restored_error_reporting);
-		zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
-		zendi_zval_dtor(restored_error_reporting);
+		key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0);
+		zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
+		STR_FREE(key);
+		zval_dtor(&restored_error_reporting);
 	}
-	EX(old_error_reporting) = NULL;
+	ZVAL_UNDEF(&EX(old_error_reporting));
 
 	if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
 		if (EX(delayed_exception)) {
@@ -5324,7 +5205,7 @@ ZEND_VM_HANDLER(146, ZEND_VERIFY_ABSTRACT_CLASS, ANY, ANY)
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC);
+	zend_verify_abstract_class(Z_CE_P(EX_VAR(opline->op1.var)) TSRMLS_CC);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5370,21 +5251,20 @@ ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
 	name  = GET_OP1_ZVAL_PTR(BP_VAR_R);
 	val   = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
-	if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
-		zval tmp;
-		zval *tmp_ptr = &tmp;
-
-		ZVAL_COPY_VALUE(&tmp, val);
-		INIT_PZVAL(&tmp);
-		zval_update_constant(&tmp_ptr, 0 TSRMLS_CC);
-		c.value = *tmp_ptr;
+	ZVAL_COPY_VALUE(&c.value, val);
+	if (Z_OPT_CONSTANT(c.value)) {
+		if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
+			zval_opt_copy_ctor(&c.value);
+		}
+		zval_update_constant(&c.value, 0 TSRMLS_CC);
 	} else {
-		INIT_PZVAL_COPY(&c.value, val);
-		zval_copy_ctor(&c.value);
+		/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
+		if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) {
+			_zval_copy_ctor_func(&c.value ZEND_FILE_LINE_CC);
+		}
 	}
 	c.flags = CONST_CS; /* non persistent, case sensetive */
-	c.name = str_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
-	c.name_len = Z_STRLEN_P(name)+1;
+	c.name = STR_DUP(Z_STR_P(name), 0);
 	c.module_number = PHP_USER_CONSTANT;
 
 	if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
@@ -5399,16 +5279,16 @@ ZEND_VM_HANDLER(143, ZEND_DECLARE_CONST, CONST, CONST)
 ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED)
 {
 	USE_OPLINE
-	zend_function *op_array;
+	zval *zfunc;
 
 	SAVE_OPLINE();
 
-	if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void *) &op_array) == FAILURE) ||
-	    UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) {
+	if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(opline->op1.zv))) == NULL) ||
+	    UNEXPECTED(Z_FUNC_P(zfunc)->type != ZEND_USER_FUNCTION)) {
 		zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
 	}
 
-	zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(scope), EG(This) TSRMLS_CC);
+	zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), Z_OBJ(EG(This)) ? &EG(This) : NULL TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5417,20 +5297,17 @@ ZEND_VM_HANDLER(153, ZEND_DECLARE_LAMBDA_FUNCTION, CONST, UNUSED)
 ZEND_VM_HANDLER(156, ZEND_SEPARATE, VAR, UNUSED)
 {
 	USE_OPLINE
-	zval *var_ptr, *new_zv;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
-	var_ptr = EX_T(opline->op1.var).var.ptr;
+	var_ptr = EX_VAR(opline->op1.var);
 	if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
-			!PZVAL_IS_REF(var_ptr) &&
-			Z_REFCOUNT_P(var_ptr) > 1) {
+	    !Z_ISREF_P(var_ptr) &&
+	    Z_REFCOUNTED_P(var_ptr) &&
+	    Z_REFCOUNT_P(var_ptr) > 1) {
 
 		Z_DELREF_P(var_ptr);
-		ALLOC_ZVAL(new_zv);
-		INIT_PZVAL_COPY(new_zv, var_ptr);
-		var_ptr = new_zv;
-		zval_copy_ctor(var_ptr);
-		EX_T(opline->op1.var).var.ptr = var_ptr;
+		ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5439,22 +5316,18 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (OP1_TYPE != IS_UNUSED) {
@@ -5464,42 +5337,35 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = GET_OP1_ZVAL_PTR(BP_VAR_R);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!IS_OP1_TMP_FREE()) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
+				zval *value_ptr = GET_OP1_ZVAL_PTR_PTR(BP_VAR_W);
 
-				if (OP1_TYPE == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (OP1_TYPE == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (OP1_TYPE == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (OP1_TYPE == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 				FREE_OP1_VAR_PTR();
 			}
@@ -5507,32 +5373,23 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 			zval *value = GET_OP1_ZVAL_PTR(BP_VAR_R);
 
 			/* Consts, temporary variables and references need copying */
-			if (OP1_TYPE == IS_CONST || OP1_TYPE == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!IS_OP1_TMP_FREE()) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (OP1_TYPE == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (OP1_TYPE == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 				FREE_OP1_IF_VAR();
 			} else {
 				if (OP1_TYPE == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -5541,46 +5398,36 @@ ZEND_VM_HANDLER(160, ZEND_YIELD, CONST|TMP|VAR|CV|UNUSED, CONST|TMP|VAR|CV|UNUSE
 		zval *key = GET_OP2_ZVAL_PTR(BP_VAR_R);
 
 		/* Consts, temporary variables and references need copying */
-		if (OP2_TYPE == IS_CONST || OP2_TYPE == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!IS_OP2_TMP_FREE()) {
-				zval_copy_ctor(copy);
-			}
-
-			generator->key = copy;
+		if (OP2_TYPE == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (OP2_TYPE == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+			FREE_OP2_IF_VAR();
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (OP2_TYPE == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
-		FREE_OP2_IF_VAR();
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -5600,7 +5447,7 @@ ZEND_VM_HANDLER(159, ZEND_DISCARD_EXCEPTION, ANY, ANY)
 {
 	if (EX(delayed_exception) != NULL) {
 		/* discard the previously thrown exception */
-		zval_ptr_dtor(&EX(delayed_exception));
+		OBJ_RELEASE(EX(delayed_exception));
 		EX(delayed_exception) = NULL;
 	}
 
@@ -5656,9 +5503,9 @@ ZEND_VM_HANDLER(166, ZEND_POW, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		GET_OP1_ZVAL_PTR(BP_VAR_R),
-		GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
+	pow_function(EX_VAR(opline->result.var),
+		GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
+		GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
 	FREE_OP1();
 	FREE_OP2();
 	CHECK_EXCEPTION();
diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 4690c3e3ae..f09990fb49 100644
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -344,11 +344,6 @@ ZEND_API void execute_ex(zend_execute_data *execute_data TSRMLS_DC)
 	original_in_execution = EG(in_execution);
 	EG(in_execution) = 1;
 
-	if (0) {
-zend_vm_enter:
-		execute_data = i_create_execute_data_from_op_array(EG(active_op_array), 1 TSRMLS_CC);
-	}
-
 	LOAD_REGS();
 	LOAD_OPLINE();
 
@@ -366,8 +361,6 @@ zend_vm_enter:
 					EG(in_execution) = original_in_execution;
 					return;
 				case 2:
-					goto zend_vm_enter;
-					break;
 				case 3:
 					execute_data = EG(current_execute_data);
 					break;
@@ -380,120 +373,139 @@ zend_vm_enter:
 	zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
 }
 
-ZEND_API void zend_execute(zend_op_array *op_array TSRMLS_DC)
+ZEND_API void zend_execute(zend_op_array *op_array, zval *return_value TSRMLS_DC)
 {
-	if (EG(exception)) {
+	if (EG(exception) != NULL) {
 		return;
 	} 
-	zend_execute_ex(i_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC) TSRMLS_CC);
+	zend_execute_ex(i_create_execute_data_from_op_array(op_array, return_value, EG(active_symbol_table) ? VM_FRAME_TOP_CODE : VM_FRAME_TOP_FUNCTION TSRMLS_CC) TSRMLS_CC);
 }
 
 static int ZEND_FASTCALL zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
 {
-	zend_bool nested = EX(nested);
-	zend_op_array *op_array = EX(op_array);
+	vm_frame_kind frame_kind = EX(frame_kind);
 
 	EG(current_execute_data) = EX(prev_execute_data);
-	EG(opline_ptr) = NULL;
-	if (!EG(active_symbol_table)) {
-		i_free_compiled_variables(execute_data TSRMLS_CC);
-	}
-
-	zend_vm_stack_free((char*)execute_data - (ZEND_MM_ALIGNED_SIZE(sizeof(temp_variable)) * op_array->T) TSRMLS_CC);
 
-	if ((op_array->fn_flags & ZEND_ACC_CLOSURE) && op_array->prototype) {
-		zval_ptr_dtor((zval**)&op_array->prototype);
-	}
+	if (frame_kind == VM_FRAME_NESTED_FUNCTION) {
+		i_free_compiled_variables(execute_data TSRMLS_CC);
+		if (UNEXPECTED(EX(symbol_table) != NULL)) {
+			zend_clean_and_cache_symbol_table(EX(symbol_table) TSRMLS_CC);
+		}
+		if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_CLOSURE) != 0) && EX(op_array)->prototype) {
+			zval_ptr_dtor((zval*)EX(op_array)->prototype);
+		}
+		zend_vm_stack_free((char*)execute_data TSRMLS_CC);
 
-	if (nested) {
 		execute_data = EG(current_execute_data);
-	}
-	if (nested) {
-		USE_OPLINE
-
-		LOAD_REGS();
-		LOAD_OPLINE();
-		if (UNEXPECTED(opline->opcode == ZEND_INCLUDE_OR_EVAL)) {
+		EG(opline_ptr) = &EX(opline);
+		EG(active_op_array) = EX(op_array);
+		EG(active_symbol_table) = EX(symbol_table);
 
-			EX(function_state).function = (zend_function *) EX(op_array);
-			EX(function_state).arguments = NULL;
+		EX(function_state).function = (zend_function *) EX(op_array);
+		EX(function_state).arguments = NULL;
 
-			EG(opline_ptr) = &EX(opline);
-			EG(active_op_array) = EX(op_array);
-			EG(return_value_ptr_ptr) = EX(original_return_value);
-			destroy_op_array(op_array TSRMLS_CC);
-			efree(op_array);
-			if (UNEXPECTED(EG(exception) != NULL)) {
-				zend_throw_exception_internal(NULL TSRMLS_CC);
-				HANDLE_EXCEPTION_LEAVE();
+		if (Z_OBJ(EG(This))) {
+			if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
+				if (EX(call)->is_ctor_result_used) {
+					Z_DELREF(EG(This));
+				}
+				if (Z_REFCOUNT(EG(This)) == 1) {
+					zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
+				}
 			}
-
-			ZEND_VM_INC_OPCODE();
-			ZEND_VM_LEAVE();
-		} else {
-			EG(opline_ptr) = &EX(opline);
-			EG(active_op_array) = EX(op_array);
-			EG(return_value_ptr_ptr) = EX(original_return_value);
-			if (EG(active_symbol_table)) {
-				zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
+			if (!Z_DELREF(EG(This))) {
+				_zval_dtor_func_for_ptr(Z_COUNTED(EG(This)) ZEND_FILE_LINE_CC);
+			} else if (UNEXPECTED(!Z_GC_INFO(EG(This)))) {
+				gc_possible_root(Z_COUNTED(EG(This)) TSRMLS_CC);
 			}
-			EG(active_symbol_table) = EX(symbol_table);
+		}
+		Z_OBJ(EG(This)) = EX(object);
+		EG(scope) = EX(scope);
+		EG(called_scope) = EX(called_scope);
 
-			EX(function_state).function = (zend_function *) EX(op_array);
-			EX(function_state).arguments = NULL;
+		EX(call)--;
 
-			if (EG(This)) {
-				if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
-					if (EX(call)->is_ctor_result_used) {
-						Z_DELREF_P(EG(This));
-					}
-					if (Z_REFCOUNT_P(EG(This)) == 1) {
-						zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
-					}
-				}
-				zval_ptr_dtor(&EG(This));
+		zend_vm_stack_clear_multiple(1 TSRMLS_CC);
+
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_op *opline = EX(opline);
+			zend_throw_exception_internal(NULL TSRMLS_CC);
+			if (RETURN_VALUE_USED(opline)) {
+				zval_ptr_dtor(EX_VAR(opline->result.var));
 			}
-			EG(This) = EX(current_this);
-			EG(scope) = EX(current_scope);
-			EG(called_scope) = EX(current_called_scope);
+			HANDLE_EXCEPTION_LEAVE();
+		}
 
-			EX(call)--;
+		LOAD_OPLINE();
+		ZEND_VM_INC_OPCODE();
+		ZEND_VM_LEAVE();
+	} else if (frame_kind == VM_FRAME_NESTED_CODE) {
+		zend_detach_symbol_table(execute_data);
+		destroy_op_array(EX(op_array) TSRMLS_CC);
+		efree(EX(op_array));
+		zend_vm_stack_free((char*)execute_data TSRMLS_CC);
 
-			zend_vm_stack_clear_multiple(1 TSRMLS_CC);
+		execute_data = EG(current_execute_data);
+		zend_attach_symbol_table(execute_data);
+		EX(function_state).function = (zend_function *) EX(op_array);
+		EX(function_state).arguments = NULL;
+		EG(opline_ptr) = &EX(opline);
+		EG(active_op_array) = EX(op_array);
+		if (UNEXPECTED(EG(exception) != NULL)) {
+			zend_throw_exception_internal(NULL TSRMLS_CC);
+			HANDLE_EXCEPTION_LEAVE();
+		}
 
-			if (UNEXPECTED(EG(exception) != NULL)) {
-				zend_throw_exception_internal(NULL TSRMLS_CC);
-				if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
-					zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
+		LOAD_OPLINE();
+		ZEND_VM_INC_OPCODE();
+		ZEND_VM_LEAVE();
+	} else {
+		if (frame_kind == VM_FRAME_TOP_FUNCTION) {
+			i_free_compiled_variables(execute_data TSRMLS_CC);
+		} else /* if (frame_kind == VM_FRAME_TOP_CODE) */ {
+			zend_array *symbol_table = EX(symbol_table);
+			zend_execute_data *old_execute_data;
+
+			zend_detach_symbol_table(execute_data);
+			old_execute_data = EX(prev_execute_data);
+			while (old_execute_data) {
+				if (old_execute_data->op_array) {
+					if (old_execute_data->symbol_table == symbol_table) {
+						zend_attach_symbol_table(old_execute_data);
+					}
+					break;
 				}
-				HANDLE_EXCEPTION_LEAVE();
+				old_execute_data = old_execute_data->prev_execute_data;
 			}
-
-			ZEND_VM_INC_OPCODE();
-			ZEND_VM_LEAVE();
 		}
+		if ((EX(op_array)->fn_flags & ZEND_ACC_CLOSURE) && EX(op_array)->prototype) {
+			zval_ptr_dtor((zval*)EX(op_array)->prototype);
+		}
+		zend_vm_stack_free((char*)execute_data TSRMLS_CC);
+		EG(opline_ptr) = NULL;
+		ZEND_VM_RETURN();
 	}
-	ZEND_VM_RETURN();
 }
 
 static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_bool should_change_scope = 0;
 	zend_function *fbc = EX(function_state).function;
+	zend_object *object;
 	zend_uint num_args;
 
 	SAVE_OPLINE();
-	EX(object) = EX(call)->object;
+	object = EX(call)->object;
 	if (UNEXPECTED((fbc->common.fn_flags & (ZEND_ACC_ABSTRACT|ZEND_ACC_DEPRECATED)) != 0)) {
 		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_ABSTRACT) != 0)) {
-			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name, fbc->common.function_name);
+			zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", fbc->common.scope->name->val, fbc->common.function_name->val);
 		}
 		if (UNEXPECTED((fbc->common.fn_flags & ZEND_ACC_DEPRECATED) != 0)) {
 			zend_error(E_DEPRECATED, "Function %s%s%s() is deprecated",
-				fbc->common.scope ? fbc->common.scope->name : "",
+				fbc->common.scope ? fbc->common.scope->name->val : "",
 				fbc->common.scope ? "::" : "",
-				fbc->common.function_name);
+				fbc->common.function_name->val);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
@@ -501,158 +513,181 @@ static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_AR
 	}
 	if (fbc->common.scope &&
 		!(fbc->common.fn_flags & ZEND_ACC_STATIC) &&
-		!EX(object)) {
+		!object) {
 
 		if (fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
 			/* FIXME: output identifiers properly */
-			zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name, fbc->common.function_name);
+			zend_error(E_STRICT, "Non-static method %s::%s() should not be called statically", fbc->common.scope->name->val, fbc->common.function_name->val);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 		} else {
 			/* FIXME: output identifiers properly */
 			/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-			zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name, fbc->common.function_name);
+			zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically", fbc->common.scope->name->val, fbc->common.function_name->val);
 		}
 	}
 
-	if (fbc->type == ZEND_USER_FUNCTION || fbc->common.scope) {
-		should_change_scope = 1;
-		EX(current_this) = EG(This);
-		EX(current_scope) = EG(scope);
-		EX(current_called_scope) = EG(called_scope);
-		EG(This) = EX(object);
-		EG(scope) = (fbc->type == ZEND_USER_FUNCTION || !EX(object)) ? fbc->common.scope : NULL;
-		EG(called_scope) = EX(call)->called_scope;
-	}
-
-	num_args = opline->extended_value + EX(call)->num_additional_args;
-	if (EX(call)->num_additional_args) {
+	if (UNEXPECTED(EX(call)->num_additional_args != 0)) {
+		num_args = opline->extended_value + EX(call)->num_additional_args;
 		EX(function_state).arguments = zend_vm_stack_push_args(num_args TSRMLS_CC);
 	} else {
+		zval tmp;
+
+		num_args = opline->extended_value;
+		ZVAL_LONG(&tmp, num_args);
 		EX(function_state).arguments = zend_vm_stack_top(TSRMLS_C);
-		zend_vm_stack_push((void*)(zend_uintptr_t) num_args TSRMLS_CC);
+		zend_vm_stack_push(&tmp TSRMLS_CC);
 	}
 	LOAD_OPLINE();
 
 	if (fbc->type == ZEND_INTERNAL_FUNCTION) {
+		int should_change_scope = 0;
+		zval *ret;
+
+		if (fbc->common.scope) {
+			should_change_scope = 1;
+			Z_OBJ(EG(This)) = object;
+//???			EG(scope) = (object) ? NULL : fbc->common.scope;
+			EG(scope) = fbc->common.scope;
+			EG(called_scope) = EX(call)->called_scope;
+		}
+
 		if (fbc->common.fn_flags & ZEND_ACC_HAS_TYPE_HINTS) {
 			zend_uint i;
-			void **p = EX(function_state).arguments - num_args;
+			zval *p = EX(function_state).arguments - num_args;
 
 			for (i = 0; i < num_args; ++i, ++p) {
-				zend_verify_arg_type(fbc, i + 1, (zval *) *p, 0 TSRMLS_CC);
+				zend_verify_arg_type(fbc, i + 1, p, 0 TSRMLS_CC);
+			}
+			if (UNEXPECTED(EG(exception) != NULL)) {
+				if (RETURN_VALUE_USED(opline)) {
+					ZVAL_UNDEF(EX_VAR(opline->result.var));
+				}
+				if (UNEXPECTED(should_change_scope)) {
+					goto fcall_end_change_scope;
+				} else {
+					goto fcall_end;
+				}
 			}
 		}
 
-		if (EXPECTED(EG(exception) == NULL)) {
-			temp_variable *ret = &EX_T(opline->result.var);
+		ret = EX_VAR(opline->result.var);
+		ZVAL_NULL(ret);
+		Z_VAR_FLAGS_P(ret) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
 
-			MAKE_STD_ZVAL(ret->var.ptr);
-			ZVAL_NULL(ret->var.ptr);
-			ret->var.ptr_ptr = &ret->var.ptr;
-			ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+		if (!zend_execute_internal) {
+			/* saves one function call if zend_execute_internal is not used */
+			fbc->internal_function.handler(num_args, ret TSRMLS_CC);
+		} else {
+			zend_execute_internal(execute_data, NULL TSRMLS_CC);
+		}
 
-			if (!zend_execute_internal) {
-				/* saves one function call if zend_execute_internal is not used */
-				fbc->internal_function.handler(num_args, ret->var.ptr, &ret->var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
-			} else {
-				zend_execute_internal(execute_data, NULL, RETURN_VALUE_USED(opline) TSRMLS_CC);
-			}
+		if (!RETURN_VALUE_USED(opline)) {
+			zval_ptr_dtor(ret);
+		}
 
-			if (!RETURN_VALUE_USED(opline)) {
-				zval_ptr_dtor(&ret->var.ptr);
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr = NULL;
+		if (UNEXPECTED(should_change_scope)) {
+			goto fcall_end_change_scope;
+		} else {
+			goto fcall_end;
 		}
 	} else if (fbc->type == ZEND_USER_FUNCTION) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
+		Z_OBJ(EG(This)) = object;
+		EG(scope) = fbc->common.scope;
+		EG(called_scope) = EX(call)->called_scope;
 		EG(active_symbol_table) = NULL;
 		EG(active_op_array) = &fbc->op_array;
-		EG(return_value_ptr_ptr) = NULL;
 		if (RETURN_VALUE_USED(opline)) {
-			temp_variable *ret = &EX_T(opline->result.var);
+			return_value = EX_VAR(opline->result.var);
 
-			ret->var.ptr = NULL;
-			EG(return_value_ptr_ptr) = &ret->var.ptr;
-			ret->var.ptr_ptr = &ret->var.ptr;
-			ret->var.fcall_returned_reference = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0;
+			ZVAL_NULL(return_value);
+			Z_VAR_FLAGS_P(return_value) = (fbc->common.fn_flags & ZEND_ACC_RETURN_REFERENCE) != 0 ? IS_VAR_RET_REF : 0;
 		}
 
 		if (UNEXPECTED((EG(active_op_array)->fn_flags & ZEND_ACC_GENERATOR) != 0)) {
 			if (RETURN_VALUE_USED(opline)) {
-				EX_T(opline->result.var).var.ptr = zend_generator_create_zval(EG(active_op_array) TSRMLS_CC);
+				zend_generator_create_zval(EG(active_op_array), EX_VAR(opline->result.var) TSRMLS_CC);
 			}
 		} else if (EXPECTED(zend_execute_ex == execute_ex)) {
 			if (EXPECTED(EG(exception) == NULL)) {
+				i_create_execute_data_from_op_array(EG(active_op_array), return_value, VM_FRAME_NESTED_FUNCTION TSRMLS_CC);
 				ZEND_VM_ENTER();
 			}
 		} else {
-			zend_execute(EG(active_op_array) TSRMLS_CC);
+			zend_execute(EG(active_op_array), return_value TSRMLS_CC);
 		}
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
-		if (EG(active_symbol_table)) {
+		if (UNEXPECTED(EG(active_symbol_table) != NULL)) {
 			zend_clean_and_cache_symbol_table(EG(active_symbol_table) TSRMLS_CC);
 		}
 		EG(active_symbol_table) = EX(symbol_table);
 	} else { /* ZEND_OVERLOADED_FUNCTION */
-		MAKE_STD_ZVAL(EX_T(opline->result.var).var.ptr);
-		ZVAL_NULL(EX_T(opline->result.var).var.ptr);
+		Z_OBJ(EG(This)) = object;
+//???		EG(scope) = NULL;
+		EG(scope) = fbc->common.scope;
+		EG(called_scope) = EX(call)->called_scope;
+
+		ZVAL_NULL(EX_VAR(opline->result.var));
 
 		/* Not sure what should be done here if it's a static method */
-		if (EXPECTED(EX(object) != NULL)) {
-			Z_OBJ_HT_P(EX(object))->call_method(fbc->common.function_name, num_args, EX_T(opline->result.var).var.ptr, &EX_T(opline->result.var).var.ptr, EX(object), RETURN_VALUE_USED(opline) TSRMLS_CC);
+		if (EXPECTED(object != NULL)) {
+			object->handlers->call_method(fbc->common.function_name, object, num_args, EX_VAR(opline->result.var) TSRMLS_CC);
 		} else {
 			zend_error_noreturn(E_ERROR, "Cannot call overloaded function for non-object");
 		}
 
 		if (fbc->type == ZEND_OVERLOADED_FUNCTION_TEMPORARY) {
-			efree((char*)fbc->common.function_name);
+			STR_RELEASE(fbc->common.function_name);
 		}
 		efree(fbc);
 
 		if (!RETURN_VALUE_USED(opline)) {
-			zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		} else {
-			Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
-			Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
-			EX_T(opline->result.var).var.fcall_returned_reference = 0;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+//???			Z_UNSET_ISREF_P(EX_T(opline->result.var).var.ptr);
+//???			Z_SET_REFCOUNT_P(EX_T(opline->result.var).var.ptr, 1);
+			Z_VAR_FLAGS_P(EX_VAR(opline->result.var)) = 0;
 		}
 	}
 
-	EX(function_state).function = (zend_function *) EX(op_array);
-	EX(function_state).arguments = NULL;
-
-	if (should_change_scope) {
-		if (EG(This)) {
-			if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
-				if (EX(call)->is_ctor_result_used) {
-					Z_DELREF_P(EG(This));
-				}
-				if (Z_REFCOUNT_P(EG(This)) == 1) {
-					zend_object_store_ctor_failed(EG(This) TSRMLS_CC);
-				}
+fcall_end_change_scope:
+	if (Z_OBJ(EG(This))) {
+		if (UNEXPECTED(EG(exception) != NULL) && EX(call)->is_ctor_call) {
+			if (EX(call)->is_ctor_result_used) {
+				Z_DELREF(EG(This));
 			}
-			zval_ptr_dtor(&EG(This));
+			if (Z_REFCOUNT(EG(This)) == 1) {
+				zend_object_store_ctor_failed(Z_OBJ(EG(This)) TSRMLS_CC);
+			}
+		}
+		if (!Z_DELREF(EG(This))) {
+			EX(function_state).function = (zend_function *) EX(op_array);
+			EX(function_state).arguments = NULL;
+			_zval_dtor_func_for_ptr(Z_COUNTED(EG(This)) ZEND_FILE_LINE_CC);
+		} else if (UNEXPECTED(!Z_GC_INFO(EG(This)))) {
+			gc_possible_root(Z_COUNTED(EG(This)) TSRMLS_CC);
 		}
-		EG(This) = EX(current_this);
-		EG(scope) = EX(current_scope);
-		EG(called_scope) = EX(current_called_scope);
 	}
+	Z_OBJ(EG(This)) = EX(object);
+	EG(scope) = EX(scope);
+	EG(called_scope) = EX(called_scope);
 
+fcall_end:
+	EX(function_state).function = (zend_function *) EX(op_array);
+	EX(function_state).arguments = NULL;
 	EX(call)--;
 
 	zend_vm_stack_clear_multiple(1 TSRMLS_CC);
 
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		zend_throw_exception_internal(NULL TSRMLS_CC);
-		if (RETURN_VALUE_USED(opline) && EX_T(opline->result.var).var.ptr) {
-			zval_ptr_dtor(&EX_T(opline->result.var).var.ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 		HANDLE_EXCEPTION();
 	}
@@ -674,15 +709,10 @@ static int ZEND_FASTCALL  ZEND_JMP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_INIT_STRING_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *tmp = &EX_T(opline->result.var).tmp_var;
+	zval *tmp = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	tmp->value.str.val = emalloc(1);
-	tmp->value.str.val[0] = 0;
-	tmp->value.str.len = 0;
-	Z_SET_REFCOUNT_P(tmp, 1);
-	tmp->type = IS_STRING;
-	Z_UNSET_ISREF_P(tmp);
+	ZVAL_EMPTY_STRING(tmp);
 	/*CHECK_EXCEPTION();*/
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -695,8 +725,8 @@ static int ZEND_FASTCALL  ZEND_DO_FCALL_BY_NAME_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 
 static int ZEND_FASTCALL  ZEND_GENERATOR_RETURN_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	/* Close the generator to free up resources */
 	zend_generator_close(generator, 1 TSRMLS_CC);
@@ -716,23 +746,17 @@ static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	args = get_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, BP_VAR_R);
 	arg_num = opline->op2.num + EX(call)->num_additional_args + 1;
 
+send_again:
 	switch (Z_TYPE_P(args)) {
 		case IS_ARRAY: {
 			HashTable *ht = Z_ARRVAL_P(args);
-			HashPosition pos;
-			zval **arg_ptr, *arg;
+			zval *arg;
+			zend_string *name;
 
 			ZEND_VM_STACK_GROW_IF_NEEDED(zend_hash_num_elements(ht));
 
-			for (zend_hash_internal_pointer_reset_ex(ht, &pos);
-			     zend_hash_get_current_data_ex(ht, (void **) &arg_ptr, &pos) == SUCCESS;
-			     zend_hash_move_forward_ex(ht, &pos), ++arg_num
-			) {
-				char *name;
-				zend_uint name_len;
-				zend_ulong index;
-
-				if (zend_hash_get_current_key_ex(ht, &name, &name_len, &index, 0, &pos) == HASH_KEY_IS_STRING) {
+			ZEND_HASH_FOREACH_STR_KEY_VAL(ht, name, arg) {
+				if (name) {
 					zend_error(E_RECOVERABLE_ERROR, "Cannot unpack array with string keys");
 					FREE_OP(free_op1);
 					CHECK_EXCEPTION();
@@ -740,20 +764,19 @@ static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 				}
 
 				if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, arg_num)) {
-					SEPARATE_ZVAL_TO_MAKE_IS_REF(arg_ptr);
-					arg = *arg_ptr;
+					SEPARATE_ZVAL_TO_MAKE_IS_REF(arg);
 					Z_ADDREF_P(arg);
-				} else if (Z_ISREF_PP(arg_ptr)) {
-					ALLOC_ZVAL(arg);
-					MAKE_COPY_ZVAL(arg_ptr, arg);
+				} else if (Z_ISREF_P(arg)) {
+					ZVAL_DUP(arg, Z_REFVAL_P(arg));
 				} else {
-					arg = *arg_ptr;
-					Z_ADDREF_P(arg);
+					if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
 				}
 
 				zend_vm_stack_push(arg TSRMLS_CC);
 				EX(call)->num_additional_args++;
-			}
+				arg_num++;
+			} ZEND_HASH_FOREACH_END();
+
 			break;
 		}
 		case IS_OBJECT: {
@@ -770,7 +793,7 @@ static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 				FREE_OP(free_op1);
 				if (!EG(exception)) {
 					zend_throw_exception_ex(
-						NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name
+						NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val
 					);
 				}
 				HANDLE_EXCEPTION();
@@ -784,13 +807,13 @@ static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 			}
 
 			for (; iter->funcs->valid(iter TSRMLS_CC) == SUCCESS; ++arg_num) {
-				zval **arg_ptr, *arg;
+				zval *arg;
 
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					goto unpack_iter_dtor;
 				}
 
-				iter->funcs->get_current_data(iter, &arg_ptr TSRMLS_CC);
+				arg = iter->funcs->get_current_data(iter TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					goto unpack_iter_dtor;
 				}
@@ -816,18 +839,16 @@ static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 					zend_error(
 						E_WARNING, "Cannot pass by-reference argument %d of %s%s%s()"
 						" by unpacking a Traversable, passing by-value instead", arg_num,
-						EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name : "",
+						EX(call)->fbc->common.scope ? EX(call)->fbc->common.scope->name->val : "",
 						EX(call)->fbc->common.scope ? "::" : "",
-						EX(call)->fbc->common.function_name
+						EX(call)->fbc->common.function_name->val
 					);
 				}
 
-				if (Z_ISREF_PP(arg_ptr)) {
-					ALLOC_ZVAL(arg);
-					MAKE_COPY_ZVAL(arg_ptr, arg);
+				if (Z_ISREF_P(arg)) {
+					ZVAL_DUP(arg, Z_REFVAL_P(arg));
 				} else {
-					arg = *arg_ptr;
-					Z_ADDREF_P(arg);
+					if (Z_REFCOUNTED_P(arg)) Z_ADDREF_P(arg);
 				}
 
 				ZEND_VM_STACK_GROW_IF_NEEDED(1);
@@ -841,9 +862,13 @@ static int ZEND_FASTCALL  ZEND_SEND_UNPACK_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 			}
 
 unpack_iter_dtor:
-			iter->funcs->dtor(iter TSRMLS_CC);
+			zend_iterator_dtor(iter TSRMLS_CC);
 			break;
 		}
+		case IS_REFERENCE:
+			args = Z_REFVAL_P(args);
+			goto send_again;
+			break;
 		default:
 			zend_error(E_WARNING, "Only arrays and Traversables can be unpacked");
 	}
@@ -857,37 +882,22 @@ static int ZEND_FASTCALL  ZEND_RECV_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_uint arg_num = opline->op1.num;
-	zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
+	zval *arguments = EX(prev_execute_data)->function_state.arguments;
+	zend_uint arg_count = Z_LVAL_P(arguments);
 
 	SAVE_OPLINE();
-	if (UNEXPECTED(param == NULL)) {
-		if (zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, NULL, opline->extended_value TSRMLS_CC)) {
-			const char *space;
-			const char *class_name;
-			zend_execute_data *ptr;
-
-			if (EG(active_op_array)->scope) {
-				class_name = EG(active_op_array)->scope->name;
-				space = "::";
-			} else {
-				class_name = space = "";
-			}
-			ptr = EX(prev_execute_data);
-
-			if(ptr && ptr->op_array) {
-				zend_error(E_WARNING, "Missing argument %u for %s%s%s(), called in %s on line %d and defined", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C), ptr->op_array->filename, ptr->opline->lineno);
-			} else {
-				zend_error(E_WARNING, "Missing argument %u for %s%s%s()", opline->op1.num, class_name, space, get_active_function_name(TSRMLS_C));
-			}
-		}
+	if (UNEXPECTED(arg_num > arg_count)) {
+		zend_verify_missing_arg(execute_data, arg_num TSRMLS_CC);
 	} else {
-		zval **var_ptr;
+		zval *var_ptr;
+		zval *param = arguments - arg_count + arg_num - 1;
 
-		zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
-		var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
-		Z_DELREF_PP(var_ptr);
-		*var_ptr = *param;
-		Z_ADDREF_PP(var_ptr);
+		if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+			zend_verify_arg_type((zend_function *) EX(op_array), arg_num, param, opline->extended_value TSRMLS_CC);
+		}
+		var_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
+		if (UNEXPECTED(Z_REFCOUNTED_P(var_ptr))) Z_DELREF_P(var_ptr);
+		ZVAL_COPY(var_ptr, param);
 	}
 
 	CHECK_EXCEPTION();
@@ -898,29 +908,36 @@ static int ZEND_FASTCALL  ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
 	USE_OPLINE
 	zend_uint arg_num = opline->op1.num;
-	zend_uint arg_count = zend_vm_stack_get_args_count(TSRMLS_C);
-	zval **var_ptr, *params;
+	zval *arguments = EX(prev_execute_data)->function_state.arguments;
+	zend_uint arg_count = Z_LVAL_P(arguments);
+	zval *params;
 
 	SAVE_OPLINE();
 
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
-	Z_DELREF_PP(var_ptr);
-	MAKE_STD_ZVAL(params);
-	*var_ptr = params;
+	params = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
+	if (UNEXPECTED(Z_REFCOUNTED_P(params))) Z_DELREF_P(params);
 
 	if (arg_num <= arg_count) {
+		zval *param = arguments - arg_count + arg_num - 1;
 		array_init_size(params, arg_count - arg_num + 1);
+		if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+			do {
+				zend_verify_arg_type((zend_function *) EX(op_array), arg_num, param, opline->extended_value TSRMLS_CC);
+				zend_hash_next_index_insert(Z_ARRVAL_P(params), param);
+				if (Z_REFCOUNTED_P(param)) Z_ADDREF_P(param);
+				param++;
+			} while (++arg_num <= arg_count);
+		} else {
+			do {
+				zend_hash_next_index_insert(Z_ARRVAL_P(params), param);
+				if (Z_REFCOUNTED_P(param)) Z_ADDREF_P(param);
+				param++;
+			} while (++arg_num <= arg_count);
+		}
 	} else {
 		array_init(params);
 	}
 
-	for (; arg_num <= arg_count; ++arg_num) {
-		zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
-		zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, *param, opline->extended_value TSRMLS_CC);
-		zend_hash_next_index_insert(Z_ARRVAL_P(params), param, sizeof(zval *), NULL);
-		Z_ADDREF_PP(param);
-	}
-
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -928,28 +945,25 @@ static int ZEND_FASTCALL  ZEND_RECV_VARIADIC_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *object_zval;
+	zval object_zval;
 	zend_function *constructor;
 
 	SAVE_OPLINE();
-	if (UNEXPECTED((EX_T(opline->op1.var).class_entry->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
-		if (EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_INTERFACE) {
-			zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", EX_T(opline->op1.var).class_entry->name);
-		} else if ((EX_T(opline->op1.var).class_entry->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
-			zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", EX_T(opline->op1.var).class_entry->name);
+	if (UNEXPECTED((Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & (ZEND_ACC_INTERFACE|ZEND_ACC_IMPLICIT_ABSTRACT_CLASS|ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) != 0)) {
+		if (Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & ZEND_ACC_INTERFACE) {
+			zend_error_noreturn(E_ERROR, "Cannot instantiate interface %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val);
+		} else if ((Z_CE_P(EX_VAR(opline->op1.var))->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT) {
+			zend_error_noreturn(E_ERROR, "Cannot instantiate trait %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val);
 		} else {
-			zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", EX_T(opline->op1.var).class_entry->name);
+			zend_error_noreturn(E_ERROR, "Cannot instantiate abstract class %s", Z_CE_P(EX_VAR(opline->op1.var))->name->val);
 		}
 	}
-	ALLOC_ZVAL(object_zval);
-	object_init_ex(object_zval, EX_T(opline->op1.var).class_entry);
-	INIT_PZVAL(object_zval);
-
-	constructor = Z_OBJ_HT_P(object_zval)->get_constructor(object_zval TSRMLS_CC);
+	object_init_ex(&object_zval, Z_CE_P(EX_VAR(opline->op1.var)));
+	constructor = Z_OBJ_HT(object_zval)->get_constructor(Z_OBJ(object_zval) TSRMLS_CC);
 
 	if (constructor == NULL) {
 		if (RETURN_VALUE_USED(opline)) {
-			AI_SET_PTR(&EX_T(opline->result.var), object_zval);
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), &object_zval);
 		} else {
 			zval_ptr_dtor(&object_zval);
 		}
@@ -958,14 +972,13 @@ static int ZEND_FASTCALL  ZEND_NEW_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 		call_slot *call = EX(call_slots) + opline->extended_value;
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(object_zval);
-			AI_SET_PTR(&EX_T(opline->result.var), object_zval);
+			ZVAL_COPY(EX_VAR(opline->result.var), &object_zval);
 		}
 
 		/* We are not handling overloaded classes right now */
 		call->fbc = constructor;
-		call->object = object_zval;
-		call->called_scope = EX_T(opline->op1.var).class_entry;
+		call->object = Z_OBJ(object_zval);
+		call->called_scope = Z_CE_P(EX_VAR(opline->op1.var));
 		call->num_additional_args = 0;
 		call->is_ctor_call = 1;
 		call->is_ctor_result_used = RETURN_VALUE_USED(opline);
@@ -981,17 +994,19 @@ static int ZEND_FASTCALL  ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = EG(error_reporting);
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_LONG;  /* shouldn't be necessary */
-	if (EX(old_error_reporting) == NULL) {
-		EX(old_error_reporting) = &EX_T(opline->result.var).tmp_var;
+	ZVAL_LONG(EX_VAR(opline->result.var), EG(error_reporting));
+	if (Z_TYPE(EX(old_error_reporting)) == IS_UNDEF) {
+		ZVAL_LONG(&EX(old_error_reporting), EG(error_reporting));
 	}
 
 	if (EG(error_reporting)) {
 		do {
 			EG(error_reporting) = 0;
 			if (!EG(error_reporting_ini_entry)) {
-				if (UNEXPECTED(zend_hash_find(EG(ini_directives), "error_reporting", sizeof("error_reporting"), (void **) &EG(error_reporting_ini_entry)) == FAILURE)) {
+				zend_ini_entry *p = zend_hash_str_find_ptr(EG(ini_directives), "error_reporting", sizeof("error_reporting")-1);
+				if (p) {
+					EG(error_reporting_ini_entry) = p;
+				} else {
 					break;
 				}
 			}
@@ -1000,7 +1015,7 @@ static int ZEND_FASTCALL  ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR
 					ALLOC_HASHTABLE(EG(modified_ini_directives));
 					zend_hash_init(EG(modified_ini_directives), 8, NULL, NULL, 0);
 				}
-				if (EXPECTED(zend_hash_add(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting"), &EG(error_reporting_ini_entry), sizeof(zend_ini_entry*), NULL) == SUCCESS)) {
+				if (EXPECTED(zend_hash_str_add_ptr(EG(modified_ini_directives), "error_reporting", sizeof("error_reporting")-1, EG(error_reporting_ini_entry)) != NULL)) {
 					EG(error_reporting_ini_entry)->orig_value = EG(error_reporting_ini_entry)->value;
 					EG(error_reporting_ini_entry)->orig_value_length = EG(error_reporting_ini_entry)->value_length;
 					EG(error_reporting_ini_entry)->orig_modifiable = EG(error_reporting_ini_entry)->modifiable;
@@ -1020,7 +1035,7 @@ static int ZEND_FASTCALL  ZEND_BEGIN_SILENCE_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_RAISE_ABSTRACT_ERROR_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	SAVE_OPLINE();
-	zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name, EX(op_array)->function_name);
+	zend_error_noreturn(E_ERROR, "Cannot call abstract method %s::%s()", EG(scope)->name->val, EX(op_array)->function_name->val);
 	ZEND_VM_NEXT_OPCODE(); /* Never reached */
 }
 
@@ -1059,7 +1074,7 @@ static int ZEND_FASTCALL  ZEND_DECLARE_CLASS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_AR
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	EX_T(opline->result.var).class_entry = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
+	Z_CE_P(EX_VAR(opline->result.var)) = do_bind_class(EX(op_array), opline, EG(class_table), 0 TSRMLS_CC);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -1069,7 +1084,7 @@ static int ZEND_FASTCALL  ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	EX_T(opline->result.var).class_entry = do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
+	Z_CE_P(EX_VAR(opline->result.var)) = do_bind_inherited_class(EX(op_array), opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -1077,13 +1092,13 @@ static int ZEND_FASTCALL  ZEND_DECLARE_INHERITED_CLASS_SPEC_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_DECLARE_INHERITED_CLASS_DELAYED_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_class_entry **pce, **pce_orig;
+	zval *zce, *orig_zce;
 
 	SAVE_OPLINE();
-	if (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void**)&pce) == FAILURE ||
-	    (zend_hash_quick_find(EG(class_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void**)&pce_orig) == SUCCESS &&
-	     *pce != *pce_orig)) {
-		do_bind_inherited_class(EX(op_array), opline, EG(class_table), EX_T(opline->extended_value).class_entry, 0 TSRMLS_CC);
+	if ((zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op2.zv))) == NULL ||
+	    ((orig_zce = zend_hash_find(EG(class_table), Z_STR_P(opline->op1.zv))) != NULL &&
+	     Z_CE_P(zce) != Z_CE_P(orig_zce))) {
+		do_bind_inherited_class(EX(op_array), opline, EG(class_table), Z_CE_P(EX_VAR(opline->extended_value)), 0 TSRMLS_CC);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -1127,25 +1142,24 @@ static int ZEND_FASTCALL  ZEND_NOP_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
+	zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
 	zend_class_entry *trait;
 
 	SAVE_OPLINE();
-	if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-		trait = CACHED_PTR(opline->op2.literal->cache_slot);
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		trait = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else {
-		trait = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv),
-		                                 Z_STRLEN_P(opline->op2.zv),
-		                                 opline->op2.literal + 1,
+		trait = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv),
+		                                 opline->op2.zv + 1,
 		                                 opline->extended_value TSRMLS_CC);
 		if (UNEXPECTED(trait == NULL)) {
 			CHECK_EXCEPTION();
 			ZEND_VM_NEXT_OPCODE();
 		}
 		if (!((trait->ce_flags & ZEND_ACC_TRAIT) == ZEND_ACC_TRAIT)) {
-			zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name, trait->name);
+			zend_error_noreturn(E_ERROR, "%s cannot use %s - it is not a trait", ce->name->val, trait->name->val);
 		}
-		CACHE_PTR(opline->op2.literal->cache_slot, trait);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), trait);
 	}
 
 	zend_do_implement_trait(ce, trait TSRMLS_CC);
@@ -1157,7 +1171,7 @@ static int ZEND_FASTCALL  ZEND_ADD_TRAIT_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_BIND_TRAITS_SPEC_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
+	zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 	SAVE_OPLINE();
 	zend_do_bind_traits(ce TSRMLS_CC);
@@ -1170,7 +1184,7 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 	zend_uint op_num = EG(opline_before_exception)-EG(active_op_array)->opcodes;
 	int i;
 	zend_uint catch_op_num = 0, finally_op_num = 0, finally_op_end = 0;
-	void **stack_frame;
+	zval *stack_frame;
 
 	/* Figure out where the next stack frame (which maybe contains pushed
 	 * arguments that have to be dtor'ed) starts */
@@ -1180,7 +1194,7 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 	 * arguments pushed to the stack that have to be dtor'ed. */
 	while (zend_vm_stack_top(TSRMLS_C) != stack_frame) {
 		zval *stack_zval_p = zend_vm_stack_pop(TSRMLS_C);
-		zval_ptr_dtor(&stack_zval_p);
+		zval_ptr_dtor(stack_zval_p);
 	}
 
 	for (i=0; i<EG(active_op_array)->last_try_catch; i++) {
@@ -1206,13 +1220,13 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 			if (call->object) {
 				if (call->is_ctor_call) {
 					if (call->is_ctor_result_used) {
-						Z_DELREF_P(call->object);
+						GC_REFCOUNT(call->object)--;
 					}
-					if (Z_REFCOUNT_P(call->object) == 1) {
+					if (GC_REFCOUNT(call->object) == 1) {
 						zend_object_store_ctor_failed(call->object TSRMLS_CC);
 					}
 				}
-				zval_ptr_dtor(&call->object);
+				OBJ_RELEASE(call->object);
 			}
 			call--;
 		} while (call >= EX(call_slots));
@@ -1233,12 +1247,12 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 				switch (brk_opline->opcode) {
 					case ZEND_SWITCH_FREE:
 						if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-							zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
+							zval_ptr_dtor(EX_VAR(brk_opline->op1.var));
 						}
 						break;
 					case ZEND_FREE:
 						if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-							zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
+							zval_dtor(EX_VAR(brk_opline->op1.var));
 						}
 						break;
 				}
@@ -1247,16 +1261,18 @@ static int ZEND_FASTCALL  ZEND_HANDLE_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLER
 	}
 
 	/* restore previous error_reporting value */
-	if (!EG(error_reporting) && EX(old_error_reporting) != NULL && Z_LVAL_P(EX(old_error_reporting)) != 0) {
+	if (!EG(error_reporting) && Z_TYPE(EX(old_error_reporting)) != IS_UNDEF && Z_LVAL(EX(old_error_reporting)) != 0) {
 		zval restored_error_reporting;
+		zend_string *key;
 
-		Z_TYPE(restored_error_reporting) = IS_LONG;
-		Z_LVAL(restored_error_reporting) = Z_LVAL_P(EX(old_error_reporting));
+		ZVAL_LONG(&restored_error_reporting, Z_LVAL(EX(old_error_reporting)));
 		convert_to_string(&restored_error_reporting);
-		zend_alter_ini_entry_ex("error_reporting", sizeof("error_reporting"), Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
-		zendi_zval_dtor(restored_error_reporting);
+		key = STR_INIT("error_reporting", sizeof("error_reporting")-1, 0);
+		zend_alter_ini_entry_ex(key, Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME, 1 TSRMLS_CC);
+		STR_FREE(key);
+		zval_dtor(&restored_error_reporting);
 	}
-	EX(old_error_reporting) = NULL;
+	ZVAL_UNDEF(&EX(old_error_reporting));
 
 	if (finally_op_num && (!catch_op_num || catch_op_num >= finally_op_num)) {
 		if (EX(delayed_exception)) {
@@ -1295,7 +1311,7 @@ static int ZEND_FASTCALL  ZEND_VERIFY_ABSTRACT_CLASS_SPEC_HANDLER(ZEND_OPCODE_HA
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	zend_verify_abstract_class(EX_T(opline->op1.var).class_entry TSRMLS_CC);
+	zend_verify_abstract_class(Z_CE_P(EX_VAR(opline->op1.var)) TSRMLS_CC);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -1333,7 +1349,7 @@ static int ZEND_FASTCALL  ZEND_DISCARD_EXCEPTION_SPEC_HANDLER(ZEND_OPCODE_HANDLE
 {
 	if (EX(delayed_exception) != NULL) {
 		/* discard the previously thrown exception */
-		zval_ptr_dtor(&EX(delayed_exception));
+		OBJ_RELEASE(EX(delayed_exception));
 		EX(delayed_exception) = NULL;
 	}
 
@@ -1392,7 +1408,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 		zend_exception_save(TSRMLS_C);
 	}
 	if (IS_CONST == IS_UNUSED) {
-		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -1400,16 +1416,16 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 		zval *class_name = opline->op2.zv;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
+				Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 			} else {
-				EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-				CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
+				Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+				CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
 			}
 		} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-			EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
+			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
-			EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC);
 		} else {
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
@@ -1425,18 +1441,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *function_name;
+	zval *function_name_ptr, *function_name, *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
 	if (IS_CONST == IS_CONST) {
-		function_name = (zval*)(opline->op2.literal+1);
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
+		function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 
 		call->object = NULL;
@@ -1448,27 +1465,27 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 		/*CHECK_EXCEPTION();*/
 		ZEND_VM_NEXT_OPCODE();
 	} else {
-		char *function_name_strval, *lcname;
-		int function_name_strlen;
+		zend_string *lcname;
 
 
 		SAVE_OPLINE();
-		function_name = opline->op2.zv;
+		function_name_ptr = function_name = opline->op2.zv;
 
+		ZVAL_DEREF(function_name);
 		if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
-			function_name_strval = Z_STRVAL_P(function_name);
-			function_name_strlen = Z_STRLEN_P(function_name);
-			if (function_name_strval[0] == '\\') {
-			    function_name_strlen -= 1;
-				lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
+			if (Z_STRVAL_P(function_name)[0] == '\\') {
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
 			} else {
-				lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
 			}
-			if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
+			if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
+				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
 			}
-			efree(lcname);
+			STR_FREE(lcname);
 
+			call->fbc = Z_FUNC_P(func);
 			call->object = NULL;
 			call->called_scope = NULL;
 			call->num_additional_args = 0;
@@ -1482,12 +1499,12 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
 			if (call->object) {
-				Z_ADDREF_P(call->object);
+				GC_REFCOUNT(call->object)++;
 			}
 			if (IS_CONST == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
 			    call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
-				call->fbc->common.prototype = (zend_function*)function_name;
+				call->fbc->common.prototype = (zend_function*)function_name_ptr;
 			} else {
 
 			}
@@ -1501,67 +1518,56 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 		} else if (IS_CONST != IS_CONST &&
 				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
-			zend_class_entry *ce;
-			zval **method = NULL;
-			zval **obj = NULL;
+			zval *obj;
+			zval *method;
 
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
+			obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
+			method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
 
 			if (!obj || !method) {
 				zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
 			}
 
-			if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
+			if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
 				zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
 			}
 
-			if (Z_TYPE_PP(method) != IS_STRING) {
+			if (Z_TYPE_P(method) != IS_STRING) {
 				zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
 			}
 
-			if (Z_TYPE_PP(obj) == IS_STRING) {
-				ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
-				if (UNEXPECTED(ce == NULL)) {
+			if (Z_TYPE_P(obj) == IS_STRING) {
+				call->object = NULL;
+				call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
+				if (UNEXPECTED(call->called_scope == NULL)) {
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				call->called_scope = ce;
-				call->object = NULL;
 
-				if (ce->get_static_method) {
-					call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
+				if (call->called_scope->get_static_method) {
+					call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC);
 				} else {
-					call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+					call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC);
+				}
+				if (UNEXPECTED(call->fbc == NULL)) {
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method));
 				}
 			} else {
-				call->object = *obj;
-				ce = call->called_scope = Z_OBJCE_PP(obj);
+				call->called_scope = Z_OBJCE_P(obj);
+				call->object = Z_OBJ_P(obj);
 
-				call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+				call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
 				if (UNEXPECTED(call->fbc == NULL)) {
-					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
 				}
 
 				if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 					call->object = NULL;
 				} else {
-					if (!PZVAL_IS_REF(call->object)) {
-						Z_ADDREF_P(call->object); /* For $this pointer */
-					} else {
-						zval *this_ptr;
-						ALLOC_ZVAL(this_ptr);
-						INIT_PZVAL_COPY(this_ptr, call->object);
-						zval_copy_ctor(this_ptr);
-						call->object = this_ptr;
-					}
+					GC_REFCOUNT(call->object)++; /* For $this pointer */
 				}
 			}
 
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
-			}
-
 			call->num_additional_args = 0;
 			call->is_ctor_call = 0;
 			EX(call) = call;
@@ -1582,61 +1588,65 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_INIT_NS_FCALL_BY_NAME_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_literal *func_name;
+	zval *func_name;
+	zval *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
-	func_name = opline->op2.literal + 1;
-	if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-	} else if (zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE) {
+	func_name = opline->op2.zv + 1;
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+	} else if ((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL) {
 		func_name++;
-		if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL(func_name->constant), Z_STRLEN(func_name->constant)+1, func_name->hash_value, (void **) &call->fbc)==FAILURE)) {
+		if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(func_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 	} else {
-		CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+		call->fbc = Z_FUNC_P(func);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 	}
 
 	call->object = NULL;
 	call->called_scope = NULL;
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
-
 	EX(call) = call;
+
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_RECV_INIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *assignment_value;
 	zend_uint arg_num = opline->op1.num;
-	zval **param = zend_vm_stack_get_arg(arg_num TSRMLS_CC);
-	zval **var_ptr;
+	zval *arguments = EX(prev_execute_data)->function_state.arguments;
+	zend_uint arg_count = Z_LVAL_P(arguments);
+	zval *var_ptr;
 
 	SAVE_OPLINE();
-	if (param == NULL) {
-		ALLOC_ZVAL(assignment_value);
-		*assignment_value = *opline->op2.zv;
-		if (IS_CONSTANT_TYPE(Z_TYPE_P(assignment_value))) {
-			Z_SET_REFCOUNT_P(assignment_value, 1);
-			zval_update_constant(&assignment_value, 0 TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
+	if (UNEXPECTED(Z_REFCOUNTED_P(var_ptr))) Z_DELREF_P(var_ptr);
+	if (arg_num > arg_count) {
+		ZVAL_COPY_VALUE(var_ptr, opline->op2.zv);
+		if (Z_OPT_CONSTANT_P(var_ptr)) {
+			zval_update_constant(var_ptr, 0 TSRMLS_CC);
 		} else {
-			zval_copy_ctor(assignment_value);
+			/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
+			if (UNEXPECTED(Z_OPT_COPYABLE_P(var_ptr))) {
+				_zval_copy_ctor_func(var_ptr ZEND_FILE_LINE_CC);
+			}
 		}
-		INIT_PZVAL(assignment_value);
 	} else {
-		assignment_value = *param;
-		Z_ADDREF_P(assignment_value);
+		zval *param = arguments - arg_count + arg_num - 1;
+		ZVAL_COPY(var_ptr, param);
 	}
 
-	zend_verify_arg_type((zend_function *) EG(active_op_array), arg_num, assignment_value, opline->extended_value TSRMLS_CC);
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->result.var TSRMLS_CC);
-	zval_ptr_dtor(var_ptr);
-	*var_ptr = assignment_value;
+	if (UNEXPECTED((EX(op_array)->fn_flags & ZEND_ACC_HAS_TYPE_HINTS) != 0)) {
+		zend_verify_arg_type((zend_function *) EX(op_array), arg_num, var_ptr, opline->extended_value TSRMLS_CC);
+	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -1679,12 +1689,12 @@ static int ZEND_FASTCALL  ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	switch (brk_opline->opcode) {
 		case ZEND_SWITCH_FREE:
 			if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-				zval_ptr_dtor(&EX_T(brk_opline->op1.var).var.ptr);
+				zval_ptr_dtor(EX_VAR(brk_opline->op1.var));
 			}
 			break;
 		case ZEND_FREE:
 			if (!(brk_opline->extended_value & EXT_TYPE_FREE_ON_RETURN)) {
-				zendi_zval_dtor(EX_T(brk_opline->op1.var).tmp_var);
+				zval_dtor(EX_VAR(brk_opline->op1.var));
 			}
 			break;
 	}
@@ -1694,23 +1704,23 @@ static int ZEND_FASTCALL  ZEND_GOTO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_ADD_INTERFACE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_class_entry *ce = EX_T(opline->op1.var).class_entry;
+	zend_class_entry *ce = Z_CE_P(EX_VAR(opline->op1.var));
 	zend_class_entry *iface;
 
 	SAVE_OPLINE();
-	if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-		iface = CACHED_PTR(opline->op2.literal->cache_slot);
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		iface = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else {
-		iface = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
+		iface = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
 		if (UNEXPECTED(iface == NULL)) {
 			CHECK_EXCEPTION();
 			ZEND_VM_NEXT_OPCODE();
 		}
-		CACHE_PTR(opline->op2.literal->cache_slot, iface);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), iface);
 	}
 
 	if (UNEXPECTED((iface->ce_flags & ZEND_ACC_INTERFACE) == 0)) {
-		zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name, iface->name);
+		zend_error_noreturn(E_ERROR, "%s cannot implement %s - it is not an interface", ce->name->val, iface->name->val);
 	}
 	zend_do_implement_interface(ce, iface TSRMLS_CC);
 
@@ -1727,7 +1737,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 		zend_exception_save(TSRMLS_C);
 	}
 	if (IS_TMP_VAR == IS_UNUSED) {
-		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -1735,16 +1745,16 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *class_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		if (IS_TMP_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
+				Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 			} else {
-				EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-				CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
+				Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+				CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
 			}
 		} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-			EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
+			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
-			EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC);
 		} else {
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
@@ -1761,18 +1771,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *function_name;
+	zval *function_name_ptr, *function_name, *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
 	if (IS_TMP_VAR == IS_CONST) {
-		function_name = (zval*)(opline->op2.literal+1);
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
+		function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 
 		call->object = NULL;
@@ -1784,28 +1795,28 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
 		/*CHECK_EXCEPTION();*/
 		ZEND_VM_NEXT_OPCODE();
 	} else {
-		char *function_name_strval, *lcname;
-		int function_name_strlen;
+		zend_string *lcname;
 		zend_free_op free_op2;
 
 		SAVE_OPLINE();
-		function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		function_name_ptr = function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
+		ZVAL_DEREF(function_name);
 		if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
-			function_name_strval = Z_STRVAL_P(function_name);
-			function_name_strlen = Z_STRLEN_P(function_name);
-			if (function_name_strval[0] == '\\') {
-			    function_name_strlen -= 1;
-				lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
+			if (Z_STRVAL_P(function_name)[0] == '\\') {
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
 			} else {
-				lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
 			}
-			if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
+			if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
+				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
 			}
-			efree(lcname);
+			STR_FREE(lcname);
 			zval_dtor(free_op2.var);
 
+			call->fbc = Z_FUNC_P(func);
 			call->object = NULL;
 			call->called_scope = NULL;
 			call->num_additional_args = 0;
@@ -1819,12 +1830,12 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
 			if (call->object) {
-				Z_ADDREF_P(call->object);
+				GC_REFCOUNT(call->object)++;
 			}
 			if (IS_TMP_VAR == IS_VAR && 1 && Z_REFCOUNT_P(function_name) == 1 &&
 			    call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
-				call->fbc->common.prototype = (zend_function*)function_name;
+				call->fbc->common.prototype = (zend_function*)function_name_ptr;
 			} else {
 				zval_dtor(free_op2.var);
 			}
@@ -1838,67 +1849,56 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_TMP_HANDLER(ZEND_OPCODE_H
 		} else if (IS_TMP_VAR != IS_CONST &&
 				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
-			zend_class_entry *ce;
-			zval **method = NULL;
-			zval **obj = NULL;
+			zval *obj;
+			zval *method;
 
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
+			obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
+			method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
 
 			if (!obj || !method) {
 				zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
 			}
 
-			if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
+			if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
 				zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
 			}
 
-			if (Z_TYPE_PP(method) != IS_STRING) {
+			if (Z_TYPE_P(method) != IS_STRING) {
 				zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
 			}
 
-			if (Z_TYPE_PP(obj) == IS_STRING) {
-				ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
-				if (UNEXPECTED(ce == NULL)) {
+			if (Z_TYPE_P(obj) == IS_STRING) {
+				call->object = NULL;
+				call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
+				if (UNEXPECTED(call->called_scope == NULL)) {
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				call->called_scope = ce;
-				call->object = NULL;
 
-				if (ce->get_static_method) {
-					call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
+				if (call->called_scope->get_static_method) {
+					call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC);
 				} else {
-					call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+					call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC);
+				}
+				if (UNEXPECTED(call->fbc == NULL)) {
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method));
 				}
 			} else {
-				call->object = *obj;
-				ce = call->called_scope = Z_OBJCE_PP(obj);
+				call->called_scope = Z_OBJCE_P(obj);
+				call->object = Z_OBJ_P(obj);
 
-				call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+				call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
 				if (UNEXPECTED(call->fbc == NULL)) {
-					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
 				}
 
 				if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 					call->object = NULL;
 				} else {
-					if (!PZVAL_IS_REF(call->object)) {
-						Z_ADDREF_P(call->object); /* For $this pointer */
-					} else {
-						zval *this_ptr;
-						ALLOC_ZVAL(this_ptr);
-						INIT_PZVAL_COPY(this_ptr, call->object);
-						zval_copy_ctor(this_ptr);
-						call->object = this_ptr;
-					}
+					GC_REFCOUNT(call->object)++; /* For $this pointer */
 				}
 			}
 
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
-			}
-
 			call->num_additional_args = 0;
 			call->is_ctor_call = 0;
 			EX(call) = call;
@@ -1926,24 +1926,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 		zend_exception_save(TSRMLS_C);
 	}
 	if (IS_VAR == IS_UNUSED) {
-		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
 		zend_free_op free_op2;
-		zval *class_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zval *class_name = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
+				Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 			} else {
-				EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-				CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
+				Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+				CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
 			}
 		} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-			EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
+			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
-			EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC);
 		} else {
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
@@ -1951,7 +1951,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 			zend_error_noreturn(E_ERROR, "Class name must be a valid object or a string");
 		}
 
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -1960,18 +1960,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *function_name;
+	zval *function_name_ptr, *function_name, *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
 	if (IS_VAR == IS_CONST) {
-		function_name = (zval*)(opline->op2.literal+1);
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
+		function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 
 		call->object = NULL;
@@ -1983,28 +1984,28 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
 		/*CHECK_EXCEPTION();*/
 		ZEND_VM_NEXT_OPCODE();
 	} else {
-		char *function_name_strval, *lcname;
-		int function_name_strlen;
+		zend_string *lcname;
 		zend_free_op free_op2;
 
 		SAVE_OPLINE();
-		function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		function_name_ptr = function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
+		ZVAL_DEREF(function_name);
 		if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
-			function_name_strval = Z_STRVAL_P(function_name);
-			function_name_strlen = Z_STRLEN_P(function_name);
-			if (function_name_strval[0] == '\\') {
-			    function_name_strlen -= 1;
-				lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
+			if (Z_STRVAL_P(function_name)[0] == '\\') {
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
 			} else {
-				lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
 			}
-			if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
+			if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
+				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
 			}
-			efree(lcname);
-			zval_ptr_dtor_nogc(&free_op2.var);
+			STR_FREE(lcname);
+			zval_ptr_dtor_nogc(free_op2.var);
 
+			call->fbc = Z_FUNC_P(func);
 			call->object = NULL;
 			call->called_scope = NULL;
 			call->num_additional_args = 0;
@@ -2018,14 +2019,14 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
 			if (call->object) {
-				Z_ADDREF_P(call->object);
+				GC_REFCOUNT(call->object)++;
 			}
 			if (IS_VAR == IS_VAR && (free_op2.var != NULL) && Z_REFCOUNT_P(function_name) == 1 &&
 			    call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
-				call->fbc->common.prototype = (zend_function*)function_name;
+				call->fbc->common.prototype = (zend_function*)function_name_ptr;
 			} else {
-				zval_ptr_dtor_nogc(&free_op2.var);
+				zval_ptr_dtor_nogc(free_op2.var);
 			}
 
 			call->num_additional_args = 0;
@@ -2037,72 +2038,61 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_VAR_HANDLER(ZEND_OPCODE_H
 		} else if (IS_VAR != IS_CONST &&
 				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
-			zend_class_entry *ce;
-			zval **method = NULL;
-			zval **obj = NULL;
+			zval *obj;
+			zval *method;
 
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
+			obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
+			method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
 
 			if (!obj || !method) {
 				zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
 			}
 
-			if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
+			if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
 				zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
 			}
 
-			if (Z_TYPE_PP(method) != IS_STRING) {
+			if (Z_TYPE_P(method) != IS_STRING) {
 				zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
 			}
 
-			if (Z_TYPE_PP(obj) == IS_STRING) {
-				ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
-				if (UNEXPECTED(ce == NULL)) {
+			if (Z_TYPE_P(obj) == IS_STRING) {
+				call->object = NULL;
+				call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
+				if (UNEXPECTED(call->called_scope == NULL)) {
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				call->called_scope = ce;
-				call->object = NULL;
 
-				if (ce->get_static_method) {
-					call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
+				if (call->called_scope->get_static_method) {
+					call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC);
 				} else {
-					call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+					call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC);
+				}
+				if (UNEXPECTED(call->fbc == NULL)) {
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method));
 				}
 			} else {
-				call->object = *obj;
-				ce = call->called_scope = Z_OBJCE_PP(obj);
+				call->called_scope = Z_OBJCE_P(obj);
+				call->object = Z_OBJ_P(obj);
 
-				call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+				call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
 				if (UNEXPECTED(call->fbc == NULL)) {
-					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
 				}
 
 				if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 					call->object = NULL;
 				} else {
-					if (!PZVAL_IS_REF(call->object)) {
-						Z_ADDREF_P(call->object); /* For $this pointer */
-					} else {
-						zval *this_ptr;
-						ALLOC_ZVAL(this_ptr);
-						INIT_PZVAL_COPY(this_ptr, call->object);
-						zval_copy_ctor(this_ptr);
-						call->object = this_ptr;
-					}
+					GC_REFCOUNT(call->object)++; /* For $this pointer */
 				}
 			}
 
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
-			}
-
 			call->num_additional_args = 0;
 			call->is_ctor_call = 0;
 			EX(call) = call;
 
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 			CHECK_EXCEPTION();
 			ZEND_VM_NEXT_OPCODE();
 		} else {
@@ -2125,7 +2115,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 		zend_exception_save(TSRMLS_C);
 	}
 	if (IS_UNUSED == IS_UNUSED) {
-		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -2133,16 +2123,16 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 		zval *class_name = NULL;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
+				Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 			} else {
-				EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-				CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
+				Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+				CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
 			}
 		} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-			EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
+			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
-			EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC);
 		} else {
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
@@ -2164,24 +2154,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 		zend_exception_save(TSRMLS_C);
 	}
 	if (IS_CV == IS_UNUSED) {
-		EX_T(opline->result.var).class_entry = zend_fetch_class(NULL, 0, opline->extended_value TSRMLS_CC);
+		Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(NULL, opline->extended_value TSRMLS_CC);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
 
-		zval *class_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zval *class_name = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		if (IS_CV == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				EX_T(opline->result.var).class_entry = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(class_name))) {
+				Z_CE_P(EX_VAR(opline->result.var)) = CACHED_PTR(Z_CACHE_SLOT_P(class_name));
 			} else {
-				EX_T(opline->result.var).class_entry = zend_fetch_class_by_name(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->op2.literal + 1, opline->extended_value TSRMLS_CC);
-				CACHE_PTR(opline->op2.literal->cache_slot, EX_T(opline->result.var).class_entry);
+				Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class_by_name(Z_STR_P(class_name), opline->op2.zv + 1, opline->extended_value TSRMLS_CC);
+				CACHE_PTR(Z_CACHE_SLOT_P(class_name), Z_CE_P(EX_VAR(opline->result.var)));
 			}
 		} else if (Z_TYPE_P(class_name) == IS_OBJECT) {
-			EX_T(opline->result.var).class_entry = Z_OBJCE_P(class_name);
+			Z_CE_P(EX_VAR(opline->result.var)) = Z_OBJCE_P(class_name);
 		} else if (Z_TYPE_P(class_name) == IS_STRING) {
-			EX_T(opline->result.var).class_entry = zend_fetch_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), opline->extended_value TSRMLS_CC);
+			Z_CE_P(EX_VAR(opline->result.var)) = zend_fetch_class(Z_STR_P(class_name), opline->extended_value TSRMLS_CC);
 		} else {
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
@@ -2197,18 +2187,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_CLASS_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *function_name;
+	zval *function_name_ptr, *function_name, *func;
 	call_slot *call = EX(call_slots) + opline->result.num;
 
 	if (IS_CV == IS_CONST) {
-		function_name = (zval*)(opline->op2.literal+1);
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(function_name), Z_STRLEN_P(function_name)+1, Z_HASH_P(function_name), (void **) &call->fbc) == FAILURE)) {
+		function_name_ptr = function_name = (zval*)(opline->op2.zv+1);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(function_name))) == NULL)) {
 			SAVE_OPLINE();
 			zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(opline->op2.zv));
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
+			call->fbc = Z_FUNC_P(func);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), call->fbc);
 		}
 
 		call->object = NULL;
@@ -2220,27 +2211,27 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 		/*CHECK_EXCEPTION();*/
 		ZEND_VM_NEXT_OPCODE();
 	} else {
-		char *function_name_strval, *lcname;
-		int function_name_strlen;
+		zend_string *lcname;
 
 
 		SAVE_OPLINE();
-		function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		function_name_ptr = function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
+		ZVAL_DEREF(function_name);
 		if (EXPECTED(Z_TYPE_P(function_name) == IS_STRING)) {
-			function_name_strval = Z_STRVAL_P(function_name);
-			function_name_strlen = Z_STRLEN_P(function_name);
-			if (function_name_strval[0] == '\\') {
-			    function_name_strlen -= 1;
-				lcname = zend_str_tolower_dup(function_name_strval + 1, function_name_strlen);
+			if (Z_STRVAL_P(function_name)[0] == '\\') {
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name) - 1, 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name) + 1, Z_STRLEN_P(function_name) - 1);
 			} else {
-				lcname = zend_str_tolower_dup(function_name_strval, function_name_strlen);
+				lcname = STR_ALLOC(Z_STRLEN_P(function_name), 0);
+				zend_str_tolower_copy(lcname->val, Z_STRVAL_P(function_name), Z_STRLEN_P(function_name));
 			}
-			if (UNEXPECTED(zend_hash_find(EG(function_table), lcname, function_name_strlen+1, (void **) &call->fbc) == FAILURE)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", function_name_strval);
+			if (UNEXPECTED((func = zend_hash_find(EG(function_table), lcname)) == NULL)) {
+				zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(function_name));
 			}
-			efree(lcname);
+			STR_FREE(lcname);
 
+			call->fbc = Z_FUNC_P(func);
 			call->object = NULL;
 			call->called_scope = NULL;
 			call->num_additional_args = 0;
@@ -2254,12 +2245,12 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 			Z_OBJ_HANDLER_P(function_name, get_closure) &&
 			Z_OBJ_HANDLER_P(function_name, get_closure)(function_name, &call->called_scope, &call->fbc, &call->object TSRMLS_CC) == SUCCESS) {
 			if (call->object) {
-				Z_ADDREF_P(call->object);
+				GC_REFCOUNT(call->object)++;
 			}
 			if (IS_CV == IS_VAR && 0 && Z_REFCOUNT_P(function_name) == 1 &&
 			    call->fbc->common.fn_flags & ZEND_ACC_CLOSURE) {
 				/* Delay closure destruction until its invocation */
-				call->fbc->common.prototype = (zend_function*)function_name;
+				call->fbc->common.prototype = (zend_function*)function_name_ptr;
 			} else {
 
 			}
@@ -2273,67 +2264,56 @@ static int ZEND_FASTCALL  ZEND_INIT_FCALL_BY_NAME_SPEC_CV_HANDLER(ZEND_OPCODE_HA
 		} else if (IS_CV != IS_CONST &&
 				EXPECTED(Z_TYPE_P(function_name) == IS_ARRAY) &&
 				zend_hash_num_elements(Z_ARRVAL_P(function_name)) == 2) {
-			zend_class_entry *ce;
-			zval **method = NULL;
-			zval **obj = NULL;
+			zval *obj;
+			zval *method;
 
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 0, (void **) &obj);
-			zend_hash_index_find(Z_ARRVAL_P(function_name), 1, (void **) &method);
+			obj = zend_hash_index_find(Z_ARRVAL_P(function_name), 0);
+			method = zend_hash_index_find(Z_ARRVAL_P(function_name), 1);
 
 			if (!obj || !method) {
 				zend_error_noreturn(E_ERROR, "Array callback has to contain indices 0 and 1");
 			}
 
-			if (Z_TYPE_PP(obj) != IS_STRING && Z_TYPE_PP(obj) != IS_OBJECT) {
+			if (Z_TYPE_P(obj) != IS_STRING && Z_TYPE_P(obj) != IS_OBJECT) {
 				zend_error_noreturn(E_ERROR, "First array member is not a valid class name or object");
 			}
 
-			if (Z_TYPE_PP(method) != IS_STRING) {
+			if (Z_TYPE_P(method) != IS_STRING) {
 				zend_error_noreturn(E_ERROR, "Second array member is not a valid method");
 			}
 
-			if (Z_TYPE_PP(obj) == IS_STRING) {
-				ce = zend_fetch_class_by_name(Z_STRVAL_PP(obj), Z_STRLEN_PP(obj), NULL, 0 TSRMLS_CC);
-				if (UNEXPECTED(ce == NULL)) {
+			if (Z_TYPE_P(obj) == IS_STRING) {
+				call->object = NULL;
+				call->called_scope = zend_fetch_class_by_name(Z_STR_P(obj), NULL, 0 TSRMLS_CC);
+				if (UNEXPECTED(call->called_scope == NULL)) {
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				call->called_scope = ce;
-				call->object = NULL;
 
-				if (ce->get_static_method) {
-					call->fbc = ce->get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method) TSRMLS_CC);
+				if (call->called_scope->get_static_method) {
+					call->fbc = call->called_scope->get_static_method(call->called_scope, Z_STR_P(method) TSRMLS_CC);
 				} else {
-					call->fbc = zend_std_get_static_method(ce, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+					call->fbc = zend_std_get_static_method(call->called_scope, Z_STR_P(method), NULL TSRMLS_CC);
+				}
+				if (UNEXPECTED(call->fbc == NULL)) {
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", call->called_scope->name->val, Z_STRVAL_P(method));
 				}
 			} else {
-				call->object = *obj;
-				ce = call->called_scope = Z_OBJCE_PP(obj);
+				call->called_scope = Z_OBJCE_P(obj);
+				call->object = Z_OBJ_P(obj);
 
-				call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, Z_STRVAL_PP(method), Z_STRLEN_PP(method), NULL TSRMLS_CC);
+				call->fbc = Z_OBJ_HT_P(obj)->get_method(&call->object, Z_STR_P(method), NULL TSRMLS_CC);
 				if (UNEXPECTED(call->fbc == NULL)) {
-					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_PP(method));
+					zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(method));
 				}
 
 				if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 					call->object = NULL;
 				} else {
-					if (!PZVAL_IS_REF(call->object)) {
-						Z_ADDREF_P(call->object); /* For $this pointer */
-					} else {
-						zval *this_ptr;
-						ALLOC_ZVAL(this_ptr);
-						INIT_PZVAL_COPY(this_ptr, call->object);
-						zval_copy_ctor(this_ptr);
-						call->object = this_ptr;
-					}
+					GC_REFCOUNT(call->object)++; /* For $this pointer */
 				}
 			}
 
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, Z_STRVAL_PP(method));
-			}
-
 			call->num_additional_args = 0;
 			call->is_ctor_call = 0;
 			EX(call) = call;
@@ -2357,7 +2337,7 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	bitwise_not_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_not_function(EX_VAR(opline->result.var),
 		opline->op1.zv TSRMLS_CC);
 
 	CHECK_EXCEPTION();
@@ -2370,7 +2350,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 
 	SAVE_OPLINE();
-	boolean_not_function(&EX_T(opline->result.var).tmp_var,
+	boolean_not_function(EX_VAR(opline->result.var),
 		opline->op1.zv TSRMLS_CC);
 
 	CHECK_EXCEPTION();
@@ -2386,10 +2366,7 @@ static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	z = opline->op1.zv;
 
-	if (IS_CONST == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
-		INIT_PZVAL(z);
-	}
-	zend_print_variable(z);
+	zend_print_variable(z TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -2399,7 +2376,7 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 
-	ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
+	ZVAL_LONG(EX_VAR(opline->result.var), 1);
 	return ZEND_ECHO_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
@@ -2516,8 +2493,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -2547,8 +2523,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -2564,15 +2539,17 @@ static int ZEND_FASTCALL  ZEND_DO_FCALL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 	USE_OPLINE
 
 	zval *fname = opline->op1.zv;
+	zval *func;
 	call_slot *call = EX(call_slots) + opline->op2.num;
 
-	if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-		EX(function_state).function = CACHED_PTR(opline->op1.literal->cache_slot);
-	} else if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(fname), Z_STRLEN_P(fname)+1, Z_HASH_P(fname), (void **) &EX(function_state).function)==FAILURE)) {
+	if (CACHED_PTR(Z_CACHE_SLOT_P(fname))) {
+		EX(function_state).function = CACHED_PTR(Z_CACHE_SLOT_P(fname));
+	} else if (UNEXPECTED((func = zend_hash_find(EG(function_table), Z_STR_P(fname))) == NULL)) {
 	    SAVE_OPLINE();
-		zend_error_noreturn(E_ERROR, "Call to undefined function %s()", fname->value.str.val);
+		zend_error_noreturn(E_ERROR, "Call to undefined function %s()", Z_STRVAL_P(fname));
 	} else {
-		CACHE_PTR(opline->op1.literal->cache_slot, EX(function_state).function);
+		EX(function_state).function = Z_FUNC_P(func);
+		CACHE_PTR(Z_CACHE_SLOT_P(fname), EX(function_state).function);
 	}
 
 	call->fbc = EX(function_state).function;
@@ -2594,34 +2571,21 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	SAVE_OPLINE();
 	retval_ptr = opline->op1.zv;
 
-	if (!EG(return_value_ptr_ptr)) {
+	if (!EX(return_value)) {
 
 	} else {
-		if (IS_CONST == IS_CONST ||
-		    IS_CONST == IS_TMP_VAR ||
-		    PZVAL_IS_REF(retval_ptr)) {
-			zval *ret;
-
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, retval_ptr);
+		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_CONST != IS_TMP_VAR) {
-				zval_copy_ctor(ret);
+				zval_opt_copy_ctor(EX(return_value));
 			}
-			*EG(return_value_ptr_ptr) = ret;
-
-		} else if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
-		           retval_ptr == &EG(uninitialized_zval)) {
-			zval *ret;
+		} else if (Z_ISREF_P(retval_ptr)) {
+			ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
 
-			if (IS_CONST == IS_VAR) {
-				Z_DELREF_P(retval_ptr);
-			}
-			ALLOC_INIT_ZVAL(ret);
-			*EG(return_value_ptr_ptr) = ret;
 		} else {
-			*EG(return_value_ptr_ptr) = retval_ptr;
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_CONST == IS_CV) {
-				Z_ADDREF_P(retval_ptr);
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
 			}
 		}
 	}
@@ -2632,7 +2596,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zval *retval_ptr;
-	zval **retval_ptr_ptr;
 
 
 	SAVE_OPLINE();
@@ -2644,55 +2607,41 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
 			retval_ptr = opline->op1.zv;
-			if (!EG(return_value_ptr_ptr)) {
+			if (!EX(return_value)) {
 				if (IS_CONST == IS_TMP_VAR) {
 
 				}
 			} else if (!0) { /* Not a temp var */
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				zval_copy_ctor(ret);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_DUP(EX(return_value), retval_ptr);
 			} else {
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			}
 			break;
 		}
 
-		retval_ptr_ptr = NULL;
+		retval_ptr = NULL;
 
-		if (IS_CONST == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
 		}
 
-		if (IS_CONST == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
+		if (IS_CONST == IS_VAR && !Z_ISREF_P(retval_ptr)) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-			    EX_T(opline->op1.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+			    (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+			} else {
 				zend_error(E_NOTICE, "Only variable references should be returned by reference");
-				if (EG(return_value_ptr_ptr)) {
-					zval *ret;
-
-					ALLOC_ZVAL(ret);
-					INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
-					zval_copy_ctor(ret);
-					*EG(return_value_ptr_ptr) = ret;
+				if (EX(return_value)) {
+					zval tmp;
+					ZVAL_DUP(&tmp, retval_ptr);
+					ZVAL_NEW_REF(EX(return_value), &tmp);
 				}
 				break;
 			}
 		}
 
-		if (EG(return_value_ptr_ptr)) {
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
-			Z_ADDREF_PP(retval_ptr_ptr);
-
-			*EG(return_value_ptr_ptr) = *retval_ptr_ptr;
+		if (EX(return_value)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
+			ZVAL_COPY(EX(return_value), retval_ptr);
 		}
 	} while (0);
 
@@ -2703,7 +2652,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zval *value;
-	zval *exception;
+	zval exception;
 
 
 	SAVE_OPLINE();
@@ -2717,14 +2666,14 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	}
 
 	zend_exception_save(TSRMLS_C);
-	/* Not sure if a complete copy is what we want here */
-	ALLOC_ZVAL(exception);
-	INIT_PZVAL_COPY(exception, value);
-	if (!0) {
-		zval_copy_ctor(exception);
+	if (IS_CONST == IS_CONST) {
+		ZVAL_DUP(&exception, value);
+		value = &exception;
+	} else if (IS_CONST != IS_TMP_VAR) {
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 	}
 
-	zend_throw_exception_object(exception TSRMLS_CC);
+	zend_throw_exception_object(value TSRMLS_CC);
 	zend_exception_restore(TSRMLS_C);
 
 	HANDLE_EXCEPTION();
@@ -2733,6 +2682,8 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *value, *top;
+
 
 	SAVE_OPLINE();
 	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
@@ -2741,22 +2692,12 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 		}
 	}
 
-	{
-		zval *valptr;
-		zval *value;
-
-
-		value = opline->op1.zv;
-
-		ALLOC_ZVAL(valptr);
-		INIT_PZVAL_COPY(valptr, value);
-		if (!0) {
-			zval_copy_ctor(valptr);
-		}
-		zend_vm_stack_push(valptr TSRMLS_CC);
-
+	value = opline->op1.zv;
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	ZVAL_COPY_VALUE(top, value);
+	if (IS_CONST == IS_CONST) {
+		zval_opt_copy_ctor(top);
 	}
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -2764,7 +2705,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval *retval = &EX_T(opline->result.var).tmp_var;
+	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
@@ -2799,7 +2740,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (UNEXPECTED(clone_call == NULL)) {
 		if (ce) {
-			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
+			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
 		} else {
 			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
 		}
@@ -2810,29 +2751,21 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(ce != EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (EXPECTED(EG(exception) == NULL)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
-		Z_TYPE_P(retval) = IS_OBJECT;
-		Z_SET_REFCOUNT_P(retval, 1);
-		Z_SET_ISREF_P(retval);
+		ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC));
 		if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&retval);
-		} else {
-			EX_T(opline->result.var).var.ptr = retval;
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -2844,18 +2777,34 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval *expr;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *expr, *expr_ptr;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	expr = opline->op1.zv;
+	expr = expr_ptr = opline->op1.zv;
+	if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
+		ZVAL_DEREF(expr);
+	}
+	if (Z_TYPE_P(expr) == opline->extended_value) {
+		ZVAL_COPY_VALUE(result, expr);
+		if (IS_CONST == IS_CONST || expr != expr_ptr) {
+			zval_opt_copy_ctor(result);
+
+		} else if (IS_CONST == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	}
 
 	if (opline->extended_value != IS_STRING) {
 		ZVAL_COPY_VALUE(result, expr);
 		if (!0) {
-			zendi_zval_copy_ctor(*result);
+			zval_opt_copy_ctor(result);
 		}
 	}
+
 	switch (opline->extended_value) {
 		case IS_NULL:
 			convert_to_null(result);
@@ -2882,7 +2831,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			} else {
 				ZVAL_COPY_VALUE(result, expr);
 				if (!0) {
-					zendi_zval_copy_ctor(*result);
+					zval_opt_copy_ctor(result);
 				}
 			}
 			break;
@@ -2905,18 +2854,17 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 	zend_op_array *new_op_array=NULL;
 
 	zval *inc_filename;
-	zval *tmp_inc_filename = NULL;
+	zval tmp_inc_filename;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
 	inc_filename = opline->op1.zv;
 
-	if (inc_filename->type!=IS_STRING) {
-		MAKE_STD_ZVAL(tmp_inc_filename);
-		ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
-		zval_copy_ctor(tmp_inc_filename);
-		convert_to_string(tmp_inc_filename);
-		inc_filename = tmp_inc_filename;
+	ZVAL_UNDEF(&tmp_inc_filename);
+	if (Z_TYPE_P(inc_filename) != IS_STRING) {
+		ZVAL_DUP(&tmp_inc_filename, inc_filename);
+		convert_to_string(&tmp_inc_filename);
+		inc_filename = &tmp_inc_filename;
 	}
 
 	if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
@@ -2934,7 +2882,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 
 					resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
 					if (resolved_path) {
-						failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
+						failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path));
 					} else {
 						resolved_path = Z_STRVAL_P(inc_filename);
 					}
@@ -2947,7 +2895,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 							file_handle.opened_path = estrdup(resolved_path);
 						}
 
-						if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
+						if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) {
 							new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
 							zend_destroy_file_handle(&file_handle TSRMLS_CC);
 						} else {
@@ -2980,40 +2928,37 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 			EMPTY_SWITCH_DEFAULT_CASE()
 		}
 	}
-	if (tmp_inc_filename) {
+	if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
 		zval_ptr_dtor(&tmp_inc_filename);
 	}
 
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		HANDLE_EXCEPTION();
 	} else if (EXPECTED(new_op_array != NULL)) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
 		EG(active_op_array) = new_op_array;
 		if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-			EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
-		} else {
-			EG(return_value_ptr_ptr) = NULL;
+			return_value = EX_VAR(opline->result.var);
 		}
 
 		EX(function_state).function = (zend_function *) new_op_array;
-		EX(object) = NULL;
 
 		if (!EG(active_symbol_table)) {
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+		    i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC);
 			ZEND_VM_ENTER();
 		} else {
-			zend_execute(new_op_array TSRMLS_CC);
+			zend_execute(new_op_array, return_value TSRMLS_CC);
 		}
 
 		EX(function_state).function = (zend_function *) EX(op_array);
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
 		destroy_op_array(new_op_array TSRMLS_CC);
 		efree(new_op_array);
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -3022,12 +2967,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CONST_HANDLER(ZEND_OPCODE_HA
 		}
 
 	} else if (RETURN_VALUE_USED(opline)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		ZVAL_BOOL(retval, failure_retval);
-		INIT_PZVAL(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -3036,7 +2976,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 
-	zval *array_ptr, **array_ptr_ptr;
+	zval *array_ptr, *array_ref, iterator;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
 	zend_class_entry *ce = NULL;
@@ -3046,71 +2986,79 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 	if ((IS_CONST == IS_CV || IS_CONST == IS_VAR) &&
 	    (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
-		array_ptr_ptr = NULL;
-		if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
-			MAKE_STD_ZVAL(array_ptr);
-			ZVAL_NULL(array_ptr);
-		} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
-			if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
+		array_ptr = array_ref = NULL;
+		ZVAL_DEREF(array_ptr);
+		if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
+			if (!Z_ISREF_P(array_ref)) {
+				SEPARATE_ZVAL(array_ptr);
+				array_ref = array_ptr;
+				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
+					ZVAL_NEW_REF(array_ptr, array_ptr);
+					array_ref = array_ptr;
+					array_ptr = Z_REFVAL_P(array_ptr);
+				}
+			}
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
+		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
+			if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) {
 				zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
 
-			ce = Z_OBJCE_PP(array_ptr_ptr);
+			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || ce->get_iterator == NULL) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				Z_ADDREF_PP(array_ptr_ptr);
-			}
-			array_ptr = *array_ptr_ptr;
-		} else {
-			if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-					Z_SET_ISREF_PP(array_ptr_ptr);
+				if (!Z_ISREF_P(array_ref)) {
+					SEPARATE_ZVAL(array_ptr);
 				}
+				Z_ADDREF_P(array_ptr);
 			}
-			array_ptr = *array_ptr_ptr;
-			Z_ADDREF_P(array_ptr);
+			array_ref = array_ptr;
+		} else {
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
 		}
 	} else {
-		array_ptr = opline->op1.zv;
+		array_ptr = array_ref = opline->op1.zv;
+		ZVAL_DEREF(array_ptr);
 		if (0) { /* IS_TMP_VAR */
-			zval *tmp;
+			zval tmp;
 
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			array_ptr = tmp;
+			ZVAL_COPY_VALUE(&tmp, array_ptr);
+			array_ptr = &tmp;
 			if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 				ce = Z_OBJCE_P(array_ptr);
 				if (ce && ce->get_iterator) {
-					Z_DELREF_P(array_ptr);
+					Z_DELREF_P(array_ref);
 				}
 			}
 		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || !ce->get_iterator) {
 				if (IS_CONST == IS_CV) {
-					Z_ADDREF_P(array_ptr);
+					Z_ADDREF_P(array_ref);
 				}
 			}
-		} else if (IS_CONST == IS_CONST ||
-		           (IS_CONST == IS_CV &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 1) ||
-		           (IS_CONST == IS_VAR &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 2)) {
-			zval *tmp;
+		} else if (Z_REFCOUNTED_P(array_ref)) {
+			if (IS_CONST == IS_CONST ||
+			           (IS_CONST == IS_CV &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 1) ||
+			           (IS_CONST == IS_VAR &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 2)) {
+				zval tmp;
 
-			if (IS_CONST == IS_VAR) {
-				Z_DELREF_P(array_ptr);
+				if (IS_CONST == IS_VAR) {
+					Z_DELREF_P(array_ref);
+				}
+				ZVAL_DUP(&tmp, array_ref);
+				array_ptr = array_ref = &tmp;
+			} else if (IS_CONST == IS_CV) {
+				if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) {
+					ZVAL_UNREF(array_ref);
+					array_ptr = array_ref;
+				}
+				Z_ADDREF_P(array_ref);
 			}
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			zval_copy_ctor(tmp);
-			array_ptr = tmp;
-		} else if (IS_CONST == IS_CV) {
-			Z_ADDREF_P(array_ptr);
 		}
 	}
 
@@ -3121,27 +3069,28 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 		}
 		if (iter && EXPECTED(EG(exception) == NULL)) {
-			array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
+			ZVAL_OBJ(&iterator, &iter->std);
+			array_ptr = array_ref = &iterator;
 		} else {
 			if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 			}
 			if (!EG(exception)) {
-				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
+				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val);
 			}
 			zend_throw_exception_internal(NULL TSRMLS_CC);
 			HANDLE_EXCEPTION();
 		}
 	}
 
-	EX_T(opline->result.var).fe.ptr = array_ptr;
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
 
 	if (iter) {
 		iter->index = 0;
 		if (iter->funcs->rewind) {
 			iter->funcs->rewind(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array_ptr);
+				zval_ptr_dtor(array_ref);
 				if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 				}
@@ -3150,7 +3099,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 		}
 		is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&array_ptr);
+			zval_ptr_dtor(array_ref);
 			if (IS_CONST == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 			}
@@ -3160,24 +3109,23 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 	} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
 		zend_hash_internal_pointer_reset(fe_ht);
 		if (ce) {
-			zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array_ptr);
 			while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
-				char *str_key;
-				uint str_key_len;
+				zend_string *str_key;
 				ulong int_key;
 				zend_uchar key_type;
 
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 				if (key_type != HASH_KEY_NON_EXISTENT &&
 					(key_type == HASH_KEY_IS_LONG ||
-				     zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
+				     zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) {
 					break;
 				}
 				zend_hash_move_forward(fe_ht);
 			}
 		}
 		is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
-		zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
+		zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var));
 	} else {
 		zend_error(E_WARNING, "Invalid argument supplied for foreach()");
 		is_empty = 1;
@@ -3207,7 +3155,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 		if (Z_TYPE_P(ptr) == IS_LONG) {
 			EG(exit_status) = Z_LVAL_P(ptr);
 		} else {
-			zend_print_variable(ptr);
+			zend_print_variable(ptr TSRMLS_CC);
 		}
 
 	}
@@ -3226,9 +3174,9 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	value = opline->op1.zv;
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
-		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!0) {
-			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 
 #if DEBUG_ZEND>=2
@@ -3245,23 +3193,18 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = opline->op1.zv;
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
 		if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-			Z_ADDREF_P(value);
-			EX_T(opline->result.var).var.ptr = value;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-		} else {
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, value);
-			EX_T(opline->result.var).var.ptr = ret;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
+		} else {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 			if (!0) {
-				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+				zval_opt_copy_ctor(EX_VAR(opline->result.var));
 			}
 		}
 
@@ -3284,9 +3227,9 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 	SAVE_OPLINE();
 	value = opline->op1.zv;
 
-	ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 	if (!0) {
-		zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+		zval_opt_copy_ctor(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -3297,22 +3240,17 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = opline->op1.zv;
 
 	if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		Z_ADDREF_P(value);
-		EX_T(opline->result.var).var.ptr = value;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	} else {
-		ALLOC_ZVAL(ret);
-		INIT_PZVAL_COPY(ret, value);
-		EX_T(opline->result.var).var.ptr = ret;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
+	} else {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!0) {
-			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -3326,7 +3264,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3341,7 +3279,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3356,7 +3294,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3371,7 +3309,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3386,7 +3324,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3401,7 +3339,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3416,7 +3354,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3431,7 +3369,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3446,7 +3384,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3459,7 +3397,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
@@ -3476,7 +3414,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -3492,7 +3430,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -3508,7 +3446,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -3524,7 +3462,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -3542,7 +3480,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3557,7 +3495,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3572,7 +3510,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDL
 
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3587,7 +3525,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -3599,21 +3537,18 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1;
+
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = opline->op1.zv;
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -3622,105 +3557,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+					if (IS_CONST != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_CONST == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_CONST != IS_TMP_VAR) {
-
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
-			case ZEND_FETCH_LOCAL:
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
 
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_CONST == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-				}
-				break;
 		}
 	}
 
-
-	if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+	if (IS_CONST != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -3745,7 +3663,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_CONST_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_CONST_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -3766,7 +3688,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_
 
 	SAVE_OPLINE();
 	container = opline->op1.zv;
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
@@ -3785,14 +3707,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 	container = opline->op1.zv;
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 
-		zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+		zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
-		PZVAL_LOCK(value);
-		EX_T(opline->result.var).var.ptr = value;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
 
 	}
 	CHECK_EXCEPTION();
@@ -3810,21 +3730,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 
 	if (IS_CONST == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -3835,51 +3755,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 
 	if (IS_CONST == IS_CONST &&
 	    IS_CONST == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_CONST != IS_CONST &&
 	           IS_CONST == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_CONST != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
-
 
-		if (IS_CONST == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = opline->op2.zv;
 
+		function_name = opline->op2.zv;
+		if (IS_CONST != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_CONST == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_CONST == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_CONST == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_CONST == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_CONST != IS_CONST) {
@@ -3889,8 +3798,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -3898,21 +3807,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CONST_HANDLER(
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -3928,11 +3837,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 opline->op1.zv,
-				 opline->op2.zv TSRMLS_CC);
+				 opline->op2.zv TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -3947,9 +3857,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
 		zend_constant *c;
 		zval *retval;
 
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			c = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
 			if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
 				char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
 				if(!actual) {
@@ -3959,52 +3869,52 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
 				}
 				/* non-qualified constant - allow text substitution */
 				zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
-				ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
+				ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)));
 				CHECK_EXCEPTION();
 				ZEND_VM_NEXT_OPCODE();
 			} else {
 				zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
 			}
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, c);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
 		}
-		retval = &EX_T(opline->result.var).tmp_var;
-		ZVAL_COPY_VALUE(retval, &c->value);
-		zval_copy_ctor(retval);
+		retval = EX_VAR(opline->result.var);
+		ZVAL_DUP(retval, &c->value);
 	} else {
 		/* class constant */
 		zend_class_entry *ce;
-		zval **value;
+		zval *value;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				value = CACHED_PTR(opline->op2.literal->cache_slot);
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
-			} else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op1.literal->cache_slot);
+			} else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 				}
-				CACHE_PTR(opline->op1.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op1.var).class_entry;
-			if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ce = Z_CE_P(EX_VAR(opline->op1.var));
+			if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
 			}
 		}
 
-		if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
-			if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
+		if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
+			if (Z_ISREF_P(value)) {
+				value = Z_REFVAL_P(value);
+			}
+			if (Z_CONSTANT_P(value)) {
 				zend_class_entry *old_scope = EG(scope);
 
 				EG(scope) = ce;
@@ -4012,23 +3922,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_CONST_CONST_HANDLER(ZEND_OPCO
 				EG(scope) = old_scope;
 			}
 			if (IS_CONST == IS_CONST) {
-				CACHE_PTR(opline->op2.literal->cache_slot, value);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
 			} else {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
 			}
-			ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-			zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ZVAL_DUP(EX_VAR(opline->result.var), value);
 		} else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
 			/* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
-			ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
+			ZVAL_STR(EX_VAR(opline->result.var), ce->name);
+			STR_ADDREF(ce->name);
 		} else {
 			zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
 		}
 	}
 constant_fetch_end:
-	if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) {
-		zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time");
-	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -4037,35 +3944,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=opline->op1.zv;
+		expr_ptr = opline->op1.zv;
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CONST == IS_CV) {
+		} else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -4073,8 +3976,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O
 	if (IS_CONST != IS_UNUSED) {
 
 		zval *offset = opline->op2.zv;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -4083,32 +3988,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -4116,9 +4021,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CONST != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CONST != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CONST == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CONST != IS_UNUSED
@@ -4134,20 +4056,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_CONST == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -4155,27 +4072,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
 	varname = opline->op1.zv;
 
 	if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_CONST != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_CONST != IS_CONST && varname == &tmp) {
+					if (IS_CONST != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 
 					HANDLE_EXCEPTION();
@@ -4183,23 +4101,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_CONST != IS_CONST && varname == &tmp) {
+	if (IS_CONST != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 
 	CHECK_EXCEPTION();
@@ -4209,21 +4125,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_CONST == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -4233,8 +4144,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 		zval tmp, *varname = opline->op1.zv;
 
 		if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -4243,26 +4153,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 			zend_class_entry *ce;
 
 			if (IS_CONST == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -4274,16 +4184,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_CONST_HANDLER(ZEND_O
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -4303,21 +4213,20 @@ static int ZEND_FASTCALL  ZEND_DECLARE_CONST_SPEC_CONST_CONST_HANDLER(ZEND_OPCOD
 	name  = opline->op1.zv;
 	val   = opline->op2.zv;
 
-	if (IS_CONSTANT_TYPE(Z_TYPE_P(val))) {
-		zval tmp;
-		zval *tmp_ptr = &tmp;
-
-		ZVAL_COPY_VALUE(&tmp, val);
-		INIT_PZVAL(&tmp);
-		zval_update_constant(&tmp_ptr, 0 TSRMLS_CC);
-		c.value = *tmp_ptr;
+	ZVAL_COPY_VALUE(&c.value, val);
+	if (Z_OPT_CONSTANT(c.value)) {
+		if (Z_TYPE_P(val) == IS_CONSTANT_ARRAY) {
+			zval_opt_copy_ctor(&c.value);
+		}
+		zval_update_constant(&c.value, 0 TSRMLS_CC);
 	} else {
-		INIT_PZVAL_COPY(&c.value, val);
-		zval_copy_ctor(&c.value);
+		/* IS_CONST can't be IS_OBJECT, IS_RESOURCE or IS_REFERENCE */
+		if (UNEXPECTED(Z_OPT_COPYABLE(c.value))) {
+			_zval_copy_ctor_func(&c.value ZEND_FILE_LINE_CC);
+		}
 	}
 	c.flags = CONST_CS; /* non persistent, case sensetive */
-	c.name = str_strndup(Z_STRVAL_P(name), Z_STRLEN_P(name));
-	c.name_len = Z_STRLEN_P(name)+1;
+	c.name = STR_DUP(Z_STR_P(name), 0);
 	c.module_number = PHP_USER_CONSTANT;
 
 	if (zend_register_constant(&c TSRMLS_CC) == FAILURE) {
@@ -4332,22 +4241,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CONST != IS_UNUSED) {
@@ -4357,74 +4262,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = opline->op1.zv;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = opline->op1.zv;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CONST == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CONST == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CONST == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -4433,45 +4322,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLE
 		zval *key = opline->op2.zv;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CONST == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CONST == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -4493,7 +4373,7 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		opline->op2.zv TSRMLS_CC);
 
@@ -4508,7 +4388,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4523,7 +4403,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4538,7 +4418,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4553,7 +4433,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4568,7 +4448,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4583,7 +4463,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4598,7 +4478,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4613,7 +4493,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4628,7 +4508,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4641,7 +4521,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
@@ -4658,7 +4538,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -4674,7 +4554,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -4690,7 +4570,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -4706,7 +4586,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_O
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -4724,7 +4604,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4739,7 +4619,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4754,7 +4634,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4769,7 +4649,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4786,7 +4666,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HA
 
 	SAVE_OPLINE();
 	container = opline->op1.zv;
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
@@ -4806,21 +4686,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
 
 	if (IS_CONST == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -4831,51 +4711,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
 
 	if (IS_CONST == IS_CONST &&
 	    IS_TMP_VAR == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_CONST != IS_CONST &&
 	           IS_TMP_VAR == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_TMP_VAR != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 		zend_free_op free_op2;
 
-		if (IS_TMP_VAR == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
+		function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		if (IS_TMP_VAR != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_TMP_VAR == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_CONST == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_TMP_VAR == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_CONST == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_TMP_VAR != IS_CONST) {
@@ -4885,8 +4754,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -4894,21 +4763,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_TMP_HANDLER(ZE
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -4924,11 +4793,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 	zend_free_op free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 opline->op1.zv,
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -4939,35 +4809,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=opline->op1.zv;
+		expr_ptr = opline->op1.zv;
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CONST == IS_CV) {
+		} else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -4975,8 +4841,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC
 	if (IS_TMP_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -4985,32 +4853,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 		zval_dtor(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5018,9 +4886,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CONST != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CONST != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CONST == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CONST != IS_UNUSED
@@ -5034,22 +4919,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CONST != IS_UNUSED) {
@@ -5059,74 +4940,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = opline->op1.zv;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = opline->op1.zv;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CONST == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CONST == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CONST == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -5135,45 +5000,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!1) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_TMP_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_TMP_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -5195,7 +5051,7 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -5210,11 +5066,11 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5225,11 +5081,11 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5240,11 +5096,11 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5255,11 +5111,11 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5270,11 +5126,11 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5285,11 +5141,11 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5300,11 +5156,11 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5315,11 +5171,11 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5330,11 +5186,11 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5343,15 +5199,15 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5360,14 +5216,14 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5376,14 +5232,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5392,14 +5248,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5408,14 +5264,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_O
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		opline->op1.zv,
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5426,11 +5282,11 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5441,11 +5297,11 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5456,11 +5312,11 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5471,11 +5327,11 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5483,21 +5339,18 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1;
+
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = opline->op1.zv;
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -5506,105 +5359,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+					if (IS_CONST != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_CONST == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_CONST != IS_TMP_VAR) {
-
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
-			case ZEND_FETCH_LOCAL:
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
 
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_CONST == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-				}
-				break;
 		}
 	}
 
-
-	if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+	if (IS_CONST != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5629,7 +5465,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_CONST_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_CONST_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -5650,8 +5490,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HA
 
 	SAVE_OPLINE();
 	container = opline->op1.zv;
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
 	}
@@ -5670,21 +5510,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
 
 	if (IS_CONST == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -5695,62 +5535,51 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
 
 	if (IS_CONST == IS_CONST &&
 	    IS_VAR == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_CONST != IS_CONST &&
 	           IS_VAR == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_VAR != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 		zend_free_op free_op2;
 
-		if (IS_VAR == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
+		function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		if (IS_VAR != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_VAR == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_CONST == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_VAR == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_CONST == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_VAR != IS_CONST) {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 		}
 	} else {
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -5758,21 +5587,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_VAR_HANDLER(ZE
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -5788,13 +5617,14 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 	zend_free_op free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 opline->op1.zv,
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -5803,35 +5633,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=opline->op1.zv;
+		expr_ptr = opline->op1.zv;
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CONST == IS_CV) {
+		} else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -5839,8 +5665,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 	if (IS_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -5849,32 +5677,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -5882,9 +5710,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CONST != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CONST != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CONST == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CONST != IS_UNUSED
@@ -5900,20 +5745,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_CONST == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -5921,27 +5761,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
 	varname = opline->op1.zv;
 
 	if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_VAR != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_CONST != IS_CONST && varname == &tmp) {
+					if (IS_CONST != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 
 					HANDLE_EXCEPTION();
@@ -5949,23 +5790,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_CONST != IS_CONST && varname == &tmp) {
+	if (IS_CONST != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 
 	CHECK_EXCEPTION();
@@ -5975,21 +5814,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_CONST == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -5999,8 +5833,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 		zval tmp, *varname = opline->op1.zv;
 
 		if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -6009,26 +5842,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 			zend_class_entry *ce;
 
 			if (IS_VAR == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -6040,16 +5873,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPC
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -6061,22 +5894,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CONST != IS_UNUSED) {
@@ -6086,74 +5915,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = opline->op1.zv;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = opline->op1.zv;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CONST == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CONST == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CONST == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -6162,46 +5975,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
-
-			generator->key = copy;
+		if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+			zval_ptr_dtor_nogc(free_op2.var);
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -6223,11 +6026,11 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -6235,21 +6038,18 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1;
+
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = opline->op1.zv;
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_CONST != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -6258,105 +6058,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+					if (IS_CONST != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_CONST == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_CONST != IS_TMP_VAR) {
-
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
-			case ZEND_FETCH_LOCAL:
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
 
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_CONST == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-				}
-				break;
 		}
 	}
 
-
-	if (IS_CONST != IS_CONST && varname == &tmp_varname) {
+	if (IS_CONST != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -6381,7 +6164,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CONST_UNUSED_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_CONST_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -6405,21 +6192,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 
 	if (IS_CONST == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -6430,51 +6217,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 
 	if (IS_CONST == IS_CONST &&
 	    IS_UNUSED == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_CONST != IS_CONST &&
 	           IS_UNUSED == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_UNUSED != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 
 
-		if (IS_UNUSED == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = NULL;
-
+		function_name = NULL;
+		if (IS_UNUSED != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_UNUSED == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_CONST == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_UNUSED == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_CONST == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_UNUSED != IS_CONST) {
@@ -6484,8 +6260,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -6493,21 +6269,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_UNUSED_HANDLER
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -6523,35 +6299,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=opline->op1.zv;
+		expr_ptr = opline->op1.zv;
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CONST == IS_CV) {
+		} else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -6559,8 +6331,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_
 	if (IS_UNUSED != IS_UNUSED) {
 
 		zval *offset = NULL;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -6569,32 +6343,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_UNUSED == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_UNUSED != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -6602,9 +6376,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CONST != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CONST != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CONST == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CONST != IS_UNUSED
@@ -6620,20 +6411,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_CONST == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -6641,27 +6427,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
 	varname = opline->op1.zv;
 
 	if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_UNUSED != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_CONST != IS_CONST && varname == &tmp) {
+					if (IS_CONST != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 
 					HANDLE_EXCEPTION();
@@ -6669,23 +6456,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_CONST != IS_CONST && varname == &tmp) {
+	if (IS_CONST != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_CONST == IS_VAR || IS_CONST == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 
 	CHECK_EXCEPTION();
@@ -6695,21 +6480,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_CONST == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -6719,8 +6499,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
 		zval tmp, *varname = opline->op1.zv;
 
 		if (IS_CONST != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -6729,26 +6508,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
 			zend_class_entry *ce;
 
 			if (IS_UNUSED == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -6760,16 +6539,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -6780,16 +6559,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_
 static int ZEND_FASTCALL  ZEND_DECLARE_LAMBDA_FUNCTION_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_function *op_array;
+	zval *zfunc;
 
 	SAVE_OPLINE();
 
-	if (UNEXPECTED(zend_hash_quick_find(EG(function_table), Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), Z_HASH_P(opline->op1.zv), (void *) &op_array) == FAILURE) ||
-	    UNEXPECTED(op_array->type != ZEND_USER_FUNCTION)) {
+	if (UNEXPECTED((zfunc = zend_hash_find(EG(function_table), Z_STR_P(opline->op1.zv))) == NULL) ||
+	    UNEXPECTED(Z_FUNC_P(zfunc)->type != ZEND_USER_FUNCTION)) {
 		zend_error_noreturn(E_ERROR, "Base lambda function for closure not found");
 	}
 
-	zend_create_closure(&EX_T(opline->result.var).tmp_var, (zend_function *) op_array, EG(scope), EG(This) TSRMLS_CC);
+	zend_create_closure(EX_VAR(opline->result.var), Z_FUNC_P(zfunc), EG(scope), Z_OBJ(EG(This)) ? &EG(This) : NULL TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -6799,22 +6578,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CONST != IS_UNUSED) {
@@ -6824,74 +6599,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = opline->op1.zv;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = opline->op1.zv;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CONST == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CONST == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CONST == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -6900,45 +6659,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_HANDL
 		zval *key = NULL;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_UNUSED == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_UNUSED == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_UNUSED == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -6960,7 +6710,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -6975,7 +6725,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -6990,7 +6740,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -7005,7 +6755,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -7020,9 +6770,9 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7035,9 +6785,9 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7050,9 +6800,9 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7065,9 +6815,9 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7080,9 +6830,9 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7093,12 +6843,12 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
@@ -7110,7 +6860,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -7126,7 +6876,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -7142,7 +6892,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -7158,7 +6908,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -7176,9 +6926,9 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7191,9 +6941,9 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7206,9 +6956,9 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7221,9 +6971,9 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
 
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7238,7 +6988,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAN
 
 	SAVE_OPLINE();
 	container = opline->op1.zv;
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_CONST != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
@@ -7258,21 +7008,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
 
 	if (IS_CONST == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -7283,51 +7033,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
 
 	if (IS_CONST == IS_CONST &&
 	    IS_CV == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_CONST != IS_CONST &&
 	           IS_CV == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_CV != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
-
 
-		if (IS_CV == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
+		function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		if (IS_CV != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_CV == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_CONST == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_CV == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_CONST == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_CV != IS_CONST) {
@@ -7337,8 +7076,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -7346,21 +7085,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_CONST_CV_HANDLER(ZEN
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -7376,7 +7115,7 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 	zend_class_entry *ce, *catch_ce;
-	zval *exception;
+	zend_object *exception;
 
 	SAVE_OPLINE();
 	/* Check whether an exception has been thrown, if not, jump over code */
@@ -7385,14 +7124,14 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 		ZEND_VM_SET_OPCODE(&EX(op_array)->opcodes[opline->extended_value]);
 		ZEND_VM_CONTINUE(); /* CHECK_ME */
 	}
-	if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-		catch_ce = CACHED_PTR(opline->op1.literal->cache_slot);
+	if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+		catch_ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 	} else {
-		catch_ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
+		catch_ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, ZEND_FETCH_CLASS_NO_AUTOLOAD TSRMLS_CC);
 
-		CACHE_PTR(opline->op1.literal->cache_slot, catch_ce);
+		CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), catch_ce);
 	}
-	ce = Z_OBJCE_P(EG(exception));
+	ce = zend_get_class_entry(EG(exception) TSRMLS_CC);
 
 #ifdef HAVE_DTRACE
 	if (DTRACE_EXCEPTION_CAUGHT_ENABLED()) {
@@ -7412,19 +7151,12 @@ static int ZEND_FASTCALL  ZEND_CATCH_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 	}
 
 	exception = EG(exception);
-	if (!EG(active_symbol_table)) {
-		if (EX_CV(opline->op2.var)) {
-			zval_ptr_dtor(EX_CV(opline->op2.var));
-		}
-		EX_CV(opline->op2.var) = (zval**)EX_CV_NUM(execute_data, EX(op_array)->last_var + opline->op2.var);
-		*EX_CV(opline->op2.var) = EG(exception);
-	} else {
-		zend_compiled_variable *cv = &CV_DEF_OF(opline->op2.var);
-		zend_hash_quick_update(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value,
-		    &EG(exception), sizeof(zval *), (void**)&EX_CV(opline->op2.var));
+	if (Z_REFCOUNTED_P(EX_VAR(opline->op2.var))) {
+		zval_ptr_dtor(EX_VAR(opline->op2.var));
 	}
+	ZVAL_OBJ(EX_VAR(opline->op2.var), EG(exception));
 	if (UNEXPECTED(EG(exception) != exception)) {
-		Z_ADDREF_P(EG(exception));
+		GC_REFCOUNT(EG(exception))++;
 		HANDLE_EXCEPTION();
 	} else {
 		EG(exception) = NULL;
@@ -7436,11 +7168,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
 	USE_OPLINE
 
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 opline->op1.zv,
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -7450,35 +7183,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_CONST == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=opline->op1.zv;
+		expr_ptr = opline->op1.zv;
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CONST == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CONST == IS_CV) {
+		} else if (IS_CONST == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -7486,8 +7215,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO
 	if (IS_CV != IS_UNUSED) {
 
 		zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -7496,32 +7227,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CONST == IS_VAR || IS_CONST == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -7529,9 +7260,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CONST != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CONST != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CONST == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CONST != IS_UNUSED
@@ -7545,22 +7293,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CONST != IS_UNUSED) {
@@ -7570,74 +7314,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = opline->op1.zv;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_CONST == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CONST == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CONST == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CONST == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = opline->op1.zv;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CONST == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CONST == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CONST == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -7646,45 +7374,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CV == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CV == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -7706,9 +7425,9 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		opline->op1.zv,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -7721,7 +7440,7 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_not_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_not_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -7734,7 +7453,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_not_function(&EX_T(opline->result.var).tmp_var,
+	boolean_not_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -7750,10 +7469,7 @@ static int ZEND_FASTCALL  ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	z = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_TMP_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
-		INIT_PZVAL(z);
-	}
-	zend_print_variable(z);
+	zend_print_variable(z TSRMLS_CC);
 
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -7764,7 +7480,7 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
+	ZVAL_LONG(EX_VAR(opline->result.var), 1);
 	return ZEND_ECHO_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
@@ -7881,8 +7597,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -7912,8 +7627,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -7930,9 +7644,9 @@ static int ZEND_FASTCALL  ZEND_FREE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_TMP_VAR) {
-		zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+		zval_dtor(EX_VAR(opline->op1.var));
 	} else {
-		zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+		zval_ptr_dtor(EX_VAR(opline->op1.var));
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -7947,34 +7661,21 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (!EG(return_value_ptr_ptr)) {
+	if (!EX(return_value)) {
 		zval_dtor(free_op1.var);
 	} else {
-		if (IS_TMP_VAR == IS_CONST ||
-		    IS_TMP_VAR == IS_TMP_VAR ||
-		    PZVAL_IS_REF(retval_ptr)) {
-			zval *ret;
-
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, retval_ptr);
+		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_TMP_VAR != IS_TMP_VAR) {
-				zval_copy_ctor(ret);
+				zval_opt_copy_ctor(EX(return_value));
 			}
-			*EG(return_value_ptr_ptr) = ret;
-
-		} else if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
-		           retval_ptr == &EG(uninitialized_zval)) {
-			zval *ret;
+		} else if (Z_ISREF_P(retval_ptr)) {
+			ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
 
-			if (IS_TMP_VAR == IS_VAR) {
-				Z_DELREF_P(retval_ptr);
-			}
-			ALLOC_INIT_ZVAL(ret);
-			*EG(return_value_ptr_ptr) = ret;
 		} else {
-			*EG(return_value_ptr_ptr) = retval_ptr;
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_TMP_VAR == IS_CV) {
-				Z_ADDREF_P(retval_ptr);
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
 			}
 		}
 	}
@@ -7985,7 +7686,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zval *retval_ptr;
-	zval **retval_ptr_ptr;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
@@ -7997,55 +7697,41 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
 			retval_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			if (!EG(return_value_ptr_ptr)) {
+			if (!EX(return_value)) {
 				if (IS_TMP_VAR == IS_TMP_VAR) {
 					zval_dtor(free_op1.var);
 				}
 			} else if (!1) { /* Not a temp var */
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				zval_copy_ctor(ret);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_DUP(EX(return_value), retval_ptr);
 			} else {
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			}
 			break;
 		}
 
-		retval_ptr_ptr = NULL;
+		retval_ptr = NULL;
 
-		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
 		}
 
-		if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
+		if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(retval_ptr)) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-			    EX_T(opline->op1.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+			    (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+			} else {
 				zend_error(E_NOTICE, "Only variable references should be returned by reference");
-				if (EG(return_value_ptr_ptr)) {
-					zval *ret;
-
-					ALLOC_ZVAL(ret);
-					INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
-					zval_copy_ctor(ret);
-					*EG(return_value_ptr_ptr) = ret;
+				if (EX(return_value)) {
+					zval tmp;
+					ZVAL_DUP(&tmp, retval_ptr);
+					ZVAL_NEW_REF(EX(return_value), &tmp);
 				}
 				break;
 			}
 		}
 
-		if (EG(return_value_ptr_ptr)) {
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
-			Z_ADDREF_PP(retval_ptr_ptr);
-
-			*EG(return_value_ptr_ptr) = *retval_ptr_ptr;
+		if (EX(return_value)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
+			ZVAL_COPY(EX(return_value), retval_ptr);
 		}
 	} while (0);
 
@@ -8056,7 +7742,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zval *value;
-	zval *exception;
+	zval exception;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
@@ -8070,14 +7756,14 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	}
 
 	zend_exception_save(TSRMLS_C);
-	/* Not sure if a complete copy is what we want here */
-	ALLOC_ZVAL(exception);
-	INIT_PZVAL_COPY(exception, value);
-	if (!1) {
-		zval_copy_ctor(exception);
+	if (IS_TMP_VAR == IS_CONST) {
+		ZVAL_DUP(&exception, value);
+		value = &exception;
+	} else if (IS_TMP_VAR != IS_TMP_VAR) {
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 	}
 
-	zend_throw_exception_object(exception TSRMLS_CC);
+	zend_throw_exception_object(value TSRMLS_CC);
 	zend_exception_restore(TSRMLS_C);
 
 	HANDLE_EXCEPTION();
@@ -8086,6 +7772,8 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *value, *top;
+	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
@@ -8094,22 +7782,12 @@ static int ZEND_FASTCALL  ZEND_SEND_VAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		}
 	}
 
-	{
-		zval *valptr;
-		zval *value;
-		zend_free_op free_op1;
-
-		value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-		ALLOC_ZVAL(valptr);
-		INIT_PZVAL_COPY(valptr, value);
-		if (!1) {
-			zval_copy_ctor(valptr);
-		}
-		zend_vm_stack_push(valptr TSRMLS_CC);
-
+	value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	ZVAL_COPY_VALUE(top, value);
+	if (IS_TMP_VAR == IS_CONST) {
+		zval_opt_copy_ctor(top);
 	}
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -8117,7 +7795,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *retval = &EX_T(opline->result.var).tmp_var;
+	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
@@ -8153,7 +7831,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (UNEXPECTED(clone_call == NULL)) {
 		if (ce) {
-			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
+			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
 		} else {
 			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
 		}
@@ -8164,29 +7842,21 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(ce != EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (EXPECTED(EG(exception) == NULL)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
-		Z_TYPE_P(retval) = IS_OBJECT;
-		Z_SET_REFCOUNT_P(retval, 1);
-		Z_SET_ISREF_P(retval);
+		ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC));
 		if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&retval);
-		} else {
-			EX_T(opline->result.var).var.ptr = retval;
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -8198,18 +7868,34 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *expr, *expr_ptr;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	expr = expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
+		ZVAL_DEREF(expr);
+	}
+	if (Z_TYPE_P(expr) == opline->extended_value) {
+		ZVAL_COPY_VALUE(result, expr);
+		if (IS_TMP_VAR == IS_CONST || expr != expr_ptr) {
+			zval_opt_copy_ctor(result);
+
+		} else if (IS_TMP_VAR == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	}
 
 	if (opline->extended_value != IS_STRING) {
 		ZVAL_COPY_VALUE(result, expr);
 		if (!1) {
-			zendi_zval_copy_ctor(*result);
+			zval_opt_copy_ctor(result);
 		}
 	}
+
 	switch (opline->extended_value) {
 		case IS_NULL:
 			convert_to_null(result);
@@ -8236,7 +7922,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			} else {
 				ZVAL_COPY_VALUE(result, expr);
 				if (!1) {
-					zendi_zval_copy_ctor(*result);
+					zval_opt_copy_ctor(result);
 				}
 			}
 			break;
@@ -8259,18 +7945,17 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
 	zend_op_array *new_op_array=NULL;
 	zend_free_op free_op1;
 	zval *inc_filename;
-	zval *tmp_inc_filename = NULL;
+	zval tmp_inc_filename;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
 	inc_filename = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (inc_filename->type!=IS_STRING) {
-		MAKE_STD_ZVAL(tmp_inc_filename);
-		ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
-		zval_copy_ctor(tmp_inc_filename);
-		convert_to_string(tmp_inc_filename);
-		inc_filename = tmp_inc_filename;
+	ZVAL_UNDEF(&tmp_inc_filename);
+	if (Z_TYPE_P(inc_filename) != IS_STRING) {
+		ZVAL_DUP(&tmp_inc_filename, inc_filename);
+		convert_to_string(&tmp_inc_filename);
+		inc_filename = &tmp_inc_filename;
 	}
 
 	if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
@@ -8288,7 +7973,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
 
 					resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
 					if (resolved_path) {
-						failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
+						failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path));
 					} else {
 						resolved_path = Z_STRVAL_P(inc_filename);
 					}
@@ -8301,7 +7986,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
 							file_handle.opened_path = estrdup(resolved_path);
 						}
 
-						if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
+						if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) {
 							new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
 							zend_destroy_file_handle(&file_handle TSRMLS_CC);
 						} else {
@@ -8334,40 +8019,37 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
 			EMPTY_SWITCH_DEFAULT_CASE()
 		}
 	}
-	if (tmp_inc_filename) {
+	if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
 		zval_ptr_dtor(&tmp_inc_filename);
 	}
 	zval_dtor(free_op1.var);
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		HANDLE_EXCEPTION();
 	} else if (EXPECTED(new_op_array != NULL)) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
 		EG(active_op_array) = new_op_array;
 		if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-			EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
-		} else {
-			EG(return_value_ptr_ptr) = NULL;
+			return_value = EX_VAR(opline->result.var);
 		}
 
 		EX(function_state).function = (zend_function *) new_op_array;
-		EX(object) = NULL;
 
 		if (!EG(active_symbol_table)) {
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+		    i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC);
 			ZEND_VM_ENTER();
 		} else {
-			zend_execute(new_op_array TSRMLS_CC);
+			zend_execute(new_op_array, return_value TSRMLS_CC);
 		}
 
 		EX(function_state).function = (zend_function *) EX(op_array);
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
 		destroy_op_array(new_op_array TSRMLS_CC);
 		efree(new_op_array);
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -8376,12 +8058,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_TMP_HANDLER(ZEND_OPCODE_HAND
 		}
 
 	} else if (RETURN_VALUE_USED(opline)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		ZVAL_BOOL(retval, failure_retval);
-		INIT_PZVAL(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -8390,7 +8067,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *array_ptr, **array_ptr_ptr;
+	zval *array_ptr, *array_ref, iterator;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
 	zend_class_entry *ce = NULL;
@@ -8400,71 +8077,79 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 	if ((IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) &&
 	    (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
-		array_ptr_ptr = NULL;
-		if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
-			MAKE_STD_ZVAL(array_ptr);
-			ZVAL_NULL(array_ptr);
-		} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
-			if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
+		array_ptr = array_ref = NULL;
+		ZVAL_DEREF(array_ptr);
+		if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
+			if (!Z_ISREF_P(array_ref)) {
+				SEPARATE_ZVAL(array_ptr);
+				array_ref = array_ptr;
+				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
+					ZVAL_NEW_REF(array_ptr, array_ptr);
+					array_ref = array_ptr;
+					array_ptr = Z_REFVAL_P(array_ptr);
+				}
+			}
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
+		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
+			if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) {
 				zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
 
-			ce = Z_OBJCE_PP(array_ptr_ptr);
+			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || ce->get_iterator == NULL) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				Z_ADDREF_PP(array_ptr_ptr);
-			}
-			array_ptr = *array_ptr_ptr;
-		} else {
-			if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-					Z_SET_ISREF_PP(array_ptr_ptr);
+				if (!Z_ISREF_P(array_ref)) {
+					SEPARATE_ZVAL(array_ptr);
 				}
+				Z_ADDREF_P(array_ptr);
 			}
-			array_ptr = *array_ptr_ptr;
-			Z_ADDREF_P(array_ptr);
+			array_ref = array_ptr;
+		} else {
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
 		}
 	} else {
-		array_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		array_ptr = array_ref = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		ZVAL_DEREF(array_ptr);
 		if (1) { /* IS_TMP_VAR */
-			zval *tmp;
+			zval tmp;
 
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			array_ptr = tmp;
+			ZVAL_COPY_VALUE(&tmp, array_ptr);
+			array_ptr = &tmp;
 			if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 				ce = Z_OBJCE_P(array_ptr);
 				if (ce && ce->get_iterator) {
-					Z_DELREF_P(array_ptr);
+					Z_DELREF_P(array_ref);
 				}
 			}
 		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || !ce->get_iterator) {
 				if (IS_TMP_VAR == IS_CV) {
-					Z_ADDREF_P(array_ptr);
+					Z_ADDREF_P(array_ref);
 				}
 			}
-		} else if (IS_TMP_VAR == IS_CONST ||
-		           (IS_TMP_VAR == IS_CV &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 1) ||
-		           (IS_TMP_VAR == IS_VAR &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 2)) {
-			zval *tmp;
+		} else if (Z_REFCOUNTED_P(array_ref)) {
+			if (IS_TMP_VAR == IS_CONST ||
+			           (IS_TMP_VAR == IS_CV &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 1) ||
+			           (IS_TMP_VAR == IS_VAR &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 2)) {
+				zval tmp;
 
-			if (IS_TMP_VAR == IS_VAR) {
-				Z_DELREF_P(array_ptr);
+				if (IS_TMP_VAR == IS_VAR) {
+					Z_DELREF_P(array_ref);
+				}
+				ZVAL_DUP(&tmp, array_ref);
+				array_ptr = array_ref = &tmp;
+			} else if (IS_TMP_VAR == IS_CV) {
+				if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) {
+					ZVAL_UNREF(array_ref);
+					array_ptr = array_ref;
+				}
+				Z_ADDREF_P(array_ref);
 			}
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			zval_copy_ctor(tmp);
-			array_ptr = tmp;
-		} else if (IS_TMP_VAR == IS_CV) {
-			Z_ADDREF_P(array_ptr);
 		}
 	}
 
@@ -8475,27 +8160,28 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 		}
 		if (iter && EXPECTED(EG(exception) == NULL)) {
-			array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
+			ZVAL_OBJ(&iterator, &iter->std);
+			array_ptr = array_ref = &iterator;
 		} else {
 			if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 			}
 			if (!EG(exception)) {
-				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
+				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val);
 			}
 			zend_throw_exception_internal(NULL TSRMLS_CC);
 			HANDLE_EXCEPTION();
 		}
 	}
 
-	EX_T(opline->result.var).fe.ptr = array_ptr;
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
 
 	if (iter) {
 		iter->index = 0;
 		if (iter->funcs->rewind) {
 			iter->funcs->rewind(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array_ptr);
+				zval_ptr_dtor(array_ref);
 				if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 				}
@@ -8504,7 +8190,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		}
 		is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&array_ptr);
+			zval_ptr_dtor(array_ref);
 			if (IS_TMP_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 			}
@@ -8514,24 +8200,23 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
 		zend_hash_internal_pointer_reset(fe_ht);
 		if (ce) {
-			zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array_ptr);
 			while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
-				char *str_key;
-				uint str_key_len;
+				zend_string *str_key;
 				ulong int_key;
 				zend_uchar key_type;
 
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 				if (key_type != HASH_KEY_NON_EXISTENT &&
 					(key_type == HASH_KEY_IS_LONG ||
-				     zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
+				     zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) {
 					break;
 				}
 				zend_hash_move_forward(fe_ht);
 			}
 		}
 		is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
-		zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
+		zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var));
 	} else {
 		zend_error(E_WARNING, "Invalid argument supplied for foreach()");
 		is_empty = 1;
@@ -8561,7 +8246,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 		if (Z_TYPE_P(ptr) == IS_LONG) {
 			EG(exit_status) = Z_LVAL_P(ptr);
 		} else {
-			zend_print_variable(ptr);
+			zend_print_variable(ptr TSRMLS_CC);
 		}
 		zval_dtor(free_op1.var);
 	}
@@ -8576,9 +8261,8 @@ static int ZEND_FASTCALL  ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 	zval restored_error_reporting;
 
 	SAVE_OPLINE();
-	if (!EG(error_reporting) && Z_LVAL(EX_T(opline->op1.var).tmp_var) != 0) {
-		Z_TYPE(restored_error_reporting) = IS_LONG;
-		Z_LVAL(restored_error_reporting) = Z_LVAL(EX_T(opline->op1.var).tmp_var);
+	if (!EG(error_reporting) && Z_LVAL_P(EX_VAR(opline->op1.var)) != 0) {
+		ZVAL_LONG(&restored_error_reporting, Z_LVAL_P(EX_VAR(opline->op1.var)));
 		EG(error_reporting) = Z_LVAL(restored_error_reporting);
 		convert_to_string(&restored_error_reporting);
 		if (EXPECTED(EG(error_reporting_ini_entry) != NULL)) {
@@ -8586,15 +8270,14 @@ static int ZEND_FASTCALL  ZEND_END_SILENCE_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 			    EG(error_reporting_ini_entry)->value != EG(error_reporting_ini_entry)->orig_value)) {
 				efree(EG(error_reporting_ini_entry)->value);
 			}
-			EG(error_reporting_ini_entry)->value = Z_STRVAL(restored_error_reporting);
+			EG(error_reporting_ini_entry)->value = estrndup(Z_STRVAL(restored_error_reporting), Z_STRLEN(restored_error_reporting));
 			EG(error_reporting_ini_entry)->value_length = Z_STRLEN(restored_error_reporting);
-		} else {
-			zendi_zval_dtor(restored_error_reporting);
 		}
+		zval_dtor(&restored_error_reporting);
 	}
-	if (EX(old_error_reporting) == &EX_T(opline->op1.var).tmp_var) {
-		EX(old_error_reporting) = NULL;
-	}
+//???	if (EX(old_error_reporting) == EX_VAR(opline->op1.var)) {
+//???		EX(old_error_reporting) = NULL;
+//???	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -8609,9 +8292,9 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
-		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!1) {
-			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 
 #if DEBUG_ZEND>=2
@@ -8629,23 +8312,18 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
 		if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-			Z_ADDREF_P(value);
-			EX_T(opline->result.var).var.ptr = value;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-		} else {
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, value);
-			EX_T(opline->result.var).var.ptr = ret;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
+		} else {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 			if (!1) {
-				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+				zval_opt_copy_ctor(EX_VAR(opline->result.var));
 			}
 		}
 
@@ -8669,9 +8347,9 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	SAVE_OPLINE();
 	value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 	if (!1) {
-		zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+		zval_opt_copy_ctor(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -8682,22 +8360,17 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		Z_ADDREF_P(value);
-		EX_T(opline->result.var).var.ptr = value;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	} else {
-		ALLOC_ZVAL(ret);
-		INIT_PZVAL_COPY(ret, value);
-		EX_T(opline->result.var).var.ptr = ret;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
+	} else {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!1) {
-			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -8716,11 +8389,11 @@ static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	expr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
-		result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
+		result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC);
 	} else {
 		result = 0;
 	}
-	ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -8732,7 +8405,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8747,7 +8420,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8762,7 +8435,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8777,7 +8450,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8792,7 +8465,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8807,7 +8480,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8822,7 +8495,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8837,7 +8510,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8852,7 +8525,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8865,7 +8538,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
@@ -8882,7 +8555,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -8898,7 +8571,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -8914,7 +8587,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -8930,7 +8603,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_O
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -8948,7 +8621,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8963,7 +8636,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8978,7 +8651,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -8993,7 +8666,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9007,19 +8680,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -9028,105 +8698,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+					if (IS_TMP_VAR != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 					zval_dtor(free_op1.var);
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 		zval_dtor(free_op1.var);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_TMP_VAR == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_TMP_VAR != IS_TMP_VAR) {
-					zval_dtor(free_op1.var);
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				zval_dtor(free_op1.var);
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			zval_dtor(free_op1.var);
 		}
 	}
 
-
-	if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+	if (IS_TMP_VAR != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -9151,7 +8804,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_TMP_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_TMP_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -9172,7 +8829,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HA
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 		zval_dtor(free_op1.var);
@@ -9191,14 +8848,12 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_ARRAY)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 
-		zval *value = *zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+		zval *value = zend_fetch_dimension_address_inner(Z_ARRVAL_P(container), opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
 
-		PZVAL_LOCK(value);
-		EX_T(opline->result.var).var.ptr = value;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
 
 	}
 	CHECK_EXCEPTION();
@@ -9208,17 +8863,13 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_TMP_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 static int ZEND_FASTCALL  ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 
 	if (IS_TMP_VAR == IS_UNUSED) {
 		/* Initialize for erealloc in add_char_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	add_char_to_string(str, str, opline->op2.zv);
@@ -9231,17 +8882,13 @@ static int ZEND_FASTCALL  ZEND_ADD_CHAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_ADD_STRING_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 
 	if (IS_TMP_VAR == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	add_string_to_string(str, str, opline->op2.zv);
@@ -9255,10 +8902,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -9272,33 +8918,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CONST != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CONST == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -9306,21 +8949,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -9336,11 +8971,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 	zend_free_op free_op1;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 opline->op2.zv TSRMLS_CC);
+				 opline->op2.zv TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -9350,35 +8986,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (1) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_TMP_VAR == IS_CV) {
+		} else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -9386,8 +9018,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 	if (IS_CONST != IS_UNUSED) {
 
 		zval *offset = opline->op2.zv;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -9396,32 +9030,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -9429,9 +9063,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_TMP_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_TMP_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_TMP_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_TMP_VAR != IS_UNUSED
@@ -9447,20 +9098,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -9468,27 +9114,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
 	varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_CONST != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+					if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 					zval_dtor(free_op1.var);
 					HANDLE_EXCEPTION();
@@ -9496,23 +9143,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+	if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -9522,21 +9167,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -9546,8 +9186,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 		zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -9556,26 +9195,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 			zend_class_entry *ce;
 
 			if (IS_CONST == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -9587,16 +9226,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPC
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -9608,22 +9247,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_TMP_VAR != IS_UNUSED) {
@@ -9633,74 +9268,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!1) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!1) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_TMP_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_TMP_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_TMP_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -9709,45 +9328,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *key = opline->op2.zv;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CONST == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CONST == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -9769,7 +9379,7 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9784,7 +9394,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9799,7 +9409,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9814,7 +9424,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9829,7 +9439,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9844,7 +9454,7 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9859,7 +9469,7 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9874,7 +9484,7 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9889,7 +9499,7 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9904,7 +9514,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -9917,7 +9527,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
@@ -9934,7 +9544,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -9950,7 +9560,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -9966,7 +9576,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -9982,7 +9592,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -10000,7 +9610,7 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -10015,7 +9625,7 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -10030,7 +9640,7 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -10045,7 +9655,7 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -10062,7 +9672,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 		zval_dtor(free_op1.var);
@@ -10075,7 +9685,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -10085,18 +9695,17 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 
 	if (IS_TMP_VAR == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -10120,10 +9729,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1, free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -10137,33 +9745,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
+	object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_TMP_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -10171,21 +9776,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
 			zval_dtor(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -10202,11 +9799,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -10217,35 +9815,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (1) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_TMP_VAR == IS_CV) {
+		} else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -10253,8 +9847,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD
 	if (IS_TMP_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -10263,32 +9859,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 		zval_dtor(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -10296,9 +9892,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_TMP_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_TMP_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_TMP_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_TMP_VAR != IS_UNUSED
@@ -10312,22 +9925,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_TMP_VAR != IS_UNUSED) {
@@ -10337,74 +9946,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!1) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!1) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_TMP_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_TMP_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_TMP_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -10413,45 +10006,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!1) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_TMP_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_TMP_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -10473,7 +10057,7 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -10488,11 +10072,11 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10503,11 +10087,11 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10518,11 +10102,11 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10533,11 +10117,11 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10548,11 +10132,11 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10563,11 +10147,11 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10578,11 +10162,11 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10593,11 +10177,11 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10608,11 +10192,11 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10621,15 +10205,15 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10638,14 +10222,14 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10654,14 +10238,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10670,14 +10254,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10686,14 +10270,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10704,11 +10288,11 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10719,11 +10303,11 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10734,11 +10318,11 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10749,11 +10333,11 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -10763,19 +10347,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -10784,105 +10365,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+					if (IS_TMP_VAR != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 					zval_dtor(free_op1.var);
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 		zval_dtor(free_op1.var);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_TMP_VAR == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_TMP_VAR != IS_TMP_VAR) {
-					zval_dtor(free_op1.var);
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				zval_dtor(free_op1.var);
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			zval_dtor(free_op1.var);
 		}
 	}
 
-
-	if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+	if (IS_TMP_VAR != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -10907,7 +10471,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_TMP_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_TMP_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -10928,8 +10496,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 		zval_dtor(free_op1.var);
 	}
@@ -10941,7 +10509,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -10951,18 +10519,17 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 
 	if (IS_TMP_VAR == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -10976,7 +10543,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 	 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
 	 * string offsets or overloaded objects
 	 */
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -10986,10 +10553,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1, free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -11003,62 +10569,51 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
 	EX(call) = call;
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -11068,13 +10623,14 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -11083,35 +10639,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (1) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_TMP_VAR == IS_CV) {
+		} else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -11119,8 +10671,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 	if (IS_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -11129,32 +10683,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -11162,9 +10716,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_TMP_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_TMP_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_TMP_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_TMP_VAR != IS_UNUSED
@@ -11180,20 +10751,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -11201,27 +10767,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
 	varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_VAR != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+					if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 					zval_dtor(free_op1.var);
 					HANDLE_EXCEPTION();
@@ -11229,23 +10796,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+	if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -11255,21 +10820,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -11279,8 +10839,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 		zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -11289,26 +10848,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 			zend_class_entry *ce;
 
 			if (IS_VAR == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -11320,16 +10879,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -11341,22 +10900,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_TMP_VAR != IS_UNUSED) {
@@ -11366,74 +10921,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!1) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!1) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_TMP_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_TMP_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_TMP_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -11442,46 +10981,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
-
-			generator->key = copy;
+		if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+			zval_ptr_dtor_nogc(free_op2.var);
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -11503,11 +11032,11 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -11517,19 +11046,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_TMP_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -11538,105 +11064,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+					if (IS_TMP_VAR != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 					zval_dtor(free_op1.var);
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 		zval_dtor(free_op1.var);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_TMP_VAR == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_TMP_VAR != IS_TMP_VAR) {
-					zval_dtor(free_op1.var);
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				zval_dtor(free_op1.var);
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_TMP_VAR == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			zval_dtor(free_op1.var);
 		}
 	}
 
-
-	if (IS_TMP_VAR != IS_CONST && varname == &tmp_varname) {
+	if (IS_TMP_VAR != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -11661,7 +11170,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_TMP_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -11678,35 +11191,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (1) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_TMP_VAR == IS_CV) {
+		} else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -11714,8 +11223,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
 	if (IS_UNUSED != IS_UNUSED) {
 
 		zval *offset = NULL;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -11724,32 +11235,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_UNUSED == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_UNUSED != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -11757,9 +11268,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_TMP_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_TMP_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_TMP_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_TMP_VAR != IS_UNUSED
@@ -11775,20 +11303,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -11796,27 +11319,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
 	varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_UNUSED != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+					if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 					zval_dtor(free_op1.var);
 					HANDLE_EXCEPTION();
@@ -11824,23 +11348,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_TMP_VAR != IS_CONST && varname == &tmp) {
+	if (IS_TMP_VAR != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 	zval_dtor(free_op1.var);
 	CHECK_EXCEPTION();
@@ -11850,21 +11372,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_TMP_VAR == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -11874,8 +11391,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
 		zval tmp, *varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -11884,26 +11400,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
 			zend_class_entry *ce;
 
 			if (IS_UNUSED == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -11915,16 +11431,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -11936,22 +11452,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_TMP_VAR != IS_UNUSED) {
@@ -11961,74 +11473,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!1) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!1) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_TMP_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_TMP_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_TMP_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -12037,45 +11533,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 		zval *key = NULL;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_UNUSED == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_UNUSED == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_UNUSED == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -12097,7 +11584,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -12112,7 +11599,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -12127,7 +11614,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -12142,7 +11629,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
@@ -12157,9 +11644,9 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
+	fast_mod_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12172,9 +11659,9 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
+	shift_left_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12187,9 +11674,9 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
+	shift_right_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12202,9 +11689,9 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
+	concat_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12217,9 +11704,9 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
+	is_identical_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12230,12 +11717,12 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 	zval_dtor(free_op1.var);
 
@@ -12247,7 +11734,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -12263,7 +11750,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -12279,7 +11766,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -12295,7 +11782,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -12313,9 +11800,9 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_or_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12328,9 +11815,9 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_and_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12343,9 +11830,9 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
+	bitwise_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12358,9 +11845,9 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
+	boolean_xor_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12375,7 +11862,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDL
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_TMP_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 		zval_dtor(free_op1.var);
@@ -12388,7 +11875,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -12398,18 +11885,17 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 
 	if (IS_TMP_VAR == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -12432,10 +11918,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -12449,33 +11934,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CV != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CV == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -12483,21 +11965,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -12513,11 +11987,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zend_free_op free_op1;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -12527,35 +12002,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = NULL;
-
-		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = NULL;
+		if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (1) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_TMP_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_TMP_VAR == IS_CV) {
+		} else if (IS_TMP_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -12563,8 +12034,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE
 	if (IS_CV != IS_UNUSED) {
 
 		zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -12573,32 +12046,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_TMP_VAR == IS_VAR || IS_TMP_VAR == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -12606,9 +12079,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_TMP_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_TMP_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_TMP_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_TMP_VAR != IS_UNUSED
@@ -12622,22 +12112,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_TMP_VAR != IS_UNUSED) {
@@ -12647,74 +12133,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!1) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_TMP_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_TMP_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!1) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_TMP_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_TMP_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_TMP_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -12723,45 +12193,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CV == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CV == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -12783,9 +12244,9 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
+	pow_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	zval_dtor(free_op1.var);
 
 	CHECK_EXCEPTION();
@@ -12798,9 +12259,9 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_not_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	bitwise_not_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -12811,9 +12272,9 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_not_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	boolean_not_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -12822,45 +12283,56 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
 	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_increment_function(var_ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		}
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+	} else {
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_increment_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_increment_function(*var_ptr);
+		increment_function(var_ptr);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -12869,45 +12341,56 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
 	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_decrement_function(var_ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		}
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+	} else {
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_decrement_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_decrement_function(*var_ptr);
+		decrement_function(var_ptr);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -12916,41 +12399,52 @@ static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr, *retval;
+	zval *var_ptr, *retval;
 
 	SAVE_OPLINE();
 	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		fast_increment_function(var_ptr);
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	retval = &EX_T(opline->result.var).tmp_var;
-	ZVAL_COPY_VALUE(retval, *var_ptr);
-	zendi_zval_copy_ctor(*retval);
+	retval = EX_VAR(opline->result.var);
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+		ZVAL_DUP(retval, var_ptr);
+	} else {
+		ZVAL_DUP(retval, var_ptr);
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_increment_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_increment_function(*var_ptr);
+		increment_function(var_ptr);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -12959,41 +12453,52 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **var_ptr, *retval;
+	zval *var_ptr, *retval;
 
 	SAVE_OPLINE();
 	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		fast_decrement_function(var_ptr);
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	retval = &EX_T(opline->result.var).tmp_var;
-	ZVAL_COPY_VALUE(retval, *var_ptr);
-	zendi_zval_copy_ctor(*retval);
+	retval = EX_VAR(opline->result.var);
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+		ZVAL_DUP(retval, var_ptr);
+	} else {
+		ZVAL_DUP(retval, var_ptr);
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_decrement_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_decrement_function(*var_ptr);
+		decrement_function(var_ptr);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -13005,14 +12510,11 @@ static int ZEND_FASTCALL  ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *z;
 
 	SAVE_OPLINE();
-	z = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	z = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
-		INIT_PZVAL(z);
-	}
-	zend_print_variable(z);
+	zend_print_variable(z TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -13021,7 +12523,7 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
+	ZVAL_LONG(EX_VAR(opline->result.var), 1);
 	return ZEND_ECHO_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
@@ -13033,13 +12535,13 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int ret;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		ret = Z_LVAL_P(val);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			HANDLE_EXCEPTION();
 		}
@@ -13063,13 +12565,13 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int ret;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		ret = Z_LVAL_P(val);
 	} else {
 		ret = i_zend_is_true(val TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			HANDLE_EXCEPTION();
 		}
@@ -13093,13 +12595,13 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int retval;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			HANDLE_EXCEPTION();
 		}
@@ -13127,19 +12629,18 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	int retval;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -13158,19 +12659,18 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	int retval;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
 	} else {
 		retval = i_zend_is_true(val TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 		if (UNEXPECTED(EG(exception) != NULL)) {
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -13187,9 +12687,9 @@ static int ZEND_FASTCALL  ZEND_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_TMP_VAR) {
-		zendi_zval_dtor(EX_T(opline->op1.var).tmp_var);
+		zval_dtor(EX_VAR(opline->op1.var));
 	} else {
-		zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+		zval_ptr_dtor(EX_VAR(opline->op1.var));
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -13204,34 +12704,21 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (!EG(return_value_ptr_ptr)) {
-		zval_ptr_dtor_nogc(&free_op1.var);
+	if (!EX(return_value)) {
+		zval_ptr_dtor_nogc(free_op1.var);
 	} else {
-		if (IS_VAR == IS_CONST ||
-		    IS_VAR == IS_TMP_VAR ||
-		    PZVAL_IS_REF(retval_ptr)) {
-			zval *ret;
-
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, retval_ptr);
+		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_VAR != IS_TMP_VAR) {
-				zval_copy_ctor(ret);
+				zval_opt_copy_ctor(EX(return_value));
 			}
-			*EG(return_value_ptr_ptr) = ret;
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
-		           retval_ptr == &EG(uninitialized_zval)) {
-			zval *ret;
-
-			if (IS_VAR == IS_VAR) {
-				Z_DELREF_P(retval_ptr);
-			}
-			ALLOC_INIT_ZVAL(ret);
-			*EG(return_value_ptr_ptr) = ret;
+		} else if (Z_ISREF_P(retval_ptr)) {
+			ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
+			zval_ptr_dtor_nogc(free_op1.var);
 		} else {
-			*EG(return_value_ptr_ptr) = retval_ptr;
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_VAR == IS_CV) {
-				Z_ADDREF_P(retval_ptr);
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
 			}
 		}
 	}
@@ -13242,7 +12729,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zval *retval_ptr;
-	zval **retval_ptr_ptr;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
@@ -13254,59 +12740,45 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
 			retval_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			if (!EG(return_value_ptr_ptr)) {
+			if (!EX(return_value)) {
 				if (IS_VAR == IS_TMP_VAR) {
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 				}
 			} else if (!0) { /* Not a temp var */
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				zval_copy_ctor(ret);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_DUP(EX(return_value), retval_ptr);
 			} else {
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			}
 			break;
 		}
 
-		retval_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		retval_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-		if (IS_VAR == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
 		}
 
-		if (IS_VAR == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
+		if (IS_VAR == IS_VAR && !Z_ISREF_P(retval_ptr)) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-			    EX_T(opline->op1.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+			    (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+			} else {
 				zend_error(E_NOTICE, "Only variable references should be returned by reference");
-				if (EG(return_value_ptr_ptr)) {
-					zval *ret;
-
-					ALLOC_ZVAL(ret);
-					INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
-					zval_copy_ctor(ret);
-					*EG(return_value_ptr_ptr) = ret;
+				if (EX(return_value)) {
+					zval tmp;
+					ZVAL_DUP(&tmp, retval_ptr);
+					ZVAL_NEW_REF(EX(return_value), &tmp);
 				}
 				break;
 			}
 		}
 
-		if (EG(return_value_ptr_ptr)) {
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
-			Z_ADDREF_PP(retval_ptr_ptr);
-
-			*EG(return_value_ptr_ptr) = *retval_ptr_ptr;
+		if (EX(return_value)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
+			ZVAL_COPY(EX(return_value), retval_ptr);
 		}
 	} while (0);
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	return zend_leave_helper_SPEC(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
@@ -13314,7 +12786,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zval *value;
-	zval *exception;
+	zval exception;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
@@ -13328,49 +12800,36 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	}
 
 	zend_exception_save(TSRMLS_C);
-	/* Not sure if a complete copy is what we want here */
-	ALLOC_ZVAL(exception);
-	INIT_PZVAL_COPY(exception, value);
-	if (!0) {
-		zval_copy_ctor(exception);
+	if (IS_VAR == IS_CONST) {
+		ZVAL_DUP(&exception, value);
+		value = &exception;
+	} else if (IS_VAR != IS_TMP_VAR) {
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 	}
 
-	zend_throw_exception_object(exception TSRMLS_CC);
+	zend_throw_exception_object(value TSRMLS_CC);
 	zend_exception_restore(TSRMLS_C);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	HANDLE_EXCEPTION();
 }
 
 static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *varptr;
+	zval *varptr, *top;
 	zend_free_op free_op1;
-	varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-	if (varptr == &EG(uninitialized_zval)) {
-		if (IS_VAR == IS_VAR) {
-			Z_DELREF_P(varptr);
-		}
-		ALLOC_INIT_ZVAL(varptr);
-	} else if (PZVAL_IS_REF(varptr)) {
-		if (IS_VAR == IS_CV ||
-		    (IS_VAR == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
-			zval *original_var = varptr;
 
-			ALLOC_ZVAL(varptr);
-			INIT_PZVAL_COPY(varptr, original_var);
-			zval_copy_ctor(varptr);
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else {
-			Z_UNSET_ISREF_P(varptr);
+	varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (Z_ISREF_P(varptr)) {
+		ZVAL_DUP(top, Z_REFVAL_P(varptr));
+		zval_ptr_dtor_nogc(free_op1.var);
+	} else {
+		ZVAL_COPY_VALUE(top, varptr);
+		if (IS_VAR == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
 		}
-	} else if (IS_VAR == IS_CV) {
-		Z_ADDREF_P(varptr);
 	}
-	zend_vm_stack_push(varptr TSRMLS_CC);
-
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -13378,7 +12837,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *varptr;
+	zval *varptr, *top;
 
 	SAVE_OPLINE();
 	if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
@@ -13393,29 +12852,29 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 
 	varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
-	     EX_T(opline->op1.var).var.fcall_returned_reference) &&
-	    varptr != &EG(uninitialized_zval) &&
-	    (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
-		Z_SET_ISREF_P(varptr);
+	     (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
+	    ((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) ||
+	     Z_ISREF_P(varptr) ||
+	     Z_TYPE_P(varptr) == IS_OBJECT ||
+	     (Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) {
+
+		if (!Z_ISREF_P(varptr)) {
+			ZVAL_NEW_REF(varptr, varptr);
+		}
 		if (IS_VAR == IS_CV) {
 			Z_ADDREF_P(varptr);
 		}
 		zend_vm_stack_push(varptr TSRMLS_CC);
 	} else {
-		zval *valptr;
-
 		if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
 			!(opline->extended_value & ZEND_ARG_SEND_SILENT) :
 			!ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
 			zend_error(E_STRICT, "Only variables should be passed by reference");
 		}
-		ALLOC_ZVAL(valptr);
-		INIT_PZVAL_COPY(valptr, varptr);
-		if (!0) {
-			zval_copy_ctor(valptr);
-		}
-		zval_ptr_dtor_nogc(&free_op1.var);
-		zend_vm_stack_push(valptr TSRMLS_CC);
+		top = zend_vm_stack_top_inc(TSRMLS_C);
+		ZVAL_COPY_VALUE(top, varptr);
+		zval_opt_copy_ctor(top);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -13425,63 +12884,74 @@ static int ZEND_FASTCALL  ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **varptr_ptr;
-	zval *varptr;
+	zval *varptr, *top;
 
 	SAVE_OPLINE();
-	varptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	varptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
 	}
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
-		ALLOC_INIT_ZVAL(varptr);
-		zend_vm_stack_push(varptr TSRMLS_CC);
-		CHECK_EXCEPTION();
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (IS_VAR == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
+		ZVAL_NEW_REF(top, &EG(uninitialized_zval));
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
-	    EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
-		if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
-			return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-		}
+	if (Z_ISREF_P(varptr)) {
+		Z_ADDREF_P(varptr);
+		ZVAL_COPY_VALUE(top, varptr);
+	} else if (IS_VAR == IS_VAR &&
+		UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
+		ZVAL_COPY_VALUE(top, varptr);
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(top);
+	} else {
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr);
+		Z_ADDREF_P(varptr);
+		ZVAL_COPY_VALUE(top, varptr);
 	}
 
-	SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
-	varptr = *varptr_ptr;
-	Z_ADDREF_P(varptr);
-	zend_vm_stack_push(varptr TSRMLS_CC);
-
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-	CHECK_EXCEPTION();
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_SEND_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *varptr, *top;
+	zend_free_op free_op1;
 
 	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
 		if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
 			return ZEND_SEND_REF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 		}
 	}
-	SAVE_OPLINE();
-	return zend_send_by_var_helper_SPEC_VAR(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+
+	varptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (Z_ISREF_P(varptr)) {
+		ZVAL_DUP(top, Z_REFVAL_P(varptr));
+		zval_ptr_dtor_nogc(free_op1.var);
+	} else {
+		ZVAL_COPY_VALUE(top, varptr);
+		if (IS_VAR == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
+		}
+	}
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *retval = &EX_T(opline->result.var).tmp_var;
+	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
 	ZVAL_BOOL(retval, i_zend_is_true(_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -13492,7 +12962,7 @@ static int ZEND_FASTCALL  ZEND_SWITCH_FREE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 	USE_OPLINE
 
 	SAVE_OPLINE();
-	zval_ptr_dtor(&EX_T(opline->op1.var).var.ptr);
+	zval_ptr_dtor(EX_VAR(opline->op1.var));
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -13522,7 +12992,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (UNEXPECTED(clone_call == NULL)) {
 		if (ce) {
-			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
+			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
 		} else {
 			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
 		}
@@ -13533,32 +13003,24 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(ce != EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (EXPECTED(EG(exception) == NULL)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
-		Z_TYPE_P(retval) = IS_OBJECT;
-		Z_SET_REFCOUNT_P(retval, 1);
-		Z_SET_ISREF_P(retval);
+		ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC));
 		if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&retval);
-		} else {
-			EX_T(opline->result.var).var.ptr = retval;
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -13567,18 +13029,34 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *expr, *expr_ptr;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	expr = expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
+		ZVAL_DEREF(expr);
+	}
+	if (Z_TYPE_P(expr) == opline->extended_value) {
+		ZVAL_COPY_VALUE(result, expr);
+		if (IS_VAR == IS_CONST || expr != expr_ptr) {
+			zval_opt_copy_ctor(result);
+			zval_ptr_dtor_nogc(free_op1.var);
+		} else if (IS_VAR == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	}
 
 	if (opline->extended_value != IS_STRING) {
 		ZVAL_COPY_VALUE(result, expr);
 		if (!0) {
-			zendi_zval_copy_ctor(*result);
+			zval_opt_copy_ctor(result);
 		}
 	}
+
 	switch (opline->extended_value) {
 		case IS_NULL:
 			convert_to_null(result);
@@ -13600,12 +13078,12 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			if (use_copy) {
 				ZVAL_COPY_VALUE(result, &var_copy);
 				if (0) {
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 				}
 			} else {
 				ZVAL_COPY_VALUE(result, expr);
 				if (!0) {
-					zendi_zval_copy_ctor(*result);
+					zval_opt_copy_ctor(result);
 				}
 			}
 			break;
@@ -13617,7 +13095,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			convert_to_object(result);
 			break;
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -13628,18 +13106,17 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 	zend_op_array *new_op_array=NULL;
 	zend_free_op free_op1;
 	zval *inc_filename;
-	zval *tmp_inc_filename = NULL;
+	zval tmp_inc_filename;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
 	inc_filename = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (inc_filename->type!=IS_STRING) {
-		MAKE_STD_ZVAL(tmp_inc_filename);
-		ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
-		zval_copy_ctor(tmp_inc_filename);
-		convert_to_string(tmp_inc_filename);
-		inc_filename = tmp_inc_filename;
+	ZVAL_UNDEF(&tmp_inc_filename);
+	if (Z_TYPE_P(inc_filename) != IS_STRING) {
+		ZVAL_DUP(&tmp_inc_filename, inc_filename);
+		convert_to_string(&tmp_inc_filename);
+		inc_filename = &tmp_inc_filename;
 	}
 
 	if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
@@ -13657,7 +13134,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 
 					resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
 					if (resolved_path) {
-						failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
+						failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path));
 					} else {
 						resolved_path = Z_STRVAL_P(inc_filename);
 					}
@@ -13670,7 +13147,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 							file_handle.opened_path = estrdup(resolved_path);
 						}
 
-						if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
+						if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) {
 							new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
 							zend_destroy_file_handle(&file_handle TSRMLS_CC);
 						} else {
@@ -13703,40 +13180,37 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 			EMPTY_SWITCH_DEFAULT_CASE()
 		}
 	}
-	if (tmp_inc_filename) {
+	if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
 		zval_ptr_dtor(&tmp_inc_filename);
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		HANDLE_EXCEPTION();
 	} else if (EXPECTED(new_op_array != NULL)) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
 		EG(active_op_array) = new_op_array;
 		if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-			EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
-		} else {
-			EG(return_value_ptr_ptr) = NULL;
+			return_value = EX_VAR(opline->result.var);
 		}
 
 		EX(function_state).function = (zend_function *) new_op_array;
-		EX(object) = NULL;
 
 		if (!EG(active_symbol_table)) {
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+		    i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC);
 			ZEND_VM_ENTER();
 		} else {
-			zend_execute(new_op_array TSRMLS_CC);
+			zend_execute(new_op_array, return_value TSRMLS_CC);
 		}
 
 		EX(function_state).function = (zend_function *) EX(op_array);
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
 		destroy_op_array(new_op_array TSRMLS_CC);
 		efree(new_op_array);
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -13745,12 +13219,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_VAR_HANDLER(ZEND_OPCODE_HAND
 		}
 
 	} else if (RETURN_VALUE_USED(opline)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		ZVAL_BOOL(retval, failure_retval);
-		INIT_PZVAL(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -13759,7 +13228,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *array_ptr, **array_ptr_ptr;
+	zval *array_ptr, *array_ref, iterator;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
 	zend_class_entry *ce = NULL;
@@ -13769,71 +13238,79 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 	if ((IS_VAR == IS_CV || IS_VAR == IS_VAR) &&
 	    (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
-		array_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-		if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
-			MAKE_STD_ZVAL(array_ptr);
-			ZVAL_NULL(array_ptr);
-		} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
-			if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
+		array_ptr = array_ref = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		ZVAL_DEREF(array_ptr);
+		if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
+			if (!Z_ISREF_P(array_ref)) {
+				SEPARATE_ZVAL(array_ptr);
+				array_ref = array_ptr;
+				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
+					ZVAL_NEW_REF(array_ptr, array_ptr);
+					array_ref = array_ptr;
+					array_ptr = Z_REFVAL_P(array_ptr);
+				}
+			}
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
+		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
+			if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) {
 				zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
 
-			ce = Z_OBJCE_PP(array_ptr_ptr);
+			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || ce->get_iterator == NULL) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				Z_ADDREF_PP(array_ptr_ptr);
-			}
-			array_ptr = *array_ptr_ptr;
-		} else {
-			if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-					Z_SET_ISREF_PP(array_ptr_ptr);
+				if (!Z_ISREF_P(array_ref)) {
+					SEPARATE_ZVAL(array_ptr);
 				}
+				Z_ADDREF_P(array_ptr);
 			}
-			array_ptr = *array_ptr_ptr;
-			Z_ADDREF_P(array_ptr);
+			array_ref = array_ptr;
+		} else {
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
 		}
 	} else {
-		array_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		array_ptr = array_ref = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		ZVAL_DEREF(array_ptr);
 		if (0) { /* IS_TMP_VAR */
-			zval *tmp;
+			zval tmp;
 
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			array_ptr = tmp;
+			ZVAL_COPY_VALUE(&tmp, array_ptr);
+			array_ptr = &tmp;
 			if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 				ce = Z_OBJCE_P(array_ptr);
 				if (ce && ce->get_iterator) {
-					Z_DELREF_P(array_ptr);
+					Z_DELREF_P(array_ref);
 				}
 			}
 		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || !ce->get_iterator) {
 				if (IS_VAR == IS_CV) {
-					Z_ADDREF_P(array_ptr);
+					Z_ADDREF_P(array_ref);
 				}
 			}
-		} else if (IS_VAR == IS_CONST ||
-		           (IS_VAR == IS_CV &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 1) ||
-		           (IS_VAR == IS_VAR &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 2)) {
-			zval *tmp;
+		} else if (Z_REFCOUNTED_P(array_ref)) {
+			if (IS_VAR == IS_CONST ||
+			           (IS_VAR == IS_CV &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 1) ||
+			           (IS_VAR == IS_VAR &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 2)) {
+				zval tmp;
 
-			if (IS_VAR == IS_VAR) {
-				Z_DELREF_P(array_ptr);
+				if (IS_VAR == IS_VAR) {
+					Z_DELREF_P(array_ref);
+				}
+				ZVAL_DUP(&tmp, array_ref);
+				array_ptr = array_ref = &tmp;
+			} else if (IS_VAR == IS_CV) {
+				if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) {
+					ZVAL_UNREF(array_ref);
+					array_ptr = array_ref;
+				}
+				Z_ADDREF_P(array_ref);
 			}
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			zval_copy_ctor(tmp);
-			array_ptr = tmp;
-		} else if (IS_VAR == IS_CV) {
-			Z_ADDREF_P(array_ptr);
 		}
 	}
 
@@ -13841,41 +13318,42 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		iter = ce->get_iterator(ce, array_ptr, opline->extended_value & ZEND_FE_RESET_REFERENCE TSRMLS_CC);
 
 		if (IS_VAR == IS_VAR && !(opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
-			zval_ptr_dtor_nogc(&free_op1.var);
+			zval_ptr_dtor_nogc(free_op1.var);
 		}
 		if (iter && EXPECTED(EG(exception) == NULL)) {
-			array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
+			ZVAL_OBJ(&iterator, &iter->std);
+			array_ptr = array_ref = &iterator;
 		} else {
 			if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 			if (!EG(exception)) {
-				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
+				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val);
 			}
 			zend_throw_exception_internal(NULL TSRMLS_CC);
 			HANDLE_EXCEPTION();
 		}
 	}
 
-	EX_T(opline->result.var).fe.ptr = array_ptr;
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
 
 	if (iter) {
 		iter->index = 0;
 		if (iter->funcs->rewind) {
 			iter->funcs->rewind(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array_ptr);
+				zval_ptr_dtor(array_ref);
 				if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
-					if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+					if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 				}
 				HANDLE_EXCEPTION();
 			}
 		}
 		is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&array_ptr);
+			zval_ptr_dtor(array_ref);
 			if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 			HANDLE_EXCEPTION();
 		}
@@ -13883,31 +13361,30 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
 		zend_hash_internal_pointer_reset(fe_ht);
 		if (ce) {
-			zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array_ptr);
 			while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
-				char *str_key;
-				uint str_key_len;
+				zend_string *str_key;
 				ulong int_key;
 				zend_uchar key_type;
 
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 				if (key_type != HASH_KEY_NON_EXISTENT &&
 					(key_type == HASH_KEY_IS_LONG ||
-				     zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
+				     zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) {
 					break;
 				}
 				zend_hash_move_forward(fe_ht);
 			}
 		}
 		is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
-		zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
+		zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var));
 	} else {
 		zend_error(E_WARNING, "Invalid argument supplied for foreach()");
 		is_empty = 1;
 	}
 
 	if (IS_VAR == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	}
 	if (is_empty) {
 		ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
@@ -13921,14 +13398,16 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 
-	zval *array = EX_T(opline->op1.var).fe.ptr;
-	zval **value;
+	zval *array, *array_ref;
+	zval *value;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
-
 	zval *key = NULL;
+
+	array = array_ref = EX_VAR(opline->op1.var);
+	ZVAL_DEREF(array);
 	if (opline->extended_value & ZEND_FE_FETCH_WITH_KEY) {
-		key = &EX_T((opline+1)->result.var).tmp_var;
+		key = EX_VAR((opline+1)->result.var);
 	}
 
 	SAVE_OPLINE();
@@ -13940,24 +13419,35 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 
 		case ZEND_ITER_PLAIN_OBJECT: {
-			zend_object *zobj = zend_objects_get_address(array TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array);
 			int key_type;
-			char *str_key;
-			zend_uint str_key_len;
+			zend_string *str_key;
 			zend_ulong int_key;
 
 			fe_ht = Z_OBJPROP_P(array);
-			zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
-			do {
-				if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
+			zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
+			while (1) {
+				if ((value = zend_hash_get_current_data(fe_ht)) == NULL) {
 					/* reached end of iteration */
 					ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 				}
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+
+				if (Z_TYPE_P(value) == IS_INDIRECT) {
+					value = Z_INDIRECT_P(value);
+					if (Z_TYPE_P(value) == IS_UNDEF) {
+						zend_hash_move_forward(fe_ht);
+						continue;
+					}
+				}
+
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 
 				zend_hash_move_forward(fe_ht);
-			} while (key_type != HASH_KEY_IS_LONG &&
-			         zend_check_property_access(zobj, str_key, str_key_len - 1 TSRMLS_CC) != SUCCESS);
+				if (key_type == HASH_KEY_IS_LONG ||
+				    zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS) {
+					break;
+				}
+			}
 
 			if (key) {
 				if (key_type == HASH_KEY_IS_LONG) {
@@ -13966,20 +13456,20 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 					const char *class_name, *prop_name;
 					int prop_name_len;
 					zend_unmangle_property_name_ex(
-						str_key, str_key_len - 1, &class_name, &prop_name, &prop_name_len
+						str_key->val, str_key->len, &class_name, &prop_name, &prop_name_len
 					);
-					ZVAL_STRINGL(key, prop_name, prop_name_len, 1);
+					ZVAL_STRINGL(key, prop_name, prop_name_len);
 				}
 			}
 
-			zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
+			zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
 			break;
 		}
 
 		case ZEND_ITER_PLAIN_ARRAY:
 			fe_ht = Z_ARRVAL_P(array);
-			zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
-			if (zend_hash_get_current_data(fe_ht, (void **) &value)==FAILURE) {
+			zend_hash_set_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
+			if ((value = zend_hash_get_current_data(fe_ht)) == NULL) {
 				/* reached end of iteration */
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
@@ -13987,7 +13477,7 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 				zend_hash_get_current_key_zval(fe_ht, key);
 			}
 			zend_hash_move_forward(fe_ht);
-			zend_hash_get_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
+			zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+1)->op1.var));
 			break;
 
 		case ZEND_ITER_OBJECT:
@@ -13997,7 +13487,7 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 				 * In case that ever happens we need an additional flag. */
 				iter->funcs->move_forward(iter TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					zval_ptr_dtor(&array);
+					zval_ptr_dtor(array_ref);
 					HANDLE_EXCEPTION();
 				}
 			}
@@ -14005,14 +13495,14 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			if (!iter || (iter->index > 0 && iter->funcs->valid(iter TSRMLS_CC) == FAILURE)) {
 				/* reached end of iteration */
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					zval_ptr_dtor(&array);
+					zval_ptr_dtor(array_ref);
 					HANDLE_EXCEPTION();
 				}
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
-			iter->funcs->get_current_data(iter, &value TSRMLS_CC);
+			value = iter->funcs->get_current_data(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array);
+				zval_ptr_dtor(array_ref);
 				HANDLE_EXCEPTION();
 			}
 			if (!value) {
@@ -14023,7 +13513,7 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 				if (iter->funcs->get_current_key) {
 					iter->funcs->get_current_key(iter, key TSRMLS_CC);
 					if (UNEXPECTED(EG(exception) != NULL)) {
-						zval_ptr_dtor(&array);
+						zval_ptr_dtor(array_ref);
 						HANDLE_EXCEPTION();
 					}
 				} else {
@@ -14034,14 +13524,9 @@ static int ZEND_FASTCALL  ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	}
 
 	if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-		SEPARATE_ZVAL_IF_NOT_REF(value);
-		Z_SET_ISREF_PP(value);
-		EX_T(opline->result.var).var.ptr_ptr = value;
-		Z_ADDREF_PP(value);
-	} else {
-		PZVAL_LOCK(*value);
-		EX_T(opline->result.var).var.ptr = *value;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(value);
 	}
+	ZVAL_COPY(EX_VAR(opline->result.var), value);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -14061,9 +13546,9 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 		if (Z_TYPE_P(ptr) == IS_LONG) {
 			EG(exit_status) = Z_LVAL_P(ptr);
 		} else {
-			zend_print_variable(ptr);
+			zend_print_variable(ptr TSRMLS_CC);
 		}
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 #endif
 	zend_bailout();
@@ -14080,18 +13565,18 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
-		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!0) {
-			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
 #endif
 		ZEND_VM_JMP(opline->op2.jmp_addr);
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14100,33 +13585,28 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
 		if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-			Z_ADDREF_P(value);
-			EX_T(opline->result.var).var.ptr = value;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-		} else {
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, value);
-			EX_T(opline->result.var).var.ptr = ret;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
+		} else {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 			if (!0) {
-				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+				zval_opt_copy_ctor(EX_VAR(opline->result.var));
 			}
 		}
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
 #endif
 		ZEND_VM_JMP(opline->op2.jmp_addr);
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14140,11 +13620,11 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	SAVE_OPLINE();
 	value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 	if (!0) {
-		zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+		zval_opt_copy_ctor(EX_VAR(opline->result.var));
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14153,26 +13633,21 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		Z_ADDREF_P(value);
-		EX_T(opline->result.var).var.ptr = value;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	} else {
-		ALLOC_ZVAL(ret);
-		INIT_PZVAL_COPY(ret, value);
-		EX_T(opline->result.var).var.ptr = ret;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
+	} else {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!0) {
-			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14185,15 +13660,15 @@ static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_bool result;
 
 	SAVE_OPLINE();
-	expr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	expr = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
-		result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
+		result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC);
 	} else {
 		result = 0;
 	}
-	ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14204,10 +13679,10 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14219,10 +13694,10 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14234,10 +13709,10 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14249,10 +13724,10 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14264,10 +13739,10 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14279,10 +13754,10 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14294,10 +13769,10 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14309,10 +13784,10 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14324,10 +13799,10 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14337,14 +13812,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14354,13 +13829,13 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14370,13 +13845,13 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14386,13 +13861,13 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14402,13 +13877,13 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_O
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14420,10 +13895,10 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14435,10 +13910,10 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14450,10 +13925,10 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14465,10 +13940,10 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -14478,18 +13953,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	zval *property = opline->op2.zv;
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -14497,325 +13972,411 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(int (*b
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-				if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = opline->op2.zv;
+	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = opline->op2.zv;
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = opline->op2.zv;
-			var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CONST TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = opline->op2.zv;
+	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_exit:
+
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = opline->op2.zv;
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14834,90 +14395,75 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CONST(incdec_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = opline->op2.zv;
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		ZVAL_NULL(retval);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -14937,19 +14483,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -14958,105 +14501,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+					if (IS_VAR != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op1.var);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_VAR == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_VAR != IS_TMP_VAR) {
-					zval_ptr_dtor_nogc(&free_op1.var);
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				zval_ptr_dtor_nogc(&free_op1.var);
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_VAR == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			zval_ptr_dtor_nogc(free_op1.var);
 		}
 	}
 
-
-	if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+	if (IS_VAR != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15081,7 +14607,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_VAR_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_VAR_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -15102,10 +14632,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15115,32 +14645,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
-
-	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
 
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15149,20 +14671,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15175,9 +14697,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15185,31 +14707,30 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		zval *container;
-
 		if (IS_CONST == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15219,41 +14740,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(ZEND_OPCODE_HANDLER_ARGS)
@@ -15265,36 +14767,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CONST(
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = opline->op2.zv;
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15309,41 +14800,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HA
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = opline->op2.zv;
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
-	}
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15353,28 +14825,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = opline->op2.zv;
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
-	}
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15388,35 +14853,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = opline->op2.zv;
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15424,33 +14878,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = opline->op2.zv;
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
-		}
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -15461,42 +14908,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CONST_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1;
+	zval *container, *property;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = opline->op2.zv;
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
-	}
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15505,26 +14932,19 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property_name = opline->op2.zv;
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -15535,76 +14955,59 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
 	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 
 		zval *property_name = opline->op2.zv;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-		}
 	} else {
 		zend_free_op free_op_data1, free_op_data2;
 		zval *value;
 		zval *dim = opline->op2.zv;
-		zval **variable_ptr_ptr;
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CONST TSRMLS_CC);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
- 	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ 	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_dim has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -15616,50 +15019,35 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = opline->op2.zv;
-	variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
-
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_CONST, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (0) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_CONST == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_CONST == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
 
 	CHECK_EXCEPTION();
@@ -15670,10 +15058,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -15687,33 +15074,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CONST != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CONST == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -15721,28 +15105,20 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
 	EX(call) = call;
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15759,21 +15135,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
 
 	if (IS_VAR == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -15784,51 +15160,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
 
 	if (IS_VAR == IS_CONST &&
 	    IS_CONST == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_VAR != IS_CONST &&
 	           IS_CONST == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_CONST != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
-
 
-		if (IS_CONST == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = opline->op2.zv;
 
+		function_name = opline->op2.zv;
+		if (IS_CONST != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_CONST == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_VAR == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_CONST == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_VAR == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_CONST != IS_CONST) {
@@ -15838,8 +15203,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -15847,21 +15212,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CONST_HANDLER(ZE
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -15877,11 +15242,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 	zend_free_op free_op1;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 opline->op2.zv TSRMLS_CC);
+				 opline->op2.zv TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -15896,9 +15262,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
 		zend_constant *c;
 		zval *retval;
 
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			c = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
 			if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
 				char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
 				if(!actual) {
@@ -15908,52 +15274,52 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
 				}
 				/* non-qualified constant - allow text substitution */
 				zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
-				ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
+				ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)));
 				CHECK_EXCEPTION();
 				ZEND_VM_NEXT_OPCODE();
 			} else {
 				zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
 			}
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, c);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
 		}
-		retval = &EX_T(opline->result.var).tmp_var;
-		ZVAL_COPY_VALUE(retval, &c->value);
-		zval_copy_ctor(retval);
+		retval = EX_VAR(opline->result.var);
+		ZVAL_DUP(retval, &c->value);
 	} else {
 		/* class constant */
 		zend_class_entry *ce;
-		zval **value;
+		zval *value;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				value = CACHED_PTR(opline->op2.literal->cache_slot);
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
-			} else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op1.literal->cache_slot);
+			} else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 				}
-				CACHE_PTR(opline->op1.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op1.var).class_entry;
-			if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ce = Z_CE_P(EX_VAR(opline->op1.var));
+			if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
 			}
 		}
 
-		if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
-			if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
+		if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
+			if (Z_ISREF_P(value)) {
+				value = Z_REFVAL_P(value);
+			}
+			if (Z_CONSTANT_P(value)) {
 				zend_class_entry *old_scope = EG(scope);
 
 				EG(scope) = ce;
@@ -15961,23 +15327,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE
 				EG(scope) = old_scope;
 			}
 			if (IS_VAR == IS_CONST) {
-				CACHE_PTR(opline->op2.literal->cache_slot, value);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
 			} else {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
 			}
-			ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-			zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ZVAL_DUP(EX_VAR(opline->result.var), value);
 		} else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
 			/* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
-			ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
+			ZVAL_STR(EX_VAR(opline->result.var), ce->name);
+			STR_ADDREF(ce->name);
 		} else {
 			zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
 		}
 	}
 constant_fetch_end:
-	if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) {
-		zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time");
-	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -15986,35 +15349,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-		if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else if (IS_VAR == IS_CV) {
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
+			zval_ptr_dtor_nogc(free_op1.var);
+		} else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -16022,8 +15381,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 	if (IS_CONST != IS_UNUSED) {
 
 		zval *offset = opline->op2.zv;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -16032,32 +15393,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16065,9 +15426,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_VAR != IS_UNUSED
@@ -16083,20 +15461,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -16104,53 +15477,52 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
 	varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_CONST != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_VAR != IS_CONST && varname == &tmp) {
+					if (IS_VAR != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_VAR != IS_CONST && varname == &tmp) {
+	if (IS_VAR != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -16159,94 +15531,92 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	if (IS_VAR != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = opline->op2.zv;
 
-	if (IS_VAR != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_CONST == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_CONST != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
-
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
 
-				break;
+			break;
 		}
-	} else {
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_CONST == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
 
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
 
+			break;
+	}
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -16255,39 +15625,26 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = opline->op2.zv;
 
-	if (IS_VAR != IS_VAR || container) {
-		if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
 
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -16295,21 +15652,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -16319,8 +15671,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 		zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -16329,26 +15680,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 			zend_class_entry *ce;
 
 			if (IS_CONST == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -16356,20 +15707,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 		if (IS_VAR != IS_CONST && varname == &tmp) {
 			zval_dtor(&tmp);
 		}
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -16377,26 +15728,25 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPC
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset = opline->op2.zv;
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -16406,25 +15756,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -16432,118 +15780,103 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-
-	} else {
-
-	}
-
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
-
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_VAR != IS_UNUSED) {
@@ -16553,75 +15886,59 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-				if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 		} else {
 			zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
-				zval_ptr_dtor_nogc(&free_op1.var);
+			if (IS_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+				zval_ptr_dtor_nogc(free_op1.var);
 			} else {
 				if (IS_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -16630,45 +15947,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *key = opline->op2.zv;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CONST == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CONST == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -16690,10 +15998,10 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16710,10 +16018,10 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16725,10 +16033,10 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16740,10 +16048,10 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16755,10 +16063,10 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16770,10 +16078,10 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16785,10 +16093,10 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16800,10 +16108,10 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16815,10 +16123,10 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16830,10 +16138,10 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16843,14 +16151,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16860,13 +16168,13 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16876,13 +16184,13 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16892,13 +16200,13 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16908,13 +16216,13 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16926,10 +16234,10 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16941,10 +16249,10 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16956,10 +16264,10 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16971,10 +16279,10 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -16984,18 +16292,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -17003,326 +16311,413 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(int (*bin
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (1) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zval_dtor(free_op2.var);
 		FREE_OP(free_op_data1);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-				if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-			var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_TMP_VAR TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		zval_dtor(free_op2.var);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
-		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_dim_exit:
 	zval_dtor(free_op2.var);
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+	zval_dtor(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		zval_dtor(free_op2.var);
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	zval_dtor(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17341,90 +16736,76 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_TMP(incdec_t
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		zval_dtor(free_op2.var);
 		ZVAL_NULL(retval);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	zval_dtor(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17447,10 +16828,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -17460,32 +16841,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+	}
 	zval_dtor(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17494,20 +16867,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17520,9 +16893,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17530,31 +16903,30 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 		zval_dtor(free_op2.var);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		zval *container;
-
 		if (IS_TMP_VAR == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 		zval_dtor(free_op2.var);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -17564,41 +16936,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZEND_OPCODE_HANDLER_ARGS)
@@ -17610,36 +16963,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_TMP(ZE
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_dtor(free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_dtor(free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17654,41 +16997,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAND
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17698,28 +17022,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17733,35 +17050,25 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_dtor(free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_dtor(free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17769,33 +17076,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (1) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		zval_dtor(free_op2.var);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -17806,42 +17106,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_TMP_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -17850,26 +17130,19 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		zval_dtor(free_op2.var);
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	zval_dtor(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -17880,77 +17153,60 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
 	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 		zend_free_op free_op2;
 		zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (1) {
-			zval_ptr_dtor(&property_name);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+		zval_dtor(free_op2.var);
 	} else {
 		zend_free_op free_op2, free_op_data1, free_op_data2;
 		zval *value;
 		zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		zval **variable_ptr_ptr;
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR TSRMLS_CC);
 		zval_dtor(free_op2.var);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
- 	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ 	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_dim has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -17962,50 +17218,35 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-	if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
+	variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_TMP_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (1) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_TMP_VAR == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_TMP_VAR == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
 
 	CHECK_EXCEPTION();
@@ -18016,10 +17257,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1, free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -18033,33 +17273,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_TMP_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -18067,21 +17304,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
 			zval_dtor(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -18089,7 +17318,7 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
 	EX(call) = call;
 
 	zval_dtor(free_op2.var);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -18106,21 +17335,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
 
 	if (IS_VAR == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -18131,51 +17360,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
 
 	if (IS_VAR == IS_CONST &&
 	    IS_TMP_VAR == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_VAR != IS_CONST &&
 	           IS_TMP_VAR == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_TMP_VAR != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 		zend_free_op free_op2;
 
-		if (IS_TMP_VAR == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
+		function_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		if (IS_TMP_VAR != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_TMP_VAR == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_VAR == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_TMP_VAR == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_VAR == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_TMP_VAR != IS_CONST) {
@@ -18185,8 +17403,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -18194,21 +17412,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_TMP_HANDLER(ZEND
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -18224,11 +17442,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -18239,35 +17458,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-		if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else if (IS_VAR == IS_CV) {
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
+			zval_ptr_dtor_nogc(free_op1.var);
+		} else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -18275,8 +17490,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD
 	if (IS_TMP_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -18285,32 +17502,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 		zval_dtor(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -18318,9 +17535,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_VAR != IS_UNUSED
@@ -18334,94 +17568,92 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	if (IS_VAR != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_VAR != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_TMP_VAR == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_TMP_VAR != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				zval_dtor(free_op2.var);
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (1) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (1) {
-					zval_ptr_dtor(&offset);
-				} else {
-					zval_dtor(free_op2.var);
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				zval_dtor(free_op2.var);
-				break;
+			zval_dtor(free_op2.var);
+			break;
 		}
-	} else {
-		zval_dtor(free_op2.var);
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_TMP_VAR == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			zval_dtor(free_op2.var);
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+			zval_dtor(free_op2.var);
+			break;
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18430,63 +17662,49 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_VAR != IS_VAR || container) {
-		if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (1) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (1) {
-				zval_ptr_dtor(&offset);
-			} else {
-				zval_dtor(free_op2.var);
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			zval_dtor(free_op2.var);
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		zval_dtor(free_op2.var);
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
+	zval_dtor(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -18496,25 +17714,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(in
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -18522,118 +17738,105 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		zval_dtor(free_op2.var);
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-		zval_dtor(free_op2.var);
-	} else {
-		zval_dtor(free_op2.var);
-	}
-
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
-
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_VAR != IS_UNUSED) {
@@ -18643,75 +17846,59 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-				if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 		} else {
 			zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
-				zval_ptr_dtor_nogc(&free_op1.var);
+			if (IS_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+				zval_ptr_dtor_nogc(free_op1.var);
 			} else {
 				if (IS_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -18720,45 +17907,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!1) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_TMP_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_TMP_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -18780,10 +17958,10 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -18800,11 +17978,11 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18815,11 +17993,11 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18830,11 +18008,11 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18845,11 +18023,11 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18860,11 +18038,11 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18875,11 +18053,11 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18890,11 +18068,11 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18905,11 +18083,11 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18920,11 +18098,11 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18933,15 +18111,15 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18950,14 +18128,14 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18966,14 +18144,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18982,14 +18160,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -18998,14 +18176,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19016,11 +18194,11 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19031,11 +18209,11 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19046,11 +18224,11 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19061,11 +18239,11 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19074,345 +18252,432 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(int (*bin
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zval_ptr_dtor_nogc(free_op2.var);
 		FREE_OP(free_op_data1);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-				if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-			var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_VAR TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
-		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
-	zval_ptr_dtor_nogc(&free_op2.var);
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+assign_op_dim_exit:
+	zval_ptr_dtor_nogc(free_op2.var);
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19431,90 +18696,76 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_VAR(incdec_t
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		ZVAL_NULL(retval);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19534,19 +18785,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -19555,105 +18803,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+					if (IS_VAR != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op1.var);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_VAR == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_VAR != IS_TMP_VAR) {
-					zval_ptr_dtor_nogc(&free_op1.var);
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				zval_ptr_dtor_nogc(&free_op1.var);
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_VAR == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			zval_ptr_dtor_nogc(free_op1.var);
 		}
 	}
 
-
-	if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+	if (IS_VAR != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -19678,7 +18909,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_VAR_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_VAR_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -19699,10 +18934,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -19712,32 +18947,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
-	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19746,20 +18973,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19772,9 +18999,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19782,31 +19009,30 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		zval_ptr_dtor_nogc(free_op2.var);
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		zval *container;
-
 		if (IS_VAR == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op2.var);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -19816,41 +19042,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZEND_OPCODE_HANDLER_ARGS)
@@ -19862,36 +19069,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_VAR(ZE
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19906,41 +19103,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAND
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19950,28 +19128,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -19985,35 +19156,25 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -20021,33 +19182,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -20058,42 +19212,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_VAR_HANDLER(ZEND_OPCO
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -20102,26 +19236,19 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -20132,77 +19259,60 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
 	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 		zend_free_op free_op2;
 		zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 	} else {
 		zend_free_op free_op2, free_op_data1, free_op_data2;
 		zval *value;
-		zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		zval **variable_ptr_ptr;
+		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_VAR TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
- 	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ 	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_dim has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -20214,52 +19324,37 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
-
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (0) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_VAR == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_VAR == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
- 	zval_ptr_dtor_nogc(&free_op2.var);
+ 	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -20269,51 +19364,60 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **variable_ptr_ptr;
-	zval **value_ptr_ptr;
+	zval *variable_ptr;
+	zval *value_ptr;
 
 	SAVE_OPLINE();
-	value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR &&
-	    value_ptr_ptr &&
-	    !Z_ISREF_PP(value_ptr_ptr) &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION &&
-	    !EX_T(opline->op2.var).var.fcall_returned_reference) {
-		if (free_op2.var == NULL) {
-			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
+	    !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) &&
+	    !Z_ISREF_P(value_ptr)) {
+		if (!(free_op2.var != NULL)) {
+			PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
+			if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);};
 			HANDLE_EXCEPTION();
 		}
 		return ZEND_ASSIGN_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		PZVAL_LOCK(*value_ptr_ptr);
+		if (!(free_op2.var != NULL)) {
+			PZVAL_LOCK(value_ptr);
+		}
 	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
+
+	variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR &&
+	    UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
+	    UNEXPECTED(!Z_ISREF_P(variable_ptr))) {
 		zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
-
-	variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
-	    (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
+	if ((IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) ||
+	    (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) {
 		zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
 	}
-	zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
+	if ((IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
+	    (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+		variable_ptr = &EG(uninitialized_zval);
+	} else {
+		zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC);
+	}
 
 	if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		Z_DELREF_PP(variable_ptr_ptr);
+		if (!(free_op2.var != NULL)) {
+			Z_DELREF_P(variable_ptr);
+		}
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*variable_ptr_ptr);
-		EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-	if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);};
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -20323,10 +19427,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1, free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -20340,63 +19443,52 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
 	EX(call) = call;
 
-	zval_ptr_dtor_nogc(&free_op2.var);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -20413,21 +19505,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
 
 	if (IS_VAR == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -20438,62 +19530,51 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
 
 	if (IS_VAR == IS_CONST &&
 	    IS_VAR == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_VAR != IS_CONST &&
 	           IS_VAR == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_VAR != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 		zend_free_op free_op2;
 
-		if (IS_VAR == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-
+		function_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		if (IS_VAR != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_VAR == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_VAR == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_VAR == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_VAR == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_VAR != IS_CONST) {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 		}
 	} else {
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -20501,21 +19582,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_VAR_HANDLER(ZEND
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -20531,13 +19612,14 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -20546,35 +19628,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-		if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else if (IS_VAR == IS_CV) {
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
+			zval_ptr_dtor_nogc(free_op1.var);
+		} else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -20582,8 +19660,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 	if (IS_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -20592,32 +19672,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -20625,9 +19705,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_VAR != IS_UNUSED
@@ -20643,20 +19740,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -20664,53 +19756,52 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
 	varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_VAR != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_VAR != IS_CONST && varname == &tmp) {
+					if (IS_VAR != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_VAR != IS_CONST && varname == &tmp) {
+	if (IS_VAR != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -20719,94 +19810,92 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	if (IS_VAR != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_VAR != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_VAR == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_VAR != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				zval_ptr_dtor_nogc(&free_op2.var);
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
-					zval_ptr_dtor_nogc(&free_op2.var);
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				zval_ptr_dtor_nogc(&free_op2.var);
-				break;
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
 		}
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_VAR == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -20815,39 +19904,26 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_VAR != IS_VAR || container) {
-		if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-				zval_ptr_dtor_nogc(&free_op2.var);
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -20855,21 +19931,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -20879,8 +19950,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 		zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -20889,26 +19959,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 			zend_class_entry *ce;
 
 			if (IS_VAR == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -20916,20 +19986,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 		if (IS_VAR != IS_CONST && varname == &tmp) {
 			zval_dtor(&tmp);
 		}
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -20937,26 +20007,25 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -20966,25 +20035,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(in
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -20992,118 +20059,105 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
-
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
-
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op1, free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_VAR != IS_UNUSED) {
@@ -21113,75 +20167,59 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-				if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 		} else {
 			zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
-				zval_ptr_dtor_nogc(&free_op1.var);
+			if (IS_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+				zval_ptr_dtor_nogc(free_op1.var);
 			} else {
 				if (IS_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -21190,46 +20228,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
-
-			generator->key = copy;
+		if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+			zval_ptr_dtor_nogc(free_op2.var);
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -21251,11 +20279,11 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -21269,18 +20297,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	zval *property = NULL;
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -21288,233 +20316,332 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(int (*
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-				if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = NULL;
+	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = NULL;
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = NULL;
-			var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_UNUSED TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = NULL;
+	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_exit:
+
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
@@ -21522,19 +20649,16 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_VAR != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -21543,105 +20667,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+					if (IS_VAR != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op1.var);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op1.var);
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_VAR == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_VAR != IS_TMP_VAR) {
-					zval_ptr_dtor_nogc(&free_op1.var);
-				}
-				break;
-			case ZEND_FETCH_LOCAL:
-				zval_ptr_dtor_nogc(&free_op1.var);
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_VAR == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
+			zval_ptr_dtor_nogc(free_op1.var);
 		}
 	}
 
-
-	if (IS_VAR != IS_CONST && varname == &tmp_varname) {
+	if (IS_VAR != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -21666,7 +20773,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_VAR_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -21683,32 +20794,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
-
-	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
 
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -21717,20 +20820,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -21738,31 +20841,30 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		zval *container;
-
 		if (IS_UNUSED == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -21772,76 +20874,59 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
 	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 
 		zval *property_name = NULL;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-		}
 	} else {
 		zend_free_op free_op_data1, free_op_data2;
 		zval *value;
 		zval *dim = NULL;
-		zval **variable_ptr_ptr;
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_UNUSED TSRMLS_CC);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
- 	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ 	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_dim has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -21859,21 +20944,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
 
 	if (IS_VAR == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -21884,51 +20969,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
 
 	if (IS_VAR == IS_CONST &&
 	    IS_UNUSED == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_VAR != IS_CONST &&
 	           IS_UNUSED == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_UNUSED != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
 
 
-		if (IS_UNUSED == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = NULL;
-
+		function_name = NULL;
+		if (IS_UNUSED != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_UNUSED == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_UNUSED == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_VAR == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_UNUSED == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_UNUSED == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_VAR == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_UNUSED != IS_CONST) {
@@ -21938,8 +21012,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -21947,21 +21021,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_UNUSED_HANDLER(Z
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -21977,35 +21051,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-		if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else if (IS_VAR == IS_CV) {
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
+			zval_ptr_dtor_nogc(free_op1.var);
+		} else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -22013,8 +21083,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 	if (IS_UNUSED != IS_UNUSED) {
 
 		zval *offset = NULL;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -22023,32 +21095,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_UNUSED == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_UNUSED != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22056,9 +21128,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_VAR != IS_UNUSED
@@ -22074,20 +21163,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 	zend_free_op free_op1;
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -22095,53 +21179,52 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
 	varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 	if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_UNUSED != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_VAR != IS_CONST && varname == &tmp) {
+					if (IS_VAR != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
-					zval_ptr_dtor_nogc(&free_op1.var);
+					zval_ptr_dtor_nogc(free_op1.var);
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_VAR != IS_CONST && varname == &tmp) {
+	if (IS_VAR != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_VAR == IS_VAR || IS_VAR == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -22149,21 +21232,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_VAR == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -22173,8 +21251,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 		zval tmp, *varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -22183,26 +21260,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 			zend_class_entry *ce;
 
 			if (IS_UNUSED == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -22210,20 +21287,20 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 		if (IS_VAR != IS_CONST && varname == &tmp) {
 			zval_dtor(&tmp);
 		}
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -22234,20 +21311,17 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_SEPARATE_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *var_ptr, *new_zv;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
-	var_ptr = EX_T(opline->op1.var).var.ptr;
+	var_ptr = EX_VAR(opline->op1.var);
 	if (Z_TYPE_P(var_ptr) != IS_OBJECT &&
-			!PZVAL_IS_REF(var_ptr) &&
-			Z_REFCOUNT_P(var_ptr) > 1) {
+	    !Z_ISREF_P(var_ptr) &&
+	    Z_REFCOUNTED_P(var_ptr) &&
+	    Z_REFCOUNT_P(var_ptr) > 1) {
 
 		Z_DELREF_P(var_ptr);
-		ALLOC_ZVAL(new_zv);
-		INIT_PZVAL_COPY(new_zv, var_ptr);
-		var_ptr = new_zv;
-		zval_copy_ctor(var_ptr);
-		EX_T(opline->op1.var).var.ptr = var_ptr;
+		ZVAL_DUP(EX_VAR(opline->op1.var), var_ptr);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -22256,22 +21330,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_VAR != IS_UNUSED) {
@@ -22281,75 +21351,59 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-				if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 		} else {
 			zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
-				zval_ptr_dtor_nogc(&free_op1.var);
+			if (IS_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+				zval_ptr_dtor_nogc(free_op1.var);
 			} else {
 				if (IS_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -22358,45 +21412,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HANDLER
 		zval *key = NULL;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_UNUSED == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_UNUSED == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_UNUSED == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -22423,10 +21468,10 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22438,10 +21483,10 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22453,10 +21498,10 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22468,10 +21513,10 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22483,10 +21528,10 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22498,10 +21543,10 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22513,10 +21558,10 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22528,10 +21573,10 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22543,10 +21588,10 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22556,14 +21601,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22573,13 +21618,13 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22589,13 +21634,13 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22605,13 +21650,13 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22621,13 +21666,13 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22639,10 +21684,10 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22654,10 +21699,10 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22669,10 +21714,10 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22684,10 +21729,10 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -22697,18 +21742,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -22716,325 +21761,411 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_VAR_CV(int (*bina
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-				if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_VAR == IS_VAR && !(free_op1.var != NULL)) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-			var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CV TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
-		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_VAR_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	var_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_VAR == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-		CHECK_EXCEPTION();
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_VAR_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_VAR_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23053,90 +22184,75 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_VAR_CV(incdec_t i
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		ZVAL_NULL(retval);
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23159,10 +22275,10 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_VAR != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -23172,32 +22288,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
-
-	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
 
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23206,20 +22314,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23232,9 +22340,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23242,31 +22350,30 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		zval *container;
-
 		if (IS_CV == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
-		zval_ptr_dtor_nogc(&free_op1.var);
+		zval_ptr_dtor_nogc(free_op1.var);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -23276,41 +22383,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEND_OPCODE_HANDLER_ARGS)
@@ -23322,36 +22410,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_VAR_CV(ZEN
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23366,41 +22443,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDL
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
-	}
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	}
-
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23410,28 +22468,21 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
-	}
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23445,35 +22496,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23481,33 +22521,26 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 		container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
-		}
 		if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	} else {
@@ -23518,42 +22551,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_VAR_CV_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1;
+	zval *container, *property;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_VAR == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
-	}
 	if (IS_VAR == IS_VAR && (free_op1.var != NULL) && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -23562,26 +22575,19 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -23592,76 +22598,59 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
 	object_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 
 		zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-		}
 	} else {
 		zend_free_op free_op_data1, free_op_data2;
 		zval *value;
-		zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-		zval **variable_ptr_ptr;
+		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CV TSRMLS_CC);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
- 	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+ 	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	/* assign_dim has two opcodes! */
 	CHECK_EXCEPTION();
 	ZEND_VM_INC_OPCODE();
@@ -23673,50 +22662,35 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-	if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
-
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_VAR == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_CV, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (0) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_CV == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_CV == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
-
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
 
 	CHECK_EXCEPTION();
@@ -23726,20 +22700,19 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2;
-	zval **variable_ptr_ptr;
-	zval **value_ptr_ptr;
+	zend_free_op free_op1;
+	zval *variable_ptr;
+	zval *value_ptr;
 
 	SAVE_OPLINE();
-	value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
+	value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
 
 	if (IS_CV == IS_VAR &&
-	    value_ptr_ptr &&
-	    !Z_ISREF_PP(value_ptr_ptr) &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION &&
-	    !EX_T(opline->op2.var).var.fcall_returned_reference) {
-		if (free_op2.var == NULL) {
-			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
+	    !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) &&
+	    !Z_ISREF_P(value_ptr)) {
+		if (!0) {
+			PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -23748,29 +22721,39 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
 		}
 		return ZEND_ASSIGN_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		PZVAL_LOCK(*value_ptr_ptr);
+		if (!0) {
+			PZVAL_LOCK(value_ptr);
+		}
 	}
-	if (IS_VAR == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
+
+	variable_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR &&
+	    UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
+	    UNEXPECTED(!Z_ISREF_P(variable_ptr))) {
 		zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
-
-	variable_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
-	    (IS_VAR == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
+	if ((IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) ||
+	    (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) {
 		zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
 	}
-	zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
+	if ((IS_VAR == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
+	    (IS_CV == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+		variable_ptr = &EG(uninitialized_zval);
+	} else {
+		zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC);
+	}
 
 	if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		Z_DELREF_PP(variable_ptr_ptr);
+		if (!0) {
+			Z_DELREF_P(variable_ptr);
+		}
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*variable_ptr_ptr);
-		EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
 	}
 
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -23780,10 +22763,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op1;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -23797,33 +22779,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	object = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CV != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CV == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -23831,28 +22810,20 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
 	EX(call) = call;
 
-	zval_ptr_dtor_nogc(&free_op1.var);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -23869,21 +22840,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
 
 	if (IS_VAR == IS_CONST) {
 		/* no function found. try a static method in class */
-		if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-			ce = CACHED_PTR(opline->op1.literal->cache_slot);
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+			ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 		} else {
-			ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+			ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
 				HANDLE_EXCEPTION();
 			}
 			if (UNEXPECTED(ce == NULL)) {
 				zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 			}
-			CACHE_PTR(opline->op1.literal->cache_slot, ce);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 		}
 		call->called_scope = ce;
 	} else {
-		ce = EX_T(opline->op1.var).class_entry;
+		ce = Z_CE_P(EX_VAR(opline->op1.var));
 
 		if (opline->extended_value == ZEND_FETCH_CLASS_PARENT || opline->extended_value == ZEND_FETCH_CLASS_SELF) {
 			call->called_scope = EG(called_scope);
@@ -23894,51 +22865,40 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
 
 	if (IS_VAR == IS_CONST &&
 	    IS_CV == IS_CONST &&
-	    CACHED_PTR(opline->op2.literal->cache_slot)) {
-		call->fbc = CACHED_PTR(opline->op2.literal->cache_slot);
+	    CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+		call->fbc = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 	} else if (IS_VAR != IS_CONST &&
 	           IS_CV == IS_CONST &&
-	           (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce))) {
+	           (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce))) {
 		/* do nothing */
 	} else if (IS_CV != IS_UNUSED) {
-		char *function_name_strval = NULL;
-		int function_name_strlen = 0;
-
 
-		if (IS_CV == IS_CONST) {
-			function_name_strval = Z_STRVAL_P(opline->op2.zv);
-			function_name_strlen = Z_STRLEN_P(opline->op2.zv);
-		} else {
-			function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
+		function_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		if (IS_CV != IS_CONST) {
 			if (UNEXPECTED(Z_TYPE_P(function_name) != IS_STRING)) {
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				zend_error_noreturn(E_ERROR, "Function name must be a string");
-			} else {
-				function_name_strval = Z_STRVAL_P(function_name);
-				function_name_strlen = Z_STRLEN_P(function_name);
  			}
 		}
 
-		if (function_name_strval) {
-			if (ce->get_static_method) {
-				call->fbc = ce->get_static_method(ce, function_name_strval, function_name_strlen TSRMLS_CC);
+		if (ce->get_static_method) {
+			call->fbc = ce->get_static_method(ce, Z_STR_P(function_name) TSRMLS_CC);
+		} else {
+			call->fbc = zend_std_get_static_method(ce, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
+		}
+		if (UNEXPECTED(call->fbc == NULL)) {
+			zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name->val, Z_STRVAL_P(function_name));
+		}
+		if (IS_CV == IS_CONST &&
+		    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
+		    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
+			if (IS_VAR == IS_CONST) {
+				CACHE_PTR(Z_CACHE_SLOT_P(function_name), call->fbc);
 			} else {
-				call->fbc = zend_std_get_static_method(ce, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
-			}
-			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", ce->name, function_name_strval);
-			}
-			if (IS_CV == IS_CONST &&
-			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
-			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0)) {
-				if (IS_VAR == IS_CONST) {
-					CACHE_PTR(opline->op2.literal->cache_slot, call->fbc);
-				} else {
-					CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, call->fbc);
-				}
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), ce, call->fbc);
 			}
 		}
 		if (IS_CV != IS_CONST) {
@@ -23948,8 +22908,8 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
 		if (UNEXPECTED(ce->constructor == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot call constructor");
 		}
-		if (EG(This) && Z_OBJCE_P(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
-			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name);
+		if (Z_OBJ(EG(This)) && Z_OBJCE(EG(This)) != ce->constructor->common.scope && (ce->constructor->common.fn_flags & ZEND_ACC_PRIVATE)) {
+			zend_error_noreturn(E_ERROR, "Cannot call private %s::__construct()", ce->name->val);
 		}
 		call->fbc = ce->constructor;
 	}
@@ -23957,21 +22917,21 @@ static int ZEND_FASTCALL  ZEND_INIT_STATIC_METHOD_CALL_SPEC_VAR_CV_HANDLER(ZEND_
 	if (call->fbc->common.fn_flags & ZEND_ACC_STATIC) {
 		call->object = NULL;
 	} else {
-		if (EG(This) &&
-		    Z_OBJ_HT_P(EG(This))->get_class_entry &&
-		    !instanceof_function(Z_OBJCE_P(EG(This)), ce TSRMLS_CC)) {
+		if (Z_OBJ(EG(This)) &&
+		    Z_OBJ_HT(EG(This))->get_class_entry &&
+		    !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {
 		    /* We are calling method of the other (incompatible) class,
 		       but passing $this. This is done for compatibility with php-4. */
 			if (call->fbc->common.fn_flags & ZEND_ACC_ALLOW_STATIC) {
-				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error(E_DEPRECATED, "Non-static method %s::%s() should not be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			} else {
 				/* An internal function assumes $this is present and won't check that. So PHP would crash by allowing the call. */
-				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name, call->fbc->common.function_name);
+				zend_error_noreturn(E_ERROR, "Non-static method %s::%s() cannot be called statically, assuming $this from incompatible context", call->fbc->common.scope->name->val, call->fbc->common.function_name->val);
 			}
 		}
-		if ((call->object = EG(This))) {
-			Z_ADDREF_P(call->object);
-			call->called_scope = Z_OBJCE_P(call->object);
+		call->object = Z_OBJ(EG(This));
+		if (call->object) {
+			GC_REFCOUNT(call->object)++;
 		}
 	}
 
@@ -23987,11 +22947,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zend_free_op free_op1;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -24001,35 +22962,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-
-		if (IS_VAR == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+		if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	} else {
-		expr_ptr=_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_VAR == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
-			zval_ptr_dtor_nogc(&free_op1.var);
-		} else if (IS_VAR == IS_CV) {
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
+			zval_ptr_dtor_nogc(free_op1.var);
+		} else if (IS_VAR == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -24037,8 +22994,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE
 	if (IS_CV != IS_UNUSED) {
 
 		zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -24047,32 +23006,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_VAR == IS_VAR || IS_VAR == IS_CV) && opline->extended_value) {
-		if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -24080,9 +23039,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_VAR != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_VAR != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_VAR == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_VAR != IS_UNUSED
@@ -24096,94 +23072,92 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-	if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	if (IS_VAR != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_VAR != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_CV == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_CV != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
 
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-
-				break;
+			break;
 		}
-	} else {
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_CV == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
 
-	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
 
+			break;
+	}
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -24192,63 +23166,49 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	if (IS_VAR == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_VAR != IS_VAR || container) {
-		if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-
 	}
-	if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
 
+	if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -24258,25 +23218,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -24284,118 +23242,103 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-
-	} else {
-
-	}
-
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	zval_ptr_dtor_nogc(&free_op1.var);
-
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op1;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+	zval_ptr_dtor_nogc(free_op1.var);
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_VAR != IS_UNUSED) {
@@ -24405,75 +23348,59 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-				if (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_VAR == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_VAR == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
-				if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);};
+				if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);};
 			}
 		} else {
 			zval *value = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
-				zval_ptr_dtor_nogc(&free_op1.var);
+			if (IS_VAR == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_VAR == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
+				zval_ptr_dtor_nogc(free_op1.var);
 			} else {
 				if (IS_VAR == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -24482,45 +23409,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CV == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CV == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -24542,10 +23460,10 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op1.var);
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op1.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -24581,7 +23499,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (UNEXPECTED(clone_call == NULL)) {
 		if (ce) {
-			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
+			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
 		} else {
 			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
 		}
@@ -24592,29 +23510,21 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(ce != EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (EXPECTED(EG(exception) == NULL)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
-		Z_TYPE_P(retval) = IS_OBJECT;
-		Z_SET_REFCOUNT_P(retval, 1);
-		Z_SET_ISREF_P(retval);
+		ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC));
 		if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&retval);
-		} else {
-			EX_T(opline->result.var).var.ptr = retval;
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -24635,7 +23545,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 		if (Z_TYPE_P(ptr) == IS_LONG) {
 			EG(exit_status) = Z_LVAL_P(ptr);
 		} else {
-			zend_print_variable(ptr);
+			zend_print_variable(ptr TSRMLS_CC);
 		}
 
 	}
@@ -24648,18 +23558,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
 {
 	USE_OPLINE
 	zend_free_op free_op_data1;
-	zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	zval *object;
+	zval *object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	zval *property = opline->op2.zv;
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -24667,81 +23577,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
@@ -24751,178 +23647,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(int
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_UNUSED == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = opline->op2.zv;
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_UNUSED == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = opline->op2.zv;
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = opline->op2.zv;
-			var_ptr = NULL;
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CONST TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
+		goto assign_op_dim_exit;
+	}
 
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
+	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = opline->op2.zv;
+	var_ptr = NULL;
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_exit:
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
-	} else {
 
-		CHECK_EXCEPTION();
-	}
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = opline->op2.zv;
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -24931,59 +23937,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CONST(incde
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -25003,23 +23999,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = opline->op2.zv;
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -25032,60 +24026,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CONST(incd
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -25116,29 +24097,19 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CON
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -25153,38 +24124,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = opline->op2.zv;
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
-	}
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -25196,26 +24149,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = opline->op2.zv;
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
-	}
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -25236,29 +24182,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -25266,31 +24202,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = opline->op2.zv;
-		container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
-		}
 		if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -25303,41 +24232,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CONST_HANDLER(ZEND
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = opline->op2.zv;
 
-	if (IS_UNUSED == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
-	}
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -25346,25 +24256,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property_name = opline->op2.zv;
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-	}
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -25375,17 +24278,13 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 
 	if (IS_UNUSED == IS_UNUSED) {
 		/* Initialize for erealloc in add_char_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	add_char_to_string(str, str, opline->op2.zv);
@@ -25398,17 +24297,13 @@ static int ZEND_FASTCALL  ZEND_ADD_CHAR_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_ADD_STRING_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 
 	if (IS_UNUSED == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	add_string_to_string(str, str, opline->op2.zv);
@@ -25422,10 +24317,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -25439,33 +24333,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
-
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CONST != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CONST == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -25473,21 +24364,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CONST_HANDLER(ZEND_O
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -25508,9 +24391,9 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
 		zend_constant *c;
 		zval *retval;
 
-		if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-			c = CACHED_PTR(opline->op2.literal->cache_slot);
-		} else if ((c = zend_quick_get_constant(opline->op2.literal + 1, opline->extended_value TSRMLS_CC)) == NULL) {
+		if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+			c = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+		} else if ((c = zend_quick_get_constant(opline->op2.zv + 1, opline->extended_value TSRMLS_CC)) == NULL) {
 			if ((opline->extended_value & IS_CONSTANT_UNQUALIFIED) != 0) {
 				char *actual = (char *)zend_memrchr(Z_STRVAL_P(opline->op2.zv), '\\', Z_STRLEN_P(opline->op2.zv));
 				if(!actual) {
@@ -25520,52 +24403,52 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
 				}
 				/* non-qualified constant - allow text substitution */
 				zend_error(E_NOTICE, "Use of undefined constant %s - assumed '%s'", actual, actual);
-				ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)), 1);
+				ZVAL_STRINGL(EX_VAR(opline->result.var), actual, Z_STRLEN_P(opline->op2.zv)-(actual - Z_STRVAL_P(opline->op2.zv)));
 				CHECK_EXCEPTION();
 				ZEND_VM_NEXT_OPCODE();
 			} else {
 				zend_error_noreturn(E_ERROR, "Undefined constant '%s'", Z_STRVAL_P(opline->op2.zv));
 			}
 		} else {
-			CACHE_PTR(opline->op2.literal->cache_slot, c);
+			CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), c);
 		}
-		retval = &EX_T(opline->result.var).tmp_var;
-		ZVAL_COPY_VALUE(retval, &c->value);
-		zval_copy_ctor(retval);
+		retval = EX_VAR(opline->result.var);
+		ZVAL_DUP(retval, &c->value);
 	} else {
 		/* class constant */
 		zend_class_entry *ce;
-		zval **value;
+		zval *value;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				value = CACHED_PTR(opline->op2.literal->cache_slot);
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				value = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
-			} else if (CACHED_PTR(opline->op1.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op1.literal->cache_slot);
+			} else if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op1.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op1.zv), Z_STRLEN_P(opline->op1.zv), opline->op1.literal + 1, opline->extended_value TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op1.zv), opline->op1.zv + 1, opline->extended_value TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
 					HANDLE_EXCEPTION();
 				}
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op1.zv));
 				}
-				CACHE_PTR(opline->op1.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op1.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op1.var).class_entry;
-			if ((value = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce)) != NULL) {
-				ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-				zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ce = Z_CE_P(EX_VAR(opline->op1.var));
+			if ((value = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce)) != NULL) {
+				ZVAL_DUP(EX_VAR(opline->result.var), value);
 				goto constant_fetch_end;
 			}
 		}
 
-		if (EXPECTED(zend_hash_quick_find(&ce->constants_table, Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv)+1, Z_HASH_P(opline->op2.zv), (void **) &value) == SUCCESS)) {
-			if (IS_CONSTANT_TYPE(Z_TYPE_PP(value))) {
+		if (EXPECTED((value = zend_hash_find(&ce->constants_table, Z_STR_P(opline->op2.zv))) != NULL)) {
+			if (Z_ISREF_P(value)) {
+				value = Z_REFVAL_P(value);
+			}
+			if (Z_CONSTANT_P(value)) {
 				zend_class_entry *old_scope = EG(scope);
 
 				EG(scope) = ce;
@@ -25573,32 +24456,46 @@ static int ZEND_FASTCALL  ZEND_FETCH_CONSTANT_SPEC_UNUSED_CONST_HANDLER(ZEND_OPC
 				EG(scope) = old_scope;
 			}
 			if (IS_UNUSED == IS_CONST) {
-				CACHE_PTR(opline->op2.literal->cache_slot, value);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), value);
 			} else {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, ce, value);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce, value);
 			}
-			ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, *value);
-			zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+			ZVAL_DUP(EX_VAR(opline->result.var), value);
 		} else if (Z_STRLEN_P(opline->op2.zv) == sizeof("class")-1 && memcmp(Z_STRVAL_P(opline->op2.zv), "class", sizeof("class") - 1) == 0) {
 			/* "class" is assigned as a case-sensitive keyword from zend_do_resolve_class_name */
-			ZVAL_STRINGL(&EX_T(opline->result.var).tmp_var, ce->name, ce->name_length, 1);
+			ZVAL_STR(EX_VAR(opline->result.var), ce->name);
+			STR_ADDREF(ce->name);
 		} else {
 			zend_error_noreturn(E_ERROR, "Undefined class constant '%s'", Z_STRVAL_P(opline->op2.zv));
 		}
 	}
 constant_fetch_end:
-	if (Z_TYPE(EX_T(opline->result.var).tmp_var) == IS_ARRAY) {
-		zend_error_noreturn(E_ERROR, "Arrays are not allowed in constants at run-time");
-	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_UNUSED != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_UNUSED != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_UNUSED == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_UNUSED != IS_UNUSED
@@ -25612,91 +24509,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = opline->op2.zv;
 
-	if (IS_UNUSED != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_CONST == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_CONST != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
 
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-
-				break;
+			break;
 		}
-	} else {
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_CONST == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
 
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -25707,49 +24603,36 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = opline->op2.zv;
 
-	if (IS_UNUSED != IS_VAR || container) {
-		if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
@@ -25757,12 +24640,12 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON
 	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	offset = opline->op2.zv;
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -25772,25 +24655,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -25798,116 +24679,103 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_UNUSED != IS_UNUSED) {
@@ -25917,74 +24785,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = NULL;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = NULL;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_UNUSED == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_UNUSED == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_UNUSED == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -25993,45 +24845,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_HANDL
 		zval *key = opline->op2.zv;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CONST == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CONST == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -26056,18 +24899,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data1;
-	zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	zval *object;
+	zval *object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -26075,81 +24918,68 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (1) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zval_dtor(free_op2.var);
 		FREE_OP(free_op_data1);
 	}
 
@@ -26159,179 +24989,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(int (*
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_UNUSED == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_UNUSED == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-			var_ptr = NULL;
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_TMP_VAR TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		zval_dtor(free_op2.var);
-
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
-		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_dim_exit:
 	zval_dtor(free_op2.var);
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	var_ptr = NULL;
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
 
-		CHECK_EXCEPTION();
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+	zval_dtor(free_op2.var);
+
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		zval_dtor(free_op2.var);
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -26340,59 +25279,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_TMP(incdec_
 
 	/* here we are sure we are dealing with an object */
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -26412,23 +25342,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -26441,60 +25369,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_TMP(incdec
 
 	/* here we are sure we are dealing with an object */
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -26525,29 +25441,20 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_TMP
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_dtor(free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_dtor(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -26562,38 +25469,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_H
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -26605,26 +25494,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -26645,29 +25527,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_dtor(free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_dtor(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -26675,31 +25548,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (1) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		zval_dtor(free_op2.var);
 		if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -26712,41 +25578,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_TMP_HANDLER(ZEND_O
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_UNUSED == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -26755,25 +25602,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	zval_dtor(free_op2.var);
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -26785,7 +25625,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -26795,18 +25635,17 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDL
 
 	if (IS_UNUSED == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -26830,10 +25669,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -26847,33 +25685,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
-
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_TMP_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -26881,21 +25716,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
 			zval_dtor(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -26910,9 +25737,26 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_TMP_HANDLER(ZEND_OPC
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_UNUSED != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_UNUSED != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_UNUSED == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_UNUSED != IS_UNUSED
@@ -26926,91 +25770,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_UNUSED != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_TMP_VAR == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_TMP_VAR != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				zval_dtor(free_op2.var);
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (1) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (1) {
-					zval_ptr_dtor(&offset);
-				} else {
-					zval_dtor(free_op2.var);
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				zval_dtor(free_op2.var);
-				break;
+			zval_dtor(free_op2.var);
+			break;
 		}
-	} else {
-		zval_dtor(free_op2.var);
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_TMP_VAR == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			zval_dtor(free_op2.var);
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+			zval_dtor(free_op2.var);
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -27021,49 +25864,36 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_UNUSED != IS_VAR || container) {
-		if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (1) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (1) {
-				zval_ptr_dtor(&offset);
-			} else {
-				zval_dtor(free_op2.var);
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			zval_dtor(free_op2.var);
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		zval_dtor(free_op2.var);
 	}
+	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
@@ -27071,12 +25901,12 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP
 	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -27086,25 +25916,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -27112,116 +25940,105 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		zval_dtor(free_op2.var);
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-		zval_dtor(free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		zval_dtor(free_op2.var);
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_UNUSED != IS_UNUSED) {
@@ -27231,74 +26048,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = NULL;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = NULL;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_UNUSED == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_UNUSED == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_UNUSED == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -27307,45 +26108,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HANDLER
 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!1) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_TMP_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_TMP_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -27370,100 +26162,87 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data1;
-	zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	zval *object;
+	zval *object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zval_ptr_dtor_nogc(free_op2.var);
 		FREE_OP(free_op_data1);
 	}
 
@@ -27473,179 +26252,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(int (*
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_UNUSED == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_UNUSED == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-			var_ptr = NULL;
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_VAR TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-		zval_ptr_dtor_nogc(&free_op2.var);
-
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
-	zval_ptr_dtor_nogc(&free_op2.var);
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_dim_exit:
+	zval_ptr_dtor_nogc(free_op2.var);
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	var_ptr = NULL;
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
 
-		CHECK_EXCEPTION();
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+	zval_ptr_dtor_nogc(free_op2.var);
+
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -27654,59 +26542,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_VAR(incdec_
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -27726,27 +26605,25 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		ZVAL_NULL(retval);
 
 		CHECK_EXCEPTION();
@@ -27755,60 +26632,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_VAR(incdec
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -27839,29 +26704,20 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_VAR
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_ptr_dtor_nogc(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -27876,38 +26732,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_H
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -27919,26 +26757,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -27959,29 +26790,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_ptr_dtor_nogc(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -27989,31 +26811,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 		if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -28026,41 +26841,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_VAR_HANDLER(ZEND_O
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_UNUSED == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -28069,25 +26865,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -28099,7 +26888,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -28109,18 +26898,17 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDL
 
 	if (IS_UNUSED == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -28134,7 +26922,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDL
 	 * which aren't affected by FREE_OP(Ts, )'s anyway, unless they're
 	 * string offsets or overloaded objects
 	 */
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -28144,10 +26932,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -28161,62 +26948,51 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
 	EX(call) = call;
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -28224,9 +27000,26 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_VAR_HANDLER(ZEND_OPC
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_UNUSED != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_UNUSED != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_UNUSED == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_UNUSED != IS_UNUSED
@@ -28240,91 +27033,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_UNUSED != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_VAR == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_VAR != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				zval_ptr_dtor_nogc(&free_op2.var);
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
-					zval_ptr_dtor_nogc(&free_op2.var);
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				zval_ptr_dtor_nogc(&free_op2.var);
-				break;
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
 		}
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_VAR == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -28335,49 +27127,36 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_UNUSED != IS_VAR || container) {
-		if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-				zval_ptr_dtor_nogc(&free_op2.var);
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
 	}
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
@@ -28385,12 +27164,12 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR
 	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -28400,25 +27179,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -28426,116 +27203,105 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_UNUSED != IS_UNUSED) {
@@ -28545,74 +27311,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = NULL;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = NULL;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_UNUSED == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_UNUSED == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_UNUSED == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -28621,46 +27371,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HANDLER
 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
-
-			generator->key = copy;
+		if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+			zval_ptr_dtor_nogc(free_op2.var);
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -28685,18 +27425,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
 {
 	USE_OPLINE
 	zend_free_op free_op_data1;
-	zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	zval *object;
+	zval *object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	zval *property = NULL;
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -28704,81 +27444,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
@@ -28788,155 +27514,285 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(int
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_UNUSED == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = NULL;
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_UNUSED == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = NULL;
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = NULL;
-			var_ptr = NULL;
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_UNUSED TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
+		goto assign_op_dim_exit;
+	}
 
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
+	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = NULL;
+	var_ptr = NULL;
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_exit:
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
-	} else {
 
-		CHECK_EXCEPTION();
-	}
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_UNUSED != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_UNUSED != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_UNUSED == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_UNUSED != IS_UNUSED
@@ -28950,22 +27806,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_UNUSED != IS_UNUSED) {
@@ -28975,74 +27827,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = NULL;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = NULL;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_UNUSED == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_UNUSED == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_UNUSED == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -29051,45 +27887,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_UNUSED_HANDLER(ZEND_OPCODE_HAND
 		zval *key = NULL;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_UNUSED == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_UNUSED == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_UNUSED == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -29114,18 +27941,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
 {
 	USE_OPLINE
 	zend_free_op free_op_data1;
-	zval **object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	zval *object;
+	zval *object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -29133,81 +27960,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
@@ -29217,178 +28030,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(int (*b
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_UNUSED == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_UNUSED == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-			var_ptr = NULL;
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CV TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
+		goto assign_op_dim_exit;
+	}
 
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
+	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_UNUSED_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	var_ptr = NULL;
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_exit:
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
-	} else {
 
-		CHECK_EXCEPTION();
-	}
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_UNUSED_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -29397,59 +28320,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_UNUSED_CV(incdec_t
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -29469,23 +28382,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -29498,60 +28409,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_UNUSED_CV(incdec_
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -29582,29 +28480,19 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_UNUSED_CV(
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -29619,38 +28507,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HA
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
-	}
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -29662,26 +28532,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
-	}
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -29702,29 +28565,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -29732,31 +28585,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-		container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+		container = _get_obj_zval_ptr_unused(TSRMLS_C);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
-		}
 		if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -29769,41 +28615,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_UNUSED_CV_HANDLER(ZEND_OP
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_UNUSED == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
-	}
 	if (IS_UNUSED == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -29812,25 +28639,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
 	property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_UNUSED == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-	}
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -29842,7 +28662,7 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	zval *str = &EX_T(opline->result.var).tmp_var;
+	zval *str = EX_VAR(opline->result.var);
 	zval *var;
 	zval var_copy;
 	int use_copy = 0;
@@ -29852,18 +28672,17 @@ static int ZEND_FASTCALL  ZEND_ADD_VAR_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLE
 
 	if (IS_UNUSED == IS_UNUSED) {
 		/* Initialize for erealloc in add_string_to_string */
-		Z_STRVAL_P(str) = NULL;
-		Z_STRLEN_P(str) = 0;
-		Z_TYPE_P(str) = IS_STRING;
-
-		INIT_PZVAL(str);
+		ZVAL_EMPTY_STRING(str);
 	}
 
 	if (Z_TYPE_P(var) != IS_STRING) {
-		zend_make_printable_zval(var, &var_copy, &use_copy);
+		ZVAL_DEREF(var);
+		if (Z_TYPE_P(var) != IS_STRING) {
+			zend_make_printable_zval(var, &var_copy, &use_copy);
 
-		if (use_copy) {
-			var = &var_copy;
+			if (use_copy) {
+				var = &var_copy;
+			}
 		}
 	}
 	add_string_to_string(str, str, var);
@@ -29886,10 +28705,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -29903,33 +28721,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_obj_zval_ptr_unused(TSRMLS_C);
+	object = _get_obj_zval_ptr_unused(TSRMLS_C);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CV != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CV == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -29937,21 +28752,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -29965,9 +28772,26 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_UNUSED_CV_HANDLER(ZEND_OPCO
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_UNUSED != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_UNUSED != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_UNUSED == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_UNUSED != IS_UNUSED
@@ -29981,91 +28805,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
-	if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_UNUSED != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_CV == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_CV != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
 
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-
-				break;
+			break;
 		}
-	} else {
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_CV == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
 
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -30076,49 +28899,36 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	if (IS_UNUSED == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_UNUSED != IS_VAR || container) {
-		if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
@@ -30126,12 +28936,12 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(
 	container = _get_obj_zval_ptr_unused(TSRMLS_C);
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -30141,25 +28951,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -30167,116 +28975,103 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_obj_zval_ptr_unused(TSRMLS_C);
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_UNUSED != IS_UNUSED) {
@@ -30286,74 +29081,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = NULL;
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = NULL;
+				zval *value_ptr = NULL;
 
-				if (IS_UNUSED == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_UNUSED == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_UNUSED == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_UNUSED == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = NULL;
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_UNUSED == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_UNUSED == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_UNUSED == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -30362,45 +29141,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CV == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CV == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -30427,8 +29197,8 @@ static int ZEND_FASTCALL  ZEND_BW_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	bitwise_not_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
+	bitwise_not_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -30440,8 +29210,8 @@ static int ZEND_FASTCALL  ZEND_BOOL_NOT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 
 	SAVE_OPLINE();
-	boolean_not_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
+	boolean_not_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC) TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -30451,42 +29221,53 @@ static int ZEND_FASTCALL  ZEND_PRE_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval **var_ptr;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_increment_function(var_ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		}
+		ZEND_VM_NEXT_OPCODE();
+	}
 
-	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+	} else {
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_increment_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_increment_function(*var_ptr);
+		increment_function(var_ptr);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
 	CHECK_EXCEPTION();
@@ -30497,42 +29278,53 @@ static int ZEND_FASTCALL  ZEND_PRE_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval **var_ptr;
+	zval *var_ptr;
 
 	SAVE_OPLINE();
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		fast_decrement_function(var_ptr);
+		if (RETURN_VALUE_USED(opline)) {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		}
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+	} else {
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_decrement_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_decrement_function(*var_ptr);
+		decrement_function(var_ptr);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
 	CHECK_EXCEPTION();
@@ -30543,38 +29335,49 @@ static int ZEND_FASTCALL  ZEND_POST_INC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 
-	zval **var_ptr, *retval;
+	zval *var_ptr, *retval;
 
 	SAVE_OPLINE();
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		fast_increment_function(var_ptr);
+		ZEND_VM_NEXT_OPCODE();
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
 
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	retval = &EX_T(opline->result.var).tmp_var;
-	ZVAL_COPY_VALUE(retval, *var_ptr);
-	zendi_zval_copy_ctor(*retval);
+	retval = EX_VAR(opline->result.var);
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+		ZVAL_DUP(retval, var_ptr);
+	} else {
+		ZVAL_DUP(retval, var_ptr);
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_increment_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_increment_function(*var_ptr);
+		increment_function(var_ptr);
 	}
 
 	CHECK_EXCEPTION();
@@ -30585,38 +29388,49 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 
-	zval **var_ptr, *retval;
+	zval *var_ptr, *retval;
 
 	SAVE_OPLINE();
-	var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (EXPECTED(Z_TYPE_P(var_ptr) == IS_LONG)) {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), var_ptr);
+		fast_decrement_function(var_ptr);
+		ZEND_VM_NEXT_OPCODE();
+	}
 
-	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
-	if (IS_CV == IS_VAR && UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		ZVAL_NULL(&EX_T(opline->result.var).tmp_var);
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		ZVAL_NULL(EX_VAR(opline->result.var));
 
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	retval = &EX_T(opline->result.var).tmp_var;
-	ZVAL_COPY_VALUE(retval, *var_ptr);
-	zendi_zval_copy_ctor(*retval);
+	retval = EX_VAR(opline->result.var);
 
-	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	if (UNEXPECTED(Z_ISREF_P(var_ptr))) {
+		var_ptr = Z_REFVAL_P(var_ptr);
+		ZVAL_DUP(retval, var_ptr);
+	} else {
+		ZVAL_DUP(retval, var_ptr);
+		SEPARATE_ZVAL(var_ptr);
+	}
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT)
+	   && Z_OBJ_HANDLER_P(var_ptr, get)
+	   && Z_OBJ_HANDLER_P(var_ptr, set)) {
 		/* proxy object */
-		zval *val = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *val = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(val);
 		fast_decrement_function(val);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, val TSRMLS_CC);
-		zval_ptr_dtor(&val);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, val TSRMLS_CC);
+		zval_ptr_dtor(val);
 	} else {
-		fast_decrement_function(*var_ptr);
+		decrement_function(var_ptr);
 	}
 
 	CHECK_EXCEPTION();
@@ -30630,12 +29444,9 @@ static int ZEND_FASTCALL  ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zval *z;
 
 	SAVE_OPLINE();
-	z = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	z = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_TMP_VAR && Z_TYPE_P(z) == IS_OBJECT) {
-		INIT_PZVAL(z);
-	}
-	zend_print_variable(z);
+	zend_print_variable(z TSRMLS_CC);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -30645,7 +29456,7 @@ static int ZEND_FASTCALL  ZEND_PRINT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	ZVAL_LONG(&EX_T(opline->result.var).tmp_var, 1);
+	ZVAL_LONG(EX_VAR(opline->result.var), 1);
 	return ZEND_ECHO_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 }
 
@@ -30657,7 +29468,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int ret;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		ret = Z_LVAL_P(val);
@@ -30687,7 +29498,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int ret;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		ret = Z_LVAL_P(val);
@@ -30717,7 +29528,7 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int retval;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
@@ -30751,7 +29562,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	int retval;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
@@ -30762,8 +29573,7 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (!retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -30782,7 +29592,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	int retval;
 
 	SAVE_OPLINE();
-	val = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
 		retval = Z_LVAL_P(val);
@@ -30793,8 +29603,7 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 			HANDLE_EXCEPTION();
 		}
 	}
-	Z_LVAL(EX_T(opline->result.var).tmp_var) = retval;
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
+	ZVAL_BOOL(EX_VAR(opline->result.var), retval);
 	if (retval) {
 #if DEBUG_ZEND>=2
 		printf("Conditional jmp to %d\n", opline->op2.opline_num);
@@ -30814,34 +29623,21 @@ static int ZEND_FASTCALL  ZEND_RETURN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	SAVE_OPLINE();
 	retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (!EG(return_value_ptr_ptr)) {
+	if (!EX(return_value)) {
 
 	} else {
-		if (IS_CV == IS_CONST ||
-		    IS_CV == IS_TMP_VAR ||
-		    PZVAL_IS_REF(retval_ptr)) {
-			zval *ret;
-
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, retval_ptr);
+		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_CV != IS_TMP_VAR) {
-				zval_copy_ctor(ret);
+				zval_opt_copy_ctor(EX(return_value));
 			}
-			*EG(return_value_ptr_ptr) = ret;
+		} else if (Z_ISREF_P(retval_ptr)) {
+			ZVAL_DUP(EX(return_value), Z_REFVAL_P(retval_ptr));
 
-		} else if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
-		           retval_ptr == &EG(uninitialized_zval)) {
-			zval *ret;
-
-			if (IS_CV == IS_VAR) {
-				Z_DELREF_P(retval_ptr);
-			}
-			ALLOC_INIT_ZVAL(ret);
-			*EG(return_value_ptr_ptr) = ret;
 		} else {
-			*EG(return_value_ptr_ptr) = retval_ptr;
+			ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			if (IS_CV == IS_CV) {
-				Z_ADDREF_P(retval_ptr);
+				if (Z_OPT_REFCOUNTED_P(retval_ptr)) Z_ADDREF_P(retval_ptr);
 			}
 		}
 	}
@@ -30852,7 +29648,6 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zval *retval_ptr;
-	zval **retval_ptr_ptr;
 
 
 	SAVE_OPLINE();
@@ -30864,55 +29659,41 @@ static int ZEND_FASTCALL  ZEND_RETURN_BY_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
 			zend_error(E_NOTICE, "Only variable references should be returned by reference");
 
 			retval_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-			if (!EG(return_value_ptr_ptr)) {
+			if (!EX(return_value)) {
 				if (IS_CV == IS_TMP_VAR) {
 
 				}
 			} else if (!0) { /* Not a temp var */
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				zval_copy_ctor(ret);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_DUP(EX(return_value), retval_ptr);
 			} else {
-				zval *ret;
-
-				ALLOC_ZVAL(ret);
-				INIT_PZVAL_COPY(ret, retval_ptr);
-				*EG(return_value_ptr_ptr) = ret;
+				ZVAL_COPY_VALUE(EX(return_value), retval_ptr);
 			}
 			break;
 		}
 
-		retval_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		retval_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-		if (IS_CV == IS_VAR && UNEXPECTED(retval_ptr_ptr == NULL)) {
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(retval_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot return string offsets by reference");
 		}
 
-		if (IS_CV == IS_VAR && !Z_ISREF_PP(retval_ptr_ptr)) {
+		if (IS_CV == IS_VAR && !Z_ISREF_P(retval_ptr)) {
 			if (opline->extended_value == ZEND_RETURNS_FUNCTION &&
-			    EX_T(opline->op1.var).var.fcall_returned_reference) {
-			} else if (EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+			    (Z_VAR_FLAGS_P(retval_ptr) & IS_VAR_RET_REF)) {
+			} else {
 				zend_error(E_NOTICE, "Only variable references should be returned by reference");
-				if (EG(return_value_ptr_ptr)) {
-					zval *ret;
-
-					ALLOC_ZVAL(ret);
-					INIT_PZVAL_COPY(ret, *retval_ptr_ptr);
-					zval_copy_ctor(ret);
-					*EG(return_value_ptr_ptr) = ret;
+				if (EX(return_value)) {
+					zval tmp;
+					ZVAL_DUP(&tmp, retval_ptr);
+					ZVAL_NEW_REF(EX(return_value), &tmp);
 				}
 				break;
 			}
 		}
 
-		if (EG(return_value_ptr_ptr)) {
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr_ptr);
-			Z_ADDREF_PP(retval_ptr_ptr);
-
-			*EG(return_value_ptr_ptr) = *retval_ptr_ptr;
+		if (EX(return_value)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
+			ZVAL_COPY(EX(return_value), retval_ptr);
 		}
 	} while (0);
 
@@ -30923,7 +29704,7 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zval *value;
-	zval *exception;
+	zval exception;
 
 
 	SAVE_OPLINE();
@@ -30937,14 +29718,14 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	}
 
 	zend_exception_save(TSRMLS_C);
-	/* Not sure if a complete copy is what we want here */
-	ALLOC_ZVAL(exception);
-	INIT_PZVAL_COPY(exception, value);
-	if (!0) {
-		zval_copy_ctor(exception);
+	if (IS_CV == IS_CONST) {
+		ZVAL_DUP(&exception, value);
+		value = &exception;
+	} else if (IS_CV != IS_TMP_VAR) {
+		if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 	}
 
-	zend_throw_exception_object(exception TSRMLS_CC);
+	zend_throw_exception_object(value TSRMLS_CC);
 	zend_exception_restore(TSRMLS_C);
 
 	HANDLE_EXCEPTION();
@@ -30953,33 +29734,20 @@ static int ZEND_FASTCALL  ZEND_THROW_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 static int ZEND_FASTCALL zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval *varptr;
+	zval *varptr, *top;
 
-	varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-
-	if (varptr == &EG(uninitialized_zval)) {
-		if (IS_CV == IS_VAR) {
-			Z_DELREF_P(varptr);
-		}
-		ALLOC_INIT_ZVAL(varptr);
-	} else if (PZVAL_IS_REF(varptr)) {
-		if (IS_CV == IS_CV ||
-		    (IS_CV == IS_VAR && Z_REFCOUNT_P(varptr) > 2)) {
-			zval *original_var = varptr;
 
-			ALLOC_ZVAL(varptr);
-			INIT_PZVAL_COPY(varptr, original_var);
-			zval_copy_ctor(varptr);
+	varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (Z_ISREF_P(varptr)) {
+		ZVAL_DUP(top, Z_REFVAL_P(varptr));
 
-		} else {
-			Z_UNSET_ISREF_P(varptr);
+	} else {
+		ZVAL_COPY_VALUE(top, varptr);
+		if (IS_CV == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
 		}
-	} else if (IS_CV == IS_CV) {
-		Z_ADDREF_P(varptr);
 	}
-	zend_vm_stack_push(varptr TSRMLS_CC);
-
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
@@ -30987,7 +29755,7 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 
-	zval *varptr;
+	zval *varptr, *top;
 
 	SAVE_OPLINE();
 	if (opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) { /* Had function_ptr at compile_time */
@@ -31002,29 +29770,29 @@ static int ZEND_FASTCALL  ZEND_SEND_VAR_NO_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 
 	varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 	if ((!(opline->extended_value & ZEND_ARG_SEND_FUNCTION) ||
-	     EX_T(opline->op1.var).var.fcall_returned_reference) &&
-	    varptr != &EG(uninitialized_zval) &&
-	    (PZVAL_IS_REF(varptr) || Z_REFCOUNT_P(varptr) == 1)) {
-		Z_SET_ISREF_P(varptr);
+	     (Z_VAR_FLAGS_P(varptr) & IS_VAR_RET_REF)) &&
+	    ((!Z_REFCOUNTED_P(varptr) && Z_TYPE_P(varptr) != IS_STRING) ||
+	     Z_ISREF_P(varptr) ||
+	     Z_TYPE_P(varptr) == IS_OBJECT ||
+	     (Z_REFCOUNTED_P(varptr) && Z_REFCOUNT_P(varptr) == 1))) {
+
+		if (!Z_ISREF_P(varptr)) {
+			ZVAL_NEW_REF(varptr, varptr);
+		}
 		if (IS_CV == IS_CV) {
 			Z_ADDREF_P(varptr);
 		}
 		zend_vm_stack_push(varptr TSRMLS_CC);
 	} else {
-		zval *valptr;
-
 		if ((opline->extended_value & ZEND_ARG_COMPILE_TIME_BOUND) ?
 			!(opline->extended_value & ZEND_ARG_SEND_SILENT) :
 			!ARG_MAY_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
 			zend_error(E_STRICT, "Only variables should be passed by reference");
 		}
-		ALLOC_ZVAL(valptr);
-		INIT_PZVAL_COPY(valptr, varptr);
-		if (!0) {
-			zval_copy_ctor(valptr);
-		}
+		top = zend_vm_stack_top_inc(TSRMLS_C);
+		ZVAL_COPY_VALUE(top, varptr);
+		zval_opt_copy_ctor(top);
 
-		zend_vm_stack_push(valptr TSRMLS_CC);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -31034,57 +29802,68 @@ static int ZEND_FASTCALL  ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 
-	zval **varptr_ptr;
-	zval *varptr;
+	zval *varptr, *top;
 
 	SAVE_OPLINE();
-	varptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	varptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(varptr_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(varptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Only variables can be passed by reference");
 	}
 
-	if (IS_CV == IS_VAR && UNEXPECTED(*varptr_ptr == &EG(error_zval))) {
-		ALLOC_INIT_ZVAL(varptr);
-		zend_vm_stack_push(varptr TSRMLS_CC);
-		CHECK_EXCEPTION();
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (IS_CV == IS_VAR && UNEXPECTED(varptr == &EG(error_zval))) {
+		ZVAL_NEW_REF(top, &EG(uninitialized_zval));
 		ZEND_VM_NEXT_OPCODE();
 	}
 
-	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME &&
-	    EX(function_state).function->type == ZEND_INTERNAL_FUNCTION) {
-		if (!ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
-			return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-		}
+	if (Z_ISREF_P(varptr)) {
+		Z_ADDREF_P(varptr);
+		ZVAL_COPY_VALUE(top, varptr);
+	} else if (IS_CV == IS_VAR &&
+		UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT)) {
+		ZVAL_COPY_VALUE(top, varptr);
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(top);
+	} else {
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr);
+		Z_ADDREF_P(varptr);
+		ZVAL_COPY_VALUE(top, varptr);
 	}
 
-	SEPARATE_ZVAL_TO_MAKE_IS_REF(varptr_ptr);
-	varptr = *varptr_ptr;
-	Z_ADDREF_P(varptr);
-	zend_vm_stack_push(varptr TSRMLS_CC);
-
-	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_SEND_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *varptr, *top;
+
 
 	if (opline->extended_value == ZEND_DO_FCALL_BY_NAME) {
 		if (ARG_SHOULD_BE_SENT_BY_REF(EX(call)->fbc, opline->op2.num)) {
 			return ZEND_SEND_REF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 		}
 	}
-	SAVE_OPLINE();
-	return zend_send_by_var_helper_SPEC_CV(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+
+	varptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	top = zend_vm_stack_top_inc(TSRMLS_C);
+	if (Z_ISREF_P(varptr)) {
+		ZVAL_DUP(top, Z_REFVAL_P(varptr));
+
+	} else {
+		ZVAL_COPY_VALUE(top, varptr);
+		if (IS_CV == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(varptr)) Z_ADDREF_P(varptr);
+		}
+	}
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_BOOL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval *retval = &EX_T(opline->result.var).tmp_var;
+	zval *retval = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	/* PHP 3.0 returned "" for false and 1 for true, here we use 0 and 1 for now */
@@ -31119,7 +29898,7 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	clone_call =  Z_OBJ_HT_P(obj)->clone_obj;
 	if (UNEXPECTED(clone_call == NULL)) {
 		if (ce) {
-			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name);
+			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object of class %s", ce->name->val);
 		} else {
 			zend_error_noreturn(E_ERROR, "Trying to clone an uncloneable object");
 		}
@@ -31130,29 +29909,21 @@ static int ZEND_FASTCALL  ZEND_CLONE_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			/* Ensure that if we're calling a private function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(ce != EG(scope))) {
-				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to private %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		} else if ((clone->common.fn_flags & ZEND_ACC_PROTECTED)) {
 			/* Ensure that if we're calling a protected function, we're allowed to do so.
 			 */
 			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(clone), EG(scope)))) {
-				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name, EG(scope) ? EG(scope)->name : "");
+				zend_error_noreturn(E_ERROR, "Call to protected %s::__clone() from context '%s'", ce->name->val, EG(scope) ? EG(scope)->name->val : "");
 			}
 		}
 	}
 
 	if (EXPECTED(EG(exception) == NULL)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		Z_OBJVAL_P(retval) = clone_call(obj TSRMLS_CC);
-		Z_TYPE_P(retval) = IS_OBJECT;
-		Z_SET_REFCOUNT_P(retval, 1);
-		Z_SET_ISREF_P(retval);
+		ZVAL_OBJ(EX_VAR(opline->result.var), clone_call(obj TSRMLS_CC));
 		if (!RETURN_VALUE_USED(opline) || UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&retval);
-		} else {
-			EX_T(opline->result.var).var.ptr = retval;
+			zval_ptr_dtor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -31164,18 +29935,34 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval *expr;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *expr, *expr_ptr;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	expr = expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR || IS_CV == IS_CV) {
+		ZVAL_DEREF(expr);
+	}
+	if (Z_TYPE_P(expr) == opline->extended_value) {
+		ZVAL_COPY_VALUE(result, expr);
+		if (IS_CV == IS_CONST || expr != expr_ptr) {
+			zval_opt_copy_ctor(result);
+
+		} else if (IS_CV == IS_CV) {
+			if (Z_OPT_REFCOUNTED_P(expr)) Z_ADDREF_P(expr);
+		}
+
+		CHECK_EXCEPTION();
+		ZEND_VM_NEXT_OPCODE();
+	}
 
 	if (opline->extended_value != IS_STRING) {
 		ZVAL_COPY_VALUE(result, expr);
 		if (!0) {
-			zendi_zval_copy_ctor(*result);
+			zval_opt_copy_ctor(result);
 		}
 	}
+
 	switch (opline->extended_value) {
 		case IS_NULL:
 			convert_to_null(result);
@@ -31202,7 +29989,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 			} else {
 				ZVAL_COPY_VALUE(result, expr);
 				if (!0) {
-					zendi_zval_copy_ctor(*result);
+					zval_opt_copy_ctor(result);
 				}
 			}
 			break;
@@ -31225,18 +30012,17 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 	zend_op_array *new_op_array=NULL;
 
 	zval *inc_filename;
-	zval *tmp_inc_filename = NULL;
+	zval tmp_inc_filename;
 	zend_bool failure_retval=0;
 
 	SAVE_OPLINE();
 	inc_filename = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (inc_filename->type!=IS_STRING) {
-		MAKE_STD_ZVAL(tmp_inc_filename);
-		ZVAL_COPY_VALUE(tmp_inc_filename, inc_filename);
-		zval_copy_ctor(tmp_inc_filename);
-		convert_to_string(tmp_inc_filename);
-		inc_filename = tmp_inc_filename;
+	ZVAL_UNDEF(&tmp_inc_filename);
+	if (Z_TYPE_P(inc_filename) != IS_STRING) {
+		ZVAL_DUP(&tmp_inc_filename, inc_filename);
+		convert_to_string(&tmp_inc_filename);
+		inc_filename = &tmp_inc_filename;
 	}
 
 	if (opline->extended_value != ZEND_EVAL && strlen(Z_STRVAL_P(inc_filename)) != Z_STRLEN_P(inc_filename)) {
@@ -31254,7 +30040,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 
 					resolved_path = zend_resolve_path(Z_STRVAL_P(inc_filename), Z_STRLEN_P(inc_filename) TSRMLS_CC);
 					if (resolved_path) {
-						failure_retval = zend_hash_exists(&EG(included_files), resolved_path, strlen(resolved_path)+1);
+						failure_retval = zend_hash_str_exists(&EG(included_files), resolved_path, strlen(resolved_path));
 					} else {
 						resolved_path = Z_STRVAL_P(inc_filename);
 					}
@@ -31267,7 +30053,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 							file_handle.opened_path = estrdup(resolved_path);
 						}
 
-						if (zend_hash_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1)==SUCCESS) {
+						if (zend_hash_str_add_empty_element(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path))) {
 							new_op_array = zend_compile_file(&file_handle, (opline->extended_value==ZEND_INCLUDE_ONCE?ZEND_INCLUDE:ZEND_REQUIRE) TSRMLS_CC);
 							zend_destroy_file_handle(&file_handle TSRMLS_CC);
 						} else {
@@ -31300,40 +30086,37 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 			EMPTY_SWITCH_DEFAULT_CASE()
 		}
 	}
-	if (tmp_inc_filename) {
+	if (Z_TYPE(tmp_inc_filename) != IS_UNDEF) {
 		zval_ptr_dtor(&tmp_inc_filename);
 	}
 
 	if (UNEXPECTED(EG(exception) != NULL)) {
 		HANDLE_EXCEPTION();
 	} else if (EXPECTED(new_op_array != NULL)) {
-		EX(original_return_value) = EG(return_value_ptr_ptr);
+		zval *return_value = NULL;
+
 		EG(active_op_array) = new_op_array;
 		if (RETURN_VALUE_USED(opline)) {
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-			EG(return_value_ptr_ptr) = EX_T(opline->result.var).var.ptr_ptr;
-		} else {
-			EG(return_value_ptr_ptr) = NULL;
+			return_value = EX_VAR(opline->result.var);
 		}
 
 		EX(function_state).function = (zend_function *) new_op_array;
-		EX(object) = NULL;
 
 		if (!EG(active_symbol_table)) {
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 
 		if (EXPECTED(zend_execute_ex == execute_ex)) {
+		    i_create_execute_data_from_op_array(new_op_array, return_value, VM_FRAME_NESTED_CODE TSRMLS_CC);
 			ZEND_VM_ENTER();
 		} else {
-			zend_execute(new_op_array TSRMLS_CC);
+			zend_execute(new_op_array, return_value TSRMLS_CC);
 		}
 
 		EX(function_state).function = (zend_function *) EX(op_array);
 
 		EG(opline_ptr) = &EX(opline);
 		EG(active_op_array) = EX(op_array);
-		EG(return_value_ptr_ptr) = EX(original_return_value);
 		destroy_op_array(new_op_array TSRMLS_CC);
 		efree(new_op_array);
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -31342,12 +30125,7 @@ static int ZEND_FASTCALL  ZEND_INCLUDE_OR_EVAL_SPEC_CV_HANDLER(ZEND_OPCODE_HANDL
 		}
 
 	} else if (RETURN_VALUE_USED(opline)) {
-		zval *retval;
-
-		ALLOC_ZVAL(retval);
-		ZVAL_BOOL(retval, failure_retval);
-		INIT_PZVAL(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		ZVAL_BOOL(EX_VAR(opline->result.var), failure_retval);
 	}
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -31356,7 +30134,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 
-	zval *array_ptr, **array_ptr_ptr;
+	zval *array_ptr, *array_ref, iterator;
 	HashTable *fe_ht;
 	zend_object_iterator *iter = NULL;
 	zend_class_entry *ce = NULL;
@@ -31366,71 +30144,79 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 	if ((IS_CV == IS_CV || IS_CV == IS_VAR) &&
 	    (opline->extended_value & ZEND_FE_RESET_VARIABLE)) {
-		array_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-		if (array_ptr_ptr == NULL || array_ptr_ptr == &EG(uninitialized_zval_ptr)) {
-			MAKE_STD_ZVAL(array_ptr);
-			ZVAL_NULL(array_ptr);
-		} else if (Z_TYPE_PP(array_ptr_ptr) == IS_OBJECT) {
-			if(Z_OBJ_HT_PP(array_ptr_ptr)->get_class_entry == NULL) {
+		array_ptr = array_ref = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		ZVAL_DEREF(array_ptr);
+		if (Z_TYPE_P(array_ptr) == IS_ARRAY) {
+			if (!Z_ISREF_P(array_ref)) {
+				SEPARATE_ZVAL(array_ptr);
+				array_ref = array_ptr;
+				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
+					ZVAL_NEW_REF(array_ptr, array_ptr);
+					array_ref = array_ptr;
+					array_ptr = Z_REFVAL_P(array_ptr);
+				}
+			}
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
+		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
+			if(Z_OBJ_HT_P(array_ptr)->get_class_entry == NULL) {
 				zend_error(E_WARNING, "foreach() cannot iterate over objects without PHP class");
 				ZEND_VM_JMP(EX(op_array)->opcodes+opline->op2.opline_num);
 			}
 
-			ce = Z_OBJCE_PP(array_ptr_ptr);
+			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || ce->get_iterator == NULL) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				Z_ADDREF_PP(array_ptr_ptr);
-			}
-			array_ptr = *array_ptr_ptr;
-		} else {
-			if (Z_TYPE_PP(array_ptr_ptr) == IS_ARRAY) {
-				SEPARATE_ZVAL_IF_NOT_REF(array_ptr_ptr);
-				if (opline->extended_value & ZEND_FE_FETCH_BYREF) {
-					Z_SET_ISREF_PP(array_ptr_ptr);
+				if (!Z_ISREF_P(array_ref)) {
+					SEPARATE_ZVAL(array_ptr);
 				}
+				Z_ADDREF_P(array_ptr);
 			}
-			array_ptr = *array_ptr_ptr;
-			Z_ADDREF_P(array_ptr);
+			array_ref = array_ptr;
+		} else {
+			if (Z_REFCOUNTED_P(array_ref)) Z_ADDREF_P(array_ref);
 		}
 	} else {
-		array_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		array_ptr = array_ref = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		ZVAL_DEREF(array_ptr);
 		if (0) { /* IS_TMP_VAR */
-			zval *tmp;
+			zval tmp;
 
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			array_ptr = tmp;
+			ZVAL_COPY_VALUE(&tmp, array_ptr);
+			array_ptr = &tmp;
 			if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 				ce = Z_OBJCE_P(array_ptr);
 				if (ce && ce->get_iterator) {
-					Z_DELREF_P(array_ptr);
+					Z_DELREF_P(array_ref);
 				}
 			}
 		} else if (Z_TYPE_P(array_ptr) == IS_OBJECT) {
 			ce = Z_OBJCE_P(array_ptr);
 			if (!ce || !ce->get_iterator) {
 				if (IS_CV == IS_CV) {
-					Z_ADDREF_P(array_ptr);
+					Z_ADDREF_P(array_ref);
 				}
 			}
-		} else if (IS_CV == IS_CONST ||
-		           (IS_CV == IS_CV &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 1) ||
-		           (IS_CV == IS_VAR &&
-		            !Z_ISREF_P(array_ptr) &&
-		            Z_REFCOUNT_P(array_ptr) > 2)) {
-			zval *tmp;
+		} else if (Z_REFCOUNTED_P(array_ref)) {
+			if (IS_CV == IS_CONST ||
+			           (IS_CV == IS_CV &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 1) ||
+			           (IS_CV == IS_VAR &&
+			            !Z_ISREF_P(array_ref) &&
+			            Z_REFCOUNT_P(array_ref) > 2)) {
+				zval tmp;
 
-			if (IS_CV == IS_VAR) {
-				Z_DELREF_P(array_ptr);
+				if (IS_CV == IS_VAR) {
+					Z_DELREF_P(array_ref);
+				}
+				ZVAL_DUP(&tmp, array_ref);
+				array_ptr = array_ref = &tmp;
+			} else if (IS_CV == IS_CV) {
+				if (Z_ISREF_P(array_ref) && Z_REFCOUNT_P(array_ref) == 1) {
+					ZVAL_UNREF(array_ref);
+					array_ptr = array_ref;
+				}
+				Z_ADDREF_P(array_ref);
 			}
-			ALLOC_ZVAL(tmp);
-			INIT_PZVAL_COPY(tmp, array_ptr);
-			zval_copy_ctor(tmp);
-			array_ptr = tmp;
-		} else if (IS_CV == IS_CV) {
-			Z_ADDREF_P(array_ptr);
 		}
 	}
 
@@ -31441,27 +30227,28 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 		}
 		if (iter && EXPECTED(EG(exception) == NULL)) {
-			array_ptr = zend_iterator_wrap(iter TSRMLS_CC);
+			ZVAL_OBJ(&iterator, &iter->std);
+			array_ptr = array_ref = &iterator;
 		} else {
 			if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 			}
 			if (!EG(exception)) {
-				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name);
+				zend_throw_exception_ex(NULL, 0 TSRMLS_CC, "Object of type %s did not create an Iterator", ce->name->val);
 			}
 			zend_throw_exception_internal(NULL TSRMLS_CC);
 			HANDLE_EXCEPTION();
 		}
 	}
 
-	EX_T(opline->result.var).fe.ptr = array_ptr;
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), array_ref);
 
 	if (iter) {
 		iter->index = 0;
 		if (iter->funcs->rewind) {
 			iter->funcs->rewind(iter TSRMLS_CC);
 			if (UNEXPECTED(EG(exception) != NULL)) {
-				zval_ptr_dtor(&array_ptr);
+				zval_ptr_dtor(array_ref);
 				if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 				}
@@ -31470,7 +30257,7 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 		}
 		is_empty = iter->funcs->valid(iter TSRMLS_CC) != SUCCESS;
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor(&array_ptr);
+			zval_ptr_dtor(array_ref);
 			if (IS_CV == IS_VAR && opline->extended_value & ZEND_FE_RESET_VARIABLE) {
 
 			}
@@ -31480,24 +30267,23 @@ static int ZEND_FASTCALL  ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 	} else if ((fe_ht = HASH_OF(array_ptr)) != NULL) {
 		zend_hash_internal_pointer_reset(fe_ht);
 		if (ce) {
-			zend_object *zobj = zend_objects_get_address(array_ptr TSRMLS_CC);
+			zend_object *zobj = Z_OBJ_P(array_ptr);
 			while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
-				char *str_key;
-				uint str_key_len;
+				zend_string *str_key;
 				ulong int_key;
 				zend_uchar key_type;
 
-				key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
+				key_type = zend_hash_get_current_key(fe_ht, &str_key, &int_key, 0);
 				if (key_type != HASH_KEY_NON_EXISTENT &&
 					(key_type == HASH_KEY_IS_LONG ||
-				     zend_check_property_access(zobj, str_key, str_key_len-1 TSRMLS_CC) == SUCCESS)) {
+				     zend_check_property_access(zobj, str_key TSRMLS_CC) == SUCCESS)) {
 					break;
 				}
 				zend_hash_move_forward(fe_ht);
 			}
 		}
 		is_empty = zend_hash_has_more_elements(fe_ht) != SUCCESS;
-		zend_hash_get_pointer(fe_ht, &EX_T(opline->result.var).fe.fe_pos);
+		zend_hash_get_pointer(fe_ht, (HashPointer*)EX_VAR((opline+2)->op1.var));
 	} else {
 		zend_error(E_WARNING, "Invalid argument supplied for foreach()");
 		is_empty = 1;
@@ -31527,7 +30313,7 @@ static int ZEND_FASTCALL  ZEND_EXIT_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 		if (Z_TYPE_P(ptr) == IS_LONG) {
 			EG(exit_status) = Z_LVAL_P(ptr);
 		} else {
-			zend_print_variable(ptr);
+			zend_print_variable(ptr TSRMLS_CC);
 		}
 
 	}
@@ -31546,9 +30332,9 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
-		ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!0) {
-			zendi_zval_copy_ctor(EX_T(opline->result.var).tmp_var);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 
 #if DEBUG_ZEND>=2
@@ -31565,23 +30351,18 @@ static int ZEND_FASTCALL  ZEND_JMP_SET_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (i_zend_is_true(value TSRMLS_CC)) {
 		if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-			Z_ADDREF_P(value);
-			EX_T(opline->result.var).var.ptr = value;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-		} else {
-			ALLOC_ZVAL(ret);
-			INIT_PZVAL_COPY(ret, value);
-			EX_T(opline->result.var).var.ptr = ret;
-			EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
+		} else {
+			ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 			if (!0) {
-				zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+				zval_opt_copy_ctor(EX_VAR(opline->result.var));
 			}
 		}
 
@@ -31604,9 +30385,9 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	SAVE_OPLINE();
 	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-	ZVAL_COPY_VALUE(&EX_T(opline->result.var).tmp_var, value);
+	ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 	if (!0) {
-		zval_copy_ctor(&EX_T(opline->result.var).tmp_var);
+		zval_opt_copy_ctor(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -31617,22 +30398,17 @@ static int ZEND_FASTCALL  ZEND_QM_ASSIGN_VAR_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
-	zval *value, *ret;
+	zval *value;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		Z_ADDREF_P(value);
-		EX_T(opline->result.var).var.ptr = value;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
-	} else {
-		ALLOC_ZVAL(ret);
-		INIT_PZVAL_COPY(ret, value);
-		EX_T(opline->result.var).var.ptr = ret;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), value);
+	} else {
+		ZVAL_COPY_VALUE(EX_VAR(opline->result.var), value);
 		if (!0) {
-			zval_copy_ctor(EX_T(opline->result.var).var.ptr);
+			zval_opt_copy_ctor(EX_VAR(opline->result.var));
 		}
 	}
 
@@ -31648,14 +30424,14 @@ static int ZEND_FASTCALL  ZEND_INSTANCEOF_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_bool result;
 
 	SAVE_OPLINE();
-	expr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	expr = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (Z_TYPE_P(expr) == IS_OBJECT && Z_OBJ_HT_P(expr)->get_class_entry) {
-		result = instanceof_function(Z_OBJCE_P(expr), EX_T(opline->op2.var).class_entry TSRMLS_CC);
+		result = instanceof_function(Z_OBJCE_P(expr), Z_CE_P(EX_VAR(opline->op2.var)) TSRMLS_CC);
 	} else {
 		result = 0;
 	}
-	ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, result);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -31667,7 +30443,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
@@ -31682,7 +30458,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
@@ -31697,7 +30473,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
@@ -31712,7 +30488,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
@@ -31727,8 +30503,8 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31742,8 +30518,8 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31757,8 +30533,8 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31772,8 +30548,8 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31787,8 +30563,8 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31800,11 +30576,11 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
@@ -31817,7 +30593,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -31833,7 +30609,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -31849,7 +30625,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -31865,7 +30641,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -31883,8 +30659,8 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31898,8 +30674,8 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31913,8 +30689,8 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31928,8 +30704,8 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
 
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -31941,18 +30717,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
 {
 	USE_OPLINE
 	zend_free_op free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	zval *property = opline->op2.zv;
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -31960,81 +30736,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
@@ -32044,178 +30806,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CONST(int (*bi
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-				if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_CV == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = opline->op2.zv;
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_CV == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = opline->op2.zv;
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CONST, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = opline->op2.zv;
-			var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CONST TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
+		goto assign_op_dim_exit;
+	}
 
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
+	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CONST(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = opline->op2.zv;
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_exit:
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
-	} else {
 
-		CHECK_EXCEPTION();
-	}
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CONST(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = opline->op2.zv;
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -32224,59 +31096,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CONST(incdec_t
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -32296,23 +31158,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = opline->op2.zv;
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -32325,60 +31185,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CONST(incdec_t
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -32397,21 +31244,18 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1;
+
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -32420,105 +31264,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_CV != IS_CONST && varname == &tmp_varname) {
+					if (IS_CV != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_CV == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_CV != IS_TMP_VAR) {
-
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
-			case ZEND_FETCH_LOCAL:
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
 
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_CV == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-				}
-				break;
 		}
 	}
 
-
-	if (IS_CV != IS_CONST && varname == &tmp_varname) {
+	if (IS_CV != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -32543,7 +31370,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_CV_CONST(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_CV_CONST(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -32564,7 +31395,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
@@ -32577,29 +31408,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
-
-	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 	}
 
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -32610,18 +31434,18 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -32636,7 +31460,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -32646,29 +31470,28 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 
 	} else {
-		zval *container;
-
 		if (IS_CONST == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 
 	}
@@ -32680,41 +31503,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, opline->op2.zv, IS_CONST, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, opline->op2.zv, IS_CONST TSRMLS_CC);
 
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
-	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(ZEND_OPCODE_HANDLER_ARGS)
@@ -32726,35 +31530,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CONST(Z
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = opline->op2.zv;
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -32769,38 +31563,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAN
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = opline->op2.zv;
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
-	}
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -32812,26 +31588,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = opline->op2.zv;
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
-	}
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -32847,34 +31616,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = opline->op2.zv;
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -32882,31 +31641,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = opline->op2.zv;
-		container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
-		}
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -32919,41 +31671,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CONST_HANDLER(ZEND_OPC
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 	property = opline->op2.zv;
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
-	}
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -32962,25 +31695,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 	property_name = opline->op2.zv;
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-	}
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -32992,73 +31718,56 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 
 		zval *property_name = opline->op2.zv;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-		}
 	} else {
 		zend_free_op free_op_data1, free_op_data2;
 		zval *value;
 		zval *dim = opline->op2.zv;
-		zval **variable_ptr_ptr;
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CONST, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CONST TSRMLS_CC);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
 
@@ -33073,46 +31782,33 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_
 	USE_OPLINE
 
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = opline->op2.zv;
-	variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-	if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CONST TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
+	variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_CONST, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (0) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_CONST == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_CONST == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+
 	}
 
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
@@ -33125,10 +31821,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -33142,33 +31837,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CONST != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CONST == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CONST == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CONST == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -33176,21 +31868,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -33206,11 +31890,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
 {
 	USE_OPLINE
 
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 opline->op2.zv TSRMLS_CC);
+				 opline->op2.zv TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -33220,35 +31905,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-		if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CV == IS_CV) {
+		} else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -33256,8 +31937,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 	if (IS_CONST != IS_UNUSED) {
 
 		zval *offset = opline->op2.zv;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -33266,32 +31949,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -33299,9 +31982,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CV != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CV != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CV == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CV != IS_UNUSED
@@ -33317,20 +32017,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_CV == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -33338,27 +32033,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 	varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_CONST != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_CONST == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_CV != IS_CONST && varname == &tmp) {
+					if (IS_CV != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 
 					HANDLE_EXCEPTION();
@@ -33366,23 +32062,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_CV != IS_CONST && varname == &tmp) {
+	if (IS_CV != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 
 	CHECK_EXCEPTION();
@@ -33393,91 +32087,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = opline->op2.zv;
 
-	if (IS_CV != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_CONST == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_CONST != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
 
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-
-				break;
+			break;
 		}
-	} else {
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_CONST == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
 
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -33488,38 +32181,26 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = opline->op2.zv;
 
-	if (IS_CV != IS_VAR || container) {
-		if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -33527,21 +32208,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_CV == IS_CV &&
 	    IS_CONST == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -33551,8 +32227,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 		zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 
 		if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -33561,26 +32236,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 			zend_class_entry *ce;
 
 			if (IS_CONST == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -33592,16 +32267,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -33609,26 +32284,25 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCO
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset = opline->op2.zv;
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -33638,25 +32312,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(i
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_CONST == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_CONST != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -33664,116 +32336,103 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CONST == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	offset = opline->op2.zv;
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CONST == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CV != IS_UNUSED) {
@@ -33783,74 +32442,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CV == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CV == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CV == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -33859,45 +32502,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
 		zval *key = opline->op2.zv;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CONST == IS_CONST || IS_CONST == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CONST == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CONST == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CONST == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -33919,8 +32553,8 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		opline->op2.zv TSRMLS_CC);
 
 
@@ -33939,7 +32573,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -33954,7 +32588,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -33969,7 +32603,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -33984,7 +32618,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -33999,8 +32633,8 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34014,8 +32648,8 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34029,8 +32663,8 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34044,8 +32678,8 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34059,8 +32693,8 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34072,11 +32706,11 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
@@ -34089,7 +32723,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -34105,7 +32739,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -34121,7 +32755,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -34137,7 +32771,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -34155,8 +32789,8 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34170,8 +32804,8 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34185,8 +32819,8 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34200,8 +32834,8 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -34213,18 +32847,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	zval *property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -34232,81 +32866,68 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (1) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zval_dtor(free_op2.var);
 		FREE_OP(free_op_data1);
 	}
 
@@ -34316,179 +32937,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_TMP(int (*bina
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-				if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_CV == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_CV == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-			var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_TMP_VAR TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-		zval_dtor(free_op2.var);
-
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_dim_exit:
 	zval_dtor(free_op2.var);
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_TMP(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
 
-		CHECK_EXCEPTION();
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+	zval_dtor(free_op2.var);
+
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_TMP(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 		zval_dtor(free_op2.var);
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -34497,59 +33227,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_TMP(incdec_t in
 
 	/* here we are sure we are dealing with an object */
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -34569,23 +33290,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -34598,60 +33317,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_TMP(incdec_t i
 
 	/* here we are sure we are dealing with an object */
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -34675,7 +33382,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
@@ -34688,29 +33395,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
+	}
 	zval_dtor(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -34721,18 +33421,18 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -34747,7 +33447,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
@@ -34757,29 +33457,28 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 		zval_dtor(free_op2.var);
 
 	} else {
-		zval *container;
-
 		if (IS_TMP_VAR == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 		zval_dtor(free_op2.var);
 
 	}
@@ -34791,41 +33490,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_TMP_VAR TSRMLS_CC);
 	zval_dtor(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
-	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEND_OPCODE_HANDLER_ARGS)
@@ -34837,35 +33517,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_TMP(ZEN
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_dtor(free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_dtor(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -34880,38 +33551,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDL
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -34923,26 +33576,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -34958,34 +33604,25 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_dtor(free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_dtor(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -34993,31 +33630,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (1) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		zval_dtor(free_op2.var);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -35030,41 +33660,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_TMP_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	zval_dtor(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35073,25 +33684,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 	property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (1) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (1) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		zval_dtor(free_op2.var);
-	}
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	zval_dtor(free_op2.var);
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -35103,74 +33707,57 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 		zend_free_op free_op2;
 		zval *property_name = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (1) {
-			zval_ptr_dtor(&property_name);
-		} else {
-			zval_dtor(free_op2.var);
-		}
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+		zval_dtor(free_op2.var);
 	} else {
 		zend_free_op free_op2, free_op_data1, free_op_data2;
 		zval *value;
 		zval *dim = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		zval **variable_ptr_ptr;
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_TMP_VAR TSRMLS_CC);
 		zval_dtor(free_op2.var);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
 
@@ -35185,46 +33772,33 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_AR
 	USE_OPLINE
 	zend_free_op free_op2;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_TMP_VAR TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
-
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_TMP_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (1) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_TMP_VAR == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_TMP_VAR == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+
 	}
 
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
@@ -35237,10 +33811,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -35254,33 +33827,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
+	object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_TMP_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_TMP_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_TMP_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_TMP_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -35288,21 +33858,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
 			zval_dtor(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -35319,11 +33881,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zend_free_op free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
 	zval_dtor(free_op2.var);
 	CHECK_EXCEPTION();
@@ -35334,35 +33897,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-		if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CV == IS_CV) {
+		} else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -35370,8 +33929,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE
 	if (IS_TMP_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -35380,32 +33941,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 		zval_dtor(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -35413,9 +33974,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CV != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CV != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CV == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CV != IS_UNUSED
@@ -35429,91 +34007,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_CV != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_TMP_VAR == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_TMP_VAR != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				zval_dtor(free_op2.var);
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (1) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (1) {
-					zval_ptr_dtor(&offset);
-				} else {
-					zval_dtor(free_op2.var);
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				zval_dtor(free_op2.var);
-				break;
+			zval_dtor(free_op2.var);
+			break;
 		}
-	} else {
-		zval_dtor(free_op2.var);
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_TMP_VAR == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			zval_dtor(free_op2.var);
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+			zval_dtor(free_op2.var);
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -35524,62 +34101,49 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_CV != IS_VAR || container) {
-		if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (1) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (1) {
-				zval_ptr_dtor(&offset);
-			} else {
-				zval_dtor(free_op2.var);
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			zval_dtor(free_op2.var);
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		zval_dtor(free_op2.var);
 	}
+	zval_dtor(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -35589,25 +34153,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_TMP_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_TMP_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -35615,116 +34177,105 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		zval_dtor(free_op2.var);
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (1) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_TMP_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (1) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_dtor(free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-		zval_dtor(free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		zval_dtor(free_op2.var);
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_TMP_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_dtor(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CV != IS_UNUSED) {
@@ -35734,74 +34285,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CV == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CV == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CV == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -35810,45 +34345,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		zval *key = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_TMP_VAR == IS_CONST || IS_TMP_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!1) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_TMP_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_TMP_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_TMP_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -35870,8 +34396,8 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
 	zval_dtor(free_op2.var);
@@ -35890,11 +34416,11 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35905,11 +34431,11 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35920,11 +34446,11 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35935,11 +34461,11 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35950,11 +34476,11 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35965,11 +34491,11 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35980,11 +34506,11 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -35995,11 +34521,11 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36010,11 +34536,11 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36023,15 +34549,15 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36040,14 +34566,14 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36056,14 +34582,14 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36072,14 +34598,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36088,14 +34614,14 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCO
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36106,11 +34632,11 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36121,11 +34647,11 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36136,11 +34662,11 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36151,11 +34677,11 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36164,100 +34690,87 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	zval *property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zval_ptr_dtor_nogc(free_op2.var);
 		FREE_OP(free_op_data1);
 	}
 
@@ -36267,179 +34780,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_VAR(int (*bina
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2, free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-				if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_CV == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_CV == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_VAR, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-			var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_VAR TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-		zval_ptr_dtor_nogc(&free_op2.var);
-
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_dim_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
-	zval_ptr_dtor_nogc(&free_op2.var);
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_dim_exit:
+	zval_ptr_dtor_nogc(free_op2.var);
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_VAR(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
+		}
+		goto assign_op_exit;
+	}
+
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
+
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
 
-		CHECK_EXCEPTION();
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
+
+assign_op_exit:
+	zval_ptr_dtor_nogc(free_op2.var);
+
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_VAR(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -36448,59 +35070,50 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_VAR(incdec_t in
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -36520,27 +35133,25 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 		ZVAL_NULL(retval);
 
 		CHECK_EXCEPTION();
@@ -36549,60 +35160,48 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_VAR(incdec_t i
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -36621,21 +35220,18 @@ static int ZEND_FASTCALL  ZEND_POST_DEC_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1;
+
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -36644,105 +35240,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_CV != IS_CONST && varname == &tmp_varname) {
+					if (IS_CV != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_CV == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_CV != IS_TMP_VAR) {
-
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
-			case ZEND_FETCH_LOCAL:
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
 
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_CV == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-				}
-				break;
 		}
 	}
 
-
-	if (IS_CV != IS_CONST && varname == &tmp_varname) {
+	if (IS_CV != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -36767,7 +35346,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_CV_VAR(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_CV_VAR(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -36788,8 +35371,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
 	}
@@ -36801,29 +35384,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
-	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
 	}
-
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	zval_ptr_dtor_nogc(free_op2.var);
+	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -36834,18 +35410,18 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_RW TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -36860,8 +35436,8 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_IS TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -36870,30 +35446,29 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1, free_op2;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 
 	} else {
-		zval *container;
-
 		if (IS_VAR == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_R TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 
 	}
 	CHECK_EXCEPTION();
@@ -36904,41 +35479,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR, BP_VAR_UNSET TSRMLS_CC);
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC), IS_VAR TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
-	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEND_OPCODE_HANDLER_ARGS)
@@ -36950,35 +35506,26 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_VAR(ZEN
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_ptr_dtor_nogc(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -36993,38 +35540,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDL
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -37036,26 +35565,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 	USE_OPLINE
 	zend_free_op free_op1, free_op2;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -37071,34 +35593,25 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+	zval_ptr_dtor_nogc(free_op2.var);
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -37106,31 +35619,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1, free_op2;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -37143,41 +35649,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_VAR_HANDLER(ZEND_OPCOD
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_op2, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1, free_op2;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -37186,25 +35673,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 	property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
-	}
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -37216,74 +35696,57 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 		zend_free_op free_op2;
 		zval *property_name = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
-		}
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 	} else {
 		zend_free_op free_op2, free_op_data1, free_op_data2;
 		zval *value;
-		zval *dim = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-		zval **variable_ptr_ptr;
+		zval *dim = _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_VAR, BP_VAR_W TSRMLS_CC);
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_VAR TSRMLS_CC);
+		zval_ptr_dtor_nogc(free_op2.var);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
 
@@ -37298,50 +35761,37 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_AR
 	USE_OPLINE
 	zend_free_op free_op2;
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
-	variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-	if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_VAR TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
+	variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_VAR, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (0) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_VAR == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_VAR == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+
 	}
 
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
- 	zval_ptr_dtor_nogc(&free_op2.var);
+ 	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -37351,50 +35801,59 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **variable_ptr_ptr;
-	zval **value_ptr_ptr;
+	zval *variable_ptr;
+	zval *value_ptr;
 
 	SAVE_OPLINE();
-	value_ptr_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+	value_ptr = _get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 	if (IS_VAR == IS_VAR &&
-	    value_ptr_ptr &&
-	    !Z_ISREF_PP(value_ptr_ptr) &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION &&
-	    !EX_T(opline->op2.var).var.fcall_returned_reference) {
-		if (free_op2.var == NULL) {
-			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
+	    !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) &&
+	    !Z_ISREF_P(value_ptr)) {
+		if (!(free_op2.var != NULL)) {
+			PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
+			if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);};
 			HANDLE_EXCEPTION();
 		}
 		return ZEND_ASSIGN_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		PZVAL_LOCK(*value_ptr_ptr);
+		if (!(free_op2.var != NULL)) {
+			PZVAL_LOCK(value_ptr);
+		}
 	}
-	if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
+
+	variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR &&
+	    UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
+	    UNEXPECTED(!Z_ISREF_P(variable_ptr))) {
 		zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
-
-	variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-	if ((IS_VAR == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
-	    (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
+	if ((IS_VAR == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) ||
+	    (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) {
 		zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
 	}
-	zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
+	if ((IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
+	    (IS_VAR == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+		variable_ptr = &EG(uninitialized_zval);
+	} else {
+		zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC);
+	}
 
 	if (IS_VAR == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		Z_DELREF_PP(variable_ptr_ptr);
+		if (!(free_op2.var != NULL)) {
+			Z_DELREF_P(variable_ptr);
+		}
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*variable_ptr_ptr);
-		EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
 	}
 
-	if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);};
+	if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);};
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -37404,10 +35863,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 	zend_free_op free_op2;
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -37421,62 +35879,51 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
-
-	call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_VAR != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_VAR == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_VAR == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_VAR == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
 		if (UNEXPECTED(EG(exception) != NULL)) {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zval_ptr_dtor_nogc(free_op2.var);
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
 	call->is_ctor_call = 0;
 	EX(call) = call;
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -37486,13 +35933,14 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 {
 	USE_OPLINE
 	zend_free_op free_op2;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -37501,35 +35949,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-		if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CV == IS_CV) {
+		} else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -37537,8 +35981,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 	if (IS_VAR != IS_UNUSED) {
 		zend_free_op free_op2;
 		zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -37547,32 +35993,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		zval_ptr_dtor_nogc(free_op2.var);
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -37580,9 +36026,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CV != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CV != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CV == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CV != IS_UNUSED
@@ -37598,20 +36061,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_CV == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -37619,27 +36077,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 	varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_VAR != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_VAR == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_CV != IS_CONST && varname == &tmp) {
+					if (IS_CV != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 
 					HANDLE_EXCEPTION();
@@ -37647,23 +36106,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_CV != IS_CONST && varname == &tmp) {
+	if (IS_CV != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 
 	CHECK_EXCEPTION();
@@ -37674,91 +36131,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_CV != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_VAR == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_VAR != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-				zval_ptr_dtor_nogc(&free_op2.var);
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
-					zval_ptr_dtor_nogc(&free_op2.var);
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-				zval_ptr_dtor_nogc(&free_op2.var);
-				break;
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
 		}
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_VAR == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+			zval_ptr_dtor_nogc(free_op2.var);
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -37769,37 +36225,25 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 	zend_free_op free_op2;
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (IS_CV != IS_VAR || container) {
-		if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-				zval_ptr_dtor_nogc(&free_op2.var);
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
 	}
+	zval_ptr_dtor_nogc(free_op2.var);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -37808,21 +36252,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_CV == IS_CV &&
 	    IS_VAR == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -37832,8 +36271,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 		zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 
 		if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -37842,26 +36280,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 			zend_class_entry *ce;
 
 			if (IS_VAR == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -37873,16 +36311,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -37890,26 +36328,25 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op2;
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -37919,25 +36356,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_VAR == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_VAR != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -37945,116 +36380,105 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_VAR == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-			zval_ptr_dtor_nogc(&free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-		zval_ptr_dtor_nogc(&free_op2.var);
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-		zval_ptr_dtor_nogc(&free_op2.var);
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+	zend_free_op free_op2;
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_VAR == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	zval_ptr_dtor_nogc(free_op2.var);
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CV != IS_UNUSED) {
@@ -38064,74 +36488,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CV == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CV == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CV == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -38140,46 +36548,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
 		zval *key = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_VAR == IS_CONST || IS_VAR == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
-
-			generator->key = copy;
+		if (IS_VAR == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_VAR == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
+			zval_ptr_dtor_nogc(free_op2.var);
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_VAR == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
-		zval_ptr_dtor_nogc(&free_op2.var);
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -38201,11 +36599,11 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 	zend_free_op free_op2;
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
-	zval_ptr_dtor_nogc(&free_op2.var);
+	zval_ptr_dtor_nogc(free_op2.var);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -38219,18 +36617,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
 {
 	USE_OPLINE
 	zend_free_op free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	zval *property = NULL;
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -38238,81 +36636,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
@@ -38322,168 +36706,278 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(int (*b
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-				if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_CV == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = NULL;
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_CV == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = NULL;
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = NULL;
-			var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_UNUSED TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
+		goto assign_op_dim_exit;
+	}
 
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
+	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_UNUSED(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = NULL;
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_exit:
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
-	} else {
 
-		CHECK_EXCEPTION();
-	}
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_UNUSED(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1;
+
 	zval *varname;
-	zval **retval;
+	zval *retval;
 	zval tmp_varname;
 	HashTable *target_symbol_table;
-	ulong hash_value;
 
 	SAVE_OPLINE();
 	varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
+	ZVAL_UNDEF(&tmp_varname);
  	if (IS_CV != IS_CONST && UNEXPECTED(Z_TYPE_P(varname) != IS_STRING)) {
-		ZVAL_COPY_VALUE(&tmp_varname, varname);
-		zval_copy_ctor(&tmp_varname);
-		Z_SET_REFCOUNT(tmp_varname, 1);
-		Z_UNSET_ISREF(tmp_varname);
+		ZVAL_DUP_DEREF(&tmp_varname, varname);
 		convert_to_string(&tmp_varname);
 		varname = &tmp_varname;
 	}
@@ -38492,105 +36986,88 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(ce == NULL)) {
-					if (IS_CV != IS_CONST && varname == &tmp_varname) {
+					if (IS_CV != IS_CONST) {
 						zval_dtor(&tmp_varname);
 					}
 
 					CHECK_EXCEPTION();
 					ZEND_VM_NEXT_OPCODE();
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		retval = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 0, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		retval = zend_std_get_static_property(ce, Z_STR_P(varname), 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 
 	} else {
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-/*
-		if (!target_symbol_table) {
-			CHECK_EXCEPTION();
-			ZEND_VM_NEXT_OPCODE();
-		}
-*/
-		if (IS_CV == IS_CONST) {
-			hash_value = Z_HASH_P(varname);
-		} else {
-			hash_value = str_hash(Z_STRVAL_P(varname), Z_STRLEN_P(varname));
-		}
-
-		if (zend_hash_quick_find(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, (void **) &retval) == FAILURE) {
+		retval = zend_hash_find(target_symbol_table, Z_STR_P(varname));
+		if (retval == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 				case BP_VAR_UNSET:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = EX_VAR(opline->result.var);
+					ZVAL_NULL(retval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
 					/* break missing intentionally */
 				case BP_VAR_W:
-					Z_ADDREF_P(&EG(uninitialized_zval));
-					zend_hash_quick_update(target_symbol_table, Z_STRVAL_P(varname), Z_STRLEN_P(varname)+1, hash_value, &EG(uninitialized_zval_ptr), sizeof(zval *), (void **) &retval);
+					retval = zend_hash_update(target_symbol_table, Z_STR_P(varname), &EG(uninitialized_zval));
 					break;
 				EMPTY_SWITCH_DEFAULT_CASE()
 			}
-		}
-		switch (opline->extended_value & ZEND_FETCH_TYPE_MASK) {
-			case ZEND_FETCH_GLOBAL:
-				if (IS_CV != IS_TMP_VAR) {
-
+		/* GLOBAL or $$name variable may be an INDIRECT pointer to CV */
+		} else if (Z_TYPE_P(retval) == IS_INDIRECT) {
+			retval = Z_INDIRECT_P(retval);
+			if (Z_TYPE_P(retval) == IS_UNDEF) {
+				switch (type) {
+					case BP_VAR_R:
+					case BP_VAR_UNSET:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_IS:
+						retval = EX_VAR(opline->result.var);
+						ZVAL_NULL(retval);
+						break;
+					case BP_VAR_RW:
+						zend_error(E_NOTICE,"Undefined variable: %s", Z_STRVAL_P(varname));
+						/* break missing intentionally */
+					case BP_VAR_W:
+						ZVAL_NULL(retval);
+						break;
+					EMPTY_SWITCH_DEFAULT_CASE()
 				}
-				break;
-			case ZEND_FETCH_LOCAL:
+			}
+		}
+		if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) == ZEND_FETCH_STATIC) {
+			zval_update_constant(retval, 1 TSRMLS_CC);
+		} else if ((opline->extended_value & ZEND_FETCH_TYPE_MASK) != ZEND_FETCH_GLOBAL_LOCK) {
 
-				break;
-			case ZEND_FETCH_STATIC:
-				zval_update_constant(retval, 1 TSRMLS_CC);
-				break;
-			case ZEND_FETCH_GLOBAL_LOCK:
-				if (IS_CV == IS_VAR && !free_op1.var) {
-					PZVAL_LOCK(*EX_T(opline->op1.var).var.ptr_ptr);
-				}
-				break;
 		}
 	}
 
-
-	if (IS_CV != IS_CONST && varname == &tmp_varname) {
+	if (IS_CV != IS_CONST) {
 		zval_dtor(&tmp_varname);
 	}
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
-	}
-	PZVAL_LOCK(*retval);
-	switch (type) {
-		case BP_VAR_R:
-		case BP_VAR_IS:
-			EX_T(opline->result.var).var.ptr = *retval;
-			break;
-		case BP_VAR_UNSET: {
-			zend_free_op free_res;
 
-			PZVAL_UNLOCK(*retval, &free_res);
-			if (retval != &EG(uninitialized_zval_ptr)) {
-				SEPARATE_ZVAL_IF_NOT_REF(retval);
-			}
-			PZVAL_LOCK(*retval);
-			FREE_OP_VAR_PTR(free_res);
+	ZEND_ASSERT(retval != NULL);
+	if (type == BP_VAR_R || type == BP_VAR_IS) {
+		ZVAL_COPY(EX_VAR(opline->result.var), retval);
+	} else {
+		if (/*type == BP_VAR_W &&*/ (opline->extended_value & ZEND_FETCH_MAKE_REF)) {
+			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval);
 		}
-		/* break missing intentionally */
-		default:
-			EX_T(opline->result.var).var.ptr_ptr = retval;
-			break;
+		ZVAL_INDIRECT(EX_VAR(opline->result.var), retval);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -38615,7 +37092,11 @@ static int ZEND_FASTCALL  ZEND_FETCH_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE
 {
 	USE_OPLINE
 
-	return zend_fetch_var_address_helper_SPEC_CV_UNUSED(zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC) ? BP_VAR_W : BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
+		return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_W, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		return zend_fetch_var_address_helper_SPEC_CV_UNUSED(BP_VAR_R, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_FETCH_UNSET_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
@@ -38632,29 +37113,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
-
-	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 	}
 
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -38665,18 +37139,18 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -38686,29 +37160,28 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_H
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 
 	} else {
-		zval *container;
-
 		if (IS_UNUSED == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, NULL, IS_UNUSED, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, NULL, IS_UNUSED TSRMLS_CC);
 
 
 	}
@@ -38720,73 +37193,56 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAN
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 
 		zval *property_name = NULL;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_UNUSED == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-		}
 	} else {
 		zend_free_op free_op_data1, free_op_data2;
 		zval *value;
 		zval *dim = NULL;
-		zval **variable_ptr_ptr;
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_UNUSED, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_UNUSED TSRMLS_CC);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
 
@@ -38800,35 +37256,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-		if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CV == IS_CV) {
+		} else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -38836,8 +37288,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
 	if (IS_UNUSED != IS_UNUSED) {
 
 		zval *offset = NULL;
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -38846,32 +37300,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_UNUSED == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_UNUSED != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -38879,9 +37333,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CV != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CV != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CV == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CV != IS_UNUSED
@@ -38897,20 +37368,15 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
 	zval tmp, *varname;
 	HashTable *target_symbol_table;
 
+	zend_bool tmp_is_dup = 0;
 
 	SAVE_OPLINE();
 	if (IS_CV == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			zend_delete_variable(EX(prev_execute_data), EG(active_symbol_table),  cv->name, cv->name_len+1, cv->hash_value TSRMLS_CC);
-			EX_CV(opline->op1.var) = NULL;
-		} else if (EX_CV(opline->op1.var)) {
-			zval_ptr_dtor(EX_CV(opline->op1.var));
-			EX_CV(opline->op1.var) = NULL;
-		}
+	    ZVAL_COPY_VALUE(&tmp, EX_VAR(opline->op1.var));
+		ZVAL_UNDEF(EX_VAR(opline->op1.var));
+		zval_ptr_dtor(&tmp);
 		CHECK_EXCEPTION();
 		ZEND_VM_NEXT_OPCODE();
 	}
@@ -38918,27 +37384,28 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
 	varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 	if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-		ZVAL_COPY_VALUE(&tmp, varname);
-		zval_copy_ctor(&tmp);
+		ZVAL_DUP(&tmp, varname);
 		convert_to_string(&tmp);
 		varname = &tmp;
+		tmp_is_dup = 1;
 	} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		Z_ADDREF_P(varname);
+		ZVAL_COPY(&tmp, varname);
+		varname = &tmp;
 	}
 
 	if (IS_UNUSED != IS_UNUSED) {
 		zend_class_entry *ce;
 
 		if (IS_UNUSED == IS_CONST) {
-			if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-				ce = CACHED_PTR(opline->op2.literal->cache_slot);
+			if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+				ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 			} else {
-				ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+				ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 				if (UNEXPECTED(EG(exception) != NULL)) {
-					if (IS_CV != IS_CONST && varname == &tmp) {
+					if (IS_CV != IS_CONST && tmp_is_dup) {
 						zval_dtor(&tmp);
 					} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-						zval_ptr_dtor(&varname);
+						zval_ptr_dtor(&tmp);
 					}
 
 					HANDLE_EXCEPTION();
@@ -38946,23 +37413,21 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
 				if (UNEXPECTED(ce == NULL)) {
 					zend_error_noreturn(E_ERROR, "Class '%s' not found", Z_STRVAL_P(opline->op2.zv));
 				}
-				CACHE_PTR(opline->op2.literal->cache_slot, ce);
+				CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 			}
 		} else {
-			ce = EX_T(opline->op2.var).class_entry;
+			ce = Z_CE_P(EX_VAR(opline->op2.var));
 		}
-		zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+		zend_std_unset_static_property(ce, Z_STR_P(varname), ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 	} else {
-		ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
-
 		target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-		zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
+		zend_hash_del_ind(target_symbol_table, Z_STR_P(varname));
 	}
 
-	if (IS_CV != IS_CONST && varname == &tmp) {
+	if (IS_CV != IS_CONST && tmp_is_dup) {
 		zval_dtor(&tmp);
 	} else if (IS_CV == IS_VAR || IS_CV == IS_CV) {
-		zval_ptr_dtor(&varname);
+		zval_ptr_dtor(&tmp);
 	}
 
 	CHECK_EXCEPTION();
@@ -38972,21 +37437,16 @@ static int ZEND_FASTCALL  ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zval **value;
+	zval *value;
 	zend_bool isset = 1;
 
 	SAVE_OPLINE();
 	if (IS_CV == IS_CV &&
 	    IS_UNUSED == IS_UNUSED &&
 	    (opline->extended_value & ZEND_QUICK_SET)) {
-		if (EX_CV(opline->op1.var)) {
-			value = EX_CV(opline->op1.var);
-		} else if (EG(active_symbol_table)) {
-			zend_compiled_variable *cv = &CV_DEF_OF(opline->op1.var);
-
-			if (zend_hash_quick_find(EG(active_symbol_table), cv->name, cv->name_len+1, cv->hash_value, (void **) &value) == FAILURE) {
-				isset = 0;
-			}
+		if (Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_UNDEF) {
+			value = EX_VAR(opline->op1.var);
+			ZVAL_DEREF(value);
 		} else {
 			isset = 0;
 		}
@@ -38996,8 +37456,7 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
 		zval tmp, *varname = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 
 		if (IS_CV != IS_CONST && Z_TYPE_P(varname) != IS_STRING) {
-			ZVAL_COPY_VALUE(&tmp, varname);
-			zval_copy_ctor(&tmp);
+			ZVAL_DUP(&tmp, varname);
 			convert_to_string(&tmp);
 			varname = &tmp;
 		}
@@ -39006,26 +37465,26 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
 			zend_class_entry *ce;
 
 			if (IS_UNUSED == IS_CONST) {
-				if (CACHED_PTR(opline->op2.literal->cache_slot)) {
-					ce = CACHED_PTR(opline->op2.literal->cache_slot);
+				if (CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv))) {
+					ce = CACHED_PTR(Z_CACHE_SLOT_P(opline->op2.zv));
 				} else {
-					ce = zend_fetch_class_by_name(Z_STRVAL_P(opline->op2.zv), Z_STRLEN_P(opline->op2.zv), opline->op2.literal + 1, 0 TSRMLS_CC);
+					ce = zend_fetch_class_by_name(Z_STR_P(opline->op2.zv), opline->op2.zv + 1, 0 TSRMLS_CC);
 					if (UNEXPECTED(ce == NULL)) {
 						CHECK_EXCEPTION();
 						ZEND_VM_NEXT_OPCODE();
 					}
-					CACHE_PTR(opline->op2.literal->cache_slot, ce);
+					CACHE_PTR(Z_CACHE_SLOT_P(opline->op2.zv), ce);
 				}
 			} else {
-				ce = EX_T(opline->op2.var).class_entry;
+				ce = Z_CE_P(EX_VAR(opline->op2.var));
 			}
-			value = zend_std_get_static_property(ce, Z_STRVAL_P(varname), Z_STRLEN_P(varname), 1, ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
+			value = zend_std_get_static_property(ce, Z_STR_P(varname), 1, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(varname) : -1) TSRMLS_CC);
 			if (!value) {
 				isset = 0;
 			}
 		} else {
 			target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
-			if (zend_hash_find(target_symbol_table, varname->value.str.val, varname->value.str.len+1, (void **) &value) == FAILURE) {
+			if ((value = zend_hash_find(target_symbol_table, Z_STR_P(varname))) == NULL) {
 				isset = 0;
 			}
 		}
@@ -39037,16 +37496,16 @@ static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
 	}
 
 	if (opline->extended_value & ZEND_ISSET) {
-		if (isset && Z_TYPE_PP(value) != IS_NULL) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (isset && Z_TYPE_P(value) != IS_NULL) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-		if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 1);
+		if (!isset || !i_zend_is_true(value TSRMLS_CC)) {
+			ZVAL_BOOL(EX_VAR(opline->result.var), 1);
 		} else {
-			ZVAL_BOOL(&EX_T(opline->result.var).tmp_var, 0);
+			ZVAL_BOOL(EX_VAR(opline->result.var), 0);
 		}
 	}
 
@@ -39058,22 +37517,18 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CV != IS_UNUSED) {
@@ -39083,74 +37538,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CV == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CV == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CV == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -39159,45 +37598,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HANDLER_
 		zval *key = NULL;
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_UNUSED == IS_CONST || IS_UNUSED == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_UNUSED == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_UNUSED == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_UNUSED == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -39224,7 +37654,7 @@ static int ZEND_FASTCALL  ZEND_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	fast_add_function(&EX_T(opline->result.var).tmp_var,
+	fast_add_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -39239,7 +37669,7 @@ static int ZEND_FASTCALL  ZEND_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	fast_sub_function(&EX_T(opline->result.var).tmp_var,
+	fast_sub_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -39254,7 +37684,7 @@ static int ZEND_FASTCALL  ZEND_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	fast_mul_function(&EX_T(opline->result.var).tmp_var,
+	fast_mul_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -39269,7 +37699,7 @@ static int ZEND_FASTCALL  ZEND_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	fast_div_function(&EX_T(opline->result.var).tmp_var,
+	fast_div_function(EX_VAR(opline->result.var),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
 		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -39284,9 +37714,9 @@ static int ZEND_FASTCALL  ZEND_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	fast_mod_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	fast_mod_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39299,9 +37729,9 @@ static int ZEND_FASTCALL  ZEND_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	shift_left_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	shift_left_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39314,9 +37744,9 @@ static int ZEND_FASTCALL  ZEND_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	shift_right_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	shift_right_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39329,9 +37759,9 @@ static int ZEND_FASTCALL  ZEND_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	concat_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	concat_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39344,9 +37774,9 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 
 
 	SAVE_OPLINE();
-	is_identical_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	is_identical_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39357,12 +37787,12 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	is_identical_function(result,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 	Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
@@ -39374,7 +37804,7 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_equal_function(result,
@@ -39390,7 +37820,7 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_not_equal_function(result,
@@ -39406,7 +37836,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_function(result,
@@ -39422,7 +37852,7 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD
 {
 	USE_OPLINE
 
-	zval *result = &EX_T(opline->result.var).tmp_var;
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
 	ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
@@ -39440,9 +37870,9 @@ static int ZEND_FASTCALL  ZEND_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 
 
 	SAVE_OPLINE();
-	bitwise_or_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	bitwise_or_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39455,9 +37885,9 @@ static int ZEND_FASTCALL  ZEND_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	bitwise_and_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	bitwise_and_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39470,9 +37900,9 @@ static int ZEND_FASTCALL  ZEND_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 
 
 	SAVE_OPLINE();
-	bitwise_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	bitwise_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39485,9 +37915,9 @@ static int ZEND_FASTCALL  ZEND_BOOL_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A
 
 
 	SAVE_OPLINE();
-	boolean_xor_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	boolean_xor_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -39498,18 +37928,18 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
 {
 	USE_OPLINE
 	zend_free_op free_op_data1;
-	zval **object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-	zval *object;
+	zval *object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	zval *property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	zval *value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+	zval *value;
 	int have_get_ptr = 0;
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC);
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC);
+
+	value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to assign property of non-object");
@@ -39517,81 +37947,67 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
 		FREE_OP(free_op_data1);
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		/* here we are sure we are dealing with an object */
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-
-		/* here property is a string */
 		if (opline->extended_value == ZEND_ASSIGN_OBJ
 			&& Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-			zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 				SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 				have_get_ptr = 1;
-				binary_op(*zptr, *zptr, value TSRMLS_CC);
+				binary_op(zptr, zptr, value TSRMLS_CC);
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(*zptr);
-					EX_T(opline->result.var).var.ptr = *zptr;
+					ZVAL_COPY(EX_VAR(opline->result.var), zptr);
 				}
 			}
 		}
 
 		if (!have_get_ptr) {
 			zval *z = NULL;
+			zval rv;
 
 			if (opline->extended_value == ZEND_ASSIGN_OBJ) {
 				if (Z_OBJ_HT_P(object)->read_property) {
-					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 				}
 			} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 				if (Z_OBJ_HT_P(object)->read_dimension) {
-					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R TSRMLS_CC);
+					z = Z_OBJ_HT_P(object)->read_dimension(object, property, BP_VAR_R, &rv TSRMLS_CC);
 				}
 			}
 			if (z) {
 				if (Z_TYPE_P(z) == IS_OBJECT && Z_OBJ_HT_P(z)->get) {
-					zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+					zval rv;
+					zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 					if (Z_REFCOUNT_P(z) == 0) {
-						GC_REMOVE_ZVAL_FROM_BUFFER(z);
 						zval_dtor(z);
-						FREE_ZVAL(z);
 					}
-					z = value;
+					ZVAL_COPY_VALUE(z, value);
 				}
-				Z_ADDREF_P(z);
-				SEPARATE_ZVAL_IF_NOT_REF(&z);
+//???				if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+				SEPARATE_ZVAL_IF_NOT_REF(z);
 				binary_op(z, z, value TSRMLS_CC);
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+					Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 				} else /* if (opline->extended_value == ZEND_ASSIGN_DIM) */ {
 					Z_OBJ_HT_P(object)->write_dimension(object, property, z TSRMLS_CC);
 				}
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(z);
-					EX_T(opline->result.var).var.ptr = z;
+					ZVAL_COPY(EX_VAR(opline->result.var), z);
 				}
-				zval_ptr_dtor(&z);
+				zval_ptr_dtor(z);
 			} else {
 				zend_error(E_WARNING, "Attempt to assign property of non-object");
 				if (RETURN_VALUE_USED(opline)) {
-					PZVAL_LOCK(&EG(uninitialized_zval));
-					EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+					ZVAL_NULL(EX_VAR(opline->result.var));
 				}
 			}
 		}
 
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
-
-		}
 		FREE_OP(free_op_data1);
 	}
 
@@ -39601,178 +38017,288 @@ static int ZEND_FASTCALL zend_binary_assign_op_obj_helper_SPEC_CV_CV(int (*binar
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL zend_binary_assign_op_dim_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 	zend_free_op free_op_data2, free_op_data1;
-	zval **var_ptr;
-	zval *value;
+	zval *var_ptr;
+	zval *value, *container;
 
 	SAVE_OPLINE();
-	switch (opline->extended_value) {
-		case ZEND_ASSIGN_OBJ:
-			return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-			break;
-		case ZEND_ASSIGN_DIM: {
-				zval **container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-
-				if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
-				} else if (UNEXPECTED(Z_TYPE_PP(container) == IS_OBJECT)) {
-					if (IS_CV == IS_VAR && !0) {
-						Z_ADDREF_PP(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
-					}
-					return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-				} else {
-					zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
+	} else if (UNEXPECTED(Z_TYPE_P(container) == IS_OBJECT)) {
+		if (IS_CV == IS_VAR && !0) {
+			Z_ADDREF_P(container);  /* undo the effect of get_obj_zval_ptr_ptr() */
+		}
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(binary_op, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else {
+		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-					zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), container, dim, IS_CV, BP_VAR_RW TSRMLS_CC);
-					value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-					var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-				}
-			}
-			break;
-		default:
-			value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-			var_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
-			/* do nothing */
-			break;
+		zend_fetch_dimension_address_RW(EX_VAR((opline+1)->op2.var), container, dim, IS_CV TSRMLS_CC);
+		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
+		var_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
 	}
 
-	if (UNEXPECTED(var_ptr == NULL)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
 	}
 
-	if (UNEXPECTED(*var_ptr == &EG(error_zval))) {
-		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+	if (UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
+		goto assign_op_dim_exit;
+	}
 
+	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-		CHECK_EXCEPTION();
-		if (opline->extended_value == ZEND_ASSIGN_DIM) {
-			ZEND_VM_INC_OPCODE();
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
+		/* proxy object */
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
+		Z_ADDREF_P(objval);
+		binary_op(objval, objval, value TSRMLS_CC);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
+	} else {
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
+	}
+
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
+	}
+
+assign_op_dim_exit:
+
+	FREE_OP(free_op_data1);
+	FREE_OP_VAR_PTR(free_op_data2);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_INC_OPCODE();
+	ZEND_VM_NEXT_OPCODE();
+}
+
+static int ZEND_FASTCALL zend_binary_assign_op_helper_SPEC_CV_CV(int (*binary_op)(zval *result, zval *op1, zval *op2 TSRMLS_DC), ZEND_OPCODE_HANDLER_ARGS)
+{
+	USE_OPLINE
+
+	zval *var_ptr;
+	zval *value;
+
+	SAVE_OPLINE();
+	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+	var_ptr = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(var_ptr) == IS_STR_OFFSET)) {
+		zend_error_noreturn(E_ERROR, "Cannot use assign-op operators with overloaded objects nor string offsets");
+	}
+
+	if (IS_CV == IS_VAR && UNEXPECTED(var_ptr == &EG(error_zval))) {
+		if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
-		ZEND_VM_NEXT_OPCODE();
+		goto assign_op_exit;
 	}
 
 	SEPARATE_ZVAL_IF_NOT_REF(var_ptr);
+	ZVAL_DEREF(var_ptr);
 
-	if (UNEXPECTED(Z_TYPE_PP(var_ptr) == IS_OBJECT)
-	   && Z_OBJ_HANDLER_PP(var_ptr, get)
-	   && Z_OBJ_HANDLER_PP(var_ptr, set)) {
+	if (UNEXPECTED(Z_TYPE_P(var_ptr) == IS_OBJECT) &&
+	    UNEXPECTED(Z_OBJ_HANDLER_P(var_ptr, get) && Z_OBJ_HANDLER_P(var_ptr, set))) {
 		/* proxy object */
-		zval *objval = Z_OBJ_HANDLER_PP(var_ptr, get)(*var_ptr TSRMLS_CC);
+		zval rv;
+		zval *objval = Z_OBJ_HANDLER_P(var_ptr, get)(var_ptr, &rv TSRMLS_CC);
 		Z_ADDREF_P(objval);
 		binary_op(objval, objval, value TSRMLS_CC);
-		Z_OBJ_HANDLER_PP(var_ptr, set)(var_ptr, objval TSRMLS_CC);
-		zval_ptr_dtor(&objval);
+		Z_OBJ_HANDLER_P(var_ptr, set)(var_ptr, objval TSRMLS_CC);
+		zval_ptr_dtor(objval);
 	} else {
-		binary_op(*var_ptr, *var_ptr, value TSRMLS_CC);
+		binary_op(var_ptr, var_ptr, value TSRMLS_CC);
 	}
 
-	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*var_ptr);
-		EX_T(opline->result.var).var.ptr = *var_ptr;
+	if (UNEXPECTED(RETURN_VALUE_USED(opline))) {
+		ZVAL_COPY(EX_VAR(opline->result.var), var_ptr);
 	}
 
-	if (opline->extended_value == ZEND_ASSIGN_DIM) {
-		FREE_OP(free_op_data1);
-		FREE_OP_VAR_PTR(free_op_data2);
+assign_op_exit:
 
-		CHECK_EXCEPTION();
-		ZEND_VM_INC_OPCODE();
-	} else {
 
-		CHECK_EXCEPTION();
-	}
+	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_ADD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(add_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SUB_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(sub_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MUL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(mul_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_DIV_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(div_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_MOD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(mod_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(shift_left_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_SR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(shift_right_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_CONCAT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(concat_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_OR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(bitwise_or_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_AND_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(bitwise_and_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL  ZEND_ASSIGN_BW_XOR_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	if (EXPECTED(opline->extended_value == 0)) {
+		return zend_binary_assign_op_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else if (EXPECTED(opline->extended_value == ZEND_ASSIGN_DIM)) {
+		return zend_binary_assign_op_dim_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	} else /* if (EXPECTED(opline->extended_value == ZEND_ASSIGN_OBJ)) */ {
+		return zend_binary_assign_op_obj_helper_SPEC_CV_CV(bitwise_xor_function, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	}
 }
 
 static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t incdec_op, ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
-	zval **retval;
+	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	retval = &EX_T(opline->result.var).var.ptr;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			*retval = &EG(uninitialized_zval);
+			ZVAL_NULL(retval);
 		}
 
 		CHECK_EXCEPTION();
@@ -39781,59 +38307,49 @@ static int ZEND_FASTCALL zend_pre_incdec_property_helper_SPEC_CV_CV(incdec_t inc
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
 			have_get_ptr = 1;
-			incdec_op(*zptr);
+			incdec_op(zptr);
 			if (RETURN_VALUE_USED(opline)) {
-				*retval = *zptr;
-				PZVAL_LOCK(*retval);
+				ZVAL_COPY(retval, zptr);
 			}
 		}
 	}
 
 	if (!have_get_ptr) {
+		zval rv;
+
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			Z_ADDREF_P(z);
-			SEPARATE_ZVAL_IF_NOT_REF(&z);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			SEPARATE_ZVAL_IF_NOT_REF(z);
 			incdec_op(z);
-			*retval = z;
-			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			SELECTIVE_PZVAL_LOCK(*retval, opline);
-			zval_ptr_dtor(&z);
+			ZVAL_COPY_VALUE(retval, z);
+			Z_OBJ_HT_P(object)->write_property(object, property, z, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
+			SELECTIVE_PZVAL_LOCK(retval, opline);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				*retval = &EG(uninitialized_zval);
+				ZVAL_NULL(retval);
 			}
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -39853,23 +38369,21 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in
 {
 	USE_OPLINE
 
-	zval **object_ptr;
 	zval *object;
 	zval *property;
 	zval *retval;
 	int have_get_ptr = 0;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	retval = &EX_T(opline->result.var).tmp_var;
+	retval = EX_VAR(opline->result.var);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot increment/decrement overloaded objects nor string offsets");
 	}
 
-	make_real_object(object_ptr TSRMLS_CC); /* this should modify object only if it's empty */
-	object = *object_ptr;
+	object = make_real_object(object TSRMLS_CC); /* this should modify object only if it's empty */
 
 	if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
 		zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
@@ -39882,60 +38396,47 @@ static int ZEND_FASTCALL zend_post_incdec_property_helper_SPEC_CV_CV(incdec_t in
 
 	/* here we are sure we are dealing with an object */
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-
 	if (Z_OBJ_HT_P(object)->get_property_ptr_ptr) {
-		zval **zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+		zval *zptr = Z_OBJ_HT_P(object)->get_property_ptr_ptr(object, property, BP_VAR_RW, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 		if (zptr != NULL) { 			/* NULL means no success in getting PTR */
 			have_get_ptr = 1;
 			SEPARATE_ZVAL_IF_NOT_REF(zptr);
 
-			ZVAL_COPY_VALUE(retval, *zptr);
-			zendi_zval_copy_ctor(*retval);
+			ZVAL_DUP(retval, zptr);
 
-			incdec_op(*zptr);
+			incdec_op(zptr);
 
 		}
 	}
 
 	if (!have_get_ptr) {
 		if (Z_OBJ_HT_P(object)->read_property && Z_OBJ_HT_P(object)->write_property) {
-			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			zval *z_copy;
+			zval rv;
+			zval *z = Z_OBJ_HT_P(object)->read_property(object, property, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), &rv TSRMLS_CC);
+			zval z_copy;
 
 			if (UNEXPECTED(Z_TYPE_P(z) == IS_OBJECT) && Z_OBJ_HT_P(z)->get) {
-				zval *value = Z_OBJ_HT_P(z)->get(z TSRMLS_CC);
+				zval rv;
+				zval *value = Z_OBJ_HT_P(z)->get(z, &rv TSRMLS_CC);
 
 				if (Z_REFCOUNT_P(z) == 0) {
-					GC_REMOVE_ZVAL_FROM_BUFFER(z);
 					zval_dtor(z);
-					FREE_ZVAL(z);
 				}
-				z = value;
+				ZVAL_COPY_VALUE(z, value);
 			}
-			ZVAL_COPY_VALUE(retval, z);
-			zendi_zval_copy_ctor(*retval);
-			ALLOC_ZVAL(z_copy);
-			INIT_PZVAL_COPY(z_copy, z);
-			zendi_zval_copy_ctor(*z_copy);
-			incdec_op(z_copy);
-			Z_ADDREF_P(z);
-			Z_OBJ_HT_P(object)->write_property(object, property, z_copy, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
+			ZVAL_DUP(retval, z);
+			ZVAL_DUP(&z_copy, z);
+			incdec_op(&z_copy);
+			if (Z_REFCOUNTED_P(z)) Z_ADDREF_P(z);
+			Z_OBJ_HT_P(object)->write_property(object, property, &z_copy, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1) TSRMLS_CC);
 			zval_ptr_dtor(&z_copy);
-			zval_ptr_dtor(&z);
+			zval_ptr_dtor(z);
 		} else {
 			zend_error(E_WARNING, "Attempt to increment/decrement property of non-object");
 			ZVAL_NULL(retval);
 		}
 	}
 
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
-
-	}
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -39959,7 +38460,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_R_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+	zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_CV != IS_VAR || !(opline->extended_value & ZEND_FETCH_ADD_LOCK)) {
 
@@ -39972,29 +38473,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
-
-	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+	if (EXPECTED(opline->extended_value == 0)) {
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
+	} else {
+		zend_fetch_dimension_address_W_ref(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 	}
 
-	/* We are going to assign the result by reference */
-	if (UNEXPECTED(opline->extended_value != 0)) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		if (retval_ptr) {
-			Z_DELREF_PP(retval_ptr);
-			SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-			Z_ADDREF_PP(retval_ptr);
-		}
+	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -40005,18 +38499,18 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_RW TSRMLS_CC);
+	zend_fetch_dimension_address_RW(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -40031,7 +38525,7 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 
 	SAVE_OPLINE();
 	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
-	zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_IS TSRMLS_CC);
+	zend_fetch_dimension_address_read_IS(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
@@ -40041,29 +38535,28 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_DIM_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 	zend_free_op free_op1;
 
 	SAVE_OPLINE();
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
-		zval **container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 		}
-		zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 
 	} else {
-		zval *container;
-
 		if (IS_CV == IS_UNUSED) {
 			zend_error_noreturn(E_ERROR, "Cannot use [] for reading");
 		}
 		container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-		zend_fetch_dimension_address_read(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_R TSRMLS_CC);
+		zend_fetch_dimension_address_read_R(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 
 	}
@@ -40075,41 +38568,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_DIM_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HA
 {
 	USE_OPLINE
 	zend_free_op free_op1;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_fetch_dimension_address(&EX_T(opline->result.var), container, _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV, BP_VAR_UNSET TSRMLS_CC);
+	zend_fetch_dimension_address_UNSET(EX_VAR(opline->result.var), container, _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC), IS_CV TSRMLS_CC);
 
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	if (UNEXPECTED(EX_T(opline->result.var).var.ptr_ptr == NULL)) {
-		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-		ZEND_VM_NEXT_OPCODE();
-	} else {
-		zend_free_op free_res;
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		PZVAL_UNLOCK(*retval_ptr, &free_res);
-		if (retval_ptr != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(retval_ptr);
-		}
-		PZVAL_LOCK(*retval_ptr);
-		FREE_OP_VAR_PTR(free_res);
-		CHECK_EXCEPTION();
-		ZEND_VM_NEXT_OPCODE();
-	}
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND_OPCODE_HANDLER_ARGS)
@@ -40121,35 +38595,25 @@ static int ZEND_FASTCALL zend_fetch_property_address_read_helper_SPEC_CV_CV(ZEND
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
 		zend_error(E_NOTICE, "Trying to get property of non-object");
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_R, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -40164,38 +38628,20 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_W_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLE
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
 
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, (opline->extended_value & ZEND_FETCH_MAKE_REF) != 0 TSRMLS_CC);
 
-	}
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
-	}
-
-	/* We are going to assign the result by reference */
-	if (opline->extended_value & ZEND_FETCH_MAKE_REF) {
-		zval **retval_ptr = EX_T(opline->result.var).var.ptr_ptr;
-
-		Z_DELREF_PP(retval_ptr);
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(retval_ptr);
-		Z_ADDREF_PP(retval_ptr);
-		EX_T(opline->result.var).var.ptr = *EX_T(opline->result.var).var.ptr_ptr;
-		EX_T(opline->result.var).var.ptr_ptr = &EX_T(opline->result.var).var.ptr;
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -40207,26 +38653,19 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_RW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 	USE_OPLINE
 	zend_free_op free_op1;
 	zval *property;
-	zval **container;
+	zval *container;
 
 	SAVE_OPLINE();
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	container = _get_zval_ptr_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_RW(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_RW TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_RW, 0 TSRMLS_CC);
 
-	}
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
 	CHECK_EXCEPTION();
@@ -40242,34 +38681,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset  = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 	if (UNEXPECTED(Z_TYPE_P(container) != IS_OBJECT) ||
 	    UNEXPECTED(Z_OBJ_HT_P(container)->read_property == NULL)) {
-		PZVAL_LOCK(&EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-
+		ZVAL_NULL(EX_VAR(opline->result.var));
 	} else {
 		zval *retval;
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-
 		/* here we are sure we are dealing with an object */
-		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-
-		PZVAL_LOCK(retval);
-		EX_T(opline->result.var).var.ptr = retval;
-
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
+		retval = Z_OBJ_HT_P(container)->read_property(container, offset, BP_VAR_IS, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1), EX_VAR(opline->result.var) TSRMLS_CC);
 
+		if (retval != EX_VAR(opline->result.var)) {
+			ZVAL_COPY(EX_VAR(opline->result.var), retval);
 		}
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -40277,31 +38706,24 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_IS_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
+	zval *container;
 
 	if (zend_is_by_ref_func_arg_fetch(opline, EX(call) TSRMLS_CC)) {
 		/* Behave like FETCH_OBJ_W */
 		zend_free_op free_op1;
 		zval *property;
-		zval **container;
 
 		SAVE_OPLINE();
 		property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-		container = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		container = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property);
-		}
-		if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 		}
-		zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_W TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property);
-		} else {
+		zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_W, 0 TSRMLS_CC);
 
-		}
 		if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-			EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+			EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 		}
 
 		CHECK_EXCEPTION();
@@ -40314,41 +38736,22 @@ static int ZEND_FASTCALL  ZEND_FETCH_OBJ_FUNC_ARG_SPEC_CV_CV_HANDLER(ZEND_OPCODE
 static int ZEND_FASTCALL  ZEND_FETCH_OBJ_UNSET_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op1, free_res;
-	zval **container;
-	zval *property;
+	zend_free_op free_op1;
+	zval *container, *property;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
 	property = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_CV == IS_CV) {
-		if (container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-	}
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(container == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(container) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an object");
 	}
-	zend_fetch_property_address(&EX_T(opline->result.var), container, property, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL), BP_VAR_UNSET TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property);
-	} else {
+	zend_fetch_property_address(EX_VAR(opline->result.var), container, property, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property) : -1), BP_VAR_UNSET, 0 TSRMLS_CC);
 
-	}
 	if (IS_CV == IS_VAR && 0 && READY_TO_DESTROY(free_op1.var)) {
-		EXTRACT_ZVAL_PTR(&EX_T(opline->result.var));
+		EXTRACT_ZVAL_PTR(EX_VAR(opline->result.var));
 	}
 
-	PZVAL_UNLOCK(*EX_T(opline->result.var).var.ptr_ptr, &free_res);
-	if (EX_T(opline->result.var).var.ptr_ptr != &EG(uninitialized_zval_ptr)) {
-		SEPARATE_ZVAL_IF_NOT_REF(EX_T(opline->result.var).var.ptr_ptr);
-	}
-	PZVAL_LOCK(*EX_T(opline->result.var).var.ptr_ptr);
-	FREE_OP_VAR_PTR(free_res);
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
@@ -40357,25 +38760,18 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object;
 	zval *property_name;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 	property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (0) {
-		MAKE_REAL_ZVAL_PTR(property_name);
-	}
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-	if (0) {
-		zval_ptr_dtor(&property_name);
-	} else {
+	zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_OBJ, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-	}
 
 	/* assign_obj has two opcodes! */
 	CHECK_EXCEPTION();
@@ -40387,73 +38783,56 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 {
 	USE_OPLINE
 
-	zval **object_ptr;
+	zval *object_ptr;
 
 	SAVE_OPLINE();
-	object_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	object_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-	if (IS_CV == IS_VAR && UNEXPECTED(object_ptr == NULL)) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(object_ptr) == IS_STR_OFFSET)) {
 		zend_error_noreturn(E_ERROR, "Cannot use string offset as an array");
 	}
-	if (Z_TYPE_PP(object_ptr) == IS_OBJECT) {
+	if (UNEXPECTED(Z_ISREF_P(object_ptr)) && Z_TYPE_P(Z_REFVAL_P(object_ptr)) == IS_OBJECT) {
+		object_ptr = Z_REFVAL_P(object_ptr);
+	}
+	if (Z_TYPE_P(object_ptr) == IS_OBJECT) {
 
 		zval *property_name = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(property_name);
-		}
-		zend_assign_to_object(RETURN_VALUE_USED(opline)?&EX_T(opline->result.var).var.ptr:NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-		if (0) {
-			zval_ptr_dtor(&property_name);
-		} else {
+		zend_assign_to_object(RETURN_VALUE_USED(opline)?EX_VAR(opline->result.var):NULL, object_ptr, property_name, (opline+1)->op1_type, &(opline+1)->op1, execute_data, ZEND_ASSIGN_DIM, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(property_name) : -1) TSRMLS_CC);
 
-		}
 	} else {
 		zend_free_op free_op_data1, free_op_data2;
 		zval *value;
-		zval *dim = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-		zval **variable_ptr_ptr;
+		zval *dim = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zval *variable_ptr;
 
-		zend_fetch_dimension_address(&EX_T((opline+1)->op2.var), object_ptr, dim, IS_CV, BP_VAR_W TSRMLS_CC);
+		zend_fetch_dimension_address_W(EX_VAR((opline+1)->op2.var), object_ptr, dim, IS_CV TSRMLS_CC);
 
 		value = get_zval_ptr((opline+1)->op1_type, &(opline+1)->op1, execute_data, &free_op_data1, BP_VAR_R);
-		variable_ptr_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
-		if (UNEXPECTED(variable_ptr_ptr == NULL)) {
-			if (zend_assign_to_string_offset(&EX_T((opline+1)->op2.var), value, (opline+1)->op1_type TSRMLS_CC)) {
-				if (RETURN_VALUE_USED(opline)) {
-					zval *retval;
-
-					ALLOC_ZVAL(retval);
-					ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T((opline+1)->op2.var).str_offset.str)+EX_T((opline+1)->op2.var).str_offset.offset, 1, 1);
-					INIT_PZVAL(retval);
-					EX_T(opline->result.var).var.ptr = retval;
-				}
-			} else if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-			}
-		} else if (UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+		variable_ptr = _get_zval_ptr_ptr_var((opline+1)->op2.var, execute_data, &free_op_data2 TSRMLS_CC);
+		if (UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+			zend_assign_to_string_offset(variable_ptr, value, (opline+1)->op1_type, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+		} else if (UNEXPECTED(variable_ptr == &EG(error_zval))) {
 			if (IS_TMP_FREE(free_op_data1)) {
 				zval_dtor(value);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(&EG(uninitialized_zval));
-				EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+				ZVAL_NULL(EX_VAR(opline->result.var));
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		} else {
 			if ((opline+1)->op1_type == IS_TMP_VAR) {
-			 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 			} else if ((opline+1)->op1_type == IS_CONST) {
-			 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 			} else {
-			 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+			 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 			}
 			if (RETURN_VALUE_USED(opline)) {
-				PZVAL_LOCK(value);
-				EX_T(opline->result.var).var.ptr = value;
+				ZVAL_COPY(EX_VAR(opline->result.var), value);
 			}
+			FREE_OP_VAR_PTR(free_op_data2);
 		}
-		FREE_OP_VAR_PTR(free_op_data2);
 	 	FREE_OP_IF_VAR(free_op_data1);
 	}
 
@@ -40468,46 +38847,33 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 	USE_OPLINE
 
 	zval *value;
-	zval **variable_ptr_ptr;
+	zval *variable_ptr;
 
 	SAVE_OPLINE();
 	value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
-	variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-	if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL)) {
-		if (zend_assign_to_string_offset(&EX_T(opline->op1.var), value, IS_CV TSRMLS_CC)) {
-			if (RETURN_VALUE_USED(opline)) {
-				zval *retval;
+	variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				ALLOC_ZVAL(retval);
-				ZVAL_STRINGL(retval, Z_STRVAL_P(EX_T(opline->op1.var).str_offset.str)+EX_T(opline->op1.var).str_offset.offset, 1, 1);
-				INIT_PZVAL(retval);
-				EX_T(opline->result.var).var.ptr = retval;
-			}
-		} else if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
-		}
-	} else if (IS_CV == IS_VAR && UNEXPECTED(*variable_ptr_ptr == &EG(error_zval))) {
+	if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET)) {
+		zend_assign_to_string_offset(variable_ptr, value, IS_CV, (RETURN_VALUE_USED(opline) ? EX_VAR(opline->result.var) : NULL) TSRMLS_CC);
+	} else if (IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) {
 		if (0) {
 			zval_dtor(value);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(&EG(uninitialized_zval));
-			EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+			ZVAL_NULL(EX_VAR(opline->result.var));
 		}
 	} else {
 		if (IS_CV == IS_TMP_VAR) {
-		 	value = zend_assign_tmp_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_tmp_to_variable(variable_ptr, value TSRMLS_CC);
 		} else if (IS_CV == IS_CONST) {
-		 	value = zend_assign_const_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_const_to_variable(variable_ptr, value TSRMLS_CC);
 		} else {
-		 	value = zend_assign_to_variable(variable_ptr_ptr, value TSRMLS_CC);
+		 	value = zend_assign_to_variable(variable_ptr, value TSRMLS_CC);
 		}
 		if (RETURN_VALUE_USED(opline)) {
-			PZVAL_LOCK(value);
-			EX_T(opline->result.var).var.ptr = value;
+			ZVAL_COPY(EX_VAR(opline->result.var), value);
 		}
+
 	}
 
 	/* zend_assign_to_variable() always takes care of op2, never free it! */
@@ -40519,20 +38885,19 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARG
 static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
-	zend_free_op free_op2;
-	zval **variable_ptr_ptr;
-	zval **value_ptr_ptr;
+
+	zval *variable_ptr;
+	zval *value_ptr;
 
 	SAVE_OPLINE();
-	value_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
+	value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op2.var TSRMLS_CC);
 
 	if (IS_CV == IS_VAR &&
-	    value_ptr_ptr &&
-	    !Z_ISREF_PP(value_ptr_ptr) &&
 	    opline->extended_value == ZEND_RETURNS_FUNCTION &&
-	    !EX_T(opline->op2.var).var.fcall_returned_reference) {
-		if (free_op2.var == NULL) {
-			PZVAL_LOCK(*value_ptr_ptr); /* undo the effect of get_zval_ptr_ptr() */
+	    !(Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF) &&
+	    !Z_ISREF_P(value_ptr)) {
+		if (!0) {
+			PZVAL_LOCK(value_ptr); /* undo the effect of get_zval_ptr_ptr() */
 		}
 		zend_error(E_STRICT, "Only variables should be assigned by reference");
 		if (UNEXPECTED(EG(exception) != NULL)) {
@@ -40541,26 +38906,36 @@ static int ZEND_FASTCALL  ZEND_ASSIGN_REF_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
 		}
 		return ZEND_ASSIGN_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
 	} else if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		PZVAL_LOCK(*value_ptr_ptr);
+		if (!0) {
+			PZVAL_LOCK(value_ptr);
+		}
 	}
-	if (IS_CV == IS_VAR && UNEXPECTED(EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr)) {
+
+	variable_ptr = _get_zval_ptr_cv_undef_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR &&
+	    UNEXPECTED(Z_TYPE_P(EX_VAR(opline->op1.var)) != IS_INDIRECT) &&
+	    UNEXPECTED(!Z_ISREF_P(variable_ptr))) {
 		zend_error_noreturn(E_ERROR, "Cannot assign by reference to overloaded object");
 	}
-
-	variable_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-	if ((IS_CV == IS_VAR && UNEXPECTED(value_ptr_ptr == NULL)) ||
-	    (IS_CV == IS_VAR && UNEXPECTED(variable_ptr_ptr == NULL))) {
+	if ((IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) ||
+	    (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(variable_ptr) == IS_STR_OFFSET))) {
 		zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets nor overloaded objects");
 	}
-	zend_assign_to_variable_reference(variable_ptr_ptr, value_ptr_ptr TSRMLS_CC);
+	if ((IS_CV == IS_VAR && UNEXPECTED(variable_ptr == &EG(error_zval))) ||
+	    (IS_CV == IS_VAR && UNEXPECTED(value_ptr == &EG(error_zval)))) {
+		variable_ptr = &EG(uninitialized_zval);
+	} else {
+		zend_assign_to_variable_reference(variable_ptr, value_ptr TSRMLS_CC);
+	}
 
 	if (IS_CV == IS_VAR && opline->extended_value == ZEND_RETURNS_NEW) {
-		Z_DELREF_PP(variable_ptr_ptr);
+		if (!0) {
+			Z_DELREF_P(variable_ptr);
+		}
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
-		PZVAL_LOCK(*variable_ptr_ptr);
-		EX_T(opline->result.var).var.ptr = *variable_ptr_ptr;
+		ZVAL_COPY(EX_VAR(opline->result.var), variable_ptr);
 	}
 
 
@@ -40572,10 +38947,9 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 {
 	USE_OPLINE
 	zval *function_name;
-	char *function_name_strval;
-	int function_name_strlen;
 
 	call_slot *call = EX(call_slots) + opline->result.num;
+	zval *object;
 
 	SAVE_OPLINE();
 
@@ -40589,33 +38963,30 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 		zend_error_noreturn(E_ERROR, "Method name must be a string");
 	}
 
-	function_name_strval = Z_STRVAL_P(function_name);
-	function_name_strlen = Z_STRLEN_P(function_name);
+	object = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+	call->object = Z_TYPE_P(object) == IS_OBJECT ? Z_OBJ_P(object) : NULL;
 
-	call->object = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-
-	if (EXPECTED(call->object != NULL) &&
-	    EXPECTED(Z_TYPE_P(call->object) == IS_OBJECT)) {
-		call->called_scope = Z_OBJCE_P(call->object);
+	if (EXPECTED(call->object != NULL)) {
+		call->called_scope = zend_get_class_entry(call->object TSRMLS_CC);
 
 		if (IS_CV != IS_CONST ||
-		    (call->fbc = CACHED_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope)) == NULL) {
-		    zval *object = call->object;
+		    (call->fbc = CACHED_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope)) == NULL) {
+		    zend_object *object = call->object;
 
-			if (UNEXPECTED(Z_OBJ_HT_P(call->object)->get_method == NULL)) {
+			if (UNEXPECTED(object->handlers->get_method == NULL)) {
 				zend_error_noreturn(E_ERROR, "Object does not support method calls");
 			}
 
 			/* First, locate the function. */
-			call->fbc = Z_OBJ_HT_P(call->object)->get_method(&call->object, function_name_strval, function_name_strlen, ((IS_CV == IS_CONST) ? (opline->op2.literal + 1) : NULL) TSRMLS_CC);
+			call->fbc = object->handlers->get_method(&call->object, Z_STR_P(function_name), ((IS_CV == IS_CONST) ? (opline->op2.zv + 1) : NULL) TSRMLS_CC);
 			if (UNEXPECTED(call->fbc == NULL)) {
-				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), function_name_strval);
+				zend_error_noreturn(E_ERROR, "Call to undefined method %s::%s()", Z_OBJ_CLASS_NAME_P(call->object), Z_STRVAL_P(function_name));
 			}
 			if (IS_CV == IS_CONST &&
 			    EXPECTED(call->fbc->type <= ZEND_USER_FUNCTION) &&
 			    EXPECTED((call->fbc->common.fn_flags & (ZEND_ACC_CALL_VIA_HANDLER|ZEND_ACC_NEVER_CACHE)) == 0) &&
 			    EXPECTED(call->object == object)) {
-				CACHE_POLYMORPHIC_PTR(opline->op2.literal->cache_slot, call->called_scope, call->fbc);
+				CACHE_POLYMORPHIC_PTR(Z_CACHE_SLOT_P(function_name), call->called_scope, call->fbc);
 			}
 		}
 	} else {
@@ -40623,21 +38994,13 @@ static int ZEND_FASTCALL  ZEND_INIT_METHOD_CALL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
 
 			HANDLE_EXCEPTION();
 		}
-		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", function_name_strval);
+		zend_error_noreturn(E_ERROR, "Call to a member function %s() on a non-object", Z_STRVAL_P(function_name));
 	}
 
 	if ((call->fbc->common.fn_flags & ZEND_ACC_STATIC) != 0) {
 		call->object = NULL;
 	} else {
-		if (!PZVAL_IS_REF(call->object)) {
-			Z_ADDREF_P(call->object); /* For $this pointer */
-		} else {
-			zval *this_ptr;
-			ALLOC_ZVAL(this_ptr);
-			INIT_PZVAL_COPY(this_ptr, call->object);
-			zval_copy_ctor(this_ptr);
-			call->object = this_ptr;
-		}
+		GC_REFCOUNT(call->object)++; /* For $this pointer */
 	}
 
 	call->num_additional_args = 0;
@@ -40653,11 +39016,12 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
+	zval *result = EX_VAR(opline->result.var);
 
 	SAVE_OPLINE();
-	is_equal_function(&EX_T(opline->result.var).tmp_var,
+	ZVAL_BOOL(result, fast_equal_function(result,
 				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+				 _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -40667,35 +39031,31 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_
 {
 	USE_OPLINE
 
-	zval *expr_ptr;
+	zval *expr_ptr, new_expr;
 
 	SAVE_OPLINE();
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-		zval **expr_ptr_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
-
-		if (IS_CV == IS_VAR && UNEXPECTED(expr_ptr_ptr == NULL)) {
+	if ((IS_CV == IS_VAR || IS_CV == IS_CV) &&
+	    (opline->extended_value & ZEND_ARRAY_ELEMENT_REF)) {
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+		if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(expr_ptr) == IS_STR_OFFSET)) {
 			zend_error_noreturn(E_ERROR, "Cannot create references to/from string offsets");
 		}
-		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr_ptr);
-		expr_ptr = *expr_ptr_ptr;
+		SEPARATE_ZVAL_TO_MAKE_IS_REF(expr_ptr);
 		Z_ADDREF_P(expr_ptr);
+
 	} else {
-		expr_ptr=_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
+		expr_ptr = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 		if (0) { /* temporary variable */
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-		} else if (IS_CV == IS_CONST || PZVAL_IS_REF(expr_ptr)) {
-			zval *new_expr;
-
-			ALLOC_ZVAL(new_expr);
-			INIT_PZVAL_COPY(new_expr, expr_ptr);
-			expr_ptr = new_expr;
-			zendi_zval_copy_ctor(*expr_ptr);
+			ZVAL_COPY_VALUE(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&new_expr, expr_ptr);
+			expr_ptr = &new_expr;
+		} else if (Z_ISREF_P(expr_ptr)) {
+			ZVAL_DUP(&new_expr, Z_REFVAL_P(expr_ptr));
+			expr_ptr = &new_expr;
 
-		} else if (IS_CV == IS_CV) {
+		} else if (IS_CV == IS_CV && Z_REFCOUNTED_P(expr_ptr)) {
 			Z_ADDREF_P(expr_ptr);
 		}
 	}
@@ -40703,8 +39063,10 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_
 	if (IS_CV != IS_UNUSED) {
 
 		zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+		zend_string *str;
 		ulong hval;
 
+add_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -40713,32 +39075,32 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_
 			case IS_BOOL:
 				hval = Z_LVAL_P(offset);
 num_index:
-				zend_hash_index_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), hval, &expr_ptr, sizeof(zval *), NULL);
+				zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index);
 				}
-				zend_hash_quick_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, &expr_ptr, sizeof(zval *), NULL);
+str_index:
+				zend_hash_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), str, expr_ptr);
 				break;
 			case IS_NULL:
-				zend_hash_update(Z_ARRVAL(EX_T(opline->result.var).tmp_var), "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
+				str = STR_EMPTY_ALLOC();
+				goto str_index;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto add_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type");
-				zval_ptr_dtor(&expr_ptr);
+				zval_ptr_dtor(expr_ptr);
 				/* do nothing */
 				break;
 		}
 
 	} else {
-		zend_hash_next_index_insert(Z_ARRVAL(EX_T(opline->result.var).tmp_var), &expr_ptr, sizeof(zval *), NULL);
-	}
-	if ((IS_CV == IS_VAR || IS_CV == IS_CV) && opline->extended_value) {
-
+		zend_hash_next_index_insert(Z_ARRVAL_P(EX_VAR(opline->result.var)), expr_ptr);
 	}
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
@@ -40746,9 +39108,26 @@ num_index:
 
 static int ZEND_FASTCALL  ZEND_INIT_ARRAY_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
+	zval *array;
+	zend_uint size;
 	USE_OPLINE
 
-	array_init(&EX_T(opline->result.var).tmp_var);
+	array = EX_VAR(opline->result.var);
+	if (IS_CV != IS_UNUSED) {
+		size = opline->extended_value >> ZEND_ARRAY_SIZE_SHIFT;
+	} else {
+		size = 0;
+	}
+	ZVAL_NEW_ARR(array);
+	zend_hash_init(Z_ARRVAL_P(array), size, NULL, ZVAL_PTR_DTOR, 0);
+
+	if (IS_CV != IS_UNUSED) {
+		/* Explicitly initialize array as not-packed if flag is set */
+		if (opline->extended_value & ZEND_ARRAY_NOT_PACKED) {
+			zend_hash_real_init(Z_ARRVAL_P(array), 0);
+		}
+	}
+
 	if (IS_CV == IS_UNUSED) {
 		ZEND_VM_NEXT_OPCODE();
 #if 0 || IS_CV != IS_UNUSED
@@ -40762,91 +39141,90 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 	ulong hval;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
-	if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV != IS_UNUSED) {
 		SEPARATE_ZVAL_IF_NOT_REF(container);
 	}
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_CV != IS_VAR || container) {
-		switch (Z_TYPE_PP(container)) {
-			case IS_ARRAY: {
-				HashTable *ht = Z_ARRVAL_PP(container);
-
-				switch (Z_TYPE_P(offset)) {
-					case IS_DOUBLE:
-						hval = zend_dval_to_lval(Z_DVAL_P(offset));
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_RESOURCE:
-					case IS_BOOL:
-					case IS_LONG:
-						hval = Z_LVAL_P(offset);
-						zend_hash_index_del(ht, hval);
-						break;
-					case IS_STRING:
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							Z_ADDREF_P(offset);
-						}
-						if (IS_CV == IS_CONST) {
-							hval = Z_HASH_P(offset);
-						} else {
-							ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
-							hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-						}
-						if (ht == &EG(symbol_table)) {
-							zend_delete_global_variable_ex(offset->value.str.val, offset->value.str.len, hval TSRMLS_CC);
-						} else {
-							zend_hash_quick_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval);
-						}
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
+container_again:
+	switch (Z_TYPE_P(container)) {
+		case IS_ARRAY: {
+			HashTable *ht = Z_ARRVAL_P(container);
+offset_again:
+			switch (Z_TYPE_P(offset)) {
+				case IS_DOUBLE:
+					hval = zend_dval_to_lval(Z_DVAL_P(offset));
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_RESOURCE:
+				case IS_BOOL:
+				case IS_LONG:
+					hval = Z_LVAL_P(offset);
+					zend_hash_index_del(ht, hval);
+					break;
+				case IS_STRING:
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
+					}
+					if (IS_CV != IS_CONST) {
+						ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+					}
+					if (ht == &EG(symbol_table).ht) {
+						zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
+					} else {
+						zend_hash_del(ht, Z_STR_P(offset));
+					}
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
 num_index_dim:
-						zend_hash_index_del(ht, hval);
-						if (IS_CV == IS_CV || IS_CV == IS_VAR) {
-							zval_ptr_dtor(&offset);
-						}
-						break;
-					case IS_NULL:
-						zend_hash_del(ht, "", sizeof(""));
-						break;
-					default:
-						zend_error(E_WARNING, "Illegal offset type in unset");
-						break;
-				}
-
-				break;
+					zend_hash_index_del(ht, hval);
+					if (IS_CV == IS_CV || IS_CV == IS_VAR) {
+						zval_ptr_dtor(offset);
+					}
+					break;
+				case IS_NULL:
+					zend_hash_del(ht, STR_EMPTY_ALLOC());
+					break;
+				case IS_REFERENCE:
+					offset = Z_REFVAL_P(offset);
+					goto offset_again;
+					break;
+				default:
+					zend_error(E_WARNING, "Illegal offset type in unset");
+					break;
 			}
-			case IS_OBJECT:
-				if (UNEXPECTED(Z_OBJ_HT_P(*container)->unset_dimension == NULL)) {
-					zend_error_noreturn(E_ERROR, "Cannot use object as array");
-				}
-				if (0) {
-					MAKE_REAL_ZVAL_PTR(offset);
-				}
-				Z_OBJ_HT_P(*container)->unset_dimension(*container, offset TSRMLS_CC);
-				if (0) {
-					zval_ptr_dtor(&offset);
-				} else {
 
-				}
-				break;
-			case IS_STRING:
-				zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
-				ZEND_VM_CONTINUE(); /* bailed out before */
-			default:
-
-				break;
+			break;
 		}
-	} else {
+		case IS_OBJECT:
+			if (UNEXPECTED(Z_OBJ_HT_P(container)->unset_dimension == NULL)) {
+				zend_error_noreturn(E_ERROR, "Cannot use object as array");
+			}
+//???			if (IS_CV == IS_CONST) {
+//???				zval_copy_ctor(offset);
+//???			}
+			Z_OBJ_HT_P(container)->unset_dimension(container, offset TSRMLS_CC);
 
+			break;
+		case IS_STRING:
+		case IS_STR_OFFSET:
+			zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+			ZEND_VM_CONTINUE(); /* bailed out before */
+		case IS_REFERENCE:
+			container = Z_REFVAL_P(container);
+			goto container_again;
+			break;
+		default:
+
+			break;
 	}
 
 	CHECK_EXCEPTION();
@@ -40857,62 +39235,49 @@ static int ZEND_FASTCALL  ZEND_UNSET_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 {
 	USE_OPLINE
 
-	zval **container;
+	zval *container;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
+	if (IS_CV == IS_VAR && Z_TYPE_P(container) == IS_STR_OFFSET) {
+		zend_error_noreturn(E_ERROR, "Cannot unset string offsets");
+	}
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (IS_CV != IS_VAR || container) {
-		if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
-			SEPARATE_ZVAL_IF_NOT_REF(container);
-		}
-		if (Z_TYPE_PP(container) == IS_OBJECT) {
-			if (0) {
-				MAKE_REAL_ZVAL_PTR(offset);
-			}
-			if (Z_OBJ_HT_P(*container)->unset_property) {
-				Z_OBJ_HT_P(*container)->unset_property(*container, offset, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to unset property of non-object");
-			}
-			if (0) {
-				zval_ptr_dtor(&offset);
-			} else {
-
-			}
+	ZVAL_DEREF(container);
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->unset_property) {
+			Z_OBJ_HT_P(container)->unset_property(container, offset, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
 		} else {
-
+			zend_error(E_NOTICE, "Trying to unset property of non-object");
 		}
-	} else {
-
 	}
 
+
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int prop_dim, ZEND_OPCODE_HANDLER_ARGS)
+static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
 	zval *container;
-	zval **value = NULL;
-	int result = 0;
+	int result;
 	ulong hval;
 	zval *offset;
 
 	SAVE_OPLINE();
-	container = _get_zval_ptr_cv_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
 	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
-	if (Z_TYPE_P(container) == IS_ARRAY && !prop_dim) {
-		HashTable *ht;
-		int isset = 0;
-
-		ht = Z_ARRVAL_P(container);
+	if (Z_TYPE_P(container) == IS_ARRAY) {
+		HashTable *ht = Z_ARRVAL_P(container);
+		zval *value = NULL;
+		zend_string *str;
 
+isset_again:
 		switch (Z_TYPE_P(offset)) {
 			case IS_DOUBLE:
 				hval = zend_dval_to_lval(Z_DVAL_P(offset));
@@ -40922,25 +39287,23 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int
 			case IS_LONG:
 				hval = Z_LVAL_P(offset);
 num_index_prop:
-				if (zend_hash_index_find(ht, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				value = zend_hash_index_find(ht, hval);
 				break;
 			case IS_STRING:
-				if (IS_CV == IS_CONST) {
-					hval = Z_HASH_P(offset);
-				} else {
-					ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_prop);
-					hval = str_hash(Z_STRVAL_P(offset), Z_STRLEN_P(offset));
-				}
-				if (zend_hash_quick_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, (void **) &value) == SUCCESS) {
-					isset = 1;
+				str = Z_STR_P(offset);
+				if (IS_CV != IS_CONST) {
+					ZEND_HANDLE_NUMERIC_EX(str->val, str->len+1, hval, goto num_index_prop);
 				}
+str_index_prop:
+				value = zend_hash_find_ind(ht, str);
 				break;
 			case IS_NULL:
-				if (zend_hash_find(ht, "", sizeof(""), (void **) &value) == SUCCESS) {
-					isset = 1;
-				}
+				str = STR_EMPTY_ALLOC();
+				goto str_index_prop;
+				break;
+			case IS_REFERENCE:
+				offset = Z_REFVAL_P(offset);
+				goto isset_again;
 				break;
 			default:
 				zend_error(E_WARNING, "Illegal offset type in isset or empty");
@@ -40948,116 +39311,103 @@ num_index_prop:
 		}
 
 		if (opline->extended_value & ZEND_ISSET) {
-			if (isset && Z_TYPE_PP(value) == IS_NULL) {
-				result = 0;
-			} else {
-				result = isset;
-			}
+			/* > IS_NULL means not IS_UNDEF and not IS_NULL */
+			result = (value != NULL && Z_TYPE_P(value) > IS_NULL);
 		} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-			if (!isset || !i_zend_is_true(*value TSRMLS_CC)) {
-				result = 0;
-			} else {
-				result = 1;
-			}
+			result = (value == NULL || !i_zend_is_true(value TSRMLS_CC));
 		}
-
 	} else if (Z_TYPE_P(container) == IS_OBJECT) {
-		if (0) {
-			MAKE_REAL_ZVAL_PTR(offset);
-		}
-		if (prop_dim) {
-			if (Z_OBJ_HT_P(container)->has_property) {
-				result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0, ((IS_CV == IS_CONST) ? opline->op2.literal : NULL) TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check property of non-object");
-				result = 0;
-			}
+		if (Z_OBJ_HT_P(container)->has_dimension) {
+			result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISSET) == 0 TSRMLS_CC);
 		} else {
-			if (Z_OBJ_HT_P(container)->has_dimension) {
-				result = Z_OBJ_HT_P(container)->has_dimension(container, offset, (opline->extended_value & ZEND_ISEMPTY) != 0 TSRMLS_CC);
-			} else {
-				zend_error(E_NOTICE, "Trying to check element of non-array");
-				result = 0;
-			}
+			zend_error(E_NOTICE, "Trying to check element of non-array");
+			result = 0;
 		}
-		if (0) {
-			zval_ptr_dtor(&offset);
-		} else {
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
 		}
-	} else if (Z_TYPE_P(container) == IS_STRING && !prop_dim) { /* string offsets */
+	} else if (Z_TYPE_P(container) == IS_STRING) { /* string offsets */
 		zval tmp;
 
-		if (Z_TYPE_P(offset) != IS_LONG) {
-			if (Z_TYPE_P(offset) <= IS_BOOL /* simple scalar types */
+		result = 0;
+		if (UNEXPECTED(Z_TYPE_P(offset) != IS_LONG)) {
+			if (Z_TYPE_P(offset) < IS_STRING /* simple scalar types */
 					|| (Z_TYPE_P(offset) == IS_STRING /* or numeric string */
 						&& IS_LONG == is_numeric_string(Z_STRVAL_P(offset), Z_STRLEN_P(offset), NULL, NULL, 0))) {
-				ZVAL_COPY_VALUE(&tmp, offset);
-				zval_copy_ctor(&tmp);
+				ZVAL_DUP(&tmp, offset);
 				convert_to_long(&tmp);
 				offset = &tmp;
-			} else {
-				/* can not be converted to proper offset, return "not set" */
-				result = 0;
 			}
 		}
 		if (Z_TYPE_P(offset) == IS_LONG) {
-			if (opline->extended_value & ZEND_ISSET) {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
-					result = 1;
-				}
-			} else /* if (opline->extended_value & ZEND_ISEMPTY) */ {
-				if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container) && Z_STRVAL_P(container)[offset->value.lval] != '0') {
+			if (offset->value.lval >= 0 && offset->value.lval < Z_STRLEN_P(container)) {
+				if ((opline->extended_value & ZEND_ISSET) ||
+				    Z_STRVAL_P(container)[offset->value.lval] != '0') {
 					result = 1;
 				}
 			}
 		}
-
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
 	} else {
-
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
 	}
 
-	Z_TYPE(EX_T(opline->result.var).tmp_var) = IS_BOOL;
-	if (opline->extended_value & ZEND_ISSET) {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = result;
-	} else {
-		Z_LVAL(EX_T(opline->result.var).tmp_var) = !result;
-	}
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
 
 	CHECK_EXCEPTION();
 	ZEND_VM_NEXT_OPCODE();
 }
 
-static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_DIM_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
-{
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(0, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
-}
-
 static int ZEND_FASTCALL  ZEND_ISSET_ISEMPTY_PROP_OBJ_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
-	return zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(1, ZEND_OPCODE_HANDLER_ARGS_PASSTHRU);
+	USE_OPLINE
+
+	zval *container;
+	int result;
+	zval *offset;
+
+	SAVE_OPLINE();
+	container = _get_zval_ptr_cv_deref_BP_VAR_IS(execute_data, opline->op1.var TSRMLS_CC);
+	offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
+
+	if (Z_TYPE_P(container) == IS_OBJECT) {
+		if (Z_OBJ_HT_P(container)->has_property) {
+			result = Z_OBJ_HT_P(container)->has_property(container, offset, (opline->extended_value & ZEND_ISSET) == 0, ((IS_CV == IS_CONST) ? Z_CACHE_SLOT_P(offset) : -1) TSRMLS_CC);
+		} else {
+			zend_error(E_NOTICE, "Trying to check property of non-object");
+			result = 0;
+		}
+		if ((opline->extended_value & ZEND_ISSET) == 0) {
+			result = !result;
+		}
+	} else {
+		result = ((opline->extended_value & ZEND_ISSET) == 0);
+	}
+
+	ZVAL_BOOL(EX_VAR(opline->result.var), result);
+
+	CHECK_EXCEPTION();
+	ZEND_VM_NEXT_OPCODE();
 }
 
 static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 {
 	USE_OPLINE
 
-	/* The generator object is stored in return_value_ptr_ptr */
-	zend_generator *generator = (zend_generator *) EG(return_value_ptr_ptr);
+	/* The generator object is stored in EX(return_value) */
+	zend_generator *generator = (zend_generator *) EX(return_value);
 
 	if (generator->flags & ZEND_GENERATOR_FORCED_CLOSE) {
 		zend_error_noreturn(E_ERROR, "Cannot yield from finally in a force-closed generator");
 	}
 
 	/* Destroy the previously yielded value */
-	if (generator->value) {
-		zval_ptr_dtor(&generator->value);
-	}
+	zval_ptr_dtor(&generator->value);
 
 	/* Destroy the previously yielded key */
-	if (generator->key) {
-		zval_ptr_dtor(&generator->key);
-	}
+	zval_ptr_dtor(&generator->key);
 
 	/* Set the new yielded value */
 	if (IS_CV != IS_UNUSED) {
@@ -41067,74 +39417,58 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 			/* Constants and temporary variables aren't yieldable by reference,
 			 * but we still allow them with a notice. */
 			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR) {
-				zval *value, *copy;
+				zval *value;
 
 				zend_error(E_NOTICE, "Only variable references should be yielded by reference");
 
 				value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
+				ZVAL_COPY_VALUE(&generator->value, value);
+				if (Z_OPT_REFCOUNTED(generator->value)) Z_SET_REFCOUNT(generator->value, 1);
 
 				/* Temporary variables don't need ctor copying */
 				if (!0) {
-					zval_copy_ctor(copy);
+					zval_copy_ctor(&generator->value);
 				}
-
-				generator->value = copy;
 			} else {
-				zval **value_ptr = _get_zval_ptr_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
+				zval *value_ptr = _get_zval_ptr_cv_BP_VAR_W(execute_data, opline->op1.var TSRMLS_CC);
 
-				if (IS_CV == IS_VAR && UNEXPECTED(value_ptr == NULL)) {
+				if (IS_CV == IS_VAR && UNEXPECTED(Z_TYPE_P(value_ptr) == IS_STR_OFFSET)) {
 					zend_error_noreturn(E_ERROR, "Cannot yield string offsets by reference");
 				}
 
 				/* If a function call result is yielded and the function did
 				 * not return by reference we throw a notice. */
-				if (IS_CV == IS_VAR && !Z_ISREF_PP(value_ptr)
+				if (IS_CV == IS_VAR && !Z_ISREF_P(value_ptr)
 				    && !(opline->extended_value == ZEND_RETURNS_FUNCTION
-				         && EX_T(opline->op1.var).var.fcall_returned_reference)
-				    && EX_T(opline->op1.var).var.ptr_ptr == &EX_T(opline->op1.var).var.ptr) {
+				         && (Z_VAR_FLAGS_P(value_ptr) & IS_VAR_RET_REF))) {
 					zend_error(E_NOTICE, "Only variable references should be yielded by reference");
-
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				} else {
 					SEPARATE_ZVAL_TO_MAKE_IS_REF(value_ptr);
-					Z_ADDREF_PP(value_ptr);
-					generator->value = *value_ptr;
 				}
+				ZVAL_COPY(&generator->value, value_ptr);
 
 			}
 		} else {
 			zval *value = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
 			/* Consts, temporary variables and references need copying */
-			if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-				|| PZVAL_IS_REF(value)
-			) {
-				zval *copy;
-
-				ALLOC_ZVAL(copy);
-				INIT_PZVAL_COPY(copy, value);
-
-				/* Temporary variables don't need ctor copying */
-				if (!0) {
-					zval_copy_ctor(copy);
-				}
-
-				generator->value = copy;
+			if (IS_CV == IS_CONST) {
+				ZVAL_DUP(&generator->value, value);
+			} else if (IS_CV == IS_TMP_VAR) {
+				ZVAL_COPY_VALUE(&generator->value, value);
+            } else if (Z_ISREF_P(value)) {
+				ZVAL_DUP(&generator->value, Z_REFVAL_P(value));
 
 			} else {
 				if (IS_CV == IS_CV) {
-					Z_ADDREF_P(value);
+					if (Z_REFCOUNTED_P(value)) Z_ADDREF_P(value);
 				}
-				generator->value = value;
+				ZVAL_COPY_VALUE(&generator->value, value);
 			}
 		}
 	} else {
 		/* If no value was specified yield null */
-		Z_ADDREF(EG(uninitialized_zval));
-		generator->value = &EG(uninitialized_zval);
+		ZVAL_NULL(&generator->value);
 	}
 
 	/* Set the new yielded key */
@@ -41143,45 +39477,36 @@ static int ZEND_FASTCALL  ZEND_YIELD_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
 		zval *key = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
 
 		/* Consts, temporary variables and references need copying */
-		if (IS_CV == IS_CONST || IS_CV == IS_TMP_VAR
-			|| (PZVAL_IS_REF(key) && Z_REFCOUNT_P(key) > 0)
-		) {
-			zval *copy;
-
-			ALLOC_ZVAL(copy);
-			INIT_PZVAL_COPY(copy, key);
-
-			/* Temporary variables don't need ctor copying */
-			if (!0) {
-				zval_copy_ctor(copy);
-			}
+		if (IS_CV == IS_CONST) {
+			ZVAL_DUP(&generator->key, key);
+		} else if (IS_CV == IS_TMP_VAR) {
+			ZVAL_COPY_VALUE(&generator->key, key);
+		} else if (Z_ISREF_P(key)) {
+			ZVAL_DUP(&generator->key, Z_REFVAL_P(key));
 
-			generator->key = copy;
 		} else {
-			Z_ADDREF_P(key);
-			generator->key = key;
+			if (IS_CV == IS_CV) {
+				if (Z_REFCOUNTED_P(key)) Z_ADDREF_P(key);
+			}
+			ZVAL_COPY_VALUE(&generator->key, key);
 		}
 
-		if (Z_TYPE_P(generator->key) == IS_LONG
-		    && Z_LVAL_P(generator->key) > generator->largest_used_integer_key
+		if (Z_TYPE(generator->key) == IS_LONG
+		    && Z_LVAL(generator->key) > generator->largest_used_integer_key
 		) {
-			generator->largest_used_integer_key = Z_LVAL_P(generator->key);
+			generator->largest_used_integer_key = Z_LVAL(generator->key);
 		}
-
 	} else {
 		/* If no key was specified we use auto-increment keys */
 		generator->largest_used_integer_key++;
-
-		ALLOC_INIT_ZVAL(generator->key);
-		ZVAL_LONG(generator->key, generator->largest_used_integer_key);
+		ZVAL_LONG(&generator->key, generator->largest_used_integer_key);
 	}
 
 	if (RETURN_VALUE_USED(opline)) {
 		/* If the return value of yield is used set the send
 		 * target and initialize it to NULL */
-		generator->send_target = &EX_T(opline->result.var).var.ptr;
-		Z_ADDREF(EG(uninitialized_zval));
-		EX_T(opline->result.var).var.ptr = &EG(uninitialized_zval);
+		generator->send_target = EX_VAR(opline->result.var);
+		ZVAL_NULL(generator->send_target);
 	} else {
 		generator->send_target = NULL;
 	}
@@ -41203,9 +39528,9 @@ static int ZEND_FASTCALL  ZEND_POW_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
 
 	SAVE_OPLINE();
-	pow_function(&EX_T(opline->result.var).tmp_var,
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-		_get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
+	pow_function(EX_VAR(opline->result.var),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+		_get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
 	CHECK_EXCEPTION();
diff --git a/Zend/zend_vm_execute.skl b/Zend/zend_vm_execute.skl
index 13fd88e2d8..fa976cb678 100644
--- a/Zend/zend_vm_execute.skl
+++ b/Zend/zend_vm_execute.skl
@@ -12,11 +12,6 @@ ZEND_API void {%EXECUTOR_NAME%}_ex(zend_execute_data *execute_data TSRMLS_DC)
 	original_in_execution = EG(in_execution);
 	EG(in_execution) = 1;
 
-	if (0) {
-zend_vm_enter:
-		execute_data = i_create_execute_data_from_op_array(EG(active_op_array), 1 TSRMLS_CC);
-	}
-
 	LOAD_REGS();
 	LOAD_OPLINE();
 
@@ -36,12 +31,12 @@ zend_vm_enter:
 	zend_error_noreturn(E_ERROR, "Arrived at end of main loop which shouldn't happen");
 }
 
-ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array TSRMLS_DC)
+ZEND_API void zend_{%EXECUTOR_NAME%}(zend_op_array *op_array, zval *return_value TSRMLS_DC)
 {
-	if (EG(exception)) {
+	if (EG(exception) != NULL) {
 		return;
 	} 
-	zend_{%EXECUTOR_NAME%}_ex(i_create_execute_data_from_op_array(op_array, 0 TSRMLS_CC) TSRMLS_CC);
+	zend_{%EXECUTOR_NAME%}_ex(i_create_execute_data_from_op_array(op_array, return_value, EG(active_symbol_table) ? VM_FRAME_TOP_CODE : VM_FRAME_TOP_FUNCTION TSRMLS_CC) TSRMLS_CC);
 }
 
 {%EXTERNAL_EXECUTOR%}
diff --git a/Zend/zend_vm_gen.php b/Zend/zend_vm_gen.php
index 9995b0b9a1..bdc6cc79b8 100644
--- a/Zend/zend_vm_gen.php
+++ b/Zend/zend_vm_gen.php
@@ -141,10 +141,8 @@ $op1_get_zval_ptr_ptr = array(
 	"VAR"    => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
 	"CONST"  => "NULL",
 	"UNUSED" => "NULL",
-	"CV"     => "_get_zval_ptr_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+	"CV"     => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
 );
-$op1_get_zval_ptr_ptr_fast = $op1_get_zval_ptr_ptr;
-$op1_get_zval_ptr_ptr_fast["VAR"] = "_get_zval_ptr_ptr_var_fast(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)";
 
 $op2_get_zval_ptr_ptr = array(
 	"ANY"    => "get_zval_ptr_ptr(opline->op2_type, &opline->op2, execute_data, &free_op2, \\1)",
@@ -152,10 +150,44 @@ $op2_get_zval_ptr_ptr = array(
 	"VAR"    => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
 	"CONST"  => "NULL",
 	"UNUSED" => "NULL",
-	"CV"     => "_get_zval_ptr_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+	"CV"     => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+);
+
+$op1_get_zval_ptr_deref = array(
+	"ANY"    => "get_zval_ptr_deref(opline->op1_type, &opline->op1, execute_data, &free_op1, \\1)",
+	"TMP"    => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
+	"CONST"  => "opline->op1.zv",
+	"UNUSED" => "NULL",
+	"CV"     => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+);
+
+$op2_get_zval_ptr_deref = array(
+	"ANY"    => "get_zval_ptr_deref(opline->op2_type, &opline->op2, execute_data, &free_op2, \\1)",
+	"TMP"    => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
+	"CONST"  => "opline->op2.zv",
+	"UNUSED" => "NULL",
+	"CV"     => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+);
+
+$op1_get_zval_ptr_ptr_undef = array(
+	"ANY"    => "get_zval_ptr_ptr_undef(opline->op1_type, &opline->op1, execute_data, &free_op1, \\1)",
+	"TMP"    => "NULL",
+	"VAR"    => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
+	"CONST"  => "NULL",
+	"UNUSED" => "NULL",
+	"CV"     => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+);
+
+$op2_get_zval_ptr_ptr_undef = array(
+	"ANY"    => "get_zval_ptr_ptr_undef(opline->op2_type, &opline->op2, execute_data, &free_op2, \\1)",
+	"TMP"    => "NULL",
+	"VAR"    => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
+	"CONST"  => "NULL",
+	"UNUSED" => "NULL",
+	"CV"     => "_get_zval_ptr_cv_undef_\\1(execute_data, opline->op2.var TSRMLS_CC)",
 );
-$op2_get_zval_ptr_ptr_fast = $op2_get_zval_ptr_ptr;
-$op2_get_zval_ptr_ptr_fast["VAR"] = "_get_zval_ptr_ptr_var_fast(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)";
 
 $op1_get_obj_zval_ptr = array(
 	"ANY"    => "get_obj_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, \\1)",
@@ -175,27 +207,41 @@ $op2_get_obj_zval_ptr = array(
 	"CV"     => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
 );
 
+$op1_get_obj_zval_ptr_deref = array(
+	"ANY"    => "get_obj_zval_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, \\1)",
+	"TMP"    => "_get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
+	"CONST"  => "opline->op1.zv",
+	"UNUSED" => "_get_obj_zval_ptr_unused(TSRMLS_C)",
+	"CV"     => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+);
+
+$op2_get_obj_zval_ptr_deref = array(
+	"ANY"    => "get_obj_zval_ptr(opline->op2_type, &opline->op2, execute_data, &free_op2, \\1)",
+	"TMP"    => "_get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
+	"VAR"    => "_get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
+	"CONST"  => "opline->op2.zv",
+	"UNUSED" => "_get_obj_zval_ptr_unused(TSRMLS_C)",
+	"CV"     => "_get_zval_ptr_cv_deref_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+);
+
 $op1_get_obj_zval_ptr_ptr = array(
 	"ANY"    => "get_obj_zval_ptr_ptr(opline->op1_type, &opline->op1, execute_data, &free_op1, \\1)",
 	"TMP"    => "NULL",
 	"VAR"    => "_get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)",
 	"CONST"  => "NULL",
-	"UNUSED" => "_get_obj_zval_ptr_ptr_unused(TSRMLS_C)",
-	"CV"     => "_get_zval_ptr_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
+	"UNUSED" => "_get_obj_zval_ptr_unused(TSRMLS_C)",
+	"CV"     => "_get_zval_ptr_cv_\\1(execute_data, opline->op1.var TSRMLS_CC)",
 );
-$op1_get_obj_zval_ptr_ptr_fast = $op1_get_obj_zval_ptr_ptr;
-$op1_get_obj_zval_ptr_ptr_fast["VAR"] = "_get_zval_ptr_ptr_var_fast(opline->op1.var, execute_data, &free_op1 TSRMLS_CC)";
 
 $op2_get_obj_zval_ptr_ptr = array(
 	"ANY"    => "get_obj_zval_ptr_ptr(opline->op2_type, &opline->op2, execute_data, &free_op2, \\1)",
 	"TMP"    => "NULL",
 	"VAR"    => "_get_zval_ptr_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)",
 	"CONST"  => "NULL",
-	"UNUSED" => "_get_obj_zval_ptr_ptr_unused(TSRMLS_C)",
-	"CV"     => "_get_zval_ptr_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
+	"UNUSED" => "_get_obj_zval_ptr_unused(TSRMLS_C)",
+	"CV"     => "_get_zval_ptr_cv_\\1(execute_data, opline->op2.var TSRMLS_CC)",
 );
-$op2_get_obj_zval_ptr_ptr_fast = $op2_get_obj_zval_ptr_ptr;
-$op2_get_obj_zval_ptr_ptr_fast["VAR"] = "_get_zval_ptr_ptr_var_fast(opline->op2.var, execute_data, &free_op2 TSRMLS_CC)";
 
 $op1_is_tmp_free = array(
 	"ANY"    => "IS_TMP_FREE(free_op1)",
@@ -218,7 +264,7 @@ $op2_is_tmp_free = array(
 $op1_free_op = array(
 	"ANY"    => "FREE_OP(free_op1)",
 	"TMP"    => "zval_dtor(free_op1.var)",
-	"VAR"    => "zval_ptr_dtor_nogc(&free_op1.var)",
+	"VAR"    => "zval_ptr_dtor_nogc(free_op1.var)",
 	"CONST"  => "",
 	"UNUSED" => "",
 	"CV"     => "",
@@ -227,7 +273,7 @@ $op1_free_op = array(
 $op2_free_op = array(
 	"ANY"    => "FREE_OP(free_op2)",
 	"TMP"    => "zval_dtor(free_op2.var)",
-	"VAR"    => "zval_ptr_dtor_nogc(&free_op2.var)",
+	"VAR"    => "zval_ptr_dtor_nogc(free_op2.var)",
 	"CONST"  => "",
 	"UNUSED" => "",
 	"CV"     => "",
@@ -236,7 +282,7 @@ $op2_free_op = array(
 $op1_free_op_if_var = array(
 	"ANY"    => "FREE_OP_IF_VAR(free_op1)",
 	"TMP"    => "",
-	"VAR"    => "zval_ptr_dtor_nogc(&free_op1.var)",
+	"VAR"    => "zval_ptr_dtor_nogc(free_op1.var)",
 	"CONST"  => "",
 	"UNUSED" => "",
 	"CV"     => "",
@@ -245,33 +291,33 @@ $op1_free_op_if_var = array(
 $op2_free_op_if_var = array(
 	"ANY"    => "FREE_OP_IF_VAR(free_op2)",
 	"TMP"    => "",
-	"VAR"    => "zval_ptr_dtor_nogc(&free_op2.var)",
+	"VAR"    => "zval_ptr_dtor_nogc(free_op2.var)",
 	"CONST"  => "",
 	"UNUSED" => "",
 	"CV"     => "",
 );
 
 $op1_free_op_var_ptr = array(
-	"ANY"    => "if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}",
+	"ANY"    => "if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}",
 	"TMP"    => "",
-	"VAR"    => "if (free_op1.var) {zval_ptr_dtor_nogc(&free_op1.var);}",
+	"VAR"    => "if (free_op1.var) {zval_ptr_dtor_nogc(free_op1.var);}",
 	"CONST"  => "",
 	"UNUSED" => "",
 	"CV"     => "",
 );
 $op1_free_op_var_ptr_fast = $op1_free_op_var_ptr;
-$op1_free_op_var_ptr_fast["VAR"] = "zval_ptr_dtor_nogc(&free_op1.var)";
+$op1_free_op_var_ptr_fast["VAR"] = "zval_ptr_dtor_nogc(free_op1.var)";
 
 $op2_free_op_var_ptr = array(
-	"ANY"    => "if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);}",
+	"ANY"    => "if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);}",
 	"TMP"    => "",
-	"VAR"    => "if (free_op2.var) {zval_ptr_dtor_nogc(&free_op2.var);}",
+	"VAR"    => "if (free_op2.var) {zval_ptr_dtor_nogc(free_op2.var);}",
 	"CONST"  => "",
 	"UNUSED" => "",
 	"CV"     => "",
 );
 $op2_free_op_var_ptr_fast = $op2_free_op_var_ptr;
-$op2_free_op_var_ptr_fast["VAR"] = "zval_ptr_dtor_nogc(&free_op2.var)";
+$op2_free_op_var_ptr_fast["VAR"] = "zval_ptr_dtor_nogc(free_op2.var)";
 
 $list    = array(); // list of opcode handlers and helpers in original order
 $opcodes = array(); // opcode handlers by code
@@ -318,14 +364,15 @@ function helper_name($name, $spec, $op1, $op2) {
 // Generates code for opcode handler or helper
 function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name) {
 	global $op1_type, $op2_type, $op1_get_zval_ptr, $op2_get_zval_ptr,
+		$op1_get_zval_ptr_deref, $op2_get_zval_ptr_deref,
 		$op1_get_zval_ptr_ptr, $op2_get_zval_ptr_ptr,
+		$op1_get_zval_ptr_ptr_undef, $op2_get_zval_ptr_ptr_undef,
 		$op1_get_obj_zval_ptr, $op2_get_obj_zval_ptr,
+		$op1_get_obj_zval_ptr_deref, $op2_get_obj_zval_ptr_deref,
 		$op1_get_obj_zval_ptr_ptr, $op2_get_obj_zval_ptr_ptr,
 		$op1_is_tmp_free, $op2_is_tmp_free, $op1_free, $op2_free,
 		$op1_free_op, $op2_free_op, $op1_free_op_if_var, $op2_free_op_if_var,
-		$op1_free_op_var_ptr, $op2_free_op_var_ptr, $prefix, 
-		$op1_get_zval_ptr_ptr_fast, $op2_get_zval_ptr_ptr_fast,
-		$op1_get_obj_zval_ptr_ptr_fast, $op2_get_obj_zval_ptr_ptr_fast,
+		$op1_free_op_var_ptr, $op2_free_op_var_ptr, $prefix,
 		$op1_free_op_var_ptr_fast, $op2_free_op_var_ptr_fast;
 
 	// Specializing
@@ -337,10 +384,16 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name) {
 			"/OP2_FREE/",
 			"/GET_OP1_ZVAL_PTR\(([^)]*)\)/",
 			"/GET_OP2_ZVAL_PTR\(([^)]*)\)/",
+			"/GET_OP1_ZVAL_PTR_DEREF\(([^)]*)\)/",
+			"/GET_OP2_ZVAL_PTR_DEREF\(([^)]*)\)/",
 			"/GET_OP1_ZVAL_PTR_PTR\(([^)]*)\)/",
 			"/GET_OP2_ZVAL_PTR_PTR\(([^)]*)\)/",
+			"/GET_OP1_ZVAL_PTR_PTR_UNDEF\(([^)]*)\)/",
+			"/GET_OP2_ZVAL_PTR_PTR_UNDEF\(([^)]*)\)/",
 			"/GET_OP1_OBJ_ZVAL_PTR\(([^)]*)\)/",
 			"/GET_OP2_OBJ_ZVAL_PTR\(([^)]*)\)/",
+			"/GET_OP1_OBJ_ZVAL_PTR_DEREF\(([^)]*)\)/",
+			"/GET_OP2_OBJ_ZVAL_PTR_DEREF\(([^)]*)\)/",
 			"/GET_OP1_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
 			"/GET_OP2_OBJ_ZVAL_PTR_PTR\(([^)]*)\)/",
 			"/IS_OP1_TMP_FREE\(\)/",
@@ -351,10 +404,6 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name) {
 			"/FREE_OP2_IF_VAR\(\)/",
 			"/FREE_OP1_VAR_PTR\(\)/",
 			"/FREE_OP2_VAR_PTR\(\)/",
-			"/GET_OP1_ZVAL_PTR_PTR_FAST\(([^)]*)\)/",
-			"/GET_OP2_ZVAL_PTR_PTR_FAST\(([^)]*)\)/",
-			"/GET_OP1_OBJ_ZVAL_PTR_PTR_FAST\(([^)]*)\)/",
-			"/GET_OP2_OBJ_ZVAL_PTR_PTR_FAST\(([^)]*)\)/",
 			"/FREE_OP1_VAR_PTR_FAST\(\)/",
 			"/FREE_OP2_VAR_PTR_FAST\(\)/",
 			"/^#ifdef\s+ZEND_VM_SPEC\s*\n/m",
@@ -375,10 +424,16 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name) {
 			$op2_free[$op2],
 			$op1_get_zval_ptr[$op1],
 			$op2_get_zval_ptr[$op2],
+			$op1_get_zval_ptr_deref[$op1],
+			$op2_get_zval_ptr_deref[$op2],
 			$op1_get_zval_ptr_ptr[$op1],
 			$op2_get_zval_ptr_ptr[$op2],
+			$op1_get_zval_ptr_ptr_undef[$op1],
+			$op2_get_zval_ptr_ptr_undef[$op2],
 			$op1_get_obj_zval_ptr[$op1],
 			$op2_get_obj_zval_ptr[$op2],
+			$op1_get_obj_zval_ptr_deref[$op1],
+			$op2_get_obj_zval_ptr_deref[$op2],
 			$op1_get_obj_zval_ptr_ptr[$op1],
 			$op2_get_obj_zval_ptr_ptr[$op2],
 			$op1_is_tmp_free[$op1],
@@ -389,10 +444,6 @@ function gen_code($f, $spec, $kind, $export, $code, $op1, $op2, $name) {
 			$op2_free_op_if_var[$op2],
 			$op1_free_op_var_ptr[$op1],
 			$op2_free_op_var_ptr[$op2],
-			$op1_get_zval_ptr_ptr_fast[$op1],
-			$op2_get_zval_ptr_ptr_fast[$op2],
-			$op1_get_obj_zval_ptr_ptr_fast[$op1],
-			$op2_get_obj_zval_ptr_ptr_fast[$op2],
 			$op1_free_op_var_ptr_fast[$op1],
 			$op2_free_op_var_ptr_fast[$op2],
 			($op1!="ANY"||$op2!="ANY")?"#if 1\n":"#if 0\n",
@@ -891,7 +942,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name,
 							out($f,"#define LOAD_REGS()\n");
 							out($f,"#define ZEND_VM_CONTINUE() goto zend_vm_continue\n");
 							out($f,"#define ZEND_VM_RETURN()   EG(in_execution) = original_in_execution; return\n");
-							out($f,"#define ZEND_VM_ENTER()    goto zend_vm_enter\n");
+							out($f,"#define ZEND_VM_ENTER()    execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n");
 							out($f,"#define ZEND_VM_LEAVE()    ZEND_VM_CONTINUE()\n");
 							out($f,"#define ZEND_VM_DISPATCH(opcode, opline) dispatch_handler = zend_vm_get_opcode_handler(opcode, opline); goto zend_vm_dispatch;\n\n");
 							out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n");
@@ -923,7 +974,7 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name,
 							out($f,"#define LOAD_REGS()\n");
 							out($f,"#define ZEND_VM_CONTINUE() goto *(void**)(OPLINE->handler)\n");
 							out($f,"#define ZEND_VM_RETURN()   EG(in_execution) = original_in_execution; return\n");
-							out($f,"#define ZEND_VM_ENTER()    goto zend_vm_enter\n");
+							out($f,"#define ZEND_VM_ENTER()    execute_data = EG(current_execute_data); LOAD_OPLINE(); ZEND_VM_CONTINUE()\n");
 							out($f,"#define ZEND_VM_LEAVE()    ZEND_VM_CONTINUE()\n");
 							out($f,"#define ZEND_VM_DISPATCH(opcode, opline) goto *(void**)(zend_vm_get_opcode_handler(opcode, opline));\n\n");
 							out($f,"#define ZEND_OPCODE_HANDLER_ARGS_PASSTHRU_INTERNAL execute_data TSRMLS_CC\n");
@@ -995,8 +1046,6 @@ function gen_executor($f, $skl, $spec, $kind, $executor_name, $initializer_name,
 						        $m[1]."\t\tEG(in_execution) = original_in_execution;\n".
 						        $m[1]."\t\treturn;\n".
 						        $m[1]."\tcase 2:\n" . 
-						        $m[1]."\t\tgoto zend_vm_enter;\n".
-						        $m[1]."\t\tbreak;\n" .
 						        $m[1]."\tcase 3:\n" . 
 						        $m[1]."\t\texecute_data = EG(current_execute_data);\n".
 						        $m[1]."\t\tbreak;\n" .
diff --git a/ext/bz2/bz2.c b/ext/bz2/bz2.c
index cc845584f0..1d1c0fb9b3 100644
--- a/ext/bz2/bz2.c
+++ b/ext/bz2/bz2.c
@@ -619,7 +619,7 @@ static void php_bz2_error(INTERNAL_FUNCTION_PARAMETERS, int opt)
 			array_init(return_value);
 		
 			add_assoc_long  (return_value, "errno",  errnum);
-			add_assoc_string(return_value, "errstr", (char*)errstr, 1);
+			add_assoc_string(return_value, "errstr", (char*)errstr);
 			break;
 	}
 }
diff --git a/ext/calendar/calendar.c b/ext/calendar/calendar.c
index 34b34da371..4a8bfc4985 100644
--- a/ext/calendar/calendar.c
+++ b/ext/calendar/calendar.c
@@ -275,14 +275,14 @@ static void _php_cal_info(int cal, zval **ret)
 	array_init(smonths);
 
 	for (i = 1; i <= calendar->num_months; i++) {
-		add_index_string(months, i, calendar->month_name_long[i], 1);
-		add_index_string(smonths, i, calendar->month_name_short[i], 1);
+		add_index_string(months, i, calendar->month_name_long[i]);
+		add_index_string(smonths, i, calendar->month_name_short[i]);
 	}
 	add_assoc_zval(*ret, "months", months);
 	add_assoc_zval(*ret, "abbrevmonths", smonths);
 	add_assoc_long(*ret, "maxdaysinmonth", calendar->max_days_in_month);
-	add_assoc_string(*ret, "calname", calendar->name, 1);
-	add_assoc_string(*ret, "calsymbol", calendar->symbol, 1);
+	add_assoc_string(*ret, "calname", calendar->name);
+	add_assoc_string(*ret, "calsymbol", calendar->symbol);
 	
 }
 
@@ -409,7 +409,7 @@ PHP_FUNCTION(cal_from_jd)
 	calendar->from_jd(jd, &year, &month, &day);
 
 	snprintf(date, sizeof(date), "%i/%i/%i", month, day, year);
-	add_assoc_string(return_value, "date", date, 1);
+	add_assoc_string(return_value, "date", date);
 
 	add_assoc_long(return_value, "month", month);
 	add_assoc_long(return_value, "day", day);
@@ -418,16 +418,16 @@ PHP_FUNCTION(cal_from_jd)
 /* day of week */
 	dow = DayOfWeek(jd);
 	add_assoc_long(return_value, "dow", dow);
-	add_assoc_string(return_value, "abbrevdayname", DayNameShort[dow], 1);
-	add_assoc_string(return_value, "dayname", DayNameLong[dow], 1);
+	add_assoc_string(return_value, "abbrevdayname", DayNameShort[dow]);
+	add_assoc_string(return_value, "dayname", DayNameLong[dow]);
 /* month name */
 	if(cal == CAL_JEWISH) {
 		/* special case for Jewish calendar */
-		add_assoc_string(return_value, "abbrevmonth", JEWISH_MONTH_NAME(year)[month], 1);
-		add_assoc_string(return_value, "monthname", JEWISH_MONTH_NAME(year)[month], 1);
+		add_assoc_string(return_value, "abbrevmonth", JEWISH_MONTH_NAME(year)[month]);
+		add_assoc_string(return_value, "monthname", JEWISH_MONTH_NAME(year)[month]);
 	} else {
-		add_assoc_string(return_value, "abbrevmonth", calendar->month_name_short[month], 1);
-		add_assoc_string(return_value, "monthname", calendar->month_name_long[month], 1);
+		add_assoc_string(return_value, "abbrevmonth", calendar->month_name_short[month]);
+		add_assoc_string(return_value, "monthname", calendar->month_name_long[month]);
 	}
 }
 /* }}} */
diff --git a/ext/com_dotnet/com_extension.c b/ext/com_dotnet/com_extension.c
index e3b3abfe28..0ba33a9b1a 100644
--- a/ext/com_dotnet/com_extension.c
+++ b/ext/com_dotnet/com_extension.c
@@ -350,7 +350,7 @@ PHP_MINIT_FUNCTION(com_dotnet)
 	php_com_persist_minit(INIT_FUNC_ARGS_PASSTHRU);
 
 	INIT_CLASS_ENTRY(ce, "com_exception", NULL);
-	php_com_exception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
+	php_com_exception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
 	php_com_exception_class_entry->ce_flags |= ZEND_ACC_FINAL;
 /*	php_com_exception_class_entry->constructor->common.fn_flags |= ZEND_ACC_PROTECTED; */
 
@@ -367,7 +367,7 @@ PHP_MINIT_FUNCTION(com_dotnet)
 
 	INIT_CLASS_ENTRY(ce, "com", NULL);
 	ce.create_object = php_com_object_new;
-	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry, "variant" TSRMLS_CC);
+	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry TSRMLS_CC);
 	tmp->get_iterator = php_com_iter_get;
 
 	zend_ts_hash_init(&php_com_typelibraries, 0, NULL, php_com_typelibrary_dtor, 1);
@@ -375,7 +375,7 @@ PHP_MINIT_FUNCTION(com_dotnet)
 #if HAVE_MSCOREE_H
 	INIT_CLASS_ENTRY(ce, "dotnet", NULL);
 	ce.create_object = php_com_object_new;
-	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry, "variant" TSRMLS_CC);
+	tmp = zend_register_internal_class_ex(&ce, php_com_variant_class_entry TSRMLS_CC);
 	tmp->get_iterator = php_com_iter_get;
 #endif
 
diff --git a/ext/curl/interface.c b/ext/curl/interface.c
index 1995f23a08..2d8fb8606d 100644
--- a/ext/curl/interface.c
+++ b/ext/curl/interface.c
@@ -156,7 +156,7 @@ static void _php_curl_close(zend_rsrc_list_entry *rsrc TSRMLS_DC);
 
 #define CAAL(s, v) add_assoc_long_ex(return_value, s, sizeof(s), (long) v);
 #define CAAD(s, v) add_assoc_double_ex(return_value, s, sizeof(s), (double) v);
-#define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s), (char *) (v ? v : ""), 1);
+#define CAAS(s, v) add_assoc_string_ex(return_value, s, sizeof(s), (char *) (v ? v : ""));
 #define CAAZ(s, v) add_assoc_zval_ex(return_value, s, sizeof(s), (zval *) v);
 
 #if defined(PHP_WIN32) || defined(__GNUC__)
@@ -1762,7 +1762,7 @@ PHP_FUNCTION(curl_version)
 		array_init(protocol_list);
 
 		while (*p != NULL) {
-			add_next_index_string(protocol_list, *p, 1);
+			add_next_index_string(protocol_list, *p);
 			p++;
 		}
 		CAAZ("protocols", protocol_list);
@@ -1826,7 +1826,7 @@ static void split_certinfo(char *string, zval *hash)
 			if(tmp) {
 				*tmp = '\0';
 				val = tmp+1;
-				add_assoc_string(hash, key, val, 1);
+				add_assoc_string(hash, key, val);
 			}
 			s = split+2;
 		} while(split);
@@ -1867,7 +1867,7 @@ static void create_certinfo(struct curl_certinfo *ci, zval *listcode TSRMLS_DC)
 						split_certinfo(&slist->data[len+1], hash);
 						add_assoc_zval(certhash, s, hash);
 					} else {
-						add_assoc_string(certhash, s, &slist->data[len+1], 1);
+						add_assoc_string(certhash, s, &slist->data[len+1]);
 					}
 				} else {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not extract hash key from certificate info");
@@ -3145,7 +3145,7 @@ PHP_FUNCTION(curl_getinfo)
 						array_init(return_value);
 						if (curl_easy_getinfo(ch->cp, option, &slist) == CURLE_OK) {
 							while (slist) {
-								add_next_index_string(return_value, slist->data, 1);
+								add_next_index_string(return_value, slist->data);
 								slist = slist->next;
 							}
 							curl_slist_free_all(slist);
diff --git a/ext/date/php_date.c b/ext/date/php_date.c
index 69f990ca51..dbcd7d8695 100644
--- a/ext/date/php_date.c
+++ b/ext/date/php_date.c
@@ -605,7 +605,7 @@ static zend_object_handlers date_object_handlers_period;
 			RETURN_FALSE;	\
 		}	\
 	}	\
-	obj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);	\
+	obj = Z_PHPDATE_P(object);	\
 
 #define DATE_CHECK_INITIALIZED(member, class_name) \
 	if (!(member)) { \
@@ -613,35 +613,35 @@ static zend_object_handlers date_object_handlers_period;
 		RETURN_FALSE; \
 	}
 
-static void date_object_free_storage_date(void *object TSRMLS_DC);
-static void date_object_free_storage_timezone(void *object TSRMLS_DC);
-static void date_object_free_storage_interval(void *object TSRMLS_DC);
-static void date_object_free_storage_period(void *object TSRMLS_DC);
+static void date_object_free_storage_date(zend_object *object TSRMLS_DC);
+static void date_object_free_storage_timezone(zend_object *object TSRMLS_DC);
+static void date_object_free_storage_interval(zend_object *object TSRMLS_DC);
+static void date_object_free_storage_period(zend_object *object TSRMLS_DC);
 
-static zend_object_value date_object_new_date(zend_class_entry *class_type TSRMLS_DC);
-static zend_object_value date_object_new_timezone(zend_class_entry *class_type TSRMLS_DC);
-static zend_object_value date_object_new_interval(zend_class_entry *class_type TSRMLS_DC);
-static zend_object_value date_object_new_period(zend_class_entry *class_type TSRMLS_DC);
+static zend_object *date_object_new_date(zend_class_entry *class_type TSRMLS_DC);
+static zend_object *date_object_new_timezone(zend_class_entry *class_type TSRMLS_DC);
+static zend_object *date_object_new_interval(zend_class_entry *class_type TSRMLS_DC);
+static zend_object *date_object_new_period(zend_class_entry *class_type TSRMLS_DC);
 
-static zend_object_value date_object_clone_date(zval *this_ptr TSRMLS_DC);
-static zend_object_value date_object_clone_timezone(zval *this_ptr TSRMLS_DC);
-static zend_object_value date_object_clone_interval(zval *this_ptr TSRMLS_DC);
-static zend_object_value date_object_clone_period(zval *this_ptr TSRMLS_DC);
+static zend_object *date_object_clone_date(zval *this_ptr TSRMLS_DC);
+static zend_object *date_object_clone_timezone(zval *this_ptr TSRMLS_DC);
+static zend_object *date_object_clone_interval(zval *this_ptr TSRMLS_DC);
+static zend_object *date_object_clone_period(zval *this_ptr TSRMLS_DC);
 
 static int date_object_compare_date(zval *d1, zval *d2 TSRMLS_DC);
-static HashTable *date_object_get_gc(zval *object, zval ***table, int *n TSRMLS_DC);
+static HashTable *date_object_get_gc(zval *object, zval **table, int *n TSRMLS_DC);
 static HashTable *date_object_get_properties(zval *object TSRMLS_DC);
-static HashTable *date_object_get_gc_interval(zval *object, zval ***table, int *n TSRMLS_DC);
+static HashTable *date_object_get_gc_interval(zval *object, zval **table, int *n TSRMLS_DC);
 static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC);
-static HashTable *date_object_get_gc_period(zval *object, zval ***table, int *n TSRMLS_DC);
+static HashTable *date_object_get_gc_period(zval *object, zval **table, int *n TSRMLS_DC);
 static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC);
 static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC);
-static HashTable *date_object_get_gc_timezone(zval *object, zval ***table, int *n TSRMLS_DC);
+static HashTable *date_object_get_gc_timezone(zval *object, zval **table, int *n TSRMLS_DC);
 
-zval *date_interval_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC);
-void date_interval_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC);
-static zval *date_period_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC);
-static void date_period_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC);
+zval *date_interval_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC);
+void date_interval_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
+static zval *date_period_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC);
+static void date_period_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC);
 
 /* {{{ Module struct */
 zend_module_entry date_module_entry = {
@@ -676,12 +676,12 @@ static PHP_GINIT_FUNCTION(date)
 /* }}} */
 
 
-static void _php_date_tzinfo_dtor(void *tzinfo)
+static void _php_date_tzinfo_dtor(zval *zv) /* {{{ */
 {
-	timelib_tzinfo **tzi = (timelib_tzinfo **)tzinfo;
+	timelib_tzinfo *tzi = (timelib_tzinfo*)Z_PTR_P(zv);
 
-	timelib_tzinfo_dtor(*tzi);
-}
+	timelib_tzinfo_dtor(tzi);
+} /* }}} */
 
 /* {{{ PHP_RINIT_FUNCTION */
 PHP_RINIT_FUNCTION(date)
@@ -899,20 +899,20 @@ PHP_MINFO_FUNCTION(date)
 /* {{{ Timezone Cache functions */
 static timelib_tzinfo *php_date_parse_tzfile(char *formal_tzname, const timelib_tzdb *tzdb TSRMLS_DC)
 {
-	timelib_tzinfo *tzi, **ptzi;
+	timelib_tzinfo *tzi;
 
 	if(!DATEG(tzcache)) {
 		ALLOC_HASHTABLE(DATEG(tzcache));
 		zend_hash_init(DATEG(tzcache), 4, NULL, _php_date_tzinfo_dtor, 0);
 	}
 
-	if (zend_hash_find(DATEG(tzcache), formal_tzname, strlen(formal_tzname) + 1, (void **) &ptzi) == SUCCESS) {
-		return *ptzi;
+	if ((tzi = zend_hash_str_find_ptr(DATEG(tzcache), formal_tzname, strlen(formal_tzname))) != NULL) {
+		return tzi;
 	}
 
 	tzi = timelib_parse_tzfile(formal_tzname, tzdb);
 	if (tzi) {
-		zend_hash_add(DATEG(tzcache), formal_tzname, strlen(formal_tzname) + 1, (void *) &tzi, sizeof(timelib_tzinfo*), NULL);
+		zend_hash_str_add_ptr(DATEG(tzcache), formal_tzname, strlen(formal_tzname), tzi);
 	}
 	return tzi;
 }
@@ -1051,7 +1051,7 @@ char *php_date_short_day_name(timelib_sll y, timelib_sll m, timelib_sll d)
 /* }}} */
 
 /* {{{ date_format - (gm)date helper */
-static char *date_format(char *format, int format_len, timelib_time *t, int localtime)
+static zend_string *date_format(char *format, int format_len, timelib_time *t, int localtime TSRMLS_DC)
 {
 	smart_str            string = {0};
 	int                  i, length = 0;
@@ -1062,7 +1062,7 @@ static char *date_format(char *format, int format_len, timelib_time *t, int loca
 	int                  weekYearSet = 0;
 
 	if (!format_len) {
-		return estrdup("");
+		return STR_EMPTY_ALLOC();
 	}
 
 	if (localtime) {
@@ -1206,7 +1206,7 @@ static char *date_format(char *format, int format_len, timelib_time *t, int loca
 		timelib_time_offset_dtor(offset);
 	}
 
-	return string.c;
+	return string.s;
 }
 
 static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
@@ -1214,7 +1214,6 @@ static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
 	char   *format;
 	int     format_len;
 	long    ts;
-	char   *string;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &format, &format_len, &ts) == FAILURE) {
 		RETURN_FALSE;
@@ -1223,17 +1222,15 @@ static void php_date(INTERNAL_FUNCTION_PARAMETERS, int localtime)
 		ts = time(NULL);
 	}
 
-	string = php_format_date(format, format_len, ts, localtime TSRMLS_CC);
-	
-	RETVAL_STRING(string, 0);
+	RETURN_STR(php_format_date(format, format_len, ts, localtime TSRMLS_CC));
 }
 /* }}} */
 
-PHPAPI char *php_format_date(char *format, int format_len, time_t ts, int localtime TSRMLS_DC) /* {{{ */
+PHPAPI zend_string *php_format_date(char *format, int format_len, time_t ts, int localtime TSRMLS_DC) /* {{{ */
 {
 	timelib_time   *t;
 	timelib_tzinfo *tzi;
-	char *string;
+	zend_string *string;
 
 	t = timelib_time_ctor();
 
@@ -1247,7 +1244,7 @@ PHPAPI char *php_format_date(char *format, int format_len, time_t ts, int localt
 		timelib_unixtime2gmt(t, ts);
 	}
 
-	string = date_format(format, format_len, t, localtime);
+	string = date_format(format, format_len, t, localtime TSRMLS_CC);
 	
 	timelib_time_dtor(t);
 	return string;
@@ -1623,7 +1620,7 @@ PHP_FUNCTION(checkdate)
 /* {{{ php_strftime - (gm)strftime helper */
 PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 {
-	char                *format, *buf;
+	char                *format;
 	int                  format_len;
 	long                 timestamp = 0;
 	struct tm            ta;
@@ -1632,6 +1629,7 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 	timelib_time        *ts;
 	timelib_tzinfo      *tzi;
 	timelib_time_offset *offset = NULL;
+	zend_string 		*buf;
 
 	timestamp = (long) time(NULL);
 
@@ -1684,10 +1682,10 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 	/* VS2012 crt has a bug where strftime crash with %z and %Z format when the
 	   initial buffer is too small. See
 	   http://connect.microsoft.com/VisualStudio/feedback/details/759720/vs2012-strftime-crash-with-z-formatting-code */
-	buf = (char *) emalloc(buf_len);
-	while ((real_len=strftime(buf, buf_len, format, &ta))==buf_len || real_len==0) {
+	buf = STR_ALLOC(buf_len, 0);
+	while ((real_len = strftime(buf->val, buf_len, format, &ta)) == buf_len || real_len == 0) {
 		buf_len *= 2;
-		buf = (char *) erealloc(buf, buf_len);
+		buf = STR_REALLOC(buf, buf_len, 0);
 		if (!--max_reallocs) {
 			break;
 		}
@@ -1706,10 +1704,10 @@ PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gmt)
 	}
 
 	if (real_len && real_len != buf_len) {
-		buf = (char *) erealloc(buf, real_len + 1);
-		RETURN_STRINGL(buf, real_len, 0);
+		buf = STR_REALLOC(buf, real_len, 0);
+		RETURN_STR(buf);
 	}
-	efree(buf);
+	STR_FREE(buf);
 	RETURN_FALSE;
 }
 /* }}} */
@@ -1814,8 +1812,8 @@ PHP_FUNCTION(getdate)
 	add_assoc_long(return_value, "mon", ts->m);
 	add_assoc_long(return_value, "year", ts->y);
 	add_assoc_long(return_value, "yday", timelib_day_of_year(ts->y, ts->m, ts->d));
-	add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d), 1);
-	add_assoc_string(return_value, "month", mon_full_names[ts->m - 1], 1);
+	add_assoc_string(return_value, "weekday", php_date_full_day_name(ts->y, ts->m, ts->d));
+	add_assoc_string(return_value, "month", mon_full_names[ts->m - 1]);
 	add_index_long(return_value, 0, timestamp);
 
 	timelib_time_dtor(ts);
@@ -1843,8 +1841,7 @@ PHP_FUNCTION(getdate)
 /* define an overloaded iterator structure */
 typedef struct {
 	zend_object_iterator  intern;
-	zval                 *date_period_zval;
-	zval                 *current;
+	zval                  current;
 	php_period_obj       *object;
 	int                   current_index;
 } date_period_it;
@@ -1854,14 +1851,13 @@ static void date_period_it_invalidate_current(zend_object_iterator *iter TSRMLS_
 {
 	date_period_it *iterator = (date_period_it *)iter;
 
-	if (iterator->current) {
+	if (Z_TYPE(iterator->current) != IS_UNDEF) {
 		zval_ptr_dtor(&iterator->current);
-		iterator->current = NULL;
+		ZVAL_UNDEF(&iterator->current);
 	}
 }
 /* }}} */
 
-
 /* {{{ date_period_it_dtor */
 static void date_period_it_dtor(zend_object_iterator *iter TSRMLS_DC)
 {
@@ -1869,18 +1865,15 @@ static void date_period_it_dtor(zend_object_iterator *iter TSRMLS_DC)
 
 	date_period_it_invalidate_current(iter TSRMLS_CC);
 
-	zval_ptr_dtor(&iterator->date_period_zval);
-
-	efree(iterator);
+	zval_ptr_dtor(&iterator->intern.data);
 }
 /* }}} */
 
-
 /* {{{ date_period_it_has_more */
 static int date_period_it_has_more(zend_object_iterator *iter TSRMLS_DC)
 {
 	date_period_it *iterator = (date_period_it *)iter;
-	php_period_obj *object   = iterator->object;
+	php_period_obj *object   = Z_PHPPERIOD_P(&iterator->intern.data);
 	timelib_time   *it_time = object->current;
 
 	/* apply modification if it's not the first iteration */
@@ -1900,19 +1893,17 @@ static int date_period_it_has_more(zend_object_iterator *iter TSRMLS_DC)
 }
 /* }}} */
 
-
 /* {{{ date_period_it_current_data */
-static void date_period_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
+static zval *date_period_it_current_data(zend_object_iterator *iter TSRMLS_DC)
 {
 	date_period_it *iterator = (date_period_it *)iter;
-	php_period_obj *object   = iterator->object;
+	php_period_obj *object   = Z_PHPPERIOD_P(&iterator->intern.data);
 	timelib_time   *it_time = object->current;
 	php_date_obj   *newdateobj;
 
 	/* Create new object */
-	MAKE_STD_ZVAL(iterator->current);
-	php_date_instantiate(object->start_ce, iterator->current TSRMLS_CC);
-	newdateobj = (php_date_obj *) zend_object_store_get_object(iterator->current TSRMLS_CC);
+	php_date_instantiate(object->start_ce, &iterator->current TSRMLS_CC);
+	newdateobj = Z_PHPDATE_P(&iterator->current);
 	newdateobj->time = timelib_time_ctor();
 	*newdateobj->time = *it_time;
 	if (it_time->tz_abbr) {
@@ -1922,11 +1913,10 @@ static void date_period_it_current_data(zend_object_iterator *iter, zval ***data
 		newdateobj->time->tz_info = it_time->tz_info;
 	}
 	
-	*data = &iterator->current;
+	return &iterator->current;
 }
 /* }}} */
 
-
 /* {{{ date_period_it_current_key */
 static void date_period_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 {
@@ -1935,7 +1925,6 @@ static void date_period_it_current_key(zend_object_iterator *iter, zval *key TSR
 }
 /* }}} */
 
-
 /* {{{ date_period_it_move_forward */
 static void date_period_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
 {
@@ -1946,11 +1935,10 @@ static void date_period_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
 }
 /* }}} */
 
-
 /* {{{ date_period_it_rewind */
 static void date_period_it_rewind(zend_object_iterator *iter TSRMLS_DC)
 {
-	date_period_it   *iterator = (date_period_it *)iter;
+	date_period_it *iterator = (date_period_it *)iter;
 
 	iterator->current_index = 0;
 	if (iterator->object->current) {
@@ -1961,7 +1949,6 @@ static void date_period_it_rewind(zend_object_iterator *iter TSRMLS_DC)
 }
 /* }}} */
 
-
 /* iterator handler table */
 zend_object_iterator_funcs date_period_it_funcs = {
 	date_period_it_dtor,
@@ -1973,28 +1960,25 @@ zend_object_iterator_funcs date_period_it_funcs = {
 	date_period_it_invalidate_current
 };
 
-
-
-zend_object_iterator *date_object_period_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
+zend_object_iterator *date_object_period_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
-	date_period_it  *iterator = emalloc(sizeof(date_period_it));
-	php_period_obj  *dpobj    = (php_period_obj *)zend_object_store_get_object(object TSRMLS_CC);
+	date_period_it *iterator = emalloc(sizeof(date_period_it));
 
 	if (by_ref) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
 
-	Z_ADDREF_P(object);
-	iterator->intern.data = (void*) dpobj;
+	zend_iterator_init((zend_object_iterator*)iterator TSRMLS_CC);
+
+	ZVAL_COPY(&iterator->intern.data, object);
 	iterator->intern.funcs = &date_period_it_funcs;
-	iterator->date_period_zval = object;
-	iterator->object = dpobj;
-	iterator->current = NULL;
+	iterator->object = Z_PHPPERIOD_P(object);
+	ZVAL_UNDEF(&iterator->current);
 
 	return (zend_object_iterator*)iterator;
-}
+} /* }}} */
 
-static int implement_date_interface_handler(zend_class_entry *interface, zend_class_entry *implementor TSRMLS_DC)
+static int implement_date_interface_handler(zend_class_entry *interface, zend_class_entry *implementor TSRMLS_DC) /* {{{ */
 {
 	if (implementor->type == ZEND_USER_CLASS &&
 		!instanceof_function(implementor, date_ce_date TSRMLS_CC) &&
@@ -2004,9 +1988,9 @@ static int implement_date_interface_handler(zend_class_entry *interface, zend_cl
 	}
 
 	return SUCCESS;
-}
+} /* }}} */
 
-static void date_register_classes(TSRMLS_D)
+static void date_register_classes(TSRMLS_D) /* {{{ */
 {
 	zend_class_entry ce_date, ce_immutable, ce_timezone, ce_interval, ce_period, ce_interface;
 
@@ -2016,8 +2000,10 @@ static void date_register_classes(TSRMLS_D)
 
 	INIT_CLASS_ENTRY(ce_date, "DateTime", date_funcs_date);
 	ce_date.create_object = date_object_new_date;
-	date_ce_date = zend_register_internal_class_ex(&ce_date, NULL, NULL TSRMLS_CC);
+	date_ce_date = zend_register_internal_class_ex(&ce_date, NULL TSRMLS_CC);
 	memcpy(&date_object_handlers_date, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	date_object_handlers_date.offset = XtOffsetOf(php_date_obj, std);
+	date_object_handlers_date.free_obj = date_object_free_storage_date;
 	date_object_handlers_date.clone_obj = date_object_clone_date;
 	date_object_handlers_date.compare_objects = date_object_compare_date;
 	date_object_handlers_date.get_properties = date_object_get_properties;
@@ -2041,7 +2027,7 @@ static void date_register_classes(TSRMLS_D)
 
 	INIT_CLASS_ENTRY(ce_immutable, "DateTimeImmutable", date_funcs_immutable);
 	ce_immutable.create_object = date_object_new_date;
-	date_ce_immutable = zend_register_internal_class_ex(&ce_immutable, NULL, NULL TSRMLS_CC);
+	date_ce_immutable = zend_register_internal_class_ex(&ce_immutable, NULL TSRMLS_CC);
 	memcpy(&date_object_handlers_immutable, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 	date_object_handlers_immutable.clone_obj = date_object_clone_date;
 	date_object_handlers_immutable.compare_objects = date_object_compare_date;
@@ -2050,8 +2036,10 @@ static void date_register_classes(TSRMLS_D)
 
 	INIT_CLASS_ENTRY(ce_timezone, "DateTimeZone", date_funcs_timezone);
 	ce_timezone.create_object = date_object_new_timezone;
-	date_ce_timezone = zend_register_internal_class_ex(&ce_timezone, NULL, NULL TSRMLS_CC);
+	date_ce_timezone = zend_register_internal_class_ex(&ce_timezone, NULL TSRMLS_CC);
 	memcpy(&date_object_handlers_timezone, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	date_object_handlers_timezone.offset = XtOffsetOf(php_timezone_obj, std);
+	date_object_handlers_timezone.free_obj = date_object_free_storage_timezone;
 	date_object_handlers_timezone.clone_obj = date_object_clone_timezone;
 	date_object_handlers_timezone.get_properties = date_object_get_properties_timezone;
 	date_object_handlers_timezone.get_gc = date_object_get_gc_timezone;
@@ -2076,8 +2064,10 @@ static void date_register_classes(TSRMLS_D)
 
 	INIT_CLASS_ENTRY(ce_interval, "DateInterval", date_funcs_interval);
 	ce_interval.create_object = date_object_new_interval;
-	date_ce_interval = zend_register_internal_class_ex(&ce_interval, NULL, NULL TSRMLS_CC);
+	date_ce_interval = zend_register_internal_class_ex(&ce_interval, NULL TSRMLS_CC);
 	memcpy(&date_object_handlers_interval, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	date_object_handlers_interval.offset = XtOffsetOf(php_interval_obj, std);
+	date_object_handlers_interval.free_obj = date_object_free_storage_interval;
 	date_object_handlers_interval.clone_obj = date_object_clone_interval;
 	date_object_handlers_interval.read_property = date_interval_read_property;
 	date_object_handlers_interval.write_property = date_interval_write_property;
@@ -2087,11 +2077,13 @@ static void date_register_classes(TSRMLS_D)
 
 	INIT_CLASS_ENTRY(ce_period, "DatePeriod", date_funcs_period);
 	ce_period.create_object = date_object_new_period;
-	date_ce_period = zend_register_internal_class_ex(&ce_period, NULL, NULL TSRMLS_CC);
+	date_ce_period = zend_register_internal_class_ex(&ce_period, NULL TSRMLS_CC);
 	date_ce_period->get_iterator = date_object_period_get_iterator;
 	date_ce_period->iterator_funcs.funcs = &date_period_it_funcs;
 	zend_class_implements(date_ce_period TSRMLS_CC, 1, zend_ce_traversable);
 	memcpy(&date_object_handlers_period, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	date_object_handlers_period.offset = XtOffsetOf(php_period_obj, std);
+	date_object_handlers_period.free_obj = date_object_free_storage_period;
 	date_object_handlers_period.clone_obj = date_object_clone_period;
 	date_object_handlers_period.get_properties = date_object_get_properties_period;
 	date_object_handlers_period.get_property_ptr_ptr = NULL;
@@ -2103,42 +2095,36 @@ static void date_register_classes(TSRMLS_D)
 	zend_declare_class_constant_long(date_ce_period, const_name, sizeof(const_name)-1, value TSRMLS_CC);
 
 	REGISTER_PERIOD_CLASS_CONST_STRING("EXCLUDE_START_DATE", PHP_DATE_PERIOD_EXCLUDE_START_DATE);
-}
+} /* }}} */
 
-static inline zend_object_value date_object_new_date_ex(zend_class_entry *class_type, php_date_obj **ptr TSRMLS_DC)
+static inline zend_object *date_object_new_date_ex(zend_class_entry *class_type, int init_props TSRMLS_DC) /* {{{ */
 {
 	php_date_obj *intern;
-	zend_object_value retval;
 
-	intern = emalloc(sizeof(php_date_obj));
-	memset(intern, 0, sizeof(php_date_obj));
-	if (ptr) {
-		*ptr = intern;
-	}
+	intern = ecalloc(1, sizeof(php_date_obj) + sizeof(zval) * (class_type->default_properties_count - 1));
 	
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
-	object_properties_init(&intern->std, class_type);
-	
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) date_object_free_storage_date, NULL TSRMLS_CC);
-	retval.handlers = &date_object_handlers_date;
+	if (init_props) {
+		object_properties_init(&intern->std, class_type);
+	}
+	intern->std.handlers = &date_object_handlers_date;
 	
-	return retval;
-}
+	return &intern->std;
+} /* }}} */
 
-static zend_object_value date_object_new_date(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *date_object_new_date(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	return date_object_new_date_ex(class_type, NULL TSRMLS_CC);
-}
+	return date_object_new_date_ex(class_type, 1 TSRMLS_CC);
+} /* }}} */
 
-static zend_object_value date_object_clone_date(zval *this_ptr TSRMLS_DC)
+static zend_object *date_object_clone_date(zval *this_ptr TSRMLS_DC) /* {{{ */
 {
-	php_date_obj *new_obj = NULL;
-	php_date_obj *old_obj = (php_date_obj *) zend_object_store_get_object(this_ptr TSRMLS_CC);
-	zend_object_value new_ov = date_object_new_date_ex(old_obj->std.ce, &new_obj TSRMLS_CC);
+	php_date_obj *old_obj = Z_PHPDATE_P(this_ptr);
+	php_date_obj *new_obj = php_date_obj_from_obj(date_object_new_date_ex(old_obj->std.ce, 0 TSRMLS_CC));
 	
-	zend_objects_clone_members(&new_obj->std, new_ov, &old_obj->std, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+	zend_objects_clone_members(&new_obj->std, &old_obj->std TSRMLS_CC);
 	if (!old_obj->time) {
-		return new_ov;
+		return &new_obj->std;
 	}
 	
 	/* this should probably moved to a new `timelib_time *timelime_time_clone(timelib_time *)` */
@@ -2151,26 +2137,20 @@ static zend_object_value date_object_clone_date(zval *this_ptr TSRMLS_DC)
 		new_obj->time->tz_info = old_obj->time->tz_info;
 	}
 	
-	return new_ov;
-}
+	return &new_obj->std;
+} /* }}} */
 
-static zval* date_clone_immutable(zval *object TSRMLS_DC)
+static void date_clone_immutable(zval *object, zval *new_object TSRMLS_DC) /* {{{ */
 {
-	zval *new_object;
-
-	ALLOC_ZVAL(new_object);
-	Z_OBJVAL_P(new_object) = date_object_clone_date(object TSRMLS_CC);
-	Z_SET_REFCOUNT_P(new_object, 1);
-	Z_SET_ISREF_P(new_object);
-	Z_TYPE_P(new_object) = IS_OBJECT;
-
-	return new_object;
-}
+	ZVAL_OBJ(new_object, date_object_clone_date(object TSRMLS_CC));
+//???	Z_SET_REFCOUNT_P(new_object, 1);
+//???	Z_SET_ISREF_P(new_object);
+} /* }}} */
 
-static int date_object_compare_date(zval *d1, zval *d2 TSRMLS_DC)
+static int date_object_compare_date(zval *d1, zval *d2 TSRMLS_DC) /* {{{ */
 {
-	php_date_obj *o1 = zend_object_store_get_object(d1 TSRMLS_CC);
-	php_date_obj *o2 = zend_object_store_get_object(d2 TSRMLS_CC);
+	php_date_obj *o1 = Z_PHPDATE_P(d1);
+	php_date_obj *o2 = Z_PHPDATE_P(d2);
 
 	if (!o1->time || !o2->time) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Trying to compare an incomplete DateTime or DateTimeImmutable object");
@@ -2184,31 +2164,30 @@ static int date_object_compare_date(zval *d1, zval *d2 TSRMLS_DC)
 	}
 	
 	return (o1->time->sse == o2->time->sse) ? 0 : ((o1->time->sse < o2->time->sse) ? -1 : 1);
-}
+} /* }}} */
 
-static HashTable *date_object_get_gc(zval *object, zval ***table, int *n TSRMLS_DC)
+static HashTable *date_object_get_gc(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
 	*table = NULL;
 	*n = 0;
 	return zend_std_get_properties(object TSRMLS_CC);
-}
+} /* }}} */
 
-static HashTable *date_object_get_gc_timezone(zval *object, zval ***table, int *n TSRMLS_DC)
+static HashTable *date_object_get_gc_timezone(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
-
        *table = NULL;
        *n = 0;
        return zend_std_get_properties(object TSRMLS_CC);
-}
+} /* }}} */
 
-static HashTable *date_object_get_properties(zval *object TSRMLS_DC)
+static HashTable *date_object_get_properties(zval *object TSRMLS_DC) /* {{{ */
 {
 	HashTable *props;
-	zval *zv;
+	zval zv;
 	php_date_obj     *dateobj;
 
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 
 	props = zend_std_get_properties(object TSRMLS_CC);
 
@@ -2217,77 +2196,68 @@ static HashTable *date_object_get_properties(zval *object TSRMLS_DC)
 	}
 
 	/* first we add the date and time in ISO format */
-	MAKE_STD_ZVAL(zv);
-	ZVAL_STRING(zv, date_format("Y-m-d H:i:s", 12, dateobj->time, 1), 0);
-	zend_hash_update(props, "date", 5, &zv, sizeof(zv), NULL);
+	ZVAL_STR(&zv, date_format("Y-m-d H:i:s", sizeof("Y-m-d H:i:s")-1, dateobj->time, 1 TSRMLS_CC));
+	zend_hash_str_update(props, "date", sizeof("date")-1, &zv);
 
 	/* then we add the timezone name (or similar) */
 	if (dateobj->time->is_localtime) {
-		MAKE_STD_ZVAL(zv);
-		ZVAL_LONG(zv, dateobj->time->zone_type);
-		zend_hash_update(props, "timezone_type", 14, &zv, sizeof(zv), NULL);
+		ZVAL_LONG(&zv, dateobj->time->zone_type);
+		zend_hash_str_update(props, "timezone_type", sizeof("timezone_type")-1, &zv);
 
-		MAKE_STD_ZVAL(zv);
 		switch (dateobj->time->zone_type) {
 			case TIMELIB_ZONETYPE_ID:
-				ZVAL_STRING(zv, dateobj->time->tz_info->name, 1);
+				ZVAL_STRING(&zv, dateobj->time->tz_info->name);
 				break;
 			case TIMELIB_ZONETYPE_OFFSET: {
-				char *tmpstr = emalloc(sizeof("UTC+05:00"));
+				zend_string *tmpstr = STR_ALLOC(sizeof("UTC+05:00")-1, 0);
 				timelib_sll utc_offset = dateobj->time->z;
 
-				snprintf(tmpstr, sizeof("+05:00"), "%c%02d:%02d",
+				tmpstr->len = snprintf(tmpstr->val, sizeof("+05:00"), "%c%02d:%02d",
 					utc_offset > 0 ? '-' : '+',
 					abs(utc_offset / 60),
 					abs((utc_offset % 60)));
 
-				ZVAL_STRING(zv, tmpstr, 0);
+				ZVAL_STR(&zv, tmpstr);
 				}
 				break;
 			case TIMELIB_ZONETYPE_ABBR:
-				ZVAL_STRING(zv, dateobj->time->tz_abbr, 1);
+				ZVAL_STRING(&zv, dateobj->time->tz_abbr);
 				break;
 		}
-		zend_hash_update(props, "timezone", 9, &zv, sizeof(zv), NULL);
+		zend_hash_str_update(props, "timezone", sizeof("timezone")-1, &zv);
 	}
 
 	return props;
-}
+} /* }}} */
 
-static inline zend_object_value date_object_new_timezone_ex(zend_class_entry *class_type, php_timezone_obj **ptr TSRMLS_DC)
+static inline zend_object *date_object_new_timezone_ex(zend_class_entry *class_type, int init_props TSRMLS_DC) /* {{{ */
 {
 	php_timezone_obj *intern;
-	zend_object_value retval;
 
-	intern = emalloc(sizeof(php_timezone_obj));
-	memset(intern, 0, sizeof(php_timezone_obj));
-	if (ptr) {
-		*ptr = intern;
-	}
+	intern = ecalloc(1, sizeof(php_timezone_obj) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
-	object_properties_init(&intern->std, class_type);
-	
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) date_object_free_storage_timezone, NULL TSRMLS_CC);
-	retval.handlers = &date_object_handlers_timezone;
+	if (init_props) {
+		object_properties_init(&intern->std, class_type);
+	}
+	intern->std.handlers = &date_object_handlers_timezone;
 	
-	return retval;
-}
+	return &intern->std;
+} /* }}} */
 
-static zend_object_value date_object_new_timezone(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *date_object_new_timezone(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	return date_object_new_timezone_ex(class_type, NULL TSRMLS_CC);
-}
+	return date_object_new_timezone_ex(class_type, 1 TSRMLS_CC);
+} /* }}} */
 
-static zend_object_value date_object_clone_timezone(zval *this_ptr TSRMLS_DC)
+static zend_object *date_object_clone_timezone(zval *this_ptr TSRMLS_DC) /* {{{ */
 {
-	php_timezone_obj *new_obj = NULL;
-	php_timezone_obj *old_obj = (php_timezone_obj *) zend_object_store_get_object(this_ptr TSRMLS_CC);
-	zend_object_value new_ov = date_object_new_timezone_ex(old_obj->std.ce, &new_obj TSRMLS_CC);
+	php_timezone_obj *old_obj = Z_PHPTIMEZONE_P(this_ptr);
+	php_timezone_obj *new_obj = php_timezone_obj_from_obj(date_object_new_timezone_ex(old_obj->std.ce, 0 TSRMLS_CC));
 	
-	zend_objects_clone_members(&new_obj->std, new_ov, &old_obj->std, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+	zend_objects_clone_members(&new_obj->std, &old_obj->std TSRMLS_CC);
 	if (!old_obj->initialized) {
-		return new_ov;
+		return &new_obj->std;
 	}
 	
 	new_obj->type = old_obj->type;
@@ -2306,17 +2276,17 @@ static zend_object_value date_object_clone_timezone(zval *this_ptr TSRMLS_DC)
 			break;
 	}
 	
-	return new_ov;
-}
+	return &new_obj->std;
+} /* }}} */
 
-static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC)
+static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC) /* {{{ */
 {
 	HashTable *props;
-	zval *zv;
+	zval zv;
 	php_timezone_obj     *tzobj;
 
 
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(object);
 
 	props = zend_std_get_properties(object TSRMLS_CC);
 
@@ -2324,87 +2294,79 @@ static HashTable *date_object_get_properties_timezone(zval *object TSRMLS_DC)
 		return props;
 	}
 
-	MAKE_STD_ZVAL(zv);
-	ZVAL_LONG(zv, tzobj->type);
-	zend_hash_update(props, "timezone_type", 14, &zv, sizeof(zv), NULL);
+	ZVAL_LONG(&zv, tzobj->type);
+	zend_hash_str_update(props, "timezone_type", sizeof("timezone_type")-1, &zv);
 
-	MAKE_STD_ZVAL(zv);
 	switch (tzobj->type) {
 		case TIMELIB_ZONETYPE_ID:
-			ZVAL_STRING(zv, tzobj->tzi.tz->name, 1);
+			ZVAL_STRING(&zv, tzobj->tzi.tz->name);
 			break;
 		case TIMELIB_ZONETYPE_OFFSET: {
-			char *tmpstr = emalloc(sizeof("UTC+05:00"));
+			zend_string *tmpstr = STR_ALLOC(sizeof("UTC+05:00")-1, 0);
 
-			snprintf(tmpstr, sizeof("+05:00"), "%c%02d:%02d",
+			tmpstr->len = snprintf(tmpstr->val, sizeof("+05:00"), "%c%02d:%02d",
 			tzobj->tzi.utc_offset > 0 ? '-' : '+',
 			abs(tzobj->tzi.utc_offset / 60),
 			abs((tzobj->tzi.utc_offset % 60)));
 
-			ZVAL_STRING(zv, tmpstr, 0);
+			ZVAL_STR(&zv, tmpstr);
 			}
 			break;
 		case TIMELIB_ZONETYPE_ABBR:
-			ZVAL_STRING(zv, tzobj->tzi.z.abbr, 1);
+			ZVAL_STRING(&zv, tzobj->tzi.z.abbr);
 			break;
 	}
-	zend_hash_update(props, "timezone", 9, &zv, sizeof(zv), NULL);
+	zend_hash_str_update(props, "timezone", sizeof("timezone")-1, &zv);
 
 	return props;
-}
+} /* }}} */
 
-static inline zend_object_value date_object_new_interval_ex(zend_class_entry *class_type, php_interval_obj **ptr TSRMLS_DC)
+static inline zend_object *date_object_new_interval_ex(zend_class_entry *class_type, int init_props TSRMLS_DC) /* {{{ */
 {
 	php_interval_obj *intern;
-	zend_object_value retval;
 
-	intern = emalloc(sizeof(php_interval_obj));
-	memset(intern, 0, sizeof(php_interval_obj));
-	if (ptr) {
-		*ptr = intern;
-	}
+	intern = ecalloc(1, sizeof(php_interval_obj) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
-	object_properties_init(&intern->std, class_type);
-	
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) date_object_free_storage_interval, NULL TSRMLS_CC);
-	retval.handlers = &date_object_handlers_interval;
+	if (init_props) {
+		object_properties_init(&intern->std, class_type);
+	}
+	intern->std.handlers = &date_object_handlers_interval;
 	
-	return retval;
-}
+	return &intern->std;
+} /* }}} */
 
-static zend_object_value date_object_new_interval(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *date_object_new_interval(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	return date_object_new_interval_ex(class_type, NULL TSRMLS_CC);
-}
+	return date_object_new_interval_ex(class_type, 1 TSRMLS_CC);
+} /* }}} */
 
-static zend_object_value date_object_clone_interval(zval *this_ptr TSRMLS_DC)
+static zend_object *date_object_clone_interval(zval *this_ptr TSRMLS_DC) /* {{{ */
 {
-	php_interval_obj *new_obj = NULL;
-	php_interval_obj *old_obj = (php_interval_obj *) zend_object_store_get_object(this_ptr TSRMLS_CC);
-	zend_object_value new_ov = date_object_new_interval_ex(old_obj->std.ce, &new_obj TSRMLS_CC);
+	php_interval_obj *old_obj = Z_PHPINTERVAL_P(this_ptr);
+	php_interval_obj *new_obj = php_interval_obj_from_obj(date_object_new_interval_ex(old_obj->std.ce, 0 TSRMLS_CC));
 	
-	zend_objects_clone_members(&new_obj->std, new_ov, &old_obj->std, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+	zend_objects_clone_members(&new_obj->std, &old_obj->std TSRMLS_CC);
 
 	/** FIX ME ADD CLONE STUFF **/
-	return new_ov;
-}
+	return &new_obj->std;
+} /* }}} */
 
-static HashTable *date_object_get_gc_interval(zval *object, zval ***table, int *n TSRMLS_DC)
+static HashTable *date_object_get_gc_interval(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
 
 	*table = NULL;
 	*n = 0;
 	return zend_std_get_properties(object TSRMLS_CC);
-}
+} /* }}} */
 
-static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC)
+static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC) /* {{{ */
 {
 	HashTable *props;
-	zval *zv;
+	zval zv;
 	php_interval_obj     *intervalobj;
 
-	intervalobj = (php_interval_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	intervalobj = Z_PHPINTERVAL_P(object);
 
 	props = zend_std_get_properties(object TSRMLS_CC);
 
@@ -2413,9 +2375,8 @@ static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC)
 	}
 
 #define PHP_DATE_INTERVAL_ADD_PROPERTY(n,f) \
-	MAKE_STD_ZVAL(zv); \
-	ZVAL_LONG(zv, (long)intervalobj->diff->f); \
-	zend_hash_update(props, n, strlen(n) + 1, &zv, sizeof(zv), NULL);
+	ZVAL_LONG(&zv, (long)intervalobj->diff->f); \
+	zend_hash_str_update(props, n, sizeof(n)-1, &zv);
 
 	PHP_DATE_INTERVAL_ADD_PROPERTY("y", y);
 	PHP_DATE_INTERVAL_ADD_PROPERTY("m", m);
@@ -2430,9 +2391,8 @@ static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC)
 	if (intervalobj->diff->days != -99999) {
 		PHP_DATE_INTERVAL_ADD_PROPERTY("days", days);
 	} else {
-		MAKE_STD_ZVAL(zv);
-		ZVAL_FALSE(zv);
-		zend_hash_update(props, "days", 5, &zv, sizeof(zv), NULL);
+		ZVAL_FALSE(&zv);
+		zend_hash_str_update(props, "days", sizeof("days")-1, &zv);
 	}
 	PHP_DATE_INTERVAL_ADD_PROPERTY("special_type", special.type);
 	PHP_DATE_INTERVAL_ADD_PROPERTY("special_amount", special.amount);
@@ -2440,80 +2400,72 @@ static HashTable *date_object_get_properties_interval(zval *object TSRMLS_DC)
 	PHP_DATE_INTERVAL_ADD_PROPERTY("have_special_relative", have_special_relative);
 
 	return props;
-}
+} /* }}} */
 
-static inline zend_object_value date_object_new_period_ex(zend_class_entry *class_type, php_period_obj **ptr TSRMLS_DC)
+static inline zend_object *date_object_new_period_ex(zend_class_entry *class_type, int init_props TSRMLS_DC) /* {{{ */
 {
 	php_period_obj *intern;
-	zend_object_value retval;
 
-	intern = emalloc(sizeof(php_period_obj));
-	memset(intern, 0, sizeof(php_period_obj));
-	if (ptr) {
-		*ptr = intern;
-	}
+	intern = ecalloc(1, sizeof(php_period_obj) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
-	object_properties_init(&intern->std, class_type);
-	
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) date_object_free_storage_period, NULL TSRMLS_CC);
-	retval.handlers = &date_object_handlers_period;
+	if (init_props) {
+		object_properties_init(&intern->std, class_type);
+	}
+//???	date_object_free_storage_period, NULL TSRMLS_CC);
+	intern->std.handlers = &date_object_handlers_period;
 	
-	return retval;
-}
+	return &intern->std;
+} /* }}} */
 
-static zend_object_value date_object_new_period(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *date_object_new_period(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	return date_object_new_period_ex(class_type, NULL TSRMLS_CC);
-}
+	return date_object_new_period_ex(class_type, 1 TSRMLS_CC);
+} /* }}} */
 
-static zend_object_value date_object_clone_period(zval *this_ptr TSRMLS_DC)
+static zend_object *date_object_clone_period(zval *this_ptr TSRMLS_DC) /* {{{ */
 {
-	php_period_obj *new_obj = NULL;
-	php_period_obj *old_obj = (php_period_obj *) zend_object_store_get_object(this_ptr TSRMLS_CC);
-	zend_object_value new_ov = date_object_new_period_ex(old_obj->std.ce, &new_obj TSRMLS_CC);
+	php_period_obj *old_obj = Z_PHPPERIOD_P(this_ptr);
+	php_period_obj *new_obj = php_period_obj_from_obj(date_object_new_period_ex(old_obj->std.ce, 0 TSRMLS_CC));
 	
-	zend_objects_clone_members(&new_obj->std, new_ov, &old_obj->std, Z_OBJ_HANDLE_P(this_ptr) TSRMLS_CC);
+	zend_objects_clone_members(&new_obj->std, &old_obj->std TSRMLS_CC);
 
 	/** FIX ME ADD CLONE STUFF **/
-	return new_ov;
-}
+	return &new_obj->std;
+} /* }}} */
 
-static void date_object_free_storage_date(void *object TSRMLS_DC)
+static void date_object_free_storage_date(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_date_obj *intern = (php_date_obj *)object;
+	php_date_obj *intern = php_date_obj_from_obj(object);
 
 	if (intern->time) {
 		timelib_time_dtor(intern->time);
 	}
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
-	efree(object);
-}
+} /* }}} */
 
-static void date_object_free_storage_timezone(void *object TSRMLS_DC)
+static void date_object_free_storage_timezone(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_timezone_obj *intern = (php_timezone_obj *)object;
+	php_timezone_obj *intern = php_timezone_obj_from_obj(object);
 
 	if (intern->type == TIMELIB_ZONETYPE_ABBR) {
 		free(intern->tzi.z.abbr);
 	}
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
-	efree(object);
-}
+} /* }}} */
 
-static void date_object_free_storage_interval(void *object TSRMLS_DC)
+static void date_object_free_storage_interval(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_interval_obj *intern = (php_interval_obj *)object;
+	php_interval_obj *intern = php_interval_obj_from_obj(object);
 
 	timelib_rel_time_dtor(intern->diff);
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
-	efree(object);
-}
+} /* }}} */
 
-static void date_object_free_storage_period(void *object TSRMLS_DC)
+static void date_object_free_storage_period(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_period_obj *intern = (php_period_obj *)object;
+	php_period_obj *intern = php_period_obj_from_obj(object);
 
 	if (intern->start) {
 		timelib_time_dtor(intern->start);
@@ -2529,39 +2481,34 @@ static void date_object_free_storage_period(void *object TSRMLS_DC)
 
 	timelib_rel_time_dtor(intern->interval);
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
-	efree(object);
-}
+} /* }}} */
 
 /* Advanced Interface */
-PHPAPI zval *php_date_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC)
+PHPAPI zval *php_date_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC) /* {{{ */
 {
-	Z_TYPE_P(object) = IS_OBJECT;
 	object_init_ex(object, pce);
-	Z_SET_REFCOUNT_P(object, 1);
-	Z_UNSET_ISREF_P(object);
-
 	return object;
-}
+} /* }}} */
 
 /* Helper function used to store the latest found warnings and errors while
  * parsing, from either strtotime or parse_from_format. */
-static void update_errors_warnings(timelib_error_container *last_errors TSRMLS_DC)
+static void update_errors_warnings(timelib_error_container *last_errors TSRMLS_DC) /* {{{ */
 {
 	if (DATEG(last_errors)) {
 		timelib_error_container_dtor(DATEG(last_errors));
 		DATEG(last_errors) = NULL;
 	}
 	DATEG(last_errors) = last_errors;
-}
+} /* }}} */
 
-PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str, int time_str_len, char *format, zval *timezone_object, int ctor TSRMLS_DC)
+PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str, int time_str_len, char *format, zval *timezone_object, int ctor TSRMLS_DC) /* {{{ */
 {
 	timelib_time   *now;
 	timelib_tzinfo *tzi = NULL;
 	timelib_error_container *err = NULL;
 	int type = TIMELIB_ZONETYPE_ID, new_dst = 0;
 	char *new_abbr = NULL;
-	timelib_sll     new_offset;
+	timelib_sll new_offset = 0;
 	
 	if (dateobj->time) {
 		timelib_time_dtor(dateobj->time);
@@ -2588,7 +2535,7 @@ PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str,
 	if (timezone_object) {
 		php_timezone_obj *tzobj;
 
-		tzobj = (php_timezone_obj *) zend_object_store_get_object(timezone_object TSRMLS_CC);
+		tzobj = Z_PHPTIMEZONE_P(timezone_object);
 		switch (tzobj->type) {
 			case TIMELIB_ZONETYPE_ID:
 				tzi = tzobj->tzi.tz;
@@ -2635,7 +2582,7 @@ PHPAPI int php_date_initialize(php_date_obj *dateobj, /*const*/ char *time_str,
 	timelib_time_dtor(now);
 
 	return 1;
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_create([string time[, DateTimeZone object]])
    Returns new DateTime object
@@ -2651,7 +2598,8 @@ PHP_FUNCTION(date_create)
 	}
 
 	php_date_instantiate(date_ce_date, return_value TSRMLS_CC);
-	if (!php_date_initialize(zend_object_store_get_object(return_value TSRMLS_CC), time_str, time_str_len, NULL, timezone_object, 0 TSRMLS_CC)) {
+	if (!php_date_initialize(Z_PHPDATE_P(return_value), time_str, time_str_len, NULL, timezone_object, 0 TSRMLS_CC)) {
+		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
 }
@@ -2671,7 +2619,8 @@ PHP_FUNCTION(date_create_immutable)
 	}
 
 	php_date_instantiate(date_ce_immutable, return_value TSRMLS_CC);
-	if (!php_date_initialize(zend_object_store_get_object(return_value TSRMLS_CC), time_str, time_str_len, NULL, timezone_object, 0 TSRMLS_CC)) {
+	if (!php_date_initialize(Z_PHPDATE_P(return_value), time_str, time_str_len, NULL, timezone_object, 0 TSRMLS_CC)) {
+		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
 }
@@ -2691,7 +2640,8 @@ PHP_FUNCTION(date_create_from_format)
 	}
 
 	php_date_instantiate(date_ce_date, return_value TSRMLS_CC);
-	if (!php_date_initialize(zend_object_store_get_object(return_value TSRMLS_CC), time_str, time_str_len, format_str, timezone_object, 0 TSRMLS_CC)) {
+	if (!php_date_initialize(Z_PHPDATE_P(return_value), time_str, time_str_len, format_str, timezone_object, 0 TSRMLS_CC)) {
+		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
 }
@@ -2711,7 +2661,8 @@ PHP_FUNCTION(date_create_immutable_from_format)
 	}
 
 	php_date_instantiate(date_ce_immutable, return_value TSRMLS_CC);
-	if (!php_date_initialize(zend_object_store_get_object(return_value TSRMLS_CC), time_str, time_str_len, format_str, timezone_object, 0 TSRMLS_CC)) {
+	if (!php_date_initialize(Z_PHPDATE_P(return_value), time_str, time_str_len, format_str, timezone_object, 0 TSRMLS_CC)) {
+		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
 }
@@ -2729,7 +2680,7 @@ PHP_METHOD(DateTime, __construct)
 
 	zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
 	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sO!", &time_str, &time_str_len, &timezone_object, date_ce_timezone)) {
-		php_date_initialize(zend_object_store_get_object(getThis() TSRMLS_CC), time_str, time_str_len, NULL, timezone_object, 1 TSRMLS_CC);
+		php_date_initialize(Z_PHPDATE_P(getThis()), time_str, time_str_len, NULL, timezone_object, 1 TSRMLS_CC);
 	}
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 }
@@ -2747,7 +2698,7 @@ PHP_METHOD(DateTimeImmutable, __construct)
 
 	zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
 	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sO!", &time_str, &time_str_len, &timezone_object, date_ce_timezone)) {
-		php_date_initialize(zend_object_store_get_object(getThis() TSRMLS_CC), time_str, time_str_len, NULL, timezone_object, 1 TSRMLS_CC);
+		php_date_initialize(Z_PHPDATE_P(getThis()), time_str, time_str_len, NULL, timezone_object, 1 TSRMLS_CC);
 	}
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 }
@@ -2767,8 +2718,8 @@ PHP_METHOD(DateTimeImmutable, createFromMutable)
 	}
 
 	php_date_instantiate(date_ce_immutable, return_value TSRMLS_CC);
-	old_obj = (php_date_obj *) zend_object_store_get_object(datetime_object TSRMLS_CC);
-	new_obj = (php_date_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
+	old_obj = Z_PHPDATE_P(datetime_object);
+	new_obj = Z_PHPDATE_P(return_value);
 
 	new_obj->time = timelib_time_ctor();
 	*new_obj->time = *old_obj->time;
@@ -2781,50 +2732,52 @@ PHP_METHOD(DateTimeImmutable, createFromMutable)
 }
 /* }}} */
 
-static int php_date_initialize_from_hash(zval **return_value, php_date_obj **dateobj, HashTable *myht TSRMLS_DC)
+static int php_date_initialize_from_hash(zval *return_value, php_date_obj **dateobj, HashTable *myht TSRMLS_DC) /* {{{ */
 {
-	zval            **z_date = NULL;
-	zval            **z_timezone = NULL;
-	zval            **z_timezone_type = NULL;
-	zval             *tmp_obj = NULL;
+	zval             *z_date;
+	zval             *z_timezone;
+	zval             *z_timezone_type;
+	zval              tmp_obj;
 	timelib_tzinfo   *tzi;
 	php_timezone_obj *tzobj;
 
-	if (zend_hash_find(myht, "date", 5, (void**) &z_date) == SUCCESS) {
-		convert_to_string(*z_date);
-		if (zend_hash_find(myht, "timezone_type", 14, (void**) &z_timezone_type) == SUCCESS) {
-			convert_to_long(*z_timezone_type);
-			if (zend_hash_find(myht, "timezone", 9, (void**) &z_timezone) == SUCCESS) {
-				convert_to_string(*z_timezone);
-
-				switch (Z_LVAL_PP(z_timezone_type)) {
+	z_date = zend_hash_str_find(myht, "date", sizeof("data")-1);
+	if (z_date) {
+		convert_to_string(z_date);
+		z_timezone_type = zend_hash_str_find(myht, "timezone_type", sizeof("timezone_type")-1);
+		if (z_timezone_type) {
+			convert_to_long(z_timezone_type);
+			z_timezone = zend_hash_str_find(myht, "timezone", sizeof("timezone")-1);
+			if (z_timezone) {
+				convert_to_string(z_timezone);
+
+				switch (Z_LVAL_P(z_timezone_type)) {
 					case TIMELIB_ZONETYPE_OFFSET:
 					case TIMELIB_ZONETYPE_ABBR: {
-						char *tmp = emalloc(Z_STRLEN_PP(z_date) + Z_STRLEN_PP(z_timezone) + 2);
+						char *tmp = emalloc(Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 2);
 						int ret;
-						snprintf(tmp, Z_STRLEN_PP(z_date) + Z_STRLEN_PP(z_timezone) + 2, "%s %s", Z_STRVAL_PP(z_date), Z_STRVAL_PP(z_timezone));
-						ret = php_date_initialize(*dateobj, tmp, Z_STRLEN_PP(z_date) + Z_STRLEN_PP(z_timezone) + 1, NULL, NULL, 0 TSRMLS_CC);
+						snprintf(tmp, Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 2, "%s %s", Z_STRVAL_P(z_date), Z_STRVAL_P(z_timezone));
+						ret = php_date_initialize(*dateobj, tmp, Z_STRLEN_P(z_date) + Z_STRLEN_P(z_timezone) + 1, NULL, NULL, 0 TSRMLS_CC);
 						efree(tmp);
 						return 1 == ret;
 					}
 
 					case TIMELIB_ZONETYPE_ID: {
 						int ret;
-						convert_to_string(*z_timezone);
+						convert_to_string(z_timezone);
 
-						tzi = php_date_parse_tzfile(Z_STRVAL_PP(z_timezone), DATE_TIMEZONEDB TSRMLS_CC);
+						tzi = php_date_parse_tzfile(Z_STRVAL_P(z_timezone), DATE_TIMEZONEDB TSRMLS_CC);
 
 						if (tzi == NULL) {
 							return 0;
 						}
 
-						ALLOC_INIT_ZVAL(tmp_obj);
-						tzobj = zend_object_store_get_object(php_date_instantiate(date_ce_timezone, tmp_obj TSRMLS_CC) TSRMLS_CC);
+						tzobj = Z_PHPTIMEZONE_P(php_date_instantiate(date_ce_timezone, &tmp_obj TSRMLS_CC));
 						tzobj->type = TIMELIB_ZONETYPE_ID;
 						tzobj->tzi.tz = tzi;
 						tzobj->initialized = 1;
 
-						ret = php_date_initialize(*dateobj, Z_STRVAL_PP(z_date), Z_STRLEN_PP(z_date), NULL, tmp_obj, 0 TSRMLS_CC);
+						ret = php_date_initialize(*dateobj, Z_STRVAL_P(z_date), Z_STRLEN_P(z_date), NULL, &tmp_obj, 0 TSRMLS_CC);
 						zval_ptr_dtor(&tmp_obj);
 						return 1 == ret;
 					}
@@ -2833,7 +2786,7 @@ static int php_date_initialize_from_hash(zval **return_value, php_date_obj **dat
 		}
 	}
 	return 0;
-}
+} /* }}} */
 
 /* {{{ proto DateTime::__set_state()
 */
@@ -2850,8 +2803,8 @@ PHP_METHOD(DateTime, __set_state)
 	myht = HASH_OF(array);
 
 	php_date_instantiate(date_ce_date, return_value TSRMLS_CC);
-	dateobj = (php_date_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
-	if (!php_date_initialize_from_hash(&return_value, &dateobj, myht TSRMLS_CC)) {
+	dateobj = Z_PHPDATE_P(return_value);
+	if (!php_date_initialize_from_hash(return_value, &dateobj, myht TSRMLS_CC)) {
 		php_error(E_ERROR, "Invalid serialization data for DateTime object");
 	}
 }
@@ -2872,8 +2825,8 @@ PHP_METHOD(DateTimeImmutable, __set_state)
 	myht = HASH_OF(array);
 
 	php_date_instantiate(date_ce_immutable, return_value TSRMLS_CC);
-	dateobj = (php_date_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
-	if (!php_date_initialize_from_hash(&return_value, &dateobj, myht TSRMLS_CC)) {
+	dateobj = Z_PHPDATE_P(return_value);
+	if (!php_date_initialize_from_hash(return_value, &dateobj, myht TSRMLS_CC)) {
 		php_error(E_ERROR, "Invalid serialization data for DateTimeImmutable object");
 	}
 }
@@ -2887,38 +2840,36 @@ PHP_METHOD(DateTime, __wakeup)
 	php_date_obj     *dateobj;
 	HashTable        *myht;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 
 	myht = Z_OBJPROP_P(object);
 
-	if (!php_date_initialize_from_hash(&return_value, &dateobj, myht TSRMLS_CC)) {
+	if (!php_date_initialize_from_hash(return_value, &dateobj, myht TSRMLS_CC)) {
 		php_error(E_ERROR, "Invalid serialization data for DateTime object");
 	}
 }
 /* }}} */
 
 /* Helper function used to add an associative array of warnings and errors to a zval */
-static void zval_from_error_container(zval *z, timelib_error_container *error)
+static void zval_from_error_container(zval *z, timelib_error_container *error) /* {{{ */
 {
 	int   i;
-	zval *element;
+	zval element;
 
 	add_assoc_long(z, "warning_count", error->warning_count);
-	MAKE_STD_ZVAL(element);
-	array_init(element);
+	array_init(&element);
 	for (i = 0; i < error->warning_count; i++) {
-		add_index_string(element, error->warning_messages[i].position, error->warning_messages[i].message, 1);
+		add_index_string(&element, error->warning_messages[i].position, error->warning_messages[i].message);
 	}
-	add_assoc_zval(z, "warnings", element);
+	add_assoc_zval(z, "warnings", &element);
 
 	add_assoc_long(z, "error_count", error->error_count);
-	MAKE_STD_ZVAL(element);
-	array_init(element);
+	array_init(&element);
 	for (i = 0; i < error->error_count; i++) {
-		add_index_string(element, error->error_messages[i].position, error->error_messages[i].message, 1);
+		add_index_string(&element, error->error_messages[i].position, error->error_messages[i].message);
 	}
-	add_assoc_zval(z, "errors", element);
-}
+	add_assoc_zval(z, "errors", &element);
+} /* }}} */
 
 /* {{{ proto array date_get_last_errors()
    Returns the warnings and errors found while parsing a date/time string.
@@ -2934,9 +2885,9 @@ PHP_FUNCTION(date_get_last_errors)
 }
 /* }}} */
 
-void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time *parsed_time, struct timelib_error_container *error)
+void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time *parsed_time, struct timelib_error_container *error) /* {{{ */
 {
-	zval *element;
+	zval element;
 
 	array_init(return_value);
 #define PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(name, elem) \
@@ -2973,41 +2924,40 @@ void php_date_do_return_parsed_time(INTERNAL_FUNCTION_PARAMETERS, timelib_time *
 				break;
 			case TIMELIB_ZONETYPE_ID:
 				if (parsed_time->tz_abbr) {
-					add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1);
+					add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr);
 				}
 				if (parsed_time->tz_info) {
-					add_assoc_string(return_value, "tz_id", parsed_time->tz_info->name, 1);
+					add_assoc_string(return_value, "tz_id", parsed_time->tz_info->name);
 				}
 				break;
 			case TIMELIB_ZONETYPE_ABBR:
 				PHP_DATE_PARSE_DATE_SET_TIME_ELEMENT(zone, z);
 				add_assoc_bool(return_value, "is_dst", parsed_time->dst);
-				add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr, 1);
+				add_assoc_string(return_value, "tz_abbr", parsed_time->tz_abbr);
 				break;
 		}
 	}
 	if (parsed_time->have_relative) {
-		MAKE_STD_ZVAL(element);
-		array_init(element);
-		add_assoc_long(element, "year",   parsed_time->relative.y);
-		add_assoc_long(element, "month",  parsed_time->relative.m);
-		add_assoc_long(element, "day",    parsed_time->relative.d);
-		add_assoc_long(element, "hour",   parsed_time->relative.h);
-		add_assoc_long(element, "minute", parsed_time->relative.i);
-		add_assoc_long(element, "second", parsed_time->relative.s);
+		array_init(&element);
+		add_assoc_long(&element, "year",   parsed_time->relative.y);
+		add_assoc_long(&element, "month",  parsed_time->relative.m);
+		add_assoc_long(&element, "day",    parsed_time->relative.d);
+		add_assoc_long(&element, "hour",   parsed_time->relative.h);
+		add_assoc_long(&element, "minute", parsed_time->relative.i);
+		add_assoc_long(&element, "second", parsed_time->relative.s);
 		if (parsed_time->relative.have_weekday_relative) {
-			add_assoc_long(element, "weekday", parsed_time->relative.weekday);
+			add_assoc_long(&element, "weekday", parsed_time->relative.weekday);
 		}
 		if (parsed_time->relative.have_special_relative && (parsed_time->relative.special.type == TIMELIB_SPECIAL_WEEKDAY)) {
-			add_assoc_long(element, "weekdays", parsed_time->relative.special.amount);
+			add_assoc_long(&element, "weekdays", parsed_time->relative.special.amount);
 		}
 		if (parsed_time->relative.first_last_day_of) {
-			add_assoc_bool(element, parsed_time->relative.first_last_day_of == 1 ? "first_day_of_month" : "last_day_of_month", 1);
+			add_assoc_bool(&element, parsed_time->relative.first_last_day_of == 1 ? "first_day_of_month" : "last_day_of_month", 1);
 		}
-		add_assoc_zval(return_value, "relative", element);
+		add_assoc_zval(return_value, "relative", &element);
 	}
 	timelib_time_dtor(parsed_time);
-}
+} /* }}} */
 
 /* {{{ proto array date_parse(string date)
    Returns associative array with detailed info about given date
@@ -3060,19 +3010,19 @@ PHP_FUNCTION(date_format)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &object, date_ce_interface, &format, &format_len) == FAILURE) {
 		RETURN_FALSE;
 	}
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
-	RETURN_STRING(date_format(format, format_len, dateobj->time, dateobj->time->is_localtime), 0);
+	RETURN_STR(date_format(format, format_len, dateobj->time, dateobj->time->is_localtime TSRMLS_CC));
 }
 /* }}} */
 
-static int php_date_modify(zval *object, char *modify, int modify_len TSRMLS_DC)
+static int php_date_modify(zval *object, char *modify, int modify_len TSRMLS_DC) /* {{{ */
 {
 	php_date_obj *dateobj;
 	timelib_time *tmp_time;
 	timelib_error_container *err = NULL;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 
 	if (!(dateobj->time)) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "The DateTime object has not been correctly initialized by its constructor");
@@ -3126,7 +3076,7 @@ static int php_date_modify(zval *object, char *modify, int modify_len TSRMLS_DC)
 	dateobj->time->have_relative = 0;
 	
 	return 1;
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_modify(DateTime object, string modify)
    Alters the timestamp.
@@ -3153,7 +3103,7 @@ PHP_FUNCTION(date_modify)
 */
 PHP_METHOD(DateTimeImmutable, modify)
 {
-	zval *object, *new_object;
+	zval *object, new_object;
 	char *modify;
 	int   modify_len;
 
@@ -3161,30 +3111,30 @@ PHP_METHOD(DateTimeImmutable, modify)
 		RETURN_FALSE;
 	}
 	
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	if (php_date_modify(new_object, modify, modify_len TSRMLS_CC)) {
-		RETURN_ZVAL(new_object, 0, 1);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	if (php_date_modify(&new_object, modify, modify_len TSRMLS_CC)) {
+		RETURN_ZVAL(&new_object, 0, 1);
 	}
 
 	RETURN_FALSE;
 }
 /* }}} */
 
-static void php_date_add(zval *object, zval *interval, zval *return_value TSRMLS_DC)
+static void php_date_add(zval *object, zval *interval, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj     *dateobj;
 	php_interval_obj *intobj;
 	timelib_time     *new_time;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
-	intobj = (php_interval_obj *) zend_object_store_get_object(interval TSRMLS_CC);
+	intobj = Z_PHPINTERVAL_P(interval);
 	DATE_CHECK_INITIALIZED(intobj->initialized, DateInterval);
 
 	new_time = timelib_add(dateobj->time, intobj->diff);
 	timelib_time_dtor(dateobj->time);
 	dateobj->time = new_time;
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_add(DateTime object, DateInterval interval)
    Adds an interval to the current date in object.
@@ -3207,28 +3157,28 @@ PHP_FUNCTION(date_add)
 */
 PHP_METHOD(DateTimeImmutable, add)
 {
-	zval *object, *interval, *new_object;
+	zval *object, *interval, new_object;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO", &object, date_ce_immutable, &interval, date_ce_interval) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_add(new_object, interval, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_add(&new_object, interval, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
-static void php_date_sub(zval *object, zval *interval, zval *return_value TSRMLS_DC)
+static void php_date_sub(zval *object, zval *interval, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj     *dateobj;
 	php_interval_obj *intobj;
 	timelib_time     *new_time;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
-	intobj = (php_interval_obj *) zend_object_store_get_object(interval TSRMLS_CC);
+	intobj = Z_PHPINTERVAL_P(interval);
 	DATE_CHECK_INITIALIZED(intobj->initialized, DateInterval);
 
 	if (intobj->diff->have_special_relative) {
@@ -3239,7 +3189,7 @@ static void php_date_sub(zval *object, zval *interval, zval *return_value TSRMLS
 	new_time = timelib_sub(dateobj->time, intobj->diff);
 	timelib_time_dtor(dateobj->time);
 	dateobj->time = new_time;
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_sub(DateTime object, DateInterval interval)
    Subtracts an interval to the current date in object.
@@ -3262,16 +3212,16 @@ PHP_FUNCTION(date_sub)
 */
 PHP_METHOD(DateTimeImmutable, sub)
 {
-	zval *object, *interval, *new_object;
+	zval *object, *interval, new_object;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO", &object, date_ce_immutable, &interval, date_ce_interval) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_sub(new_object, interval, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_sub(&new_object, interval, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
@@ -3307,11 +3257,11 @@ PHP_FUNCTION(date_timezone_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, date_ce_interface) == FAILURE) {
 		RETURN_FALSE;
 	}
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	if (dateobj->time->is_localtime/* && dateobj->time->tz_info*/) {
 		php_date_instantiate(date_ce_timezone, return_value TSRMLS_CC);
-		tzobj = (php_timezone_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
+		tzobj = Z_PHPTIMEZONE_P(return_value);
 		set_timezone_from_timelib_time(tzobj, dateobj->time);
 	} else {
 		RETURN_FALSE;
@@ -3319,14 +3269,14 @@ PHP_FUNCTION(date_timezone_get)
 }
 /* }}} */
 
-static void php_date_timezone_set(zval *object, zval *timezone_object, zval *return_value TSRMLS_DC)
+static void php_date_timezone_set(zval *object, zval *timezone_object, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj     *dateobj;
 	php_timezone_obj *tzobj;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(timezone_object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(timezone_object);
 
 	switch (tzobj->type) {
 		case TIMELIB_ZONETYPE_OFFSET:
@@ -3340,7 +3290,7 @@ static void php_date_timezone_set(zval *object, zval *timezone_object, zval *ret
 			break;
 	}
 	timelib_unixtime2local(dateobj->time, dateobj->time->sse);
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_timezone_set(DateTime object, DateTimeZone object)
    Sets the timezone for the DateTime object.
@@ -3364,17 +3314,17 @@ PHP_FUNCTION(date_timezone_set)
 */
 PHP_METHOD(DateTimeImmutable, setTimezone)
 {
-	zval *object, *new_object;
+	zval *object, new_object;
 	zval *timezone_object;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO", &object, date_ce_immutable, &timezone_object, date_ce_timezone) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_timezone_set(new_object, timezone_object, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_timezone_set(&new_object, timezone_object, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
@@ -3390,7 +3340,7 @@ PHP_FUNCTION(date_offset_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, date_ce_interface) == FAILURE) {
 		RETURN_FALSE;
 	}
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	if (dateobj->time->is_localtime/* && dateobj->time->tz_info*/) {
 		switch (dateobj->time->zone_type) {
@@ -3413,17 +3363,17 @@ PHP_FUNCTION(date_offset_get)
 }
 /* }}} */
 
-static void php_date_time_set(zval *object, long h, long i, long s, zval *return_value TSRMLS_DC)
+static void php_date_time_set(zval *object, long h, long i, long s, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj *dateobj;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	dateobj->time->h = h;
 	dateobj->time->i = i;
 	dateobj->time->s = s;
 	timelib_update_ts(dateobj->time, NULL);
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_time_set(DateTime object, long hour, long minute[, long second])
    Sets the time.
@@ -3447,31 +3397,31 @@ PHP_FUNCTION(date_time_set)
 */
 PHP_METHOD(DateTimeImmutable, setTime)
 {
-	zval *object, *new_object;
+	zval *object, new_object;
 	long  h, i, s = 0;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll|l", &object, date_ce_immutable, &h, &i, &s) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_time_set(new_object, h, i, s, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_time_set(&new_object, h, i, s, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
-static void php_date_date_set(zval *object, long y, long m, long d, zval *return_value TSRMLS_DC)
+static void php_date_date_set(zval *object, long y, long m, long d, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj *dateobj;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	dateobj->time->y = y;
 	dateobj->time->m = m;
 	dateobj->time->d = d;
 	timelib_update_ts(dateobj->time, NULL);
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_date_set(DateTime object, long year, long month, long day)
    Sets the date.
@@ -3495,25 +3445,25 @@ PHP_FUNCTION(date_date_set)
 */
 PHP_METHOD(DateTimeImmutable, setDate)
 {
-	zval *object, *new_object;
+	zval *object, new_object;
 	long  y, m, d;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Olll", &object, date_ce_immutable, &y, &m, &d) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_date_set(new_object, y, m, d, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_date_set(&new_object, y, m, d, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
-static void php_date_isodate_set(zval *object, long y, long w, long d, zval *return_value TSRMLS_DC)
+static void php_date_isodate_set(zval *object, long y, long w, long d, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj *dateobj;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	dateobj->time->y = y;
 	dateobj->time->m = 1;
@@ -3523,7 +3473,7 @@ static void php_date_isodate_set(zval *object, long y, long w, long d, zval *ret
 	dateobj->time->have_relative = 1;
 	
 	timelib_update_ts(dateobj->time, NULL);
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_isodate_set(DateTime object, long year, long week[, long day])
    Sets the ISO date.
@@ -3547,29 +3497,29 @@ PHP_FUNCTION(date_isodate_set)
 */
 PHP_METHOD(DateTimeImmutable, setISODate)
 {
-	zval *object, *new_object;
+	zval *object, new_object;
 	long  y, w, d = 1;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oll|l", &object, date_ce_immutable, &y, &w, &d) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_isodate_set(new_object, y, w, d, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_isodate_set(&new_object, y, w, d, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
-static void php_date_timestamp_set(zval *object, long timestamp, zval *return_value TSRMLS_DC)
+static void php_date_timestamp_set(zval *object, long timestamp, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	php_date_obj *dateobj;
 
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	timelib_unixtime2local(dateobj->time, (timelib_sll)timestamp);
 	timelib_update_ts(dateobj->time, NULL);
-}
+} /* }}} */
 
 /* {{{ proto DateTime date_timestamp_set(DateTime object, long unixTimestamp)
    Sets the date and time based on an Unix timestamp.
@@ -3593,17 +3543,17 @@ PHP_FUNCTION(date_timestamp_set)
 */
 PHP_METHOD(DateTimeImmutable, setTimestamp)
 {
-	zval *object, *new_object;
+	zval *object, new_object;
 	long  timestamp;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &object, date_ce_immutable, &timestamp) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	new_object = date_clone_immutable(object TSRMLS_CC);
-	php_date_timestamp_set(new_object, timestamp, return_value TSRMLS_CC);
+	date_clone_immutable(object, &new_object TSRMLS_CC);
+	php_date_timestamp_set(&new_object, timestamp, return_value TSRMLS_CC);
 
-	RETURN_ZVAL(new_object, 0, 1);
+	RETURN_ZVAL(&new_object, 0, 1);
 }
 /* }}} */
 
@@ -3620,7 +3570,7 @@ PHP_FUNCTION(date_timestamp_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, date_ce_interface) == FAILURE) {
 		RETURN_FALSE;
 	}
-	dateobj = (php_date_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(object);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 	timelib_update_ts(dateobj->time, NULL);
 
@@ -3646,15 +3596,15 @@ PHP_FUNCTION(date_diff)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO|l", &object1, date_ce_interface, &object2, date_ce_interface, &absolute) == FAILURE) {
 		RETURN_FALSE;
 	}
-	dateobj1 = (php_date_obj *) zend_object_store_get_object(object1 TSRMLS_CC);
-	dateobj2 = (php_date_obj *) zend_object_store_get_object(object2 TSRMLS_CC);
+	dateobj1 = Z_PHPDATE_P(object1);
+	dateobj2 = Z_PHPDATE_P(object2);
 	DATE_CHECK_INITIALIZED(dateobj1->time, DateTimeInterface);
 	DATE_CHECK_INITIALIZED(dateobj2->time, DateTimeInterface);
 	timelib_update_ts(dateobj1->time, NULL);
 	timelib_update_ts(dateobj2->time, NULL);
 
 	php_date_instantiate(date_ce_interval, return_value TSRMLS_CC);
-	interval = zend_object_store_get_object(return_value TSRMLS_CC);
+	interval = Z_PHPINTERVAL_P(return_value);
 	interval->diff = timelib_diff(dateobj1->time, dateobj2->time);
 	if (absolute) {
 		interval->diff->invert = 0;
@@ -3663,7 +3613,7 @@ PHP_FUNCTION(date_diff)
 }
 /* }}} */
 
-static int timezone_initialize(php_timezone_obj *tzobj, /*const*/ char *tz TSRMLS_DC)
+static int timezone_initialize(php_timezone_obj *tzobj, /*const*/ char *tz TSRMLS_DC) /* {{{ */
 {
 	timelib_time *dummy_t = ecalloc(1, sizeof(timelib_time));
 	int           dst, not_found;
@@ -3679,7 +3629,7 @@ static int timezone_initialize(php_timezone_obj *tzobj, /*const*/ char *tz TSRML
 		efree(dummy_t);
 		return SUCCESS;
 	}
-}
+} /* }}} */
 
 /* {{{ proto DateTimeZone timezone_open(string timezone)
    Returns new DateTimeZone object
@@ -3693,7 +3643,7 @@ PHP_FUNCTION(timezone_open)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &tz, &tz_len) == FAILURE) {
 		RETURN_FALSE;
 	}
-	tzobj = zend_object_store_get_object(php_date_instantiate(date_ce_timezone, return_value TSRMLS_CC) TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(php_date_instantiate(date_ce_timezone, return_value TSRMLS_CC));
 	if (SUCCESS != timezone_initialize(tzobj, tz TSRMLS_CC)) {
 		RETURN_FALSE;
 	}
@@ -3712,30 +3662,30 @@ PHP_METHOD(DateTimeZone, __construct)
 	
 	zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
 	if (SUCCESS == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &tz, &tz_len)) {
-		tzobj = zend_object_store_get_object(getThis() TSRMLS_CC);
+		tzobj = Z_PHPTIMEZONE_P(getThis());
 		if (FAILURE == timezone_initialize(tzobj, tz TSRMLS_CC)) {
-			ZVAL_NULL(getThis());
+//???			ZVAL_NULL(getThis());
 		}
 	}
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 }
 /* }}} */
 
-static int php_date_timezone_initialize_from_hash(zval **return_value, php_timezone_obj **tzobj, HashTable *myht TSRMLS_DC)
+static int php_date_timezone_initialize_from_hash(zval **return_value, php_timezone_obj **tzobj, HashTable *myht TSRMLS_DC) /* {{{ */
 {
-	zval            **z_timezone = NULL;
-	zval            **z_timezone_type = NULL;
+	zval            *z_timezone;
+	zval            *z_timezone_type;
 
-	if (zend_hash_find(myht, "timezone_type", 14, (void**) &z_timezone_type) == SUCCESS) {
-		if (zend_hash_find(myht, "timezone", 9, (void**) &z_timezone) == SUCCESS) {
-			convert_to_long(*z_timezone_type);
-			if (SUCCESS == timezone_initialize(*tzobj, Z_STRVAL_PP(z_timezone) TSRMLS_CC)) {
+	if ((z_timezone_type = zend_hash_str_find(myht, "timezone_type", sizeof("timezone_type")-1)) != NULL) {
+		if ((z_timezone = zend_hash_str_find(myht, "timezone", sizeof("timezone")-1)) != NULL) {
+			convert_to_long(z_timezone_type);
+			if (SUCCESS == timezone_initialize(*tzobj, Z_STRVAL_P(z_timezone) TSRMLS_CC)) {
 				return SUCCESS;
 			}
 		}
 	}
 	return FAILURE;
-}
+} /* }}} */
 
 /* {{{ proto DateTimeZone::__set_state()
  *  */
@@ -3752,7 +3702,7 @@ PHP_METHOD(DateTimeZone, __set_state)
 	myht = HASH_OF(array);
 
 	php_date_instantiate(date_ce_timezone, return_value TSRMLS_CC);
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(return_value);
 	php_date_timezone_initialize_from_hash(&return_value, &tzobj, myht TSRMLS_CC);
 }
 /* }}} */
@@ -3765,7 +3715,7 @@ PHP_METHOD(DateTimeZone, __wakeup)
 	php_timezone_obj *tzobj;
 	HashTable        *myht;
 
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(object);
 
 	myht = Z_OBJPROP_P(object);
 	
@@ -3784,27 +3734,27 @@ PHP_FUNCTION(timezone_name_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, date_ce_timezone) == FAILURE) {
 		RETURN_FALSE;
 	}
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(object);
 	DATE_CHECK_INITIALIZED(tzobj->initialized, DateTimeZone);
 
 	switch (tzobj->type) {
 		case TIMELIB_ZONETYPE_ID:
-			RETURN_STRING(tzobj->tzi.tz->name, 1);
+			RETURN_STRING(tzobj->tzi.tz->name);
 			break;
 		case TIMELIB_ZONETYPE_OFFSET: {
-			char *tmpstr = emalloc(sizeof("UTC+05:00"));
+			zend_string *tmpstr = STR_ALLOC(sizeof("UTC+05:00")-1, 0);
 			timelib_sll utc_offset = tzobj->tzi.utc_offset;
 
-			snprintf(tmpstr, sizeof("+05:00"), "%c%02d:%02d",
+			tmpstr->len = snprintf(tmpstr->val, sizeof("+05:00"), "%c%02d:%02d",
 				utc_offset > 0 ? '-' : '+',
 				abs(utc_offset / 60),
 				abs((utc_offset % 60)));
 
-			RETURN_STRING(tmpstr, 0);
+			RETURN_STR(tmpstr);
 			}
 			break;
 		case TIMELIB_ZONETYPE_ABBR:
-			RETURN_STRING(tzobj->tzi.z.abbr, 1);
+			RETURN_STRING(tzobj->tzi.z.abbr);
 			break;
 	}
 }
@@ -3827,7 +3777,7 @@ PHP_FUNCTION(timezone_name_from_abbr)
 	tzid = timelib_timezone_id_from_abbr(abbr, gmtoffset, isdst);
 
 	if (tzid) {
-		RETURN_STRING(tzid, 1);
+		RETURN_STRING(tzid);
 	} else {
 		RETURN_FALSE;
 	}
@@ -3847,9 +3797,9 @@ PHP_FUNCTION(timezone_offset_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OO", &object, date_ce_timezone, &dateobject, date_ce_date) == FAILURE) {
 		RETURN_FALSE;
 	}
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(object);
 	DATE_CHECK_INITIALIZED(tzobj->initialized, DateTimeZone);
-	dateobj = (php_date_obj *) zend_object_store_get_object(dateobject TSRMLS_CC);
+	dateobj = Z_PHPDATE_P(dateobject);
 	DATE_CHECK_INITIALIZED(dateobj->time, DateTime);
 
 	switch (tzobj->type) {
@@ -3873,7 +3823,7 @@ PHP_FUNCTION(timezone_offset_get)
 */
 PHP_FUNCTION(timezone_transitions_get)
 {
-	zval                *object, *element;
+	zval                *object, element;
 	php_timezone_obj    *tzobj;
 	unsigned int         i, begin = 0, found;
 	long                 timestamp_begin = LONG_MIN, timestamp_end = LONG_MAX;
@@ -3881,31 +3831,29 @@ PHP_FUNCTION(timezone_transitions_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O|ll", &object, date_ce_timezone, &timestamp_begin, &timestamp_end) == FAILURE) {
 		RETURN_FALSE;
 	}
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(object);
 	DATE_CHECK_INITIALIZED(tzobj->initialized, DateTimeZone);
 	if (tzobj->type != TIMELIB_ZONETYPE_ID) {
 		RETURN_FALSE;
 	}
 
 #define add_nominal() \
-		MAKE_STD_ZVAL(element); \
-		array_init(element); \
-		add_assoc_long(element, "ts",     timestamp_begin); \
-		add_assoc_string(element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, timestamp_begin, 0 TSRMLS_CC), 0); \
-		add_assoc_long(element, "offset", tzobj->tzi.tz->type[0].offset); \
-		add_assoc_bool(element, "isdst",  tzobj->tzi.tz->type[0].isdst); \
-		add_assoc_string(element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx], 1); \
-		add_next_index_zval(return_value, element);
+		array_init(&element); \
+		add_assoc_long(&element, "ts",     timestamp_begin); \
+		add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, timestamp_begin, 0 TSRMLS_CC)); \
+		add_assoc_long(&element, "offset", tzobj->tzi.tz->type[0].offset); \
+		add_assoc_bool(&element, "isdst",  tzobj->tzi.tz->type[0].isdst); \
+		add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[0].abbr_idx]); \
+		add_next_index_zval(return_value, &element);
 
 #define add(i,ts) \
-		MAKE_STD_ZVAL(element); \
-		array_init(element); \
-		add_assoc_long(element, "ts",     ts); \
-		add_assoc_string(element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, ts, 0 TSRMLS_CC), 0); \
-		add_assoc_long(element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \
-		add_assoc_bool(element, "isdst",  tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].isdst); \
-		add_assoc_string(element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx], 1); \
-		add_next_index_zval(return_value, element);
+		array_init(&element); \
+		add_assoc_long(&element, "ts",     ts); \
+		add_assoc_str(&element, "time", php_format_date(DATE_FORMAT_ISO8601, 13, ts, 0 TSRMLS_CC)); \
+		add_assoc_long(&element, "offset", tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].offset); \
+		add_assoc_bool(&element, "isdst",  tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].isdst); \
+		add_assoc_string(&element, "abbr", &tzobj->tzi.tz->timezone_abbr[tzobj->tzi.tz->type[tzobj->tzi.tz->trans_idx[i]].abbr_idx]); \
+		add_next_index_zval(return_value, &element);
 
 #define add_last() add(tzobj->tzi.tz->timecnt - 1, timestamp_begin)
 
@@ -3961,21 +3909,21 @@ PHP_FUNCTION(timezone_location_get)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "O", &object, date_ce_timezone) == FAILURE) {
 		RETURN_FALSE;
 	}
-	tzobj = (php_timezone_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	tzobj = Z_PHPTIMEZONE_P(object);
 	DATE_CHECK_INITIALIZED(tzobj->initialized, DateTimeZone);
 	if (tzobj->type != TIMELIB_ZONETYPE_ID) {
 		RETURN_FALSE;
 	}
 
 	array_init(return_value);
-	add_assoc_string(return_value, "country_code", tzobj->tzi.tz->location.country_code, 1);
+	add_assoc_string(return_value, "country_code", tzobj->tzi.tz->location.country_code);
 	add_assoc_double(return_value, "latitude", tzobj->tzi.tz->location.latitude);
 	add_assoc_double(return_value, "longitude", tzobj->tzi.tz->location.longitude);
-	add_assoc_string(return_value, "comments", tzobj->tzi.tz->location.comments, 1);
+	add_assoc_string(return_value, "comments", tzobj->tzi.tz->location.comments);
 }
 /* }}} */
 
-static int date_interval_initialize(timelib_rel_time **rt, /*const*/ char *format, int format_length TSRMLS_DC)
+static int date_interval_initialize(timelib_rel_time **rt, /*const*/ char *format, int format_length TSRMLS_DC) /* {{{ */
 {
 	timelib_time     *b = NULL, *e = NULL;
 	timelib_rel_time *p = NULL;
@@ -4006,28 +3954,28 @@ static int date_interval_initialize(timelib_rel_time **rt, /*const*/ char *forma
 	}
 	timelib_error_container_dtor(errors);
 	return retval;
-}
+} /* }}} */
 
 /* {{{ date_interval_read_property */
-zval *date_interval_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
+zval *date_interval_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
 	php_interval_obj *obj;
 	zval *retval;
 	zval tmp_member;
 	timelib_sll value = -1;
 
- 	if (member->type != IS_STRING) {
+ 	if (Z_TYPE_P(member) != IS_STRING) {
 		tmp_member = *member;
 		zval_copy_ctor(&tmp_member);
 		convert_to_string(&tmp_member);
 		member = &tmp_member;
-		key = NULL;
+		cache_slot = -1;
 	}
 
-	obj = (php_interval_obj *)zend_objects_get_address(object TSRMLS_CC);
+	obj = Z_PHPINTERVAL_P(object);
 
 	if (!obj->initialized) {
-		retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
+		retval = (zend_get_std_object_handlers())->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 		if (member == &tmp_member) {
 			zval_dtor(member);
 		}
@@ -4049,7 +3997,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, const ze
 		GET_VALUE_FROM_STRUCT(invert, "invert");
 		GET_VALUE_FROM_STRUCT(days, "days");
 		/* didn't find any */
-		retval = (zend_get_std_object_handlers())->read_property(object, member, type, key TSRMLS_CC);
+		retval = (zend_get_std_object_handlers())->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 
 		if (member == &tmp_member) {
 			zval_dtor(member);
@@ -4058,8 +4006,7 @@ zval *date_interval_read_property(zval *object, zval *member, int type, const ze
 		return retval;
 	} while(0);
 
-	ALLOC_INIT_ZVAL(retval);
-	Z_SET_REFCOUNT_P(retval, 0);
+	retval = rv;
 
 	if (value != -99999) {
 		ZVAL_LONG(retval, value);
@@ -4076,23 +4023,23 @@ zval *date_interval_read_property(zval *object, zval *member, int type, const ze
 /* }}} */
 
 /* {{{ date_interval_write_property */
-void date_interval_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+void date_interval_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
 	php_interval_obj *obj;
-	zval tmp_member, tmp_value;
+	zval tmp_member;
 
- 	if (member->type != IS_STRING) {
+ 	if (Z_TYPE_P(member) != IS_STRING) {
 		tmp_member = *member;
 		zval_copy_ctor(&tmp_member);
 		convert_to_string(&tmp_member);
 		member = &tmp_member;
-		key = NULL;
+		cache_slot = -1;
 	}
 
-	obj = (php_interval_obj *)zend_objects_get_address(object TSRMLS_CC);
+	obj = Z_PHPINTERVAL_P(object);
 
 	if (!obj->initialized) {
-		(zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
+		(zend_get_std_object_handlers())->write_property(object, member, value, cache_slot TSRMLS_CC);
 		if (member == &tmp_member) {
 			zval_dtor(member);
 		}
@@ -4101,16 +4048,7 @@ void date_interval_write_property(zval *object, zval *member, zval *value, const
 
 #define SET_VALUE_FROM_STRUCT(n,m)            \
 	if (strcmp(Z_STRVAL_P(member), m) == 0) { \
-		if (value->type != IS_LONG) {         \
-			tmp_value = *value;               \
-			zval_copy_ctor(&tmp_value);       \
-			convert_to_long(&tmp_value);      \
-			value = &tmp_value;               \
-		}                                     \
-		obj->diff->n = Z_LVAL_P(value);       \
-		if (value == &tmp_value) {            \
-			zval_dtor(value);                 \
-		}                                     \
+		obj->diff->n = zval_get_long(value TSRMLS_CC); \
 		break;								  \
 	}
 
@@ -4123,7 +4061,7 @@ void date_interval_write_property(zval *object, zval *member, zval *value, const
 		SET_VALUE_FROM_STRUCT(s, "s");
 		SET_VALUE_FROM_STRUCT(invert, "invert");
 		/* didn't find any */
-		(zend_get_std_object_handlers())->write_property(object, member, value, key TSRMLS_CC);
+		(zend_get_std_object_handlers())->write_property(object, member, value, cache_slot TSRMLS_CC);
 	} while(0);
 
 	if (member == &tmp_member) {
@@ -4147,11 +4085,11 @@ PHP_METHOD(DateInterval, __construct)
 	zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &interval_string, &interval_string_length) == SUCCESS) {
 		if (date_interval_initialize(&reltime, interval_string, interval_string_length TSRMLS_CC) == SUCCESS) {
-			diobj = zend_object_store_get_object(getThis() TSRMLS_CC);
+			diobj = Z_PHPINTERVAL_P(getThis());
 			diobj->diff = reltime;
 			diobj->initialized = 1;
-		} else {
-			ZVAL_NULL(getThis());
+//???		} else {
+//???			ZVAL_NULL(getThis());
 		}
 	}
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
@@ -4159,16 +4097,16 @@ PHP_METHOD(DateInterval, __construct)
 /* }}} */
 
 
-static int php_date_interval_initialize_from_hash(zval **return_value, php_interval_obj **intobj, HashTable *myht TSRMLS_DC)
+static int php_date_interval_initialize_from_hash(zval **return_value, php_interval_obj **intobj, HashTable *myht TSRMLS_DC) /* {{{ */
 {
 	(*intobj)->diff = timelib_rel_time_ctor();
 
 #define PHP_DATE_INTERVAL_READ_PROPERTY(element, member, itype, def) \
 	do { \
-		zval **z_arg = NULL; \
-		if (zend_hash_find(myht, element, strlen(element) + 1, (void**) &z_arg) == SUCCESS) { \
-			convert_to_long(*z_arg); \
-			(*intobj)->diff->member = (itype)Z_LVAL_PP(z_arg); \
+		zval *z_arg = zend_hash_str_find(myht, element, sizeof(element) - 1); \
+		if (z_arg) { \
+			convert_to_long(z_arg); \
+			(*intobj)->diff->member = (itype)Z_LVAL_P(z_arg); \
 		} else { \
 			(*intobj)->diff->member = (itype)def; \
 		} \
@@ -4176,10 +4114,10 @@ static int php_date_interval_initialize_from_hash(zval **return_value, php_inter
 
 #define PHP_DATE_INTERVAL_READ_PROPERTY_I64(element, member) \
 	do { \
-		zval **z_arg = NULL; \
-		if (zend_hash_find(myht, element, strlen(element) + 1, (void**) &z_arg) == SUCCESS) { \
-			convert_to_string(*z_arg); \
-			DATE_A64I((*intobj)->diff->member, Z_STRVAL_PP(z_arg)); \
+		zval *z_arg = zend_hash_str_find(myht, element, sizeof(element) - 1); \
+		if (z_arg) { \
+			convert_to_string(z_arg); \
+			DATE_A64I((*intobj)->diff->member, Z_STRVAL_P(z_arg)); \
 		} else { \
 			(*intobj)->diff->member = -1LL; \
 		} \
@@ -4203,7 +4141,7 @@ static int php_date_interval_initialize_from_hash(zval **return_value, php_inter
 	(*intobj)->initialized = 1;
 
 	return 0;
-}
+} /* }}} */
 
 /* {{{ proto DateInterval::__set_state()
 */
@@ -4220,7 +4158,7 @@ PHP_METHOD(DateInterval, __set_state)
 	myht = HASH_OF(array);
 
 	php_date_instantiate(date_ce_interval, return_value TSRMLS_CC);
-	intobj = (php_interval_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
+	intobj = Z_PHPINTERVAL_P(return_value);
 	php_date_interval_initialize_from_hash(&return_value, &intobj, myht TSRMLS_CC);
 }
 /* }}} */
@@ -4233,13 +4171,14 @@ PHP_METHOD(DateInterval, __wakeup)
 	php_interval_obj *intobj;
 	HashTable        *myht;
 
-	intobj = (php_interval_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	intobj = Z_PHPINTERVAL_P(object);
 
 	myht = Z_OBJPROP_P(object);
 
 	php_date_interval_initialize_from_hash(&return_value, &intobj, myht TSRMLS_CC);
 }
 /* }}} */
+
 /* {{{ proto DateInterval date_interval_create_from_date_string(string time)
    Uses the normal date parsers and sets up a DateInterval from the relative parts of the parsed string
 */
@@ -4258,7 +4197,7 @@ PHP_FUNCTION(date_interval_create_from_date_string)
 	php_date_instantiate(date_ce_interval, return_value TSRMLS_CC);
 
 	time = timelib_strtotime(time_str, time_str_len, &err, DATE_TIMEZONEDB, php_date_parse_tzfile_wrapper);
-	diobj = (php_interval_obj *) zend_object_store_get_object(return_value TSRMLS_CC);
+	diobj = Z_PHPINTERVAL_P(return_value);
 	diobj->diff = timelib_rel_time_clone(&time->relative);
 	diobj->initialized = 1;
 	timelib_time_dtor(time);
@@ -4267,14 +4206,14 @@ PHP_FUNCTION(date_interval_create_from_date_string)
 /* }}} */
 
 /* {{{ date_interval_format -  */
-static char *date_interval_format(char *format, int format_len, timelib_rel_time *t)
+static zend_string *date_interval_format(char *format, int format_len, timelib_rel_time *t TSRMLS_DC)
 {
 	smart_str            string = {0};
 	int                  i, length, have_format_spec = 0;
 	char                 buffer[33];
 
 	if (!format_len) {
-		return estrdup("");
+		return STR_EMPTY_ALLOC();
 	}
 
 	for (i = 0; i < format_len; i++) {
@@ -4324,7 +4263,7 @@ static char *date_interval_format(char *format, int format_len, timelib_rel_time
 
 	smart_str_0(&string);
 
-	return string.c;
+	return string.s;
 }
 /* }}} */
 
@@ -4341,14 +4280,14 @@ PHP_FUNCTION(date_interval_format)
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Os", &object, date_ce_interval, &format, &format_len) == FAILURE) {
 		RETURN_FALSE;
 	}
-	diobj = (php_interval_obj *) zend_object_store_get_object(object TSRMLS_CC);
+	diobj = Z_PHPINTERVAL_P(object);
 	DATE_CHECK_INITIALIZED(diobj->initialized, DateInterval);
 
-	RETURN_STRING(date_interval_format(format, format_len, diobj->diff), 0);
+	RETURN_STR(date_interval_format(format, format_len, diobj->diff TSRMLS_CC));
 }
 /* }}} */
 
-static int date_period_initialize(timelib_time **st, timelib_time **et, timelib_rel_time **d, long *recurrences, /*const*/ char *format, int format_length TSRMLS_DC)
+static int date_period_initialize(timelib_time **st, timelib_time **et, timelib_rel_time **d, long *recurrences, /*const*/ char *format, int format_length TSRMLS_DC) /* {{{ */
 {
 	timelib_time     *b = NULL, *e = NULL;
 	timelib_rel_time *p = NULL;
@@ -4370,7 +4309,7 @@ static int date_period_initialize(timelib_time **st, timelib_time **et, timelib_
 	}
 	timelib_error_container_dtor(errors);
 	return retval;
-}
+} /* }}} */
 
 /* {{{ proto DatePeriod::__construct(DateTime $start, DateInterval $interval, int recurrences|DateTime $end)
    Creates new DatePeriod object.
@@ -4398,7 +4337,7 @@ PHP_METHOD(DatePeriod, __construct)
 		}
 	}
 
-	dpobj = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dpobj = Z_PHPPERIOD_P(getThis());
 	dpobj->current = NULL;
 
 	if (isostr) {
@@ -4422,10 +4361,10 @@ PHP_METHOD(DatePeriod, __construct)
 		dpobj->start_ce = date_ce_date;
 	} else {
 		/* init */
-		intobj  = (php_interval_obj *) zend_object_store_get_object(interval TSRMLS_CC);
+		intobj  = Z_PHPINTERVAL_P(interval);
 
 		/* start date */
-		dateobj = (php_date_obj *) zend_object_store_get_object(start TSRMLS_CC);
+		dateobj = Z_PHPDATE_P(start);
 		clone = timelib_time_ctor();
 		memcpy(clone, dateobj->time, sizeof(timelib_time));
 		if (dateobj->time->tz_abbr) {
@@ -4442,7 +4381,7 @@ PHP_METHOD(DatePeriod, __construct)
 
 		/* end date */
 		if (end) {
-			dateobj = (php_date_obj *) zend_object_store_get_object(end TSRMLS_CC);
+			dateobj = Z_PHPDATE_P(end);
 			clone = timelib_time_clone(dateobj->time);
 			dpobj->end = clone;
 		}
@@ -4460,7 +4399,7 @@ PHP_METHOD(DatePeriod, __construct)
 }
 /* }}} */
 
-static int check_id_allowed(char *id, long what)
+static int check_id_allowed(char *id, long what) /* {{{ */
 {
 	if (what & PHP_DATE_TIMEZONE_GROUP_AFRICA     && strncasecmp(id, "Africa/",      7) == 0) return 1;
 	if (what & PHP_DATE_TIMEZONE_GROUP_AMERICA    && strncasecmp(id, "America/",     8) == 0) return 1;
@@ -4474,7 +4413,7 @@ static int check_id_allowed(char *id, long what)
 	if (what & PHP_DATE_TIMEZONE_GROUP_PACIFIC    && strncasecmp(id, "Pacific/",     8) == 0) return 1;
 	if (what & PHP_DATE_TIMEZONE_GROUP_UTC        && strncasecmp(id, "UTC",          3) == 0) return 1;
 	return 0;
-}
+} /* }}} */
 
 /* {{{ proto array timezone_identifiers_list([long what[, string country]])
    Returns numerically index array with all timezone identifiers.
@@ -4507,10 +4446,10 @@ PHP_FUNCTION(timezone_identifiers_list)
 	for (i = 0; i < item_count; ++i) {
 		if (what == PHP_DATE_TIMEZONE_PER_COUNTRY) {
 			if (tzdb->data[table[i].pos + 5] == option[0] && tzdb->data[table[i].pos + 6] == option[1]) {
-				add_next_index_string(return_value, table[i].id, 1);
+				add_next_index_string(return_value, table[i].id);
 			}
 		} else if (what == PHP_DATE_TIMEZONE_GROUP_ALL_W_BC || (check_id_allowed(table[i].id, what) && (tzdb->data[table[i].pos + 4] == '\1'))) {
-			add_next_index_string(return_value, table[i].id, 1);
+			add_next_index_string(return_value, table[i].id);
 		}
 	};
 }
@@ -4524,7 +4463,7 @@ PHP_FUNCTION(timezone_version_get)
 	const timelib_tzdb *tzdb;
 
 	tzdb = DATE_TIMEZONEDB;
-	RETURN_STRING(tzdb->version, 1);
+	RETURN_STRING(tzdb->version);
 }
 /* }}} */
 
@@ -4534,31 +4473,30 @@ PHP_FUNCTION(timezone_version_get)
 PHP_FUNCTION(timezone_abbreviations_list)
 {
 	const timelib_tz_lookup_table *table, *entry;
-	zval                          *element, **abbr_array_pp, *abbr_array;
+	zval                          element, *abbr_array_p, abbr_array;
 	
 	table = timelib_timezone_abbreviations_list();
 	array_init(return_value);
 	entry = table;
 
 	do {
-		MAKE_STD_ZVAL(element);
-		array_init(element);
-		add_assoc_bool(element, "dst", entry->type);
-		add_assoc_long(element, "offset", entry->gmtoffset);
+		array_init(&element);
+		add_assoc_bool(&element, "dst", entry->type);
+		add_assoc_long(&element, "offset", entry->gmtoffset);
 		if (entry->full_tz_name) {
-			add_assoc_string(element, "timezone_id", entry->full_tz_name, 1);
+			add_assoc_string(&element, "timezone_id", entry->full_tz_name);
 		} else {
-			add_assoc_null(element, "timezone_id");
+			add_assoc_null(&element, "timezone_id");
 		}
 
-		if (zend_hash_find(HASH_OF(return_value), entry->name, strlen(entry->name) + 1, (void **) &abbr_array_pp) == FAILURE) {
-			MAKE_STD_ZVAL(abbr_array);
-			array_init(abbr_array);
-			add_assoc_zval(return_value, entry->name, abbr_array);
+		abbr_array_p = zend_hash_str_find(HASH_OF(return_value), entry->name, strlen(entry->name));
+		if (!abbr_array_p) {
+			array_init(&abbr_array);
+			add_assoc_zval(return_value, entry->name, &abbr_array);
 		} else {
-			abbr_array = *abbr_array_pp;
+			ZVAL_COPY_VALUE(&abbr_array, abbr_array_p);
 		}
-		add_next_index_zval(abbr_array, element);
+		add_next_index_zval(&abbr_array, &element);
 		entry++;
 	} while (entry->name);
 }
@@ -4594,7 +4532,7 @@ PHP_FUNCTION(date_default_timezone_get)
 	timelib_tzinfo *default_tz;
 
 	default_tz = get_timezone_info(TSRMLS_C);
-	RETVAL_STRING(default_tz->name, 1);
+	RETVAL_STRING(default_tz->name);
 }
 /* }}} */
 
@@ -4676,7 +4614,10 @@ static void php_do_date_sunrise_sunset(INTERNAL_FUNCTION_PARAMETERS, int calc_su
 	switch (retformat) {
 		case SUNFUNCS_RET_STRING:
 			spprintf(&retstr, 0, "%02d:%02d", (int) N, (int) (60 * (N - (int) N)));
-			RETURN_STRINGL(retstr, 5, 0);
+			// TODO: avoid reallocation ???
+			RETVAL_STRINGL(retstr, 5);
+			efree(retstr);
+			return;
 			break;
 		case SUNFUNCS_RET_DOUBLE:
 			RETURN_DOUBLE(N);
@@ -4806,20 +4747,20 @@ PHP_FUNCTION(date_sun_info)
 }
 /* }}} */
 
-static HashTable *date_object_get_gc_period(zval *object, zval ***table, int *n TSRMLS_DC)
+static HashTable *date_object_get_gc_period(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
 	*table = NULL;
 	*n = 0;
 	return zend_std_get_properties(object TSRMLS_CC);
-}
+} /* }}} */
 
-static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC)
+static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC) /* {{{ */
 {
 	HashTable		*props;
-	zval			*zv;
+	zval			 zv;
 	php_period_obj	*period_obj;
 
-	period_obj = zend_object_store_get_object(object TSRMLS_CC);
+	period_obj = Z_PHPPERIOD_P(object);
 
 	props = zend_std_get_properties(object TSRMLS_CC);
 
@@ -4827,110 +4768,108 @@ static HashTable *date_object_get_properties_period(zval *object TSRMLS_DC)
 		return props;
 	}
 
-	MAKE_STD_ZVAL(zv);
 	if (period_obj->start) {
 		php_date_obj *date_obj;
-		object_init_ex(zv, date_ce_date);
-		date_obj = zend_object_store_get_object(zv TSRMLS_CC);
+		object_init_ex(&zv, date_ce_date);
+		date_obj = Z_PHPDATE_P(&zv);
 		date_obj->time = timelib_time_clone(period_obj->start);
 	} else {
-		ZVAL_NULL(zv);
+		ZVAL_NULL(&zv);
 	}
-	zend_hash_update(props, "start", sizeof("start"), &zv, sizeof(zv), NULL);
+	zend_hash_str_update(props, "start", sizeof("start")-1, &zv);
 
-	MAKE_STD_ZVAL(zv);
 	if (period_obj->current) {
 		php_date_obj *date_obj;
-		object_init_ex(zv, date_ce_date);
-		date_obj = zend_object_store_get_object(zv TSRMLS_CC);
+		object_init_ex(&zv, date_ce_date);
+		date_obj = Z_PHPDATE_P(&zv);
 		date_obj->time = timelib_time_clone(period_obj->current);
 	} else {
-		ZVAL_NULL(zv);
+		ZVAL_NULL(&zv);
 	}
-	zend_hash_update(props, "current", sizeof("current"), &zv, sizeof(zv), NULL);
+	zend_hash_str_update(props, "current", sizeof("current")-1, &zv);
 
-	MAKE_STD_ZVAL(zv);
 	if (period_obj->end) {
 		php_date_obj *date_obj;
-		object_init_ex(zv, date_ce_date);
-		date_obj = zend_object_store_get_object(zv TSRMLS_CC);
+		object_init_ex(&zv, date_ce_date);
+		date_obj = Z_PHPDATE_P(&zv);
 		date_obj->time = timelib_time_clone(period_obj->end);
 	} else {
-		ZVAL_NULL(zv);
+		ZVAL_NULL(&zv);
 	}
-	zend_hash_update(props, "end", sizeof("end"), &zv, sizeof(zv), NULL);
+	zend_hash_str_update(props, "end", sizeof("end")-1, &zv);
 
-	MAKE_STD_ZVAL(zv);
 	if (period_obj->interval) {
 		php_interval_obj *interval_obj;
-		object_init_ex(zv, date_ce_interval);
-		interval_obj = zend_object_store_get_object(zv TSRMLS_CC);
+		object_init_ex(&zv, date_ce_interval);
+		interval_obj = Z_PHPINTERVAL_P(&zv);
 		interval_obj->diff = timelib_rel_time_clone(period_obj->interval);
 		interval_obj->initialized = 1;
 	} else {
-		ZVAL_NULL(zv);
+		ZVAL_NULL(&zv);
 	}
-	zend_hash_update(props, "interval", sizeof("interval"), &zv, sizeof(zv), NULL);
+	zend_hash_str_update(props, "interval", sizeof("interval")-1, &zv);
 	
 	/* converted to larger type (int->long); must check when unserializing */
-	MAKE_STD_ZVAL(zv);
-	ZVAL_LONG(zv, (long) period_obj->recurrences);
-	zend_hash_update(props, "recurrences", sizeof("recurrences"), &zv, sizeof(zv), NULL);
+	ZVAL_LONG(&zv, (long) period_obj->recurrences);
+	zend_hash_str_update(props, "recurrences", sizeof("recurrences")-1, &zv);
 
-	MAKE_STD_ZVAL(zv);
-	ZVAL_BOOL(zv, period_obj->include_start_date);
-	zend_hash_update(props, "include_start_date", sizeof("include_start_date"), &zv, sizeof(zv), NULL);
+	ZVAL_BOOL(&zv, period_obj->include_start_date);
+	zend_hash_str_update(props, "include_start_date", sizeof("include_start_date")-1, &zv);
 
 	return props;
-}
+} /* }}} */
 
-static int php_date_period_initialize_from_hash(php_period_obj *period_obj, HashTable *myht TSRMLS_DC)
+static int php_date_period_initialize_from_hash(php_period_obj *period_obj, HashTable *myht TSRMLS_DC) /* {{{ */
 {
-	zval **ht_entry;
+	zval *ht_entry;
 
 	/* this function does no rollback on error */
 
-	if (zend_hash_find(myht, "start", sizeof("start"), (void**) &ht_entry) == SUCCESS) {
-		if (Z_TYPE_PP(ht_entry) == IS_OBJECT && Z_OBJCE_PP(ht_entry) == date_ce_date) {
+	ht_entry = zend_hash_str_find(myht, "start", sizeof("start")-1);
+	if (ht_entry) {
+		if (Z_TYPE_P(ht_entry) == IS_OBJECT && Z_OBJCE_P(ht_entry) == date_ce_date) {
 			php_date_obj *date_obj;
-			date_obj = zend_object_store_get_object(*ht_entry TSRMLS_CC);
+			date_obj = Z_PHPDATE_P(ht_entry);
 			period_obj->start = timelib_time_clone(date_obj->time);
-			period_obj->start_ce = Z_OBJCE_PP(ht_entry);
-		} else if (Z_TYPE_PP(ht_entry) != IS_NULL) {
+			period_obj->start_ce = Z_OBJCE_P(ht_entry);
+		} else if (Z_TYPE_P(ht_entry) != IS_NULL) {
 			return 0;
 		}
 	} else {
 		return 0;
 	}
 
-	if (zend_hash_find(myht, "end", sizeof("end"), (void**) &ht_entry) == SUCCESS) {
-		if (Z_TYPE_PP(ht_entry) == IS_OBJECT && Z_OBJCE_PP(ht_entry) == date_ce_date) {
+	ht_entry = zend_hash_str_find(myht, "end", sizeof("end")-1);
+	if (ht_entry) {
+		if (Z_TYPE_P(ht_entry) == IS_OBJECT && Z_OBJCE_P(ht_entry) == date_ce_date) {
 			php_date_obj *date_obj;
-			date_obj = zend_object_store_get_object(*ht_entry TSRMLS_CC);
+			date_obj = Z_PHPDATE_P(ht_entry);
 			period_obj->end = timelib_time_clone(date_obj->time);
-		} else if (Z_TYPE_PP(ht_entry) != IS_NULL) {
+		} else if (Z_TYPE_P(ht_entry) != IS_NULL) {
 			return 0;
 		}
 	} else {
 		return 0;
 	}
 
-	if (zend_hash_find(myht, "current", sizeof("current"), (void**) &ht_entry) == SUCCESS) {
-		if (Z_TYPE_PP(ht_entry) == IS_OBJECT && Z_OBJCE_PP(ht_entry) == date_ce_date) {
+	ht_entry = zend_hash_str_find(myht, "current", sizeof("current")-1);
+	if (ht_entry) {
+		if (Z_TYPE_P(ht_entry) == IS_OBJECT && Z_OBJCE_P(ht_entry) == date_ce_date) {
 			php_date_obj *date_obj;
-			date_obj = zend_object_store_get_object(*ht_entry TSRMLS_CC);
+			date_obj = Z_PHPDATE_P(ht_entry);
 			period_obj->current = timelib_time_clone(date_obj->time);
-		} else if (Z_TYPE_PP(ht_entry) != IS_NULL)  {
+		} else if (Z_TYPE_P(ht_entry) != IS_NULL)  {
 			return 0;
 		}
 	} else {
 		return 0;
 	}
 
-	if (zend_hash_find(myht, "interval", sizeof("interval"), (void**) &ht_entry) == SUCCESS) {
-		if (Z_TYPE_PP(ht_entry) == IS_OBJECT && Z_OBJCE_PP(ht_entry) == date_ce_interval) {
+	ht_entry = zend_hash_str_find(myht, "interval", sizeof("interval")-1);
+	if (ht_entry) {
+		if (Z_TYPE_P(ht_entry) == IS_OBJECT && Z_OBJCE_P(ht_entry) == date_ce_interval) {
 			php_interval_obj *interval_obj;
-			interval_obj = zend_object_store_get_object(*ht_entry TSRMLS_CC);
+			interval_obj = Z_PHPINTERVAL_P(ht_entry);
 			period_obj->interval = timelib_rel_time_clone(interval_obj->diff);
 		} else { /* interval is required */
 			return 0;
@@ -4939,16 +4878,18 @@ static int php_date_period_initialize_from_hash(php_period_obj *period_obj, Hash
 		return 0;
 	}
 
-	if (zend_hash_find(myht, "recurrences", sizeof("recurrences"), (void**) &ht_entry) == SUCCESS &&
-			Z_TYPE_PP(ht_entry) == IS_LONG && Z_LVAL_PP(ht_entry) >= 0 && Z_LVAL_PP(ht_entry) <= INT_MAX) {
-		period_obj->recurrences = Z_LVAL_PP(ht_entry);
+	ht_entry = zend_hash_str_find(myht, "recurrences", sizeof("recurrences")-1);
+	if (ht_entry &&
+			Z_TYPE_P(ht_entry) == IS_LONG && Z_LVAL_P(ht_entry) >= 0 && Z_LVAL_P(ht_entry) <= INT_MAX) {
+		period_obj->recurrences = Z_LVAL_P(ht_entry);
 	} else {
 		return 0;
 	}
 
-	if (zend_hash_find(myht, "include_start_date", sizeof("include_start_date"), (void**) &ht_entry) == SUCCESS &&
-			Z_TYPE_PP(ht_entry) == IS_BOOL) {
-		period_obj->include_start_date = Z_BVAL_PP(ht_entry);
+	ht_entry = zend_hash_str_find(myht, "include_start_date", sizeof("include_start_date")-1);
+	if (ht_entry &&
+			Z_TYPE_P(ht_entry) == IS_BOOL) {
+		period_obj->include_start_date = Z_BVAL_P(ht_entry);
 	} else {
 		return 0;
 	}
@@ -4956,7 +4897,7 @@ static int php_date_period_initialize_from_hash(php_period_obj *period_obj, Hash
 	period_obj->initialized = 1;
 	
 	return 1;
-}
+} /* }}} */
 
 /* {{{ proto DatePeriod::__set_state()
 */
@@ -4973,7 +4914,7 @@ PHP_METHOD(DatePeriod, __set_state)
 	myht = Z_ARRVAL_P(array);
 	
 	object_init_ex(return_value, date_ce_period);
-	period_obj = zend_object_store_get_object(return_value TSRMLS_CC);
+	period_obj = Z_PHPPERIOD_P(return_value);
 	if (!php_date_period_initialize_from_hash(period_obj, myht TSRMLS_CC)) {
 		php_error(E_ERROR, "Invalid serialization data for DatePeriod object");
 	}
@@ -4988,7 +4929,7 @@ PHP_METHOD(DatePeriod, __wakeup)
 	php_period_obj   *period_obj;
 	HashTable        *myht;
 
-	period_obj = zend_object_store_get_object(object TSRMLS_CC);
+	period_obj = Z_PHPPERIOD_P(object);
 
 	myht = Z_OBJPROP_P(object);
 
@@ -4999,7 +4940,7 @@ PHP_METHOD(DatePeriod, __wakeup)
 /* }}} */
 
 /* {{{ date_period_read_property */
-static zval *date_period_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
+static zval *date_period_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
 	zval *zv;
 	if (type != BP_VAR_IS && type != BP_VAR_R) {
@@ -5008,13 +4949,10 @@ static zval *date_period_read_property(zval *object, zval *member, int type, con
 
 	Z_OBJPROP_P(object); /* build properties hash table */
 
-	zv = std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
+	zv = std_object_handlers.read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 	if (Z_TYPE_P(zv) == IS_OBJECT && Z_OBJ_HANDLER_P(zv, clone_obj)) {
 		/* defensive copy */
-		zend_object_value zov = Z_OBJ_HANDLER_P(zv, clone_obj)(zv TSRMLS_CC);
-		MAKE_STD_ZVAL(zv);
-		Z_TYPE_P(zv) = IS_OBJECT;
-		Z_OBJVAL_P(zv) = zov;
+		ZVAL_OBJ(zv, Z_OBJ_HANDLER_P(zv, clone_obj)(zv TSRMLS_CC));
 	}
 
 	return zv;
@@ -5022,13 +4960,12 @@ static zval *date_period_read_property(zval *object, zval *member, int type, con
 /* }}} */
 
 /* {{{ date_period_write_property */
-static void date_period_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void date_period_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
 	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Writing to DatePeriod properties is unsupported");
 }
 /* }}} */
 
-
 /*
  * Local variables:
  * tab-width: 4
diff --git a/ext/date/php_date.h b/ext/date/php_date.h
index 2b3ae4dcc1..ff26c0fba3 100644
--- a/ext/date/php_date.h
+++ b/ext/date/php_date.h
@@ -128,13 +128,18 @@ typedef struct _php_interval_obj php_interval_obj;
 typedef struct _php_period_obj php_period_obj;
 
 struct _php_date_obj {
-	zend_object   std;
 	timelib_time *time;
 	HashTable    *props;
+	zend_object   std;
 };
 
+static inline php_date_obj *php_date_obj_from_obj(zend_object *obj) {
+	return (php_date_obj*)((char*)(obj) - XtOffsetOf(php_date_obj, std));
+}
+
+#define Z_PHPDATE_P(zv)  php_date_obj_from_obj(Z_OBJ_P((zv)))
+
 struct _php_timezone_obj {
-	zend_object     std;
 	int             initialized;
 	int             type;
 	union {
@@ -143,17 +148,29 @@ struct _php_timezone_obj {
 		timelib_abbr_info z;          /* TIMELIB_ZONETYPE_ABBR */
 	} tzi;
 	HashTable *props;
+	zend_object std;
 };
 
+static inline php_timezone_obj *php_timezone_obj_from_obj(zend_object *obj) {
+	return (php_timezone_obj*)((char*)(obj) - XtOffsetOf(php_timezone_obj, std));
+}
+
+#define Z_PHPTIMEZONE_P(zv)  php_timezone_obj_from_obj(Z_OBJ_P((zv)))
+
 struct _php_interval_obj {
-	zend_object       std;
 	timelib_rel_time *diff;
 	HashTable        *props;
 	int               initialized;
+	zend_object       std;
 };
 
+static inline php_interval_obj *php_interval_obj_from_obj(zend_object *obj) {
+	return (php_interval_obj*)((char*)(obj) - XtOffsetOf(php_interval_obj, std));
+}
+
+#define Z_PHPINTERVAL_P(zv)  php_interval_obj_from_obj(Z_OBJ_P((zv)))
+
 struct _php_period_obj {
-	zend_object       std;
 	timelib_time     *start;
 	zend_class_entry *start_ce;
 	timelib_time     *current;
@@ -162,8 +179,15 @@ struct _php_period_obj {
 	int               recurrences;
 	int               initialized;
 	int               include_start_date;
+	zend_object       std;
 };
 
+static inline php_period_obj *php_period_obj_from_obj(zend_object *obj) {
+	return (php_period_obj*)((char*)(obj) - XtOffsetOf(php_period_obj, std));
+}
+
+#define Z_PHPPERIOD_P(zv)  php_period_obj_from_obj(Z_OBJ_P((zv)))
+
 ZEND_BEGIN_MODULE_GLOBALS(date)
 	char                    *default_timezone;
 	char                    *timezone;
@@ -186,7 +210,7 @@ PHPAPI int php_idate(char format, time_t ts, int localtime TSRMLS_DC);
 #define _php_strftime php_strftime
 PHPAPI void php_strftime(INTERNAL_FUNCTION_PARAMETERS, int gm);
 #endif
-PHPAPI char *php_format_date(char *format, int format_len, time_t ts, int localtime TSRMLS_DC);
+PHPAPI zend_string *php_format_date(char *format, int format_len, time_t ts, int localtime TSRMLS_DC);
 
 /* Mechanism to set new TZ database */
 PHPAPI void php_date_set_tzdb(timelib_tzdb *tzdb);
diff --git a/ext/date/tests/DateTimeZone_verify.phpt b/ext/date/tests/DateTimeZone_verify.phpt
index 241d91e665..f28742d26a 100644
--- a/ext/date/tests/DateTimeZone_verify.phpt
+++ b/ext/date/tests/DateTimeZone_verify.phpt
@@ -28,63 +28,63 @@ object(ReflectionClass)#%d (1) {
 ..and get names of all its methods
 array(9) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "__construct"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(8) "__wakeup"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [2]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "__set_state"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [3]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "getName"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [4]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(9) "getOffset"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [5]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(14) "getTransitions"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [6]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "getLocation"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [7]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(17) "listAbbreviations"
     ["class"]=>
     string(12) "DateTimeZone"
   }
   [8]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(15) "listIdentifiers"
     ["class"]=>
diff --git a/ext/date/tests/DateTime_verify.phpt b/ext/date/tests/DateTime_verify.phpt
index c790974729..95aa37a526 100644
--- a/ext/date/tests/DateTime_verify.phpt
+++ b/ext/date/tests/DateTime_verify.phpt
@@ -29,126 +29,126 @@ object(ReflectionClass)#%d (1) {
 ..and get names of all its methods
 array(18) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "__construct"
     ["class"]=>
     string(8) "DateTime"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(8) "__wakeup"
     ["class"]=>
     string(8) "DateTime"
   }
   [2]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "__set_state"
     ["class"]=>
     string(8) "DateTime"
   }
   [3]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(16) "createFromFormat"
     ["class"]=>
     string(8) "DateTime"
   }
   [4]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(13) "getLastErrors"
     ["class"]=>
     string(8) "DateTime"
   }
   [5]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "format"
     ["class"]=>
     string(8) "DateTime"
   }
   [6]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "modify"
     ["class"]=>
     string(8) "DateTime"
   }
   [7]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(3) "add"
     ["class"]=>
     string(8) "DateTime"
   }
   [8]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(3) "sub"
     ["class"]=>
     string(8) "DateTime"
   }
   [9]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "getTimezone"
     ["class"]=>
     string(8) "DateTime"
   }
   [10]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(11) "setTimezone"
     ["class"]=>
     string(8) "DateTime"
   }
   [11]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(9) "getOffset"
     ["class"]=>
     string(8) "DateTime"
   }
   [12]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "setTime"
     ["class"]=>
     string(8) "DateTime"
   }
   [13]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "setDate"
     ["class"]=>
     string(8) "DateTime"
   }
   [14]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(10) "setISODate"
     ["class"]=>
     string(8) "DateTime"
   }
   [15]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(12) "setTimestamp"
     ["class"]=>
     string(8) "DateTime"
   }
   [16]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(12) "getTimestamp"
     ["class"]=>
     string(8) "DateTime"
   }
   [17]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(4) "diff"
     ["class"]=>
diff --git a/ext/date/tests/bug51866.phpt b/ext/date/tests/bug51866.phpt
index 8d765b02f0..01ca555fd9 100644
--- a/ext/date/tests/bug51866.phpt
+++ b/ext/date/tests/bug51866.phpt
@@ -44,7 +44,7 @@ array(4) {
 
 string(6) "Y-m-d+"
 string(19) "2001-11-29 13:20:01"
-object(DateTime)#2 (3) {
+object(DateTime)#%d (3) {
   ["date"]=>
   string(19) "2001-11-29 %d:%d:%d"
   ["timezone_type"]=>
@@ -70,7 +70,7 @@ array(4) {
 
 string(7) "Y-m-d +"
 string(19) "2001-11-29 13:20:01"
-object(DateTime)#3 (3) {
+object(DateTime)#%d (3) {
   ["date"]=>
   string(19) "2001-11-29 %d:%d:%d"
   ["timezone_type"]=>
@@ -96,7 +96,7 @@ array(4) {
 
 string(6) "Y-m-d+"
 string(10) "2001-11-29"
-object(DateTime)#2 (3) {
+object(DateTime)#%d (3) {
   ["date"]=>
   string(19) "2001-11-29 %d:%d:%d"
   ["timezone_type"]=>
@@ -139,7 +139,7 @@ array(4) {
 
 string(7) "Y-m-d +"
 string(11) "2001-11-29 "
-object(DateTime)#2 (3) {
+object(DateTime)#%d (3) {
   ["date"]=>
   string(19) "2001-11-29 %d:%d:%d"
   ["timezone_type"]=>
diff --git a/ext/dba/dba.c b/ext/dba/dba.c
index 3bb45aa561..66a6bee479 100644
--- a/ext/dba/dba.c
+++ b/ext/dba/dba.c
@@ -1062,11 +1062,11 @@ PHP_FUNCTION(dba_key_split)
 	}
 	array_init(return_value);
 	if (key[0] == '[' && (name = strchr(key, ']')) != NULL) {
-		add_next_index_stringl(return_value, key+1, name - (key + 1), 1);
-		add_next_index_stringl(return_value, name+1, key_len - (name - key + 1), 1);
+		add_next_index_stringl(return_value, key+1, name - (key + 1));
+		add_next_index_stringl(return_value, name+1, key_len - (name - key + 1));
 	} else {
-		add_next_index_stringl(return_value, "", 0, 1);
-		add_next_index_stringl(return_value, key, key_len, 1);
+		add_next_index_stringl(return_value, "", 0);
+		add_next_index_stringl(return_value, key, key_len);
 	}
 }
 /* }}} */
@@ -1215,9 +1215,12 @@ PHP_FUNCTION(dba_handlers)
 
 	for(hptr = handler; hptr->name; hptr++) {
 		if (full_info) {
-			add_assoc_string(return_value, hptr->name, hptr->info(hptr, NULL TSRMLS_CC), 0);
+			// TODO: avoid reallocation ???
+			char *str = hptr->info(hptr, NULL TSRMLS_CC);
+			add_assoc_string(return_value, hptr->name, str);
+			efree(str);
 		} else {
-			add_next_index_string(return_value, hptr->name, 1);
+			add_next_index_string(return_value, hptr->name);
 		}
  	}
 }
@@ -1244,7 +1247,7 @@ PHP_FUNCTION(dba_list)
 		}
 		if (Z_TYPE_P(le) == le_db || Z_TYPE_P(le) == le_pdb) {
 			info = (dba_info *)(le->ptr);
-			add_index_string(return_value, i, info->path, 1);
+			add_index_string(return_value, i, info->path);
 		}
 	}
 }
diff --git a/ext/dom/attr.c b/ext/dom/attr.c
index ebbc41f6f5..b0489ef122 100644
--- a/ext/dom/attr.c
+++ b/ext/dom/attr.c
@@ -55,7 +55,6 @@ const zend_function_entry php_dom_attr_class_functions[] = {
 /* {{{ proto void DOMAttr::__construct(string name, [string value]); */
 PHP_METHOD(domattr, __construct)
 {
-
 	zval *id;
 	xmlAttrPtr nodep = NULL;
 	xmlNodePtr oldnode = NULL;
@@ -71,7 +70,7 @@ PHP_METHOD(domattr, __construct)
 	}
 
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 
 	name_valid = xmlValidateName((xmlChar *) name, 0);
 	if (name_valid != 0) {
@@ -86,13 +85,11 @@ PHP_METHOD(domattr, __construct)
 		RETURN_FALSE;
 	}
 
-	if (intern != NULL) {
-		oldnode = dom_object_get_node(intern);
-		if (oldnode != NULL) {
-			php_libxml_node_free_resource(oldnode  TSRMLS_CC);
-		}
-		php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)nodep, (void *)intern TSRMLS_CC);
+	oldnode = dom_object_get_node(intern);
+	if (oldnode != NULL) {
+		php_libxml_node_free_resource(oldnode  TSRMLS_CC);
 	}
+	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, (xmlNodePtr)nodep, (void *)intern TSRMLS_CC);
 }
 
 /* }}} end DOMAttr::__construct */
@@ -102,7 +99,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-1112119403
 Since: 
 */
-int dom_attr_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_attr_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlAttrPtr attrp;
 
@@ -113,8 +110,7 @@ int dom_attr_name_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, (char *) (attrp->name), 1);
+	ZVAL_STRING(retval, (char *) attrp->name);
 
 	return SUCCESS;
 }
@@ -126,11 +122,10 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-862529273
 Since: 
 */
-int dom_attr_specified_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_attr_specified_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	/* TODO */
-	ALLOC_ZVAL(*retval);
-	ZVAL_TRUE(*retval);
+	ZVAL_TRUE(retval);
 	return SUCCESS;
 }
 
@@ -141,26 +136,21 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-221662474
 Since: 
 */
-int dom_attr_value_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_attr_value_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlAttrPtr attrp;
+	xmlAttrPtr attrp = (xmlAttrPtr) dom_object_get_node(obj);
 	xmlChar *content;
 
-	attrp = (xmlAttrPtr) dom_object_get_node(obj);
-
 	if (attrp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	
 	if ((content = xmlNodeGetContent((xmlNodePtr) attrp)) != NULL) {
-		ZVAL_STRING(*retval, content, 1);
+		ZVAL_STRING(retval, content);
 		xmlFree(content);
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
@@ -169,10 +159,8 @@ int dom_attr_value_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 int dom_attr_value_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlAttrPtr attrp;
-
-	attrp = (xmlAttrPtr) dom_object_get_node(obj);
+	zend_string *str;
+	xmlAttrPtr attrp = (xmlAttrPtr) dom_object_get_node(obj);
 
 	if (attrp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
@@ -183,21 +171,11 @@ int dom_attr_value_write(dom_object *obj, zval *newval TSRMLS_DC)
 		node_list_unlink(attrp->children TSRMLS_CC);
 	}
 
-	if (newval->type != IS_STRING) {
-		if(Z_REFCOUNT_P(newval) > 1) {
-			value_copy = *newval;
-			zval_copy_ctor(&value_copy);
-			newval = &value_copy;
-		}
-		convert_to_string(newval);
-	}
-
-	xmlNodeSetContentLen((xmlNodePtr) attrp, Z_STRVAL_P(newval), Z_STRLEN_P(newval) + 1);
+	str = zval_get_string(newval);
 
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
+	xmlNodeSetContentLen((xmlNodePtr) attrp, str->val, str->len + 1);
 
+	STR_RELEASE(str);
 	return SUCCESS;
 }
 
@@ -208,10 +186,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Attr-ownerElement
 Since: DOM Level 2
 */
-int dom_attr_owner_element_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_attr_owner_element_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNodePtr nodep, nodeparent;
-	int ret;
 
 	nodep = dom_object_get_node(obj);
 
@@ -220,18 +197,13 @@ int dom_attr_owner_element_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	nodeparent = nodep->parent;
 	if (!nodeparent) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object(nodeparent, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING,  "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(nodeparent, retval, obj TSRMLS_CC);
 	return SUCCESS;
 
 }
@@ -243,11 +215,10 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Attr-schemaTypeInfo
 Since: DOM Level 3
 */
-int dom_attr_schema_type_info_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_attr_schema_type_info_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not yet implemented");
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
diff --git a/ext/dom/cdatasection.c b/ext/dom/cdatasection.c
index 6ca1ffcf0c..a2f0589464 100644
--- a/ext/dom/cdatasection.c
+++ b/ext/dom/cdatasection.c
@@ -71,14 +71,12 @@ PHP_METHOD(domcdatasection, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
-	if (intern != NULL) {
-		oldnode = dom_object_get_node(intern);
-		if (oldnode != NULL) {
-			php_libxml_node_free_resource(oldnode  TSRMLS_CC);
-		}
-		php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
+	oldnode = dom_object_get_node(intern);
+	if (oldnode != NULL) {
+		php_libxml_node_free_resource(oldnode  TSRMLS_CC);
 	}
+	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
 }
 /* }}} end DOMCdataSection::__construct */
 
diff --git a/ext/dom/characterdata.c b/ext/dom/characterdata.c
index 92eb280159..2ef6352f20 100644
--- a/ext/dom/characterdata.c
+++ b/ext/dom/characterdata.c
@@ -76,25 +76,21 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-72AB8359
 Since: 
 */
-int dom_characterdata_data_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_characterdata_data_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNodePtr nodep;
+	xmlNodePtr nodep = dom_object_get_node(obj);
 	xmlChar *content;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	
 	if ((content = xmlNodeGetContent(nodep)) != NULL) {
-		ZVAL_STRING(*retval, content, 1);
+		ZVAL_STRING(retval, content);
 		xmlFree(content);
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
@@ -102,31 +98,19 @@ int dom_characterdata_data_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 int dom_characterdata_data_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlNode *nodep;
-
-	nodep = dom_object_get_node(obj);
+	xmlNode *nodep = dom_object_get_node(obj);
+	zend_string *str;
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	if (newval->type != IS_STRING) {
-		if(Z_REFCOUNT_P(newval) > 1) {
-			value_copy = *newval;
-			zval_copy_ctor(&value_copy);
-			newval = &value_copy;
-		}
-		convert_to_string(newval);
-	}
+	str = zval_get_string(newval);
 
-	xmlNodeSetContentLen(nodep, Z_STRVAL_P(newval), Z_STRLEN_P(newval) + 1);
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
+	xmlNodeSetContentLen(nodep, str->val, str->len + 1);
 
+	STR_RELEASE(str);
 	return SUCCESS;
 }
 
@@ -137,21 +121,17 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-7D61178C
 Since: 
 */
-int dom_characterdata_length_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_characterdata_length_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNodePtr nodep;
+	xmlNodePtr nodep = dom_object_get_node(obj);
 	xmlChar *content;
 	long length = 0;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	
 	content = xmlNodeGetContent(nodep);
 
 	if (content) {
@@ -159,7 +139,7 @@ int dom_characterdata_length_read(dom_object *obj, zval **retval TSRMLS_DC)
 		xmlFree(content);
 	}
 
-	ZVAL_LONG(*retval, length);
+	ZVAL_LONG(retval, length);
 
 	return SUCCESS;
 }
@@ -207,7 +187,7 @@ PHP_FUNCTION(dom_characterdata_substring_data)
 	xmlFree(cur);
 
 	if (substring) {
-		RETVAL_STRING(substring, 1);
+		RETVAL_STRING(substring);
 		xmlFree(substring);
 	} else {
 		RETVAL_EMPTY_STRING();
diff --git a/ext/dom/comment.c b/ext/dom/comment.c
index eb181ec454..0670337651 100644
--- a/ext/dom/comment.c
+++ b/ext/dom/comment.c
@@ -71,7 +71,7 @@ PHP_METHOD(domcomment, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 	if (intern != NULL) {
 		oldnode = dom_object_get_node(intern);
 		if (oldnode != NULL) {
diff --git a/ext/dom/document.c b/ext/dom/document.c
index 095f96dc09..7dd6d41671 100644
--- a/ext/dom/document.c
+++ b/ext/dom/document.c
@@ -240,33 +240,24 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-B63ED1A31
 Since: 
 */
-int dom_document_doctype_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_doctype_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
 	xmlDtdPtr dtdptr;
-	int ret;
-
-	docp = (xmlDocPtr) dom_object_get_node(obj);
 
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	dtdptr = xmlGetIntSubset(docp);
 	if (!dtdptr) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object((xmlNodePtr) dtdptr, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object((xmlNodePtr) dtdptr, retval, obj TSRMLS_CC);
 	return SUCCESS;
-	
 }
 
 /* }}} */
@@ -276,9 +267,8 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1B793EBA
 Since: 
 */
-int dom_document_implementation_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_implementation_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
 	php_dom_create_implementation(retval TSRMLS_CC);
 	return SUCCESS;
 }
@@ -290,31 +280,23 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-87CD092
 Since: 
 */
-int dom_document_document_element_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_document_element_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
 	xmlNode *root;
-	int ret;
-
-	docp = (xmlDocPtr) dom_object_get_node(obj);
 
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	root = xmlDocGetRootElement(docp);
 	if (!root) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object(root, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(root, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -324,25 +306,22 @@ int dom_document_document_element_read(dom_object *obj, zval **retval TSRMLS_DC)
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-encoding
 Since: DOM Level 3
 */
-int dom_document_encoding_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_encoding_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
 	char *encoding;
 
-	docp = (xmlDocPtr) dom_object_get_node(obj);
-
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
 	encoding = (char *) docp->encoding;
-	ALLOC_ZVAL(*retval);
 
 	if (encoding != NULL) {
-		ZVAL_STRING(*retval, encoding, 1);
+		ZVAL_STRING(retval, encoding);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -350,25 +329,16 @@ int dom_document_encoding_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 int dom_document_encoding_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
+	zend_string *str;
 	xmlCharEncodingHandlerPtr handler;
 
-	docp = (xmlDocPtr) dom_object_get_node(obj);
-
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	if (newval->type != IS_STRING) {
-		if(Z_REFCOUNT_P(newval) > 1) {
-			value_copy = *newval;
-			zval_copy_ctor(&value_copy);
-			newval = &value_copy;
-		}
-		convert_to_string(newval);
-	}
+	str = zval_get_string(newval);
 
 	handler = xmlFindCharEncodingHandler(Z_STRVAL_P(newval));
 
@@ -377,15 +347,12 @@ int dom_document_encoding_write(dom_object *obj, zval *newval TSRMLS_DC)
 		if (docp->encoding != NULL) {
 			xmlFree((xmlChar *)docp->encoding);
 		}
-		docp->encoding = xmlStrdup((const xmlChar *) Z_STRVAL_P(newval));
+		docp->encoding = xmlStrdup((const xmlChar *) str->val);
     } else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Document Encoding");
     }
 
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
-
+	STR_RELEASE(str);
 	return SUCCESS;
 }
 
@@ -396,10 +363,9 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-standalone
 Since: DOM Level 3
 */
-int dom_document_standalone_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_standalone_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlDoc *docp;
-	int standalone;
 
 	docp = (xmlDocPtr) dom_object_get_node(obj);
 
@@ -408,47 +374,22 @@ int dom_document_standalone_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	standalone = docp->standalone;
-	ZVAL_BOOL(*retval, standalone);
-
+	ZVAL_BOOL(retval, docp->standalone);
 	return SUCCESS;
 }
 
 int dom_document_standalone_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
 	int standalone;
 
-	docp = (xmlDocPtr) dom_object_get_node(obj);
-
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_long(newval);
-
-	standalone = Z_LVAL_P(newval);
-    if (standalone > 0) {
-        docp->standalone = 1;
-    }
-    else if (standalone < 0) {
-        docp->standalone = -1;
-    }
-    else {
-        docp->standalone = 0;
-    }
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
+	standalone = zval_get_long(newval TSRMLS_CC);
+	docp->standalone = ZEND_NORMALIZE_BOOL(standalone);
 
 	return SUCCESS;
 }
@@ -460,25 +401,22 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-version
 Since: DOM Level 3
 */
-int dom_document_version_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_version_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
 	char *version;
 
-	docp = (xmlDocPtr) dom_object_get_node(obj);
-
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
 	version = (char *) docp->version;
-	ALLOC_ZVAL(*retval);
 
 	if (version != NULL) {
-		ZVAL_STRING(*retval, version, 1);
+		ZVAL_STRING(retval, version);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -486,10 +424,8 @@ int dom_document_version_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 int dom_document_version_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlDoc *docp;
-
-	docp = (xmlDocPtr) dom_object_get_node(obj);
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
+	zend_string *str;
 
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
@@ -500,21 +436,11 @@ int dom_document_version_write(dom_object *obj, zval *newval TSRMLS_DC)
 		xmlFree((xmlChar *) docp->version );
 	}
 
-	if (newval->type != IS_STRING) {
-		if(Z_REFCOUNT_P(newval) > 1) {
-			value_copy = *newval;
-			zval_copy_ctor(&value_copy);
-			newval = &value_copy;
-		}
-		convert_to_string(newval);
-	}
-
-	docp->version = xmlStrdup((const xmlChar *) Z_STRVAL_P(newval));
+	str = zval_get_string(newval);
 
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
+	docp->version = xmlStrdup((const xmlChar *) str->val);
 
+	STR_RELEASE(str);
 	return SUCCESS;
 }
 
@@ -525,39 +451,23 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-strictErrorChecking
 Since: DOM Level 3
 */
-int dom_document_strict_error_checking_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_strict_error_checking_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->stricterror);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->stricterror);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_strict_error_checking_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
 
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->stricterror = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->stricterror = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -568,39 +478,22 @@ int dom_document_strict_error_checking_write(dom_object *obj, zval *newval TSRML
 /* {{{ formatOutput	boolean	
 readonly=no
 */
-int dom_document_format_output_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_format_output_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->formatoutput);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->formatoutput);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_format_output_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
-
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->formatoutput = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->formatoutput = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -610,39 +503,22 @@ int dom_document_format_output_write(dom_object *obj, zval *newval TSRMLS_DC)
 /* {{{ validateOnParse	boolean	
 readonly=no
 */
-int	dom_document_validate_on_parse_read(dom_object *obj, zval **retval TSRMLS_DC)
+int	dom_document_validate_on_parse_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->validateonparse);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->validateonparse);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_validate_on_parse_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
-
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->validateonparse = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->validateonparse = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -652,39 +528,22 @@ int dom_document_validate_on_parse_write(dom_object *obj, zval *newval TSRMLS_DC
 /* {{{ resolveExternals	boolean	
 readonly=no
 */
-int dom_document_resolve_externals_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_resolve_externals_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->resolveexternals);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->resolveexternals);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_resolve_externals_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
-
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->resolveexternals = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->resolveexternals = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -694,39 +553,22 @@ int dom_document_resolve_externals_write(dom_object *obj, zval *newval TSRMLS_DC
 /* {{{ preserveWhiteSpace	boolean	
 readonly=no
 */
-int dom_document_preserve_whitespace_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_preserve_whitespace_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->preservewhitespace);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->preservewhitespace);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_preserve_whitespace_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
-
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->preservewhitespace = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->preservewhitespace = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -736,39 +578,22 @@ int dom_document_preserve_whitespace_write(dom_object *obj, zval *newval TSRMLS_
 /* {{{ recover	boolean	
 readonly=no
 */
-int dom_document_recover_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_recover_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->recover);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->recover);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_recover_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
-
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->recover = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->recover = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -778,39 +603,22 @@ int dom_document_recover_write(dom_object *obj, zval *newval TSRMLS_DC)
 /* {{{ substituteEntities	boolean	
 readonly=no
 */
-int dom_document_substitue_entities_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_substitue_entities_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	dom_doc_propsptr doc_prop;
-
-	ALLOC_ZVAL(*retval);
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		ZVAL_BOOL(*retval, doc_prop->substituteentities);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		ZVAL_BOOL(retval, doc_prop->substituteentities);
 	} else {
-		ZVAL_FALSE(*retval);
+		ZVAL_FALSE(retval);
 	}
 	return SUCCESS;
 }
 
 int dom_document_substitue_entities_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	dom_doc_propsptr doc_prop;
-
-	if(Z_REFCOUNT_P(newval) > 1) {
-		value_copy = *newval;
-		zval_copy_ctor(&value_copy);
-		newval = &value_copy;
-	}
-	convert_to_boolean(newval);
-
 	if (obj->document) {
-		doc_prop = dom_get_doc_props(obj->document);
-		doc_prop->substituteentities = Z_LVAL_P(newval);
-	}
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
+		dom_doc_propsptr doc_prop = dom_get_doc_props(obj->document);
+		doc_prop->substituteentities = zend_is_true(newval TSRMLS_CC);
 	}
 
 	return SUCCESS;
@@ -822,24 +630,21 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-documentURI
 Since: DOM Level 3
 */
-int dom_document_document_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_document_uri_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDoc *docp;
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
 	char *url;
 
-	docp = (xmlDocPtr) dom_object_get_node(obj);
-
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	url = (char *) docp->URL;
 	if (url != NULL) {
-		ZVAL_STRING(*retval, url, 1);
+		ZVAL_STRING(retval, url);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -847,10 +652,8 @@ int dom_document_document_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 int dom_document_document_uri_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlDoc *docp;
-
-	docp = (xmlDocPtr) dom_object_get_node(obj);
+	xmlDoc *docp = (xmlDocPtr) dom_object_get_node(obj);
+	zend_string *str;
 
 	if (docp == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
@@ -861,21 +664,11 @@ int dom_document_document_uri_write(dom_object *obj, zval *newval TSRMLS_DC)
 		xmlFree((xmlChar *) docp->URL);
 	}
 
-	if (newval->type != IS_STRING) {
-		if(Z_REFCOUNT_P(newval) > 1) {
-			value_copy = *newval;
-			zval_copy_ctor(&value_copy);
-			newval = &value_copy;
-		}
-		convert_to_string(newval);
-	}
-
-	docp->URL = xmlStrdup((const xmlChar *) Z_STRVAL_P(newval));
+	str = zval_get_string(newval);
 
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
+	docp->URL = xmlStrdup((const xmlChar *) str->val);
 
+	STR_RELEASE(str);
 	return SUCCESS;
 }
 
@@ -886,10 +679,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Document3-config
 Since: DOM Level 3
 */
-int dom_document_config_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_document_config_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
@@ -1161,7 +953,7 @@ PHP_FUNCTION(dom_document_get_elements_by_tag_name)
 	DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
 
 	php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
-	namednode = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
+	namednode = Z_DOMOBJ_P(return_value);
 	local = xmlCharStrndup(name, name_len);
 	dom_namednode_iter(intern, 0, namednode, NULL, local, NULL TSRMLS_CC);
 }
@@ -1370,7 +1162,7 @@ PHP_FUNCTION(dom_document_get_elements_by_tag_name_ns)
 	DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
 
 	php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
-	namednode = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
+	namednode = Z_DOMOBJ_P(return_value);
 	local = xmlCharStrndup(name, name_len);
 	nsuri = xmlCharStrndup(uri, uri_len);
 	dom_namednode_iter(intern, 0, namednode, NULL, local, nsuri TSRMLS_CC);
@@ -1476,7 +1268,7 @@ PHP_METHOD(domdocument, __construct)
 		docp->encoding = (const xmlChar*)xmlStrdup(encoding);
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 	if (intern != NULL) {
 		olddoc = (xmlDocPtr) dom_object_get_node(intern);
 		if (olddoc != NULL) {
@@ -1562,7 +1354,7 @@ static xmlDocPtr dom_document_parser(zval *id, int mode, char *source, int sourc
 	char *directory=NULL, resolved_path[MAXPATHLEN];
 
 	if (id != NULL) {
-		intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_DOMOBJ_P(id);
 		document = intern->document;
 	}
 
@@ -1695,7 +1487,7 @@ static void dom_parse_document(INTERNAL_FUNCTION_PARAMETERS, int mode) {
 		RETURN_FALSE;
 
 	if (id != NULL) {
-		intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_DOMOBJ_P(id);
 		if (intern != NULL) {
 			docp = (xmlDocPtr) dom_object_get_node(intern);
 			doc_prop = NULL;
@@ -1837,7 +1629,7 @@ PHP_FUNCTION(dom_document_savexml)
 			xmlBufferFree(buf);
 			RETURN_FALSE;
 		}
-		RETVAL_STRING(mem, 1);
+		RETVAL_STRING(mem);
 		xmlBufferFree(buf);
 	} else {
 		if (options & LIBXML_SAVE_NOEMPTYTAG) {
@@ -1852,7 +1644,7 @@ PHP_FUNCTION(dom_document_savexml)
 		if (!size) {
 			RETURN_FALSE;
 		}
-		RETVAL_STRINGL(mem, size, 1);
+		RETVAL_STRINGL(mem, size);
 		xmlFree(mem);
 	}
 }
@@ -2214,7 +2006,7 @@ static void dom_load_html(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
 		RETURN_FALSE;
 
 	if (id != NULL && instanceof_function(Z_OBJCE_P(id), dom_document_class_entry TSRMLS_CC)) {
-		intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_DOMOBJ_P(id);
 		if (intern != NULL) {
 			docp = (xmlDocPtr) dom_object_get_node(intern);
 			doc_prop = NULL;
@@ -2359,7 +2151,7 @@ PHP_FUNCTION(dom_document_save_html)
 			if (!mem) {
 				RETVAL_FALSE;
 			} else {
-				RETVAL_STRINGL((const char*) mem, size, 1);
+				RETVAL_STRINGL((const char*) mem, size);
 			}
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error dumping HTML node");
@@ -2375,7 +2167,7 @@ PHP_FUNCTION(dom_document_save_html)
 		if (!size) {
 			RETVAL_FALSE;
 		} else {
-			RETVAL_STRINGL((const char*) mem, size, 1);
+			RETVAL_STRINGL((const char*) mem, size);
 		}
 		if (mem)
 			xmlFree(mem);
@@ -2392,47 +2184,22 @@ PHP_METHOD(domdocument, registerNodeClass)
 {
 	zval *id;
 	xmlDoc *docp;
-	char *baseclass = NULL, *extendedclass = NULL;
-	int baseclass_len = 0, extendedclass_len = 0;
-	zend_class_entry *basece = NULL, *ce = NULL;
+	zend_class_entry *basece = dom_node_class_entry, *ce = NULL;
 	dom_object *intern;
 
-	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Oss!", &id, dom_document_class_entry, &baseclass, &baseclass_len, &extendedclass, &extendedclass_len) == FAILURE) {
+	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "OCC!", &id, dom_document_class_entry, &basece, &ce) == FAILURE) {
 		return;
 	}
 
-	if (baseclass_len) {
-		zend_class_entry **pce;
-		if (zend_lookup_class(baseclass, baseclass_len, &pce TSRMLS_CC) == FAILURE) {
-			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", baseclass);
-			return;
-		}
-		basece = *pce;
-	}
-
-	if (basece == NULL || ! instanceof_function(basece, dom_node_class_entry TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from DOMNode.", baseclass);
-		return;
-	}
-
-	if (extendedclass_len) {
-		zend_class_entry **pce;
-		if (zend_lookup_class(extendedclass, extendedclass_len, &pce TSRMLS_CC) == FAILURE) {
-			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s does not exist", extendedclass);
-		}
-		ce = *pce;
-	}
-
 	if (ce == NULL || instanceof_function(ce, basece TSRMLS_CC)) {
-
 		DOM_GET_OBJ(docp, id, xmlDocPtr, intern);
 
 		if (dom_set_doc_classmap(intern->document, basece, ce TSRMLS_CC) == FAILURE) {
-			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be registered.", extendedclass);
+			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be registered.", ce->name->val);
 		}
 		RETURN_TRUE;
 	} else {
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from %s.", extendedclass, baseclass);
+		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s is not derived from %s.", ce->name->val, basece->name->val);
 	}
 
 	RETURN_FALSE;
diff --git a/ext/dom/documentfragment.c b/ext/dom/documentfragment.c
index e99f57151f..f20ada3db4 100644
--- a/ext/dom/documentfragment.c
+++ b/ext/dom/documentfragment.c
@@ -72,15 +72,13 @@ PHP_METHOD(domdocumentfragment, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
-	if (intern != NULL) {
-		oldnode = dom_object_get_node(intern);
-		if (oldnode != NULL) {
-			php_libxml_node_free_resource(oldnode  TSRMLS_CC);
-		}
-		/* php_dom_set_object(intern, nodep TSRMLS_CC); */
-		php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
+	oldnode = dom_object_get_node(intern);
+	if (oldnode != NULL) {
+		php_libxml_node_free_resource(oldnode  TSRMLS_CC);
 	}
+	/* php_dom_set_object(intern, nodep TSRMLS_CC); */
+	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
 }
 /* }}} end DOMDocumentFragment::__construct */
 
diff --git a/ext/dom/documenttype.c b/ext/dom/documenttype.c
index 9042457e86..1193ed44d5 100644
--- a/ext/dom/documenttype.c
+++ b/ext/dom/documenttype.c
@@ -43,19 +43,16 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1844763134
 Since: 
 */
-int dom_documenttype_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_documenttype_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDtdPtr dtdptr;
-
-	dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
+	xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
 
 	if (dtdptr == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, (char *) (dtdptr->name), 1);
+	ZVAL_STRING(retval, (char *) (dtdptr->name));
 
 	return SUCCESS;
 }
@@ -67,25 +64,22 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1788794630
 Since: 
 */
-int dom_documenttype_entities_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_documenttype_entities_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDtdPtr doctypep;
+	xmlDtdPtr doctypep = (xmlDtdPtr) dom_object_get_node(obj);
 	xmlHashTable *entityht;
 	dom_object *intern;
 
-	doctypep = (xmlDtdPtr) dom_object_get_node(obj);
-
 	if (doctypep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	MAKE_STD_ZVAL(*retval);
-	php_dom_create_interator(*retval, DOM_NAMEDNODEMAP TSRMLS_CC);
+	php_dom_create_interator(retval, DOM_NAMEDNODEMAP TSRMLS_CC);
 
 	entityht = (xmlHashTable *) doctypep->entities;
 
-	intern = (dom_object *)zend_objects_get_address(*retval TSRMLS_CC);
+	intern = Z_DOMOBJ_P(retval);
 	dom_namednode_iter(obj, XML_ENTITY_NODE, intern, entityht, NULL, NULL TSRMLS_CC);
 
 	return SUCCESS;
@@ -98,25 +92,22 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-D46829EF
 Since: 
 */
-int dom_documenttype_notations_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_documenttype_notations_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDtdPtr doctypep;
+	xmlDtdPtr doctypep = (xmlDtdPtr) dom_object_get_node(obj);
 	xmlHashTable *notationht;
 	dom_object *intern;
 
-	doctypep = (xmlDtdPtr) dom_object_get_node(obj);
-
 	if (doctypep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	MAKE_STD_ZVAL(*retval);
-	php_dom_create_interator(*retval, DOM_NAMEDNODEMAP TSRMLS_CC);
+	php_dom_create_interator(retval, DOM_NAMEDNODEMAP TSRMLS_CC);
 
 	notationht = (xmlHashTable *) doctypep->notations;
 
-	intern = (dom_object *)zend_objects_get_address(*retval TSRMLS_CC);
+	intern = Z_DOMOBJ_P(retval);
 	dom_namednode_iter(obj, XML_NOTATION_NODE, intern, notationht, NULL, NULL TSRMLS_CC);
 
 	return SUCCESS;
@@ -129,22 +120,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-Core-DocType-publicId
 Since: DOM Level 2
 */
-int dom_documenttype_public_id_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_documenttype_public_id_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDtdPtr dtdptr;
-
-	dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
+	xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
 
 	if (dtdptr == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (dtdptr->ExternalID) {
-		ZVAL_STRING(*retval, (char *) (dtdptr->ExternalID), 1);
+		ZVAL_STRING(retval, (char *) (dtdptr->ExternalID));
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 	return SUCCESS;
 
@@ -157,22 +145,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-Core-DocType-systemId
 Since: DOM Level 2
 */
-int dom_documenttype_system_id_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_documenttype_system_id_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlDtdPtr dtdptr;
-
-	dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
+	xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
 
 	if (dtdptr == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (dtdptr->SystemID) {
-		ZVAL_STRING(*retval, (char *) (dtdptr->SystemID), 1);
+		ZVAL_STRING(retval, (char *) (dtdptr->SystemID));
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 	return SUCCESS;
 }
@@ -184,22 +169,17 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-Core-DocType-internalSubset
 Since: DOM Level 2
 */
-int dom_documenttype_internal_subset_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_documenttype_internal_subset_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-
-	xmlDtdPtr dtdptr;
+	xmlDtdPtr dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
 	xmlDtdPtr intsubset;
 
-	dtdptr = (xmlDtdPtr) dom_object_get_node(obj);
-
 	if (dtdptr == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	if (dtdptr->doc != NULL && ((intsubset = xmlGetIntSubset(dtdptr->doc)) != NULL) && intsubset->children != NULL) {
+	if (dtdptr->doc != NULL && ((intsubset = xmlGetIntSubset(dtdptr->doc)) != NULL)) {
 		smart_str ret_buf = {0};
 		xmlNodePtr cur = intsubset->children;
 
@@ -222,14 +202,14 @@ int dom_documenttype_internal_subset_read(dom_object *obj, zval **retval TSRMLS_
 			cur = cur->next;
 		}
 
-		if (ret_buf.len) {
-			ZVAL_STRINGL(*retval, ret_buf.c, ret_buf.len, 1);
-			smart_str_free(&ret_buf);
+		if (ret_buf.s) {
+			smart_str_0(&ret_buf);
+			ZVAL_STR(retval, ret_buf.s);
 			return SUCCESS;
 		}
 	}
 
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 
 	return SUCCESS;
 
diff --git a/ext/dom/dom_iterators.c b/ext/dom/dom_iterators.c
index 987d54de25..22d0ab0ee3 100644
--- a/ext/dom/dom_iterators.c
+++ b/ext/dom/dom_iterators.c
@@ -126,13 +126,8 @@ static void php_dom_iterator_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ *
 {
 	php_dom_iterator *iterator = (php_dom_iterator *)iter;
 
-	zval_ptr_dtor((zval**)&iterator->intern.data);
-
-	if (iterator->curobj) {
-		zval_ptr_dtor((zval**)&iterator->curobj);
-	}
-
-	efree(iterator);
+	zval_ptr_dtor(&iterator->intern.data);
+	zval_ptr_dtor(&iterator->curobj);
 }
 /* }}} */
 
@@ -141,7 +136,7 @@ static int php_dom_iterator_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ *
 
 	php_dom_iterator *iterator = (php_dom_iterator *)iter;
 
-	if (iterator->curobj) {
+	if (Z_TYPE(iterator->curobj) != IS_UNDEF) {
 		return SUCCESS;
 	} else {
 		return FAILURE;
@@ -149,27 +144,27 @@ static int php_dom_iterator_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ *
 }
 /* }}} */
 
-static void php_dom_iterator_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+zval *php_dom_iterator_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
 	php_dom_iterator *iterator = (php_dom_iterator *)iter;
 
-	*data = &iterator->curobj;
+	return &iterator->curobj;
 }
 /* }}} */
 
 static void php_dom_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
 {
 	php_dom_iterator *iterator = (php_dom_iterator *)iter;
-	zval *object = (zval *)iterator->intern.data;
+	zval *object = &iterator->intern.data;
 
 	if (instanceof_function(Z_OBJCE_P(object), dom_nodelist_class_entry TSRMLS_CC)) {
 		ZVAL_LONG(key, iter->index);
 	} else {
-		dom_object *intern = (dom_object *)zend_object_store_get_object(iterator->curobj TSRMLS_CC);
+		dom_object *intern = Z_DOMOBJ_P(&iterator->curobj);
 
 		if (intern != NULL && intern->ptr != NULL) {
 			xmlNodePtr curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->ptr)->node;
-			ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name), 1);
+			ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
 		} else {
 			ZVAL_NULL(key);
 		}
@@ -179,33 +174,33 @@ static void php_dom_iterator_current_key(zend_object_iterator *iter, zval *key T
 
 static void php_dom_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	zval *curobj, *curattr = NULL;
 	zval *object;
 	xmlNodePtr curnode = NULL, basenode;
 	dom_object *intern;
 	dom_object *nnmap;
 	dom_nnodemap_object *objmap;
-	int ret, previndex=0;
+	int previndex=0;
 	HashTable *nodeht;
-	zval **entry;
+	zval *entry;
 
 	php_dom_iterator *iterator = (php_dom_iterator *)iter;
 
-	object = (zval *)iterator->intern.data;
-	nnmap = (dom_object *)zend_object_store_get_object(object TSRMLS_CC);
+	object = &iterator->intern.data;
+	nnmap = Z_DOMOBJ_P(object);
 	objmap = (dom_nnodemap_object *)nnmap->ptr;
 
-	curobj = iterator->curobj;
-	intern = (dom_object *)zend_object_store_get_object(curobj TSRMLS_CC);
+	intern = Z_DOMOBJ_P(&iterator->curobj);
+	zval_ptr_dtor(&iterator->curobj);
+	ZVAL_UNDEF(&iterator->curobj);
+
 	if (intern != NULL && intern->ptr != NULL) {
 		if (objmap->nodetype != XML_ENTITY_NODE && 
 			objmap->nodetype != XML_NOTATION_NODE) {
 			if (objmap->nodetype == DOM_NODESET) {
-				nodeht = HASH_OF(objmap->baseobjptr);
+				nodeht = HASH_OF(&objmap->baseobj_zv);
 				zend_hash_move_forward(nodeht);
-				if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) {
-					curattr = *entry;
-					Z_ADDREF_P(curattr);
+				if ((entry = zend_hash_get_current_data(nodeht))) {
+					ZVAL_COPY(&iterator->curobj, entry);
 				}
 			} else {
 				curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->ptr)->node;
@@ -235,13 +230,9 @@ static void php_dom_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC)
 		}
 	}
 err:
-	zval_ptr_dtor((zval**)&curobj);
 	if (curnode) {
-		MAKE_STD_ZVAL(curattr);
-		curattr = php_dom_create_object(curnode, &ret, curattr, objmap->baseobj TSRMLS_CC);
+		php_dom_create_object(curnode, &iterator->curobj, objmap->baseobj TSRMLS_CC);
 	}
-
-	iterator->curobj = curattr;
 }
 /* }}} */
 
@@ -259,32 +250,32 @@ zend_object_iterator *php_dom_get_iterator(zend_class_entry *ce, zval *object, i
 	dom_object *intern;
 	dom_nnodemap_object *objmap;
 	xmlNodePtr nodep, curnode=NULL;
-	zval *curattr = NULL;
-	int ret, curindex = 0;
+	int curindex = 0;
 	HashTable *nodeht;
-	zval **entry;
+	zval *entry;
 	php_dom_iterator *iterator;
 
 	if (by_ref) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
 	iterator = emalloc(sizeof(php_dom_iterator));
+	zend_iterator_init(&iterator->intern TSRMLS_CC);
 
-	Z_ADDREF_P(object);
-	iterator->intern.data = (void*)object;
+	ZVAL_COPY(&iterator->intern.data, object);
 	iterator->intern.funcs = &php_dom_iterator_funcs;
 
-	intern = (dom_object *)zend_object_store_get_object(object TSRMLS_CC);
+	ZVAL_UNDEF(&iterator->curobj);
+
+	intern = Z_DOMOBJ_P(object);
 	objmap = (dom_nnodemap_object *)intern->ptr;
 	if (objmap != NULL) {
 		if (objmap->nodetype != XML_ENTITY_NODE && 
 			objmap->nodetype != XML_NOTATION_NODE) {
 			if (objmap->nodetype == DOM_NODESET) {
-				nodeht = HASH_OF(objmap->baseobjptr);
+				nodeht = HASH_OF(&objmap->baseobj_zv);
 				zend_hash_internal_pointer_reset(nodeht);
-				if (zend_hash_get_current_data(nodeht, (void **) &entry)==SUCCESS) {
-					curattr = *entry;
-					Z_ADDREF_P(curattr);
+				if ((entry = zend_hash_get_current_data(nodeht))) {
+					ZVAL_COPY(&iterator->curobj, entry);
 				}
 			} else {
 				nodep = (xmlNode *)dom_object_get_node(objmap->baseobj);
@@ -316,13 +307,10 @@ zend_object_iterator *php_dom_get_iterator(zend_class_entry *ce, zval *object, i
 	}
 err:
 	if (curnode) {
-		MAKE_STD_ZVAL(curattr);
-		curattr = php_dom_create_object(curnode, &ret, curattr, objmap->baseobj TSRMLS_CC);
+		php_dom_create_object(curnode, &iterator->curobj, objmap->baseobj TSRMLS_CC);
 	}
 
-	iterator->curobj = curattr;
-
-	return (zend_object_iterator*)iterator;
+	return &iterator->intern;
 }
 /* }}} */
 
diff --git a/ext/dom/dom_properties.h b/ext/dom/dom_properties.h
index a658b1d843..60551bdca1 100644
--- a/ext/dom/dom_properties.h
+++ b/ext/dom/dom_properties.h
@@ -22,141 +22,141 @@
 #define DOM_PROPERTIES_H
 
 /* attr properties */
-int dom_attr_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_attr_specified_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_attr_value_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_attr_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_attr_specified_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_attr_value_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_attr_value_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_attr_owner_element_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_attr_schema_type_info_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_attr_owner_element_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_attr_schema_type_info_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* characterdata properties */
-int dom_characterdata_data_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_characterdata_data_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_characterdata_data_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_characterdata_length_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_characterdata_length_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* document properties */
-int dom_document_doctype_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_document_implementation_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_document_document_element_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_document_actual_encoding_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_doctype_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_document_implementation_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_document_document_element_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_document_actual_encoding_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_actual_encoding_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_encoding_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_encoding_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_encoding_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_standalone_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_standalone_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_standalone_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_version_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_version_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_version_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_strict_error_checking_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_strict_error_checking_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_strict_error_checking_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_document_uri_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_document_uri_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_document_uri_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_config_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_document_format_output_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_config_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_document_format_output_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_format_output_write(dom_object *obj, zval *newval TSRMLS_DC);
-int	dom_document_validate_on_parse_read(dom_object *obj, zval **retval TSRMLS_DC);
+int	dom_document_validate_on_parse_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_validate_on_parse_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_resolve_externals_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_resolve_externals_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_resolve_externals_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_preserve_whitespace_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_preserve_whitespace_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_preserve_whitespace_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_recover_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_recover_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_recover_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_document_substitue_entities_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_document_substitue_entities_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_document_substitue_entities_write(dom_object *obj, zval *newval TSRMLS_DC);
 
 /* documenttype properties */
-int dom_documenttype_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_documenttype_entities_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_documenttype_notations_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_documenttype_public_id_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_documenttype_system_id_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_documenttype_internal_subset_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_documenttype_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_documenttype_entities_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_documenttype_notations_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_documenttype_public_id_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_documenttype_system_id_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_documenttype_internal_subset_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* domerror properties */
-int dom_domerror_severity_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domerror_message_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domerror_type_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domerror_related_exception_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domerror_related_data_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domerror_location_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_domerror_severity_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domerror_message_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domerror_type_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domerror_related_exception_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domerror_related_data_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domerror_location_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* domimplementationlist properties */
-int dom_domimplementationlist_length_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_domimplementationlist_length_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* domlocator properties */
-int dom_domlocator_line_number_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domlocator_column_number_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domlocator_offset_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domlocator_related_node_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_domlocator_uri_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_domlocator_line_number_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domlocator_column_number_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domlocator_offset_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domlocator_related_node_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_domlocator_uri_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* domstringlist properties */
-int dom_domstringlist_length_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_domstringlist_length_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* element properties */
-int dom_element_tag_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_element_schema_type_info_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_element_tag_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_element_schema_type_info_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* entity properties */
-int dom_entity_public_id_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_entity_system_id_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_entity_notation_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_entity_actual_encoding_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_entity_public_id_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_entity_system_id_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_entity_notation_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_entity_actual_encoding_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_entity_actual_encoding_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_entity_encoding_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_entity_encoding_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_entity_encoding_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_entity_version_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_entity_version_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_entity_version_write(dom_object *obj, zval *newval TSRMLS_DC);
 
 /* namednodemap properties */
-int dom_namednodemap_length_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_namednodemap_length_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* namelist properties */
-int dom_namelist_length_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_namelist_length_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* node properties */
-int dom_node_node_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_node_value_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_node_node_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_node_value_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_node_node_value_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_node_node_type_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_parent_node_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_child_nodes_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_first_child_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_last_child_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_previous_sibling_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_next_sibling_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_attributes_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_owner_document_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_namespace_uri_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_prefix_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_node_node_type_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_parent_node_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_child_nodes_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_first_child_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_last_child_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_previous_sibling_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_next_sibling_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_attributes_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_owner_document_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_namespace_uri_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_prefix_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_node_prefix_write(dom_object *obj, zval *newval TSRMLS_DC);
-int dom_node_local_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_base_uri_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_node_text_content_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_node_local_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_base_uri_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_node_text_content_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_node_text_content_write(dom_object *obj, zval *newval TSRMLS_DC);
 
 /* nodelist properties */
-int dom_nodelist_length_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_nodelist_length_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* notation properties */
-int dom_notation_public_id_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_notation_system_id_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_notation_public_id_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_notation_system_id_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* processinginstruction properties */
-int dom_processinginstruction_target_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_processinginstruction_data_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_processinginstruction_target_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_processinginstruction_data_read(dom_object *obj, zval *retval TSRMLS_DC);
 int dom_processinginstruction_data_write(dom_object *obj, zval *newval TSRMLS_DC);
 
 /* text properties */
-int dom_text_whole_text_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_text_whole_text_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 /* typeinfo properties */
-int dom_typeinfo_type_name_read(dom_object *obj, zval **retval TSRMLS_DC);
-int dom_typeinfo_type_namespace_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_typeinfo_type_name_read(dom_object *obj, zval *retval TSRMLS_DC);
+int dom_typeinfo_type_namespace_read(dom_object *obj, zval *retval TSRMLS_DC);
 
 #if defined(LIBXML_XPATH_ENABLED)
 /* xpath properties */
-int dom_xpath_document_read(dom_object *obj, zval **retval TSRMLS_DC);
+int dom_xpath_document_read(dom_object *obj, zval *retval TSRMLS_DC);
 #endif
 
 #endif /* DOM_PROPERTIERS_H */
diff --git a/ext/dom/domerror.c b/ext/dom/domerror.c
index cf0eb8da69..cd35b326b7 100644
--- a/ext/dom/domerror.c
+++ b/ext/dom/domerror.c
@@ -46,10 +46,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ERROR-DOMError-severity
 Since: 
 */
-int dom_domerror_severity_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domerror_severity_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -60,10 +59,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ERROR-DOMError-message
 Since: 
 */
-int dom_domerror_message_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domerror_message_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -74,10 +72,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ERROR-DOMError-type
 Since: 
 */
-int dom_domerror_type_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domerror_type_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -88,10 +85,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ERROR-DOMError-relatedException
 Since: 
 */
-int dom_domerror_related_exception_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domerror_related_exception_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -102,10 +98,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ERROR-DOMError-relatedData
 Since: 
 */
-int dom_domerror_related_data_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domerror_related_data_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -116,10 +111,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ERROR-DOMError-location
 Since: 
 */
-int dom_domerror_location_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domerror_location_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
diff --git a/ext/dom/domimplementationlist.c b/ext/dom/domimplementationlist.c
index fde89b7d94..07479f52eb 100644
--- a/ext/dom/domimplementationlist.c
+++ b/ext/dom/domimplementationlist.c
@@ -52,10 +52,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMImplementationList-length
 Since: 
 */
-int dom_domimplementationlist_length_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domimplementationlist_length_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
diff --git a/ext/dom/domlocator.c b/ext/dom/domlocator.c
index 93cd580a01..4e01b3a443 100644
--- a/ext/dom/domlocator.c
+++ b/ext/dom/domlocator.c
@@ -46,10 +46,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMLocator-line-number
 Since: 
 */
-int dom_domlocator_line_number_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domlocator_line_number_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -60,10 +59,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMLocator-column-number
 Since: 
 */
-int dom_domlocator_column_number_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domlocator_column_number_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -74,10 +72,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMLocator-offset
 Since: 
 */
-int dom_domlocator_offset_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domlocator_offset_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -88,10 +85,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMLocator-node
 Since: 
 */
-int dom_domlocator_related_node_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domlocator_related_node_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
@@ -102,10 +98,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMLocator-uri
 Since: 
 */
-int dom_domlocator_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domlocator_uri_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
diff --git a/ext/dom/domstringlist.c b/ext/dom/domstringlist.c
index f036fbbdd6..a12d8633ac 100644
--- a/ext/dom/domstringlist.c
+++ b/ext/dom/domstringlist.c
@@ -52,10 +52,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#DOMStringList-length
 Since: 
 */
-int dom_domstringlist_length_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_domstringlist_length_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
diff --git a/ext/dom/element.c b/ext/dom/element.c
index b570471b7d..5ecf031c4c 100644
--- a/ext/dom/element.c
+++ b/ext/dom/element.c
@@ -219,14 +219,12 @@ PHP_METHOD(domelement, __construct)
 		xmlNodeSetContentLen(nodep, (xmlChar *) value, value_len);
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
-	if (intern != NULL) {
-		oldnode = dom_object_get_node(intern);
-		if (oldnode != NULL) {
-			php_libxml_node_free_resource(oldnode  TSRMLS_CC);
-		}
-		php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
+	oldnode = dom_object_get_node(intern);
+	if (oldnode != NULL) {
+		php_libxml_node_free_resource(oldnode  TSRMLS_CC);
 	}
+	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
 }
 /* }}} end DOMElement::__construct */
 
@@ -235,7 +233,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-104682815
 Since: 
 */
-int dom_element_tag_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_element_tag_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNodePtr nodep;
 	xmlNsPtr ns;
@@ -248,16 +246,15 @@ int dom_element_tag_name_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	ns = nodep->ns;
 	if (ns != NULL && ns->prefix) {
 		qname = xmlStrdup(ns->prefix);
 		qname = xmlStrcat(qname, (xmlChar *)":");
 		qname = xmlStrcat(qname, nodep->name);
-		ZVAL_STRING(*retval, (char *)qname, 1);
+		ZVAL_STRING(retval, (char *)qname);
 		xmlFree(qname);
 	} else {
-		ZVAL_STRING(*retval, (char *) nodep->name, 1);
+		ZVAL_STRING(retval, (char *) nodep->name);
 	}
 
 	return SUCCESS;
@@ -270,10 +267,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Element-schemaTypeInfo
 Since: DOM Level 3
 */
-int dom_element_schema_type_info_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_element_schema_type_info_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
@@ -359,7 +355,7 @@ PHP_FUNCTION(dom_element_get_attribute)
 	if (value == NULL) {
 		RETURN_EMPTY_STRING();
 	} else {
-		RETVAL_STRING((char *)value, 1);
+		RETVAL_STRING((char *)value);
 		xmlFree(value);
 	}
 }
@@ -648,7 +644,7 @@ PHP_FUNCTION(dom_element_get_elements_by_tag_name)
 	DOM_GET_OBJ(elemp, id, xmlNodePtr, intern);
 
 	php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
-	namednode = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
+	namednode = Z_DOMOBJ_P(return_value);
 	local = xmlCharStrndup(name, name_len);
 	dom_namednode_iter(intern, 0, namednode, NULL, local, NULL TSRMLS_CC);
 }
@@ -677,13 +673,13 @@ PHP_FUNCTION(dom_element_get_attribute_ns)
 	strattr = xmlGetNsProp(elemp, (xmlChar *) name, (xmlChar *) uri);
 
 	if (strattr != NULL) {
-		RETVAL_STRING((char *)strattr, 1);
+		RETVAL_STRING((char *)strattr);
 		xmlFree(strattr);
 	} else {
 		if (xmlStrEqual((xmlChar *) uri, (xmlChar *)DOM_XMLNS_NAMESPACE)) {
 			nsptr = dom_get_nsdecl(elemp, (xmlChar *)name);
 			if (nsptr != NULL) {
-				RETVAL_STRING((char *) nsptr->href, 1);
+				RETVAL_STRING((char *) nsptr->href);
 			} else {
 				RETVAL_EMPTY_STRING();
 			}
@@ -1042,7 +1038,7 @@ PHP_FUNCTION(dom_element_get_elements_by_tag_name_ns)
 	DOM_GET_OBJ(elemp, id, xmlNodePtr, intern);
 
 	php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
-	namednode = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
+	namednode = Z_DOMOBJ_P(return_value);
 	local = xmlCharStrndup(name, name_len);
 	nsuri = xmlCharStrndup(uri, uri_len);
 	dom_namednode_iter(intern, 0, namednode, NULL, local, nsuri TSRMLS_CC);
diff --git a/ext/dom/entity.c b/ext/dom/entity.c
index 803bb70eec..264683e28b 100644
--- a/ext/dom/entity.c
+++ b/ext/dom/entity.c
@@ -44,22 +44,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-D7303025
 Since: 
 */
-int dom_entity_public_id_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_entity_public_id_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlEntity *nodep;
-
-	nodep = (xmlEntity *) dom_object_get_node(obj);
+	xmlEntity *nodep = (xmlEntity *) dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (nodep->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	} else {
-		ZVAL_STRING(*retval, (char *) (nodep->ExternalID), 1);
+		ZVAL_STRING(retval, (char *) (nodep->ExternalID));
 	}
 
 	return SUCCESS;
@@ -72,22 +69,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-D7C29F3E
 Since: 
 */
-int dom_entity_system_id_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_entity_system_id_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlEntity *nodep;
-
-	nodep = (xmlEntity *) dom_object_get_node(obj);
+	xmlEntity *nodep = (xmlEntity *) dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (nodep->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	} else {
-		ZVAL_STRING(*retval, (char *) (nodep->SystemID), 1);
+		ZVAL_STRING(retval, (char *) (nodep->SystemID));
 	}
 
 	return SUCCESS;
@@ -100,24 +94,21 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-6ABAEB38
 Since: 
 */
-int dom_entity_notation_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_entity_notation_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlEntity *nodep;
+	xmlEntity *nodep = (xmlEntity *) dom_object_get_node(obj);
 	char *content;
 
-	nodep = (xmlEntity *) dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (nodep->etype != XML_EXTERNAL_GENERAL_UNPARSED_ENTITY) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	} else {
 		content = xmlNodeGetContent((xmlNodePtr) nodep);
-		ZVAL_STRING(*retval, content, 1);
+		ZVAL_STRING(retval, content);
 		xmlFree(content);
 	}
 
@@ -131,10 +122,9 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Entity3-actualEncoding
 Since: DOM Level 3
 */
-int dom_entity_actual_encoding_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_entity_actual_encoding_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
@@ -150,10 +140,9 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Entity3-encoding
 Since: DOM Level 3
 */
-int dom_entity_encoding_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_entity_encoding_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
@@ -169,10 +158,9 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Entity3-version
 Since: DOM Level 3
 */
-int dom_entity_version_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_entity_version_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
diff --git a/ext/dom/entityreference.c b/ext/dom/entityreference.c
index f2fe3945da..bc03385116 100644
--- a/ext/dom/entityreference.c
+++ b/ext/dom/entityreference.c
@@ -77,7 +77,7 @@ PHP_METHOD(domentityreference, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 	if (intern != NULL) {
 		oldnode = dom_object_get_node(intern);
 		if (oldnode != NULL) {
diff --git a/ext/dom/namednodemap.c b/ext/dom/namednodemap.c
index d3c8cee558..13acf5cbce 100644
--- a/ext/dom/namednodemap.c
+++ b/ext/dom/namednodemap.c
@@ -83,7 +83,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-6D0FB19E
 Since: 
 */
-int dom_namednodemap_length_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_namednodemap_length_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	dom_nnodemap_object *objmap;
 	xmlAttrPtr curnode;
@@ -113,8 +113,7 @@ int dom_namednodemap_length_read(dom_object *obj, zval **retval TSRMLS_DC)
 		}
 	}
 
-	MAKE_STD_ZVAL(*retval);
-	ZVAL_LONG(*retval, count);
+	ZVAL_LONG(retval, count);
 	return SUCCESS;
 }
 
@@ -140,7 +139,7 @@ PHP_FUNCTION(dom_namednodemap_get_named_item)
 		return;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 
 	objmap = (dom_nnodemap_object *)intern->ptr;
 
@@ -214,7 +213,7 @@ PHP_FUNCTION(dom_namednodemap_item)
 		return;
 	}
 	if (index >= 0) {
-		intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_DOMOBJ_P(id);
 
 		objmap = (dom_nnodemap_object *)intern->ptr;
 
@@ -272,7 +271,7 @@ PHP_FUNCTION(dom_namednodemap_get_named_item_ns)
 		return;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 
 	objmap = (dom_nnodemap_object *)intern->ptr;
 
diff --git a/ext/dom/namelist.c b/ext/dom/namelist.c
index 57e6f5d37c..02b63af9ff 100644
--- a/ext/dom/namelist.c
+++ b/ext/dom/namelist.c
@@ -55,10 +55,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#NameList-length
 Since: 
 */
-int dom_namelist_length_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_namelist_length_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, "TEST", 1);
+	ZVAL_STRING(retval, "TEST");
 	return SUCCESS;
 }
 
diff --git a/ext/dom/node.c b/ext/dom/node.c
index ae74ea04cf..25c8daee6f 100644
--- a/ext/dom/node.c
+++ b/ext/dom/node.c
@@ -196,7 +196,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-F68D095
 Since: 
 */
-int dom_node_node_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_node_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep;
 	xmlNsPtr ns;
@@ -262,12 +262,10 @@ int dom_node_node_name_read(dom_object *obj, zval **retval TSRMLS_DC)
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Node Type");
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	if(str != NULL) {
-		ZVAL_STRING(*retval, str, 1);
+	if (str != NULL) {
+		ZVAL_STRING(retval, str);
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 	
 	if (qname != NULL) {
@@ -285,13 +283,11 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-F68D080
 Since: 
 */
-int dom_node_node_value_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_node_value_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	char *str = NULL;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
@@ -315,26 +311,20 @@ int dom_node_node_value_read(dom_object *obj, zval **retval TSRMLS_DC)
 			break;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	if(str != NULL) {
-		ZVAL_STRING(*retval, str, 1);
+		ZVAL_STRING(retval, str);
 		xmlFree(str);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
-
 	return SUCCESS;
 
 }
 
 int dom_node_node_value_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	xmlNode *nodep;
-	zval value_copy;
-
-	nodep = dom_object_get_node(obj);
+	xmlNode *nodep = dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
@@ -352,19 +342,12 @@ int dom_node_node_value_write(dom_object *obj, zval *newval TSRMLS_DC)
 		case XML_COMMENT_NODE:
 		case XML_CDATA_SECTION_NODE:
 		case XML_PI_NODE:
-			if (newval->type != IS_STRING) {
-				if(Z_REFCOUNT_P(newval) > 1) {
-					value_copy = *newval;
-					zval_copy_ctor(&value_copy);
-					newval = &value_copy;
-				}
-				convert_to_string(newval);
-			}
-			xmlNodeSetContentLen(nodep, Z_STRVAL_P(newval), Z_STRLEN_P(newval) + 1);
-			if (newval == &value_copy) {
-				zval_dtor(newval);
+			{
+				zend_string *str = zval_get_string(newval);
+				xmlNodeSetContentLen(nodep, str->val, str->len + 1);
+				STR_RELEASE(str);
+				break;
 			}
-			break;
 		default:
 			break;
 	}
@@ -379,7 +362,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-111237558
 Since:
 */
-int dom_node_node_type_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_node_type_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep;
 
@@ -390,13 +373,11 @@ int dom_node_node_type_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	/* Specs dictate that they are both type XML_DOCUMENT_TYPE_NODE */
 	if (nodep->type == XML_DTD_NODE) {
-		ZVAL_LONG(*retval, XML_DOCUMENT_TYPE_NODE);
+		ZVAL_LONG(retval, XML_DOCUMENT_TYPE_NODE);
 	} else {
-		ZVAL_LONG(*retval, nodep->type);
+		ZVAL_LONG(retval, nodep->type);
 	}
 
 	return SUCCESS;
@@ -409,10 +390,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1060184317
 Since: 
 */
-int dom_node_parent_node_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_parent_node_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep, *nodeparent;
-	int ret;
 
 	nodep = dom_object_get_node(obj);
 
@@ -421,18 +401,13 @@ int dom_node_parent_node_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	nodeparent = nodep->parent;
 	if (!nodeparent) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object(nodeparent, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(nodeparent, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -443,25 +418,21 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-1451460987
 Since: 
 */
-int dom_node_child_nodes_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_child_nodes_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	dom_object *intern;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	
 	if (dom_node_children_valid(nodep) == FAILURE) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	} else {
-		php_dom_create_interator(*retval, DOM_NODELIST TSRMLS_CC);
-		intern = (dom_object *)zend_objects_get_address(*retval TSRMLS_CC);
+		php_dom_create_interator(retval, DOM_NODELIST TSRMLS_CC);
+		intern = Z_DOMOBJ_P(retval);
 		dom_namednode_iter(obj, XML_ELEMENT_NODE, intern, NULL, NULL, NULL TSRMLS_CC);
 	}
 
@@ -475,10 +446,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-169727388
 Since: 
 */
-int dom_node_first_child_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_first_child_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep, *first = NULL;
-	int ret;
 
 	nodep = dom_object_get_node(obj);
 
@@ -491,17 +461,12 @@ int dom_node_first_child_read(dom_object *obj, zval **retval TSRMLS_DC)
 		first = nodep->children;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	if (!first) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object(first, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(first, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -512,10 +477,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-61AD09FB
 Since: 
 */
-int dom_node_last_child_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_last_child_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep, *last = NULL;
-	int ret;
 
 	nodep = dom_object_get_node(obj);
 
@@ -528,17 +492,12 @@ int dom_node_last_child_read(dom_object *obj, zval **retval TSRMLS_DC)
 		last = nodep->last;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	if (!last) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object(last, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(last, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -549,10 +508,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-640FB3C8
 Since: 
 */
-int dom_node_previous_sibling_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_previous_sibling_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep, *prevsib;
-	int ret;
 
 	nodep = dom_object_get_node(obj);
 
@@ -561,18 +519,13 @@ int dom_node_previous_sibling_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	prevsib = nodep->prev;
 	if (!prevsib) {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
-	if (NULL == (*retval = php_dom_create_object(prevsib, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(prevsib, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -583,10 +536,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-6AC54C2F
 Since:
 */
-int dom_node_next_sibling_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_next_sibling_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNode *nodep, *nextsib;
-	int ret;
 
 	nodep = dom_object_get_node(obj);
 
@@ -600,12 +552,7 @@ int dom_node_next_sibling_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	if (NULL == (*retval = php_dom_create_object(nextsib, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object(nextsib, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -616,26 +563,22 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-84CF096
 Since: 
 */
-int dom_node_attributes_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_attributes_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	dom_object *intern;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	if (nodep->type == XML_ELEMENT_NODE) {
-		php_dom_create_interator(*retval, DOM_NAMEDNODEMAP TSRMLS_CC);
-		intern = (dom_object *)zend_objects_get_address(*retval TSRMLS_CC);
+		php_dom_create_interator(retval, DOM_NAMEDNODEMAP TSRMLS_CC);
+		intern = Z_DOMOBJ_P(retval);
 		dom_namednode_iter(obj, XML_ATTRIBUTE_NODE, intern, NULL, NULL, NULL TSRMLS_CC);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -648,13 +591,10 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-node-ownerDoc
 Since: 
 */
-int dom_node_owner_document_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_owner_document_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	xmlDocPtr docp;
-	int ret;
-
-	nodep = dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
@@ -662,8 +602,7 @@ int dom_node_owner_document_read(dom_object *obj, zval **retval TSRMLS_DC)
 	}
 
 	if (nodep->type == XML_DOCUMENT_NODE || nodep->type == XML_HTML_DOCUMENT_NODE) {
-		ALLOC_ZVAL(*retval);
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 		return SUCCESS;
 	}
 
@@ -672,12 +611,7 @@ int dom_node_owner_document_read(dom_object *obj, zval **retval TSRMLS_DC)
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	if (NULL == (*retval = php_dom_create_object((xmlNodePtr) docp, &ret, *retval, obj TSRMLS_CC))) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
+	php_dom_create_object((xmlNodePtr) docp, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 
@@ -688,13 +622,11 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeNSname
 Since: DOM Level 2
 */
-int dom_node_namespace_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_namespace_uri_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	char *str = NULL;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
@@ -713,12 +645,10 @@ int dom_node_namespace_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
 			break;
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	if(str != NULL) {
-		ZVAL_STRING(*retval, str, 1);
+	if (str != NULL) {
+		ZVAL_STRING(retval, str);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -731,14 +661,12 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeNSPrefix
 Since: DOM Level 2
 */
-int dom_node_prefix_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_prefix_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	xmlNsPtr ns;
 	char *str = NULL;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
@@ -758,12 +686,10 @@ int dom_node_prefix_read(dom_object *obj, zval **retval TSRMLS_DC)
 			break;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	if (str == NULL) {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	} else {
-		ZVAL_STRING(*retval, str, 1);
+		ZVAL_STRING(retval, str);
 	}
 	return SUCCESS;
 
@@ -771,7 +697,7 @@ int dom_node_prefix_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 int dom_node_prefix_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
+	zend_string *str;
 	xmlNode *nodep, *nsnode = NULL;
 	xmlNsPtr ns = NULL, curns;
 	char *strURI;
@@ -794,15 +720,8 @@ int dom_node_prefix_write(dom_object *obj, zval *newval TSRMLS_DC)
 					nsnode = xmlDocGetRootElement(nodep->doc);
 				}
 			}
-			if (newval->type != IS_STRING) {
-				if(Z_REFCOUNT_P(newval) > 1) {
-					value_copy = *newval;
-					zval_copy_ctor(&value_copy);
-					newval = &value_copy;
-				}
-				convert_to_string(newval);
-			}
-			prefix = Z_STRVAL_P(newval);
+			str = zval_get_string(newval);
+			prefix = str->val;
 			if (nsnode && nodep->ns != NULL && !xmlStrEqual(nodep->ns->prefix, (xmlChar *)prefix)) {
 				strURI = (char *) nodep->ns->href;
 				if (strURI == NULL || 
@@ -826,18 +745,14 @@ int dom_node_prefix_write(dom_object *obj, zval *newval TSRMLS_DC)
 				}
 
 				if (ns == NULL) {
-					if (newval == &value_copy) {
-						zval_dtor(newval);
-					}
+					STR_RELEASE(str);
 					php_dom_throw_error(NAMESPACE_ERR, dom_get_strict_error(obj->document) TSRMLS_CC);
 					return FAILURE;
 				}
 
 				xmlSetNs(nodep, ns);
 			}
-			if (newval == &value_copy) {
-				zval_dtor(newval);
-			}
+			STR_RELEASE(str);
 			break;
 		default:
 			break;
@@ -853,23 +768,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-ID-NodeNSLocalN
 Since: DOM Level 2
 */
-int dom_node_local_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_local_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
-
-	nodep = dom_object_get_node(obj);
+	xmlNode *nodep = dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	if (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE || nodep->type == XML_NAMESPACE_DECL) {
-		ZVAL_STRING(*retval, (char *) (nodep->name), 1);
+		ZVAL_STRING(retval, (char *) (nodep->name));
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -882,26 +793,22 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-baseURI
 Since: DOM Level 3
 */
-int dom_node_base_uri_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_base_uri_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	xmlChar *baseuri;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
 	baseuri = xmlNodeGetBase(nodep->doc, nodep);
 	if (baseuri) {
-		ZVAL_STRING(*retval, (char *) (baseuri), 1);
+		ZVAL_STRING(retval, (char *) (baseuri));
 		xmlFree(baseuri);
 	} else {
-		ZVAL_NULL(*retval);
+		ZVAL_NULL(retval);
 	}
 
 	return SUCCESS;
@@ -914,13 +821,11 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#Node3-textContent
 Since: DOM Level 3
 */
-int dom_node_text_content_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_node_text_content_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNode *nodep;
+	xmlNode *nodep = dom_object_get_node(obj);
 	char *str = NULL;
 
-	nodep = dom_object_get_node(obj);
-
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
@@ -928,13 +833,11 @@ int dom_node_text_content_read(dom_object *obj, zval **retval TSRMLS_DC)
 
 	str = xmlNodeGetContent(nodep);
 
-	ALLOC_ZVAL(*retval);
-
-	if(str != NULL) {
-		ZVAL_STRING(*retval, str, 1);
+	if (str != NULL) {
+		ZVAL_STRING(retval, str);
 		xmlFree(str);
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
@@ -1629,7 +1532,7 @@ PHP_FUNCTION(dom_node_lookup_prefix)
 
 		if (lookupp != NULL && (nsptr = xmlSearchNsByHref(lookupp->doc, lookupp, uri))) {
 			if (nsptr->prefix != NULL) {
-				RETURN_STRING((char *) nsptr->prefix, 1);
+				RETURN_STRING((char *) nsptr->prefix);
 			}
 		}
 	}
@@ -1698,7 +1601,7 @@ PHP_FUNCTION(dom_node_lookup_namespace_uri)
 
 	nsptr = xmlSearchNs(nodep->doc, nodep, prefix);
 	if (nsptr && nsptr->href != NULL) {
-		RETURN_STRING((char *) nsptr->href, 1);
+		RETURN_STRING((char *) nsptr->href);
 	}
 
 	RETURN_NULL();
@@ -1804,12 +1707,12 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{
 	} else {
 		/*xpath query from xpath_array */
 		HashTable *ht = Z_ARRVAL_P(xpath_array);
-		zval **tmp;
+		zval *tmp;
 		char *xquery;
 
-		if (zend_hash_find(ht, "query", sizeof("query"), (void**)&tmp) == SUCCESS &&
-		    Z_TYPE_PP(tmp) == IS_STRING) {
-			xquery = Z_STRVAL_PP(tmp);
+		tmp = zend_hash_str_find(ht, "query", sizeof("query")-1);
+		if (tmp && Z_TYPE_P(tmp) == IS_STRING) {
+			xquery = Z_STRVAL_P(tmp);
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "'query' missing from xpath array or is not a string");
 			RETURN_FALSE;
@@ -1818,21 +1721,20 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{
 		ctxp = xmlXPathNewContext(docp);
 		ctxp->node = nodep;
 
-		if (zend_hash_find(ht, "namespaces", sizeof("namespaces"), (void**)&tmp) == SUCCESS &&
-		    Z_TYPE_PP(tmp) == IS_ARRAY) {
-			zval **tmpns;
-			while (zend_hash_get_current_data(Z_ARRVAL_PP(tmp), (void **)&tmpns) == SUCCESS) {
-				if (Z_TYPE_PP(tmpns) == IS_STRING) {
-					char *prefix;
+		tmp = zend_hash_str_find(ht, "namespaces", sizeof("namespaces")-1);
+		if (tmp && Z_TYPE_P(tmp) == IS_ARRAY) {
+			zval *tmpns;
+			while ((tmpns = zend_hash_get_current_data(Z_ARRVAL_P(tmp)))) {
+				if (Z_TYPE_P(tmpns) == IS_STRING) {
+					zend_string *prefix;
 					ulong idx;
-					uint prefix_key_len;
 
-					if (zend_hash_get_current_key_ex(Z_ARRVAL_PP(tmp), 
-						&prefix, &prefix_key_len, &idx, 0, NULL) == HASH_KEY_IS_STRING) {
-						xmlXPathRegisterNs(ctxp, prefix, Z_STRVAL_PP(tmpns));
+					if (zend_hash_get_current_key(Z_ARRVAL_P(tmp), 
+						&prefix, &idx, 0) == HASH_KEY_IS_STRING) {
+						xmlXPathRegisterNs(ctxp, prefix->val, Z_STRVAL_P(tmpns));
 					}
 				}
-				zend_hash_move_forward(Z_ARRVAL_PP(tmp));
+				zend_hash_move_forward(Z_ARRVAL_P(tmp));
 			}
 		}
 
@@ -1852,14 +1754,14 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{
 
 	if (ns_prefixes != NULL) {
 		if (exclusive) {
-			zval **tmpns;
+			zval *tmpns;
 			int nscount = 0;
 
 			inclusive_ns_prefixes = safe_emalloc(zend_hash_num_elements(Z_ARRVAL_P(ns_prefixes)) + 1,
 				sizeof(xmlChar *), 0);
-			while (zend_hash_get_current_data(Z_ARRVAL_P(ns_prefixes), (void **)&tmpns) == SUCCESS) {
-				if (Z_TYPE_PP(tmpns) == IS_STRING) {
-					inclusive_ns_prefixes[nscount++] = Z_STRVAL_PP(tmpns);
+			while ((tmpns = zend_hash_get_current_data(Z_ARRVAL_P(ns_prefixes)))) {
+				if (Z_TYPE_P(tmpns) == IS_STRING) {
+					inclusive_ns_prefixes[nscount++] = Z_STRVAL_P(tmpns);
 				}
 				zend_hash_move_forward(Z_ARRVAL_P(ns_prefixes));
 			}
@@ -1902,9 +1804,9 @@ static void dom_canonicalization(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{
 #endif
 			if (ret > 0) {
 #ifdef LIBXML2_NEW_BUFFER
-				RETVAL_STRINGL((char *) xmlOutputBufferGetContent(buf), ret, 1);
+				RETVAL_STRINGL((char *) xmlOutputBufferGetContent(buf), ret);
 #else
-				RETVAL_STRINGL((char *) buf->buffer->content, ret, 1);
+				RETVAL_STRINGL((char *) buf->buffer->content, ret);
 #endif
 			} else {
 				RETVAL_EMPTY_STRING();
@@ -1954,7 +1856,7 @@ PHP_METHOD(domnode, getNodePath)
 	if (value == NULL) {
 		RETURN_NULL();
 	} else {
-		RETVAL_STRING(value, 1);
+		RETVAL_STRING(value);
 		xmlFree(value);
 	}
 }
diff --git a/ext/dom/nodelist.c b/ext/dom/nodelist.c
index 1a0c811185..3ef43f2ac7 100644
--- a/ext/dom/nodelist.c
+++ b/ext/dom/nodelist.c
@@ -51,7 +51,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-203510337
 Since: 
 */
-int dom_nodelist_length_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_nodelist_length_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	dom_nnodemap_object *objmap;
 	xmlNodePtr nodep, curnode;
@@ -64,7 +64,7 @@ int dom_nodelist_length_read(dom_object *obj, zval **retval TSRMLS_DC)
 			count = xmlHashSize(objmap->ht);
 		} else {
 			if (objmap->nodetype == DOM_NODESET) {
-				nodeht = HASH_OF(objmap->baseobjptr);
+				nodeht = HASH_OF(&objmap->baseobj_zv);
 				count = zend_hash_num_elements(nodeht);
 			} else {
 				nodep = dom_object_get_node(objmap->baseobj);
@@ -91,8 +91,7 @@ int dom_nodelist_length_read(dom_object *obj, zval **retval TSRMLS_DC)
 		}
 	}
 
-	MAKE_STD_ZVAL(*retval);
-	ZVAL_LONG(*retval, count);
+	ZVAL_LONG(retval, count);
 	return SUCCESS;
 }
 
@@ -113,15 +112,13 @@ PHP_FUNCTION(dom_nodelist_item)
 	dom_nnodemap_object *objmap;
 	xmlNodePtr nodep, curnode;
 	int count = 0;
-	HashTable *nodeht;
-	zval **entry;
 
 	if (zend_parse_method_parameters(ZEND_NUM_ARGS() TSRMLS_CC, getThis(), "Ol", &id, dom_nodelist_class_entry, &index) == FAILURE) {
 		return;
 	}
 
 	if (index >= 0) {
-		intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_DOMOBJ_P(id);
 
 		objmap = (dom_nnodemap_object *)intern->ptr;
 		if (objmap != NULL) {
@@ -133,10 +130,10 @@ PHP_FUNCTION(dom_nodelist_item)
 				}
 			} else {
 				if (objmap->nodetype == DOM_NODESET) {
-					nodeht = HASH_OF(objmap->baseobjptr);
-					if (zend_hash_index_find(nodeht, index, (void **) &entry)==SUCCESS) {
-						*return_value = **entry;
-						zval_copy_ctor(return_value);
+					HashTable *nodeht = HASH_OF(&objmap->baseobj_zv);
+					zval *entry = zend_hash_index_find(nodeht, index);
+					if (entry) {
+						ZVAL_COPY(return_value, entry);
 						return;
 					}
 				} else if (objmap->baseobj) {
diff --git a/ext/dom/notation.c b/ext/dom/notation.c
index 4c0258cc1f..dc63f1516d 100644
--- a/ext/dom/notation.c
+++ b/ext/dom/notation.c
@@ -45,22 +45,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-54F2B4D0
 Since: 
 */
-int dom_notation_public_id_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_notation_public_id_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlEntityPtr nodep;
-
-	nodep = (xmlEntityPtr) dom_object_get_node(obj);
+	xmlEntityPtr nodep = (xmlEntityPtr) dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (nodep->ExternalID) {
-		ZVAL_STRING(*retval, (char *) (nodep->ExternalID), 1);
+		ZVAL_STRING(retval, (char *) (nodep->ExternalID));
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
@@ -73,22 +70,19 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-E8AAB1D0
 Since: 
 */
-int dom_notation_system_id_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_notation_system_id_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlEntityPtr nodep;
-
-	nodep = (xmlEntityPtr) dom_object_get_node(obj);
+	xmlEntityPtr nodep = (xmlEntityPtr) dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (nodep->SystemID) {
-		ZVAL_STRING(*retval, (char *) (nodep->SystemID), 1);
+		ZVAL_STRING(retval, (char *) (nodep->SystemID));
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
diff --git a/ext/dom/php_dom.c b/ext/dom/php_dom.c
index bfe966bd82..9f971ee0ac 100644
--- a/ext/dom/php_dom.c
+++ b/ext/dom/php_dom.c
@@ -72,6 +72,10 @@ zend_class_entry *dom_namespace_node_class_entry;
 /* }}} */
 
 zend_object_handlers dom_object_handlers;
+zend_object_handlers dom_nnodemap_object_handlers;
+#if defined(LIBXML_XPATH_ENABLED)
+zend_object_handlers dom_xpath_object_handlers;
+#endif
 
 static HashTable classes;
 /* {{{ prop handler tables */
@@ -99,7 +103,7 @@ static HashTable dom_xpath_prop_handlers;
 #endif
 /* }}} */
 
-typedef int (*dom_read_t)(dom_object *obj, zval **retval TSRMLS_DC);
+typedef int (*dom_read_t)(dom_object *obj, zval *retval TSRMLS_DC);
 typedef int (*dom_write_t)(dom_object *obj, zval *newval TSRMLS_DC);
 
 typedef struct _dom_prop_handler {
@@ -107,6 +111,10 @@ typedef struct _dom_prop_handler {
 	dom_write_t write_func;
 } dom_prop_handler;
 
+static zend_object_handlers* dom_get_obj_handlers(TSRMLS_D) {
+	return &dom_object_handlers;
+}
+
 /* {{{ int dom_node_is_read_only(xmlNodePtr node) */
 int dom_node_is_read_only(xmlNodePtr node) {
 	switch (node->type) {
@@ -192,7 +200,7 @@ static void dom_copy_doc_props(php_libxml_ref_obj *source_doc, php_libxml_ref_ob
 		if (source->classmap) {
 			ALLOC_HASHTABLE(dest->classmap);
 			zend_hash_init(dest->classmap, 0, NULL, NULL, 0);
-			zend_hash_copy(dest->classmap, source->classmap, NULL, NULL, sizeof(zend_class_entry *));
+			zend_hash_copy(dest->classmap, source->classmap, NULL);
 		}
 
 	}
@@ -212,9 +220,9 @@ int dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece,
 			zend_hash_init(doc_props->classmap, 0, NULL, NULL, 0);
 		}
 		if (ce) {
-			return zend_hash_update(doc_props->classmap, basece->name, basece->name_length + 1, &ce, sizeof(zend_class_entry *), NULL);
+			zend_hash_update_ptr(doc_props->classmap, basece->name, ce);
 		} else {
-			zend_hash_del(doc_props->classmap, basece->name, basece->name_length + 1);
+			zend_hash_del(doc_props->classmap, basece->name);
 		}
 	}
 	return SUCCESS;
@@ -223,13 +231,13 @@ int dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece,
 zend_class_entry *dom_get_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece TSRMLS_DC)
 {
 	dom_doc_propsptr doc_props;
-	zend_class_entry **ce = NULL;
 
 	if (document) {
 		doc_props = dom_get_doc_props(document);
 		if (doc_props->classmap) {
-			if (zend_hash_find(doc_props->classmap, basece->name, basece->name_length + 1,  (void**) &ce) == SUCCESS) {
-				return *ce;
+			zend_class_entry *ce = zend_hash_find_ptr(doc_props->classmap, basece->name);
+			if (ce) {
+				return ce;
 			}
 		}
 	}
@@ -276,9 +284,8 @@ PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj)
 /* }}} end php_dom_object_get_data */
 
 /* {{{ dom_read_na */
-static int dom_read_na(dom_object *obj, zval **retval TSRMLS_DC)
+static int dom_read_na(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	*retval = NULL;
 	php_error_docref(NULL TSRMLS_CC, E_ERROR, "Cannot read property");
 	return FAILURE;
 }
@@ -299,183 +306,121 @@ static void dom_register_prop_handler(HashTable *prop_handler, char *name, dom_r
 
 	hnd.read_func = read_func ? read_func : dom_read_na;
 	hnd.write_func = write_func ? write_func : dom_write_na;
-	zend_hash_add(prop_handler, name, strlen(name)+1, &hnd, sizeof(dom_prop_handler), NULL);
+	zend_hash_str_add_mem(prop_handler, name, strlen(name), &hnd, sizeof(dom_prop_handler));
 }
 /* }}} */
 
-static zval **dom_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *dom_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
-	dom_object *obj;
-	zval tmp_member;
-	zval **retval = NULL;
-	dom_prop_handler *hnd;
-	zend_object_handlers *std_hnd;
-	int ret = FAILURE;
-
- 	if (member->type != IS_STRING) {
-		tmp_member = *member;
-		zval_copy_ctor(&tmp_member);
-		convert_to_string(&tmp_member);
-		member = &tmp_member;
-	}
-
-	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
+	dom_object *obj = Z_DOMOBJ_P(object);
+	zend_string *member_str = zval_get_string(member);
+	zval *retval = NULL;
 
-	if (obj->prop_handler != NULL) {
-		ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
-	}
-	if (ret == FAILURE) {
-		std_hnd = zend_get_std_object_handlers();
-		retval = std_hnd->get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
+	if (!obj->prop_handler || !zend_hash_exists(obj->prop_handler, member_str)) {
+		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
+		retval = std_hnd->get_property_ptr_ptr(object, member, type, cache_slot TSRMLS_CC);
 	}
 
-	if (member == &tmp_member) {
-		zval_dtor(member);
-	}
+	STR_RELEASE(member_str);
 	return retval;
 }
 /* }}} */
 
 /* {{{ dom_read_property */
-zval *dom_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
+zval *dom_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
-	dom_object *obj;
-	zval tmp_member;
+	dom_object *obj = Z_DOMOBJ_P(object);
+	zend_string *member_str = zval_get_string(member);
 	zval *retval;
-	dom_prop_handler *hnd;
-	zend_object_handlers *std_hnd;
-	int ret;
-
- 	if (member->type != IS_STRING) {
-		tmp_member = *member;
-		zval_copy_ctor(&tmp_member);
-		convert_to_string(&tmp_member);
-		member = &tmp_member;
-	}
-
-	ret = FAILURE;
-	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
+	dom_prop_handler *hnd = NULL;
 
 	if (obj->prop_handler != NULL) {
-		ret = zend_hash_find(obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
+		hnd = zend_hash_find_ptr(obj->prop_handler, member_str);
 	} else if (instanceof_function(obj->std.ce, dom_node_class_entry TSRMLS_CC)) {
-		php_error(E_WARNING, "Couldn't fetch %s. Node no longer exists", obj->std.ce->name);
+		php_error(E_WARNING, "Couldn't fetch %s. Node no longer exists", obj->std.ce->name->val);
 	}
-	if (ret == SUCCESS) {
-		ret = hnd->read_func(obj, &retval TSRMLS_CC);
+
+	if (hnd) {
+		int ret = hnd->read_func(obj, rv TSRMLS_CC);
 		if (ret == SUCCESS) {
-			/* ensure we're creating a temporary variable */
-			Z_SET_REFCOUNT_P(retval, 0);
-			Z_UNSET_ISREF_P(retval);
+			retval = rv;
 		} else {
-			retval = EG(uninitialized_zval_ptr);
+			retval = &EG(uninitialized_zval);
 		}
 	} else {
-		std_hnd = zend_get_std_object_handlers();
-		retval = std_hnd->read_property(object, member, type, key TSRMLS_CC);
+		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
+		retval = std_hnd->read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 	}
 
-	if (member == &tmp_member) {
-		zval_dtor(member);
-	}
+	STR_RELEASE(member_str);
 	return retval;
 }
 /* }}} */
 
 /* {{{ dom_write_property */
-void dom_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+void dom_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
-	dom_object *obj;
-	zval tmp_member;
-	dom_prop_handler *hnd;
-	zend_object_handlers *std_hnd;
-	int ret;
-
- 	if (member->type != IS_STRING) {
-		tmp_member = *member;
-		zval_copy_ctor(&tmp_member);
-		convert_to_string(&tmp_member);
-		member = &tmp_member;
-	}
-
-	ret = FAILURE;
-	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
+	dom_object *obj = Z_DOMOBJ_P(object);
+	zend_string *member_str = zval_get_string(member);
+	dom_prop_handler *hnd = NULL;
 
 	if (obj->prop_handler != NULL) {
-		ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
+		hnd = zend_hash_find_ptr(obj->prop_handler, member_str);
 	}
-	if (ret == SUCCESS) {
+	if (hnd) {
 		hnd->write_func(obj, value TSRMLS_CC);
 	} else {
-		std_hnd = zend_get_std_object_handlers();
-		std_hnd->write_property(object, member, value, key TSRMLS_CC);
+		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
+		std_hnd->write_property(object, member, value, cache_slot TSRMLS_CC);
 	}
 
-	if (member == &tmp_member) {
-		zval_dtor(member);
-	}
+	STR_RELEASE(member_str);
 }
 /* }}} */
 
 /* {{{ dom_property_exists */
-static int dom_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
+static int dom_property_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)
 {
-	dom_object *obj;
-	zval tmp_member;
-	dom_prop_handler *hnd;
-	zend_object_handlers *std_hnd;
-	int ret, retval=0;
-
- 	if (member->type != IS_STRING) {
-		tmp_member = *member;
-		zval_copy_ctor(&tmp_member);
-		convert_to_string(&tmp_member);
-		member = &tmp_member;
-	}
-
-	ret = FAILURE;
-	obj = (dom_object *)zend_objects_get_address(object TSRMLS_CC);
+	dom_object *obj = Z_DOMOBJ_P(object);
+	zend_string *member_str = zval_get_string(member);
+	dom_prop_handler *hnd = NULL;
+	int retval = 0;
 
 	if (obj->prop_handler != NULL) {
-		ret = zend_hash_find((HashTable *)obj->prop_handler, Z_STRVAL_P(member), Z_STRLEN_P(member)+1, (void **) &hnd);
+		hnd = zend_hash_find_ptr(obj->prop_handler, member_str);
 	}
-	if (ret == SUCCESS) {
-		zval *tmp;
+	if (hnd) {
+		zval tmp;
 
 		if (check_empty == 2) {
 			retval = 1;
 		} else if (hnd->read_func(obj, &tmp TSRMLS_CC) == SUCCESS) {
-			Z_SET_REFCOUNT_P(tmp, 1);
-			Z_UNSET_ISREF_P(tmp);
 			if (check_empty == 1) {
-				retval = zend_is_true(tmp TSRMLS_CC);
+				retval = zend_is_true(&tmp TSRMLS_CC);
 			} else if (check_empty == 0) {
-				retval = (Z_TYPE_P(tmp) != IS_NULL);
+				retval = (Z_TYPE(tmp) != IS_NULL);
 			}
-			zval_ptr_dtor(&tmp);
+			zval_dtor(&tmp);
 		}
 	} else {
-		std_hnd = zend_get_std_object_handlers();
-		retval = std_hnd->has_property(object, member, check_empty, key TSRMLS_CC);
+		zend_object_handlers *std_hnd = zend_get_std_object_handlers();
+		retval = std_hnd->has_property(object, member, check_empty, cache_slot TSRMLS_CC);
 	}
 
-	if (member == &tmp_member) {
-		zval_dtor(member);
-	}
+	STR_RELEASE(member_str);
 	return retval;
 }
 /* }}} */
 
 static HashTable* dom_get_debug_info_helper(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
 {
-	dom_object			*obj = zend_object_store_get_object(object TSRMLS_CC);
+	dom_object			*obj = Z_DOMOBJ_P(object);
 	HashTable			*debug_info,
 						*prop_handlers = obj->prop_handler,
 						*std_props;
 	HashPosition		pos;
 	dom_prop_handler	*entry;
-	zval				*object_value,
-						*null_value;
+	zval object_value;
 
 	*is_temp = 1;
 
@@ -483,59 +428,39 @@ static HashTable* dom_get_debug_info_helper(zval *object, int *is_temp TSRMLS_DC
 	ZEND_INIT_SYMTABLE_EX(debug_info, 32, 0);
 
 	std_props = zend_std_get_properties(object TSRMLS_CC);
-	zend_hash_copy(debug_info, std_props, (copy_ctor_func_t)zval_add_ref,
-			NULL, sizeof(zval*));
+	zend_hash_copy(debug_info, std_props, (copy_ctor_func_t) zval_add_ref);
 
 	if (!prop_handlers) {
 		return debug_info;
 	}
 
-	ALLOC_INIT_ZVAL(object_value);
-	ZVAL_STRING(object_value, "(object value omitted)", 1);
-
-	ALLOC_INIT_ZVAL(null_value);
-	ZVAL_NULL(null_value);
+	ZVAL_STRING(&object_value, "(object value omitted)");
 
 	for (zend_hash_internal_pointer_reset_ex(prop_handlers, &pos);
-			zend_hash_get_current_data_ex(prop_handlers, (void **)&entry, &pos)
-					== SUCCESS;
+			(entry = zend_hash_get_current_data_ptr_ex(prop_handlers, &pos)) != NULL;
 			zend_hash_move_forward_ex(prop_handlers, &pos)) {
-		zval	*value;
-		char	*string_key		= NULL;
-		uint	string_length	= 0;
-		ulong	num_key;
+		zval value;
+		zend_string *string_key;
+		ulong num_key;
 
 		if (entry->read_func(obj, &value TSRMLS_CC) == FAILURE) {
 			continue;
 		}
 
 		if (zend_hash_get_current_key_ex(prop_handlers, &string_key,
-			&string_length, &num_key, 0, &pos) != HASH_KEY_IS_STRING) {
+			&num_key, 0, &pos) != HASH_KEY_IS_STRING) {
 			continue;
 		}
 
-		if (value == EG(uninitialized_zval_ptr)) {
-			value = null_value;
-		} else if (Z_TYPE_P(value) == IS_OBJECT) {
-			/* these are zvalues create on demand, with refcount and is_ref
-			 * status left in an uninitalized stated */
-			zval_dtor(value);
-			efree(value);
-
-			value = object_value;
-		} else {
-			/* see comment above */
-			Z_SET_REFCOUNT_P(value, 0);
-			Z_UNSET_ISREF_P(value);
+		if (Z_TYPE(value) == IS_OBJECT) {
+			zval_dtor(&value);
+			ZVAL_COPY(&value, &object_value);
 		}
 
-		zval_add_ref(&value);
-		zend_hash_add(debug_info, string_key, string_length,
-				&value, sizeof(zval *), NULL);
+		zend_hash_add(debug_info, string_key, &value);
 	}
 
-	zval_ptr_dtor(&null_value);
-	zval_ptr_dtor(&object_value);
+	zval_dtor(&object_value);
 
 	return debug_info;
 }
@@ -552,8 +477,8 @@ void *php_dom_export_node(zval *object TSRMLS_DC) /* {{{ */
 	php_libxml_node_object *intern;
 	xmlNodePtr nodep = NULL;
 
-	intern = (php_libxml_node_object *)zend_object_store_get_object(object TSRMLS_CC);
-	if (intern && intern->node) {
+	intern = (php_libxml_node_object *) Z_DOMOBJ_P(object);
+	if (intern->node) {
   		nodep = intern->node->node;
 	}
 
@@ -574,7 +499,7 @@ PHP_FUNCTION(dom_import_simplexml)
 		return;
 	}
 
-	nodeobj = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
+	nodeobj = (php_libxml_node_object *) ((char *) Z_OBJ_P(node) - Z_OBJ_HT_P(node)->offset);
 	nodep = php_libxml_import_node(node TSRMLS_CC);
 
 	if (nodep && nodeobj && (nodep->type == XML_ELEMENT_NODE || nodep->type == XML_ATTRIBUTE_NODE)) {
@@ -586,35 +511,52 @@ PHP_FUNCTION(dom_import_simplexml)
 }
 /* }}} */
 
-zend_object_value dom_objects_store_clone_obj(zval *zobject TSRMLS_DC) /* {{{ */
-{
-	zend_object_value retval;
-	void *new_object;
-	dom_object *intern;
-	dom_object *old_object;
-	struct _store_object *obj;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
+static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy TSRMLS_DC);
 
-	obj = &EG(objects_store).object_buckets[handle].bucket.obj;
+static zend_object *dom_objects_store_clone_obj(zval *zobject TSRMLS_DC) /* {{{ */
+{
+	dom_object *intern = Z_DOMOBJ_P(zobject);
+	dom_object *clone = dom_objects_set_class(intern->std.ce, 0 TSRMLS_CC);
 
-	if (obj->clone == NULL) {
-		php_error(E_ERROR, "Trying to clone an uncloneable object of class %s", Z_OBJCE_P(zobject)->name);
-	}
+	clone->std.handlers = dom_get_obj_handlers(TSRMLS_C);
+	zend_objects_clone_members(&clone->std, &intern->std TSRMLS_CC);
 
-	obj->clone(obj->object, &new_object TSRMLS_CC);
+	if (instanceof_function(intern->std.ce, dom_node_class_entry TSRMLS_CC)) {
+		xmlNodePtr node = (xmlNodePtr)dom_object_get_node(intern);
+		if (node != NULL) {
+			xmlNodePtr cloned_node = xmlDocCopyNode(node, node->doc, 1);
+			if (cloned_node != NULL) {
+				/* If we cloned a document then we must create new doc proxy */
+				if (cloned_node->doc == node->doc) {
+					clone->document = intern->document;
+				}
+				php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc TSRMLS_CC);
+				php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone TSRMLS_CC);
+				if (intern->document != clone->document) {
+					dom_copy_doc_props(intern->document, clone->document);
+				}
+			}
 
-	retval.handle = zend_objects_store_put(new_object, obj->dtor, obj->free_storage, obj->clone TSRMLS_CC);
-	intern = (dom_object *) new_object;
-	intern->handle = retval.handle;
-	retval.handlers = Z_OBJ_HT_P(zobject);
+		}
+	}
 
-	old_object = (dom_object *) obj->object;
-	zend_objects_clone_members(&intern->std, retval, &old_object->std, intern->handle TSRMLS_CC);
+	return &clone->std;
+}
+/* }}} */
 
-	return retval;
+static void dom_copy_prop_handler(zval *zv) /* {{{ */
+{
+	dom_prop_handler *hnd = Z_PTR_P(zv);
+	Z_PTR_P(zv) = malloc(sizeof(dom_prop_handler));
+	memcpy(Z_PTR_P(zv), hnd, sizeof(dom_prop_handler));
 }
 /* }}} */
 
+static void dom_dtor_prop_handler(zval *zv) /* {{{ */
+{
+	free(Z_PTR_P(zv));
+}
+
 /* {{{ arginfo */
 ZEND_BEGIN_ARG_INFO_EX(arginfo_dom_import_simplexml, 0, 0, 1)
 	ZEND_ARG_INFO(0, node)
@@ -626,10 +568,6 @@ static const zend_function_entry dom_functions[] = {
 	PHP_FE_END
 };
 
-static zend_object_handlers* dom_get_obj_handlers(TSRMLS_D) {
-	return &dom_object_handlers;
-}
-
 static const zend_module_dep dom_deps[] = {
 	ZEND_MOD_REQUIRED("libxml")
 	ZEND_MOD_CONFLICTS("domxml")
@@ -655,12 +593,23 @@ zend_module_entry dom_module_entry = { /* {{{ */
 ZEND_GET_MODULE(dom)
 #endif
 
+void dom_objects_free_storage(zend_object *object TSRMLS_DC);
+void dom_nnodemap_objects_free_storage(zend_object *object TSRMLS_DC);
+static zend_object *dom_objects_store_clone_obj(zval *zobject TSRMLS_DC);
+static void dom_nnodemap_object_dtor(zend_object *object TSRMLS_DC);
+#if defined(LIBXML_XPATH_ENABLED)
+void dom_xpath_objects_free_storage(zend_object *object TSRMLS_DC);
+#endif
+
 /* {{{ PHP_MINIT_FUNCTION(dom) */
 PHP_MINIT_FUNCTION(dom)
 {
 	zend_class_entry ce;
 
 	memcpy(&dom_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	dom_object_handlers.offset = XtOffsetOf(dom_object, std);
+	dom_object_handlers.free_obj = dom_objects_free_storage;
+	dom_object_handlers.clone_obj = dom_objects_store_clone_obj;
 	dom_object_handlers.read_property = dom_read_property;
 	dom_object_handlers.write_property = dom_write_property;
 	dom_object_handlers.get_property_ptr_ptr = dom_get_property_ptr_ptr;
@@ -668,37 +617,41 @@ PHP_MINIT_FUNCTION(dom)
 	dom_object_handlers.has_property = dom_property_exists;
 	dom_object_handlers.get_debug_info = dom_get_debug_info;
 
+	memcpy(&dom_nnodemap_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
+	dom_nnodemap_object_handlers.free_obj = dom_nnodemap_objects_free_storage;
+	dom_nnodemap_object_handlers.dtor_obj = dom_nnodemap_object_dtor;
+
 	zend_hash_init(&classes, 0, NULL, NULL, 1);
 
 	INIT_CLASS_ENTRY(ce, "DOMException", php_dom_domexception_class_functions);
-	dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
+	dom_domexception_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
 	dom_domexception_class_entry->ce_flags |= ZEND_ACC_FINAL;
 	zend_declare_property_long(dom_domexception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PUBLIC TSRMLS_CC);
 
 	REGISTER_DOM_CLASS(ce, "DOMStringList", NULL, php_dom_domstringlist_class_functions, dom_domstringlist_class_entry);
 
-	zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_domstringlist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_domstringlist_prop_handlers, "length", dom_domstringlist_length_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domstringlist_prop_handlers, sizeof(dom_domstringlist_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_domstringlist_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMNameList", NULL, php_dom_namelist_class_functions, dom_namelist_class_entry);
 
-	zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_namelist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_namelist_prop_handlers, "length", dom_namelist_length_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namelist_prop_handlers, sizeof(dom_namelist_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_namelist_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMImplementationList", NULL, php_dom_domimplementationlist_class_functions, dom_domimplementationlist_class_entry);
 
-	zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_domimplementationlist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_domimplementationlist_prop_handlers, "length", dom_domimplementationlist_length_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domimplementationlist_prop_handlers, sizeof(dom_domimplementationlist_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_domimplementationlist_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMImplementationSource", NULL, php_dom_domimplementationsource_class_functions, dom_domimplementationsource_class_entry);
 	REGISTER_DOM_CLASS(ce, "DOMImplementation", NULL, php_dom_domimplementation_class_functions, dom_domimplementation_class_entry);
 
 	REGISTER_DOM_CLASS(ce, "DOMNode", NULL, php_dom_node_class_functions, dom_node_class_entry);
 
-	zend_hash_init(&dom_node_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeValue", dom_node_node_value_read, dom_node_node_value_write TSRMLS_CC);
 	dom_register_prop_handler(&dom_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
@@ -715,11 +668,11 @@ PHP_MINIT_FUNCTION(dom)
 	dom_register_prop_handler(&dom_node_prop_handlers, "localName", dom_node_local_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_node_prop_handlers, "baseURI", dom_node_base_uri_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_node_prop_handlers, "textContent", dom_node_text_content_read, dom_node_text_content_write TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_node_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMNameSpaceNode", NULL, NULL, dom_namespace_node_class_entry);
 
-	zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_namespace_node_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeName", dom_node_node_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeValue", dom_node_node_value_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "nodeType", dom_node_node_type_read, NULL TSRMLS_CC);
@@ -728,13 +681,13 @@ PHP_MINIT_FUNCTION(dom)
 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "namespaceURI", dom_node_namespace_uri_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "ownerDocument", dom_node_owner_document_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_namespace_node_prop_handlers, "parentNode", dom_node_parent_node_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namespace_node_prop_handlers, sizeof(dom_namespace_node_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_namespace_node_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMDocumentFragment", dom_node_class_entry, php_dom_documentfragment_class_functions, dom_documentfragment_class_entry);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_node_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_node_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMDocument", dom_node_class_entry, php_dom_document_class_functions, dom_document_class_entry);
-	zend_hash_init(&dom_document_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_document_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_document_prop_handlers, "doctype", dom_document_doctype_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_document_prop_handlers, "implementation", dom_document_implementation_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_document_prop_handlers, "documentElement", dom_document_document_element_read, NULL TSRMLS_CC);
@@ -755,154 +708,157 @@ PHP_MINIT_FUNCTION(dom)
 	dom_register_prop_handler(&dom_document_prop_handlers, "recover", dom_document_recover_read, dom_document_recover_write TSRMLS_CC);
 	dom_register_prop_handler(&dom_document_prop_handlers, "substituteEntities", dom_document_substitue_entities_read, dom_document_substitue_entities_write TSRMLS_CC);
 
-	zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_document_prop_handlers, sizeof(dom_document_prop_handlers), NULL);
+	zend_hash_merge(&dom_document_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_document_prop_handlers);
 
 	INIT_CLASS_ENTRY(ce, "DOMNodeList", php_dom_nodelist_class_functions);
 	ce.create_object = dom_nnodemap_objects_new;
-	dom_nodelist_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
+	dom_nodelist_class_entry = zend_register_internal_class_ex(&ce, NULL TSRMLS_CC);
 	dom_nodelist_class_entry->get_iterator = php_dom_get_iterator;
 	zend_class_implements(dom_nodelist_class_entry TSRMLS_CC, 1, zend_ce_traversable);
 
-	zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_nodelist_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_nodelist_prop_handlers, "length", dom_nodelist_length_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_nodelist_prop_handlers, sizeof(dom_nodelist_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_nodelist_prop_handlers);
 
 	INIT_CLASS_ENTRY(ce, "DOMNamedNodeMap", php_dom_namednodemap_class_functions);
 	ce.create_object = dom_nnodemap_objects_new;
-	dom_namednodemap_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
+	dom_namednodemap_class_entry = zend_register_internal_class_ex(&ce, NULL TSRMLS_CC);
 	dom_namednodemap_class_entry->get_iterator = php_dom_get_iterator;
 	zend_class_implements(dom_namednodemap_class_entry TSRMLS_CC, 1, zend_ce_traversable);
 
-	zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_namednodemap_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_namednodemap_prop_handlers, "length", dom_namednodemap_length_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_namednodemap_prop_handlers, sizeof(dom_namednodemap_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_namednodemap_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMCharacterData", dom_node_class_entry, php_dom_characterdata_class_functions, dom_characterdata_class_entry);
 
-	zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_characterdata_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "data", dom_characterdata_data_read, dom_characterdata_data_write TSRMLS_CC);
 	dom_register_prop_handler(&dom_characterdata_prop_handlers, "length", dom_characterdata_length_read, NULL TSRMLS_CC);
-	zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_characterdata_prop_handlers), NULL);
+	zend_hash_merge(&dom_characterdata_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_characterdata_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMAttr", dom_node_class_entry, php_dom_attr_class_functions, dom_attr_class_entry);
 
-	zend_hash_init(&dom_attr_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_attr_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_attr_prop_handlers, "name", dom_attr_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_attr_prop_handlers, "specified", dom_attr_specified_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_attr_prop_handlers, "value", dom_attr_value_read, dom_attr_value_write TSRMLS_CC);
 	dom_register_prop_handler(&dom_attr_prop_handlers, "ownerElement", dom_attr_owner_element_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_attr_prop_handlers, "schemaTypeInfo", dom_attr_schema_type_info_read, NULL TSRMLS_CC);
-	zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_attr_prop_handlers, sizeof(dom_attr_prop_handlers), NULL);
+	zend_hash_merge(&dom_attr_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_attr_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMElement", dom_node_class_entry, php_dom_element_class_functions, dom_element_class_entry);
 
-	zend_hash_init(&dom_element_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_element_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_element_prop_handlers, "tagName", dom_element_tag_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_element_prop_handlers, "schemaTypeInfo", dom_element_schema_type_info_read, NULL TSRMLS_CC);
-	zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_element_prop_handlers, sizeof(dom_element_prop_handlers), NULL);
+	zend_hash_merge(&dom_element_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_element_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMText", dom_characterdata_class_entry, php_dom_text_class_functions, dom_text_class_entry);
 
-	zend_hash_init(&dom_text_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_text_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_text_prop_handlers, "wholeText", dom_text_whole_text_read, NULL TSRMLS_CC);
-	zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_text_prop_handlers), NULL);
+	zend_hash_merge(&dom_text_prop_handlers, &dom_characterdata_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_text_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMComment", dom_characterdata_class_entry, php_dom_comment_class_functions, dom_comment_class_entry);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_characterdata_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_characterdata_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMTypeinfo", NULL, php_dom_typeinfo_class_functions, dom_typeinfo_class_entry);
 
-	zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_typeinfo_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeName", dom_typeinfo_type_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_typeinfo_prop_handlers, "typeNamespace", dom_typeinfo_type_namespace_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_typeinfo_prop_handlers, sizeof(dom_typeinfo_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_typeinfo_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMUserDataHandler", NULL, php_dom_userdatahandler_class_functions, dom_userdatahandler_class_entry);
 	REGISTER_DOM_CLASS(ce, "DOMDomError", NULL, php_dom_domerror_class_functions, dom_domerror_class_entry);
 
-	zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_domerror_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_domerror_prop_handlers, "severity", dom_domerror_severity_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domerror_prop_handlers, "message", dom_domerror_message_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domerror_prop_handlers, "type", dom_domerror_type_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domerror_prop_handlers, "relatedException", dom_domerror_related_exception_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domerror_prop_handlers, "related_data", dom_domerror_related_data_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domerror_prop_handlers, "location", dom_domerror_location_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domerror_prop_handlers, sizeof(dom_domerror_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_domerror_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMErrorHandler", NULL, php_dom_domerrorhandler_class_functions, dom_domerrorhandler_class_entry);
 	REGISTER_DOM_CLASS(ce, "DOMLocator", NULL, php_dom_domlocator_class_functions, dom_domlocator_class_entry);
 
-	zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_domlocator_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "lineNumber", dom_domlocator_line_number_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "columnNumber", dom_domlocator_column_number_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "offset", dom_domlocator_offset_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "relatedNode", dom_domlocator_related_node_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_domlocator_prop_handlers, "uri", dom_domlocator_uri_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_domlocator_prop_handlers, sizeof(dom_domlocator_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_domlocator_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMConfiguration", NULL, php_dom_domconfiguration_class_functions, dom_domconfiguration_class_entry);
 	REGISTER_DOM_CLASS(ce, "DOMCdataSection", dom_text_class_entry, php_dom_cdatasection_class_functions, dom_cdatasection_class_entry);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_text_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_text_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMDocumentType", dom_node_class_entry, php_dom_documenttype_class_functions, dom_documenttype_class_entry);
 
-	zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_documenttype_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "name", dom_documenttype_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "entities", dom_documenttype_entities_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "notations", dom_documenttype_notations_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "publicId", dom_documenttype_public_id_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "systemId", dom_documenttype_system_id_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_documenttype_prop_handlers, "internalSubset", dom_documenttype_internal_subset_read, NULL TSRMLS_CC);
-	zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_documenttype_prop_handlers, sizeof(dom_documenttype_prop_handlers), NULL);
+	zend_hash_merge(&dom_documenttype_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_documenttype_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMNotation", dom_node_class_entry, php_dom_notation_class_functions, dom_notation_class_entry);
 
-	zend_hash_init(&dom_notation_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_notation_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_notation_prop_handlers, "publicId", dom_notation_public_id_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_notation_prop_handlers, "systemId", dom_notation_system_id_read, NULL TSRMLS_CC);
-	zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_notation_prop_handlers, sizeof(dom_notation_prop_handlers), NULL);
+	zend_hash_merge(&dom_notation_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_notation_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMEntity", dom_node_class_entry, php_dom_entity_class_functions, dom_entity_class_entry);
 
-	zend_hash_init(&dom_entity_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_entity_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_entity_prop_handlers, "publicId", dom_entity_public_id_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_entity_prop_handlers, "systemId", dom_entity_system_id_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_entity_prop_handlers, "notationName", dom_entity_notation_name_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_entity_prop_handlers, "actualEncoding", dom_entity_actual_encoding_read, dom_entity_actual_encoding_write TSRMLS_CC);
 	dom_register_prop_handler(&dom_entity_prop_handlers, "encoding", dom_entity_encoding_read, dom_entity_encoding_write TSRMLS_CC);
 	dom_register_prop_handler(&dom_entity_prop_handlers, "version", dom_entity_version_read, dom_entity_version_write TSRMLS_CC);
-	zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_entity_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
+	zend_hash_merge(&dom_entity_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_entity_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMEntityReference", dom_node_class_entry, php_dom_entityreference_class_functions, dom_entityreference_class_entry);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_node_prop_handlers, sizeof(dom_entity_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_node_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMProcessingInstruction", dom_node_class_entry, php_dom_processinginstruction_class_functions, dom_processinginstruction_class_entry);
 
-	zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_processinginstruction_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "target", dom_processinginstruction_target_read, NULL TSRMLS_CC);
 	dom_register_prop_handler(&dom_processinginstruction_prop_handlers, "data", dom_processinginstruction_data_read, dom_processinginstruction_data_write TSRMLS_CC);
-	zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, NULL, NULL, sizeof(dom_prop_handler), 0);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_processinginstruction_prop_handlers, sizeof(dom_processinginstruction_prop_handlers), NULL);
+	zend_hash_merge(&dom_processinginstruction_prop_handlers, &dom_node_prop_handlers, dom_copy_prop_handler, 0);
+	zend_hash_add_ptr(&classes, ce.name, &dom_processinginstruction_prop_handlers);
 
 	REGISTER_DOM_CLASS(ce, "DOMStringExtend", NULL, php_dom_string_extend_class_functions, dom_string_extend_class_entry);
 
 #if defined(LIBXML_XPATH_ENABLED)
+	memcpy(&dom_xpath_object_handlers, &dom_object_handlers, sizeof(zend_object_handlers));
+	dom_xpath_object_handlers.offset = XtOffsetOf(dom_xpath_object, dom) + XtOffsetOf(dom_object, std);
+	dom_xpath_object_handlers.free_obj = dom_xpath_objects_free_storage;
+
 	INIT_CLASS_ENTRY(ce, "DOMXPath", php_dom_xpath_class_functions);
 	ce.create_object = dom_xpath_objects_new;
-	dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
+	dom_xpath_class_entry = zend_register_internal_class_ex(&ce, NULL TSRMLS_CC);
 
-	zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, NULL, 1);
+	zend_hash_init(&dom_xpath_prop_handlers, 0, NULL, dom_dtor_prop_handler, 1);
 	dom_register_prop_handler(&dom_xpath_prop_handlers, "document", dom_xpath_document_read, NULL TSRMLS_CC);
-	zend_hash_add(&classes, ce.name, ce.name_length + 1, &dom_xpath_prop_handlers, sizeof(dom_xpath_prop_handlers), NULL);
+	zend_hash_add_ptr(&classes, ce.name, &dom_xpath_prop_handlers);
 #endif
 
 	REGISTER_LONG_CONSTANT("XML_ELEMENT_NODE",			XML_ELEMENT_NODE,			CONST_CS | CONST_PERSISTENT);
@@ -1058,16 +1014,15 @@ void node_list_unlink(xmlNodePtr node TSRMLS_DC)
 
 #if defined(LIBXML_XPATH_ENABLED)
 /* {{{ dom_xpath_objects_free_storage */
-void dom_xpath_objects_free_storage(void *object TSRMLS_DC)
+void dom_xpath_objects_free_storage(zend_object *object TSRMLS_DC)
 {
-	dom_xpath_object *intern = (dom_xpath_object *)object;
+	dom_xpath_object *intern = php_xpath_obj_from_obj(object);
 
-	zend_object_std_dtor(&intern->std TSRMLS_CC);
+	zend_object_std_dtor(&intern->dom.std TSRMLS_CC);
 
-	if (intern->ptr != NULL) {
-		xmlXPathFreeContext((xmlXPathContextPtr) intern->ptr);
-		php_libxml_decrement_doc_ref((php_libxml_node_object *) intern TSRMLS_CC);
-		intern->ptr = NULL;
+	if (intern->dom.ptr != NULL) {
+		xmlXPathFreeContext((xmlXPathContextPtr) intern->dom.ptr);
+		php_libxml_decrement_doc_ref((php_libxml_node_object *) &intern->dom TSRMLS_CC);
 	}
 
 	if (intern->registered_phpfunctions) {
@@ -1079,16 +1034,14 @@ void dom_xpath_objects_free_storage(void *object TSRMLS_DC)
 		zend_hash_destroy(intern->node_list);
 		FREE_HASHTABLE(intern->node_list);
 	}
-
-	efree(object);
 }
 /* }}} */
 #endif
 
 /* {{{ dom_objects_free_storage */
-void dom_objects_free_storage(void *object TSRMLS_DC)
+void dom_objects_free_storage(zend_object *object TSRMLS_DC)
 {
-	dom_object *intern = (dom_object *)object;
+	dom_object *intern = php_dom_obj_from_obj(object);
 #if defined(__GNUC__) && __GNUC__ >= 3
 	int retcount __attribute__((unused)); /* keep compiler quiet */
 #else
@@ -1106,56 +1059,35 @@ void dom_objects_free_storage(void *object TSRMLS_DC)
 		}
 		intern->ptr = NULL;
 	}
-
-	efree(object);
 }
 /* }}} */
 
 void dom_namednode_iter(dom_object *basenode, int ntype, dom_object *intern, xmlHashTablePtr ht, xmlChar *local, xmlChar *ns TSRMLS_DC) /* {{{ */
 {
-	dom_nnodemap_object *mapptr;
-	zval *baseobj = NULL;
-
-	mapptr = (dom_nnodemap_object *)intern->ptr;
-	if (basenode) {
-		MAKE_STD_ZVAL(baseobj);
-		baseobj->type = IS_OBJECT;
-		Z_SET_ISREF_P(baseobj);
-		baseobj->value.obj.handle = basenode->handle;
-		baseobj->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
-		zval_copy_ctor(baseobj);
-	}
-	mapptr->baseobjptr = baseobj;
+	dom_nnodemap_object *mapptr = (dom_nnodemap_object *) intern->ptr;
+
+	//??? if (basenode)
+	ZVAL_OBJ(&mapptr->baseobj_zv, &basenode->std);
+	Z_ADDREF(mapptr->baseobj_zv);
+
 	mapptr->baseobj = basenode;
 	mapptr->nodetype = ntype;
 	mapptr->ht = ht;
 	mapptr->local = local;
 	mapptr->ns = ns;
-
 }
 /* }}} */
 
 static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool hash_copy TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry *base_class;
-	dom_object *intern;
+	dom_object *intern = ecalloc(1, sizeof(dom_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 
-	if (instanceof_function(class_type, dom_xpath_class_entry TSRMLS_CC)) {
-		intern = emalloc(sizeof(dom_xpath_object));
-		memset(intern, 0, sizeof(dom_xpath_object));
-	} else {
-		intern = emalloc(sizeof(dom_object));
-	}
-	intern->ptr = NULL;
-	intern->prop_handler = NULL;
-	intern->document = NULL;
-
-	base_class = class_type;
-	while(base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
+	zend_class_entry *base_class = class_type;
+	while (base_class->type != ZEND_INTERNAL_CLASS && base_class->parent != NULL) {
 		base_class = base_class->parent;
 	}
 
-	zend_hash_find(&classes, base_class->name, base_class->name_length + 1, (void **) &intern->prop_handler);
+	intern->prop_handler = zend_hash_find_ptr(&classes, base_class->name);
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	if (hash_copy) {
@@ -1166,86 +1098,41 @@ static dom_object* dom_objects_set_class(zend_class_entry *class_type, zend_bool
 }
 /* }}} */
 
-/* {{{ dom_objects_clone */
-void dom_objects_clone(void *object, void **object_clone TSRMLS_DC)
-{
-	dom_object *intern = (dom_object *) object;
-	dom_object *clone;
-	xmlNodePtr node;
-	xmlNodePtr cloned_node;
-
-	clone = dom_objects_set_class(intern->std.ce, 0 TSRMLS_CC);
-
-	if (instanceof_function(intern->std.ce, dom_node_class_entry TSRMLS_CC)) {
-		node = (xmlNodePtr)dom_object_get_node((dom_object *) object);
-		if (node != NULL) {
-			cloned_node = xmlDocCopyNode(node, node->doc, 1);
-			if (cloned_node != NULL) {
-				/* If we cloned a document then we must create new doc proxy */
-				if (cloned_node->doc == node->doc) {
-					clone->document = intern->document;
-				}
-				php_libxml_increment_doc_ref((php_libxml_node_object *)clone, cloned_node->doc TSRMLS_CC);
-				php_libxml_increment_node_ptr((php_libxml_node_object *)clone, cloned_node, (void *)clone TSRMLS_CC);
-				if (intern->document != clone->document) {
-					dom_copy_doc_props(intern->document, clone->document);
-				}
-			}
-
-		}
-	}
-
-	*object_clone = (void *) clone;
-}
-/* }}} */
-
 /* {{{ dom_objects_new */
-zend_object_value dom_objects_new(zend_class_entry *class_type TSRMLS_DC)
+zend_object *dom_objects_new(zend_class_entry *class_type TSRMLS_DC)
 {
-	zend_object_value retval;
-	dom_object *intern;
-
-	intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
-
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)dom_objects_free_storage, dom_objects_clone TSRMLS_CC);
-	intern->handle = retval.handle;
-	retval.handlers = dom_get_obj_handlers(TSRMLS_C);
-
-	return retval;
+	dom_object *intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
+	intern->std.handlers = dom_get_obj_handlers(TSRMLS_C);
+	return &intern->std;
 }
 /* }}} */
 
 #if defined(LIBXML_XPATH_ENABLED)
 /* {{{ zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC) */
-zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC)
+zend_object *dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC)
 {
-	zend_object_value retval;
-	dom_xpath_object *intern;
-
-	intern = (dom_xpath_object *)dom_objects_set_class(class_type, 1 TSRMLS_CC);
-	intern->registerPhpFunctions = 0;
-	intern->registered_phpfunctions = NULL;
-	intern->node_list = NULL;
+	dom_xpath_object *intern = ecalloc(1, sizeof(dom_xpath_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	ALLOC_HASHTABLE(intern->registered_phpfunctions);
 	zend_hash_init(intern->registered_phpfunctions, 0, NULL, ZVAL_PTR_DTOR, 0);
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)dom_xpath_objects_free_storage, dom_objects_clone TSRMLS_CC);
-	intern->handle = retval.handle;
-	retval.handlers = dom_get_obj_handlers(TSRMLS_C);
+	intern->dom.prop_handler = &dom_xpath_prop_handlers;
+	intern->dom.std.handlers = &dom_xpath_object_handlers;
 
-	return retval;
+	zend_object_std_init(&intern->dom.std, class_type TSRMLS_CC);
+	object_properties_init(&intern->dom.std, class_type);
+
+	return &intern->dom.std;
 }
 /* }}} */
 #endif
 
-static void dom_nnodemap_object_dtor(void *object, zend_object_handle handle TSRMLS_DC) /* {{{ */
+static void dom_nnodemap_object_dtor(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	zval *baseobj;
 	dom_object *intern;
 	dom_nnodemap_object *objmap;
 
-	intern = (dom_object *)object;
+	intern = php_dom_obj_from_obj(object);
 	objmap = (dom_nnodemap_object *)intern->ptr;
 
 	if (objmap) {
@@ -1255,51 +1142,43 @@ static void dom_nnodemap_object_dtor(void *object, zend_object_handle handle TSR
 		if (objmap->ns) {
 			xmlFree(objmap->ns);
 		}
-		if (objmap->baseobjptr) {
-			baseobj = objmap->baseobjptr;
-			zval_ptr_dtor((zval **)&baseobj);
+		if (!ZVAL_IS_UNDEF(&objmap->baseobj_zv)) {
+			zval_ptr_dtor(&objmap->baseobj_zv);
 		}
 		efree(objmap);
 		intern->ptr = NULL;
 	}
-
-
 }
 /* }}} */
 
-void dom_nnodemap_objects_free_storage(void *object TSRMLS_DC) /* {{{ */
+void dom_nnodemap_objects_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	dom_object *intern = (dom_object *)object;
+	dom_object *intern = php_dom_obj_from_obj(object);
 
 	php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
-
-	efree(object);
 }
 /* }}} */
 
-zend_object_value dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+zend_object *dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	zend_object_value retval;
 	dom_object *intern;
 	dom_nnodemap_object *objmap;
 
 	intern = dom_objects_set_class(class_type, 1 TSRMLS_CC);
 	intern->ptr = emalloc(sizeof(dom_nnodemap_object));
 	objmap = (dom_nnodemap_object *)intern->ptr;
+	ZVAL_UNDEF(&objmap->baseobj_zv);
 	objmap->baseobj = NULL;
-	objmap->baseobjptr = NULL;
 	objmap->nodetype = 0;
 	objmap->ht = NULL;
 	objmap->local = NULL;
 	objmap->ns = NULL;
 
-	retval.handle = zend_objects_store_put(intern, dom_nnodemap_object_dtor, (zend_objects_free_object_storage_t)dom_nnodemap_objects_free_storage, dom_objects_clone TSRMLS_CC);
-	intern->handle = retval.handle;
-	retval.handlers = dom_get_obj_handlers(TSRMLS_C);
+	intern->std.handlers = &dom_nnodemap_object_handlers;
 
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
@@ -1318,32 +1197,22 @@ void php_dom_create_interator(zval *return_value, int ce_type TSRMLS_DC) /* {{{
 /* }}} */
 
 /* {{{ php_dom_create_object */
-PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *return_value, dom_object *domobj TSRMLS_DC)
+PHP_DOM_EXPORT zend_bool php_dom_create_object(xmlNodePtr obj, zval *return_value, dom_object *domobj TSRMLS_DC)
 {
-	zval *wrapper;
 	zend_class_entry *ce;
 	dom_object *intern;
 
-	*found = 0;
-
 	if (!obj) {
-		ALLOC_ZVAL(wrapper);
-		ZVAL_NULL(wrapper);
-		return wrapper;
+		ZVAL_NULL(return_value);
+		return 0;
 	}
 
 	if ((intern = (dom_object *) php_dom_object_get_data((void *) obj))) {
-		return_value->type = IS_OBJECT;
-		Z_SET_ISREF_P(return_value);
-		return_value->value.obj.handle = intern->handle;
-		return_value->value.obj.handlers = dom_get_obj_handlers(TSRMLS_C);
-		zval_copy_ctor(return_value);
-		*found = 1;
-		return return_value;
+		GC_REFCOUNT(&intern->std)++;
+		ZVAL_OBJ(return_value, &intern->std);
+		return 1;
 	}
 
-	wrapper = return_value;
-
 	switch (obj->type) {
 		case XML_DOCUMENT_NODE:
 		case XML_HTML_DOCUMENT_NODE:
@@ -1414,17 +1283,17 @@ PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *ret
 			break;
 		}
 		default:
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported node type: %d", Z_TYPE_P(obj));
-			ZVAL_NULL(wrapper);
-			return wrapper;
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported node type: %d", obj->type);
+			ZVAL_NULL(return_value);
+			return 0;
 	}
 
 	if (domobj && domobj->document) {
 		ce = dom_get_doc_classmap(domobj->document, ce TSRMLS_CC);
 	}
-	object_init_ex(wrapper, ce);
+	object_init_ex(return_value, ce);
 
-	intern = (dom_object *)zend_objects_get_address(wrapper TSRMLS_CC);
+	intern = Z_DOMOBJ_P(return_value);
 	if (obj->doc != NULL) {
 		if (domobj != NULL) {
 			intern->document = domobj->document;
@@ -1433,12 +1302,12 @@ PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval *ret
 	}
 
 	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, obj, (void *)intern TSRMLS_CC);
-	return (wrapper);
+	return 0;
 }
 /* }}} end php_domobject_new */
 
-void php_dom_create_implementation(zval **retval  TSRMLS_DC) {
-	object_init_ex(*retval, dom_domimplementation_class_entry);
+void php_dom_create_implementation(zval *retval TSRMLS_DC) {
+	object_init_ex(retval, dom_domimplementation_class_entry);
 }
 
 /* {{{ int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child) */
diff --git a/ext/dom/php_dom.h b/ext/dom/php_dom.h
index f2bccf7b87..628a19e978 100644
--- a/ext/dom/php_dom.h
+++ b/ext/dom/php_dom.h
@@ -68,38 +68,41 @@ extern zend_module_entry dom_module_entry;
 #define DOM_NODESET XML_XINCLUDE_START
 
 typedef struct _dom_xpath_object {
-	zend_object  std;
-	void *ptr;
-	php_libxml_ref_obj *document;
-	HashTable *prop_handler;
-	zend_object_handle handle;
 	int registerPhpFunctions;
 	HashTable *registered_phpfunctions;
 	HashTable *node_list;
+	dom_object dom;
 } dom_xpath_object;
 
+static inline dom_xpath_object *php_xpath_obj_from_obj(zend_object *obj) {
+	return (dom_xpath_object*)((char*)(obj)
+		- XtOffsetOf(dom_xpath_object, dom) - XtOffsetOf(dom_object, std));
+}
+
+#define Z_XPATHOBJ_P(zv)  php_xpath_obj_from_obj(Z_OBJ_P((zv)))
+
 typedef struct _dom_nnodemap_object {
 	dom_object *baseobj;
+	zval baseobj_zv;
 	int nodetype;
 	xmlHashTable *ht;
 	xmlChar *local;
 	xmlChar *ns;
-	zval *baseobjptr;
 } dom_nnodemap_object;
 
 typedef struct {
-	zend_object_iterator     intern;
-	zval *curobj;
+	zend_object_iterator intern;
+	zval curobj;
 } php_dom_iterator;
 
 #include "dom_fe.h"
 
 dom_object *dom_object_get_data(xmlNodePtr obj);
 dom_doc_propsptr dom_get_doc_props(php_libxml_ref_obj *document);
-zend_object_value dom_objects_new(zend_class_entry *class_type TSRMLS_DC);
-zend_object_value dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC);
+zend_object *dom_objects_new(zend_class_entry *class_type TSRMLS_DC);
+zend_object *dom_nnodemap_objects_new(zend_class_entry *class_type TSRMLS_DC);
 #if defined(LIBXML_XPATH_ENABLED)
-zend_object_value dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC);
+zend_object *dom_xpath_objects_new(zend_class_entry *class_type TSRMLS_DC);
 #endif
 int dom_get_strict_error(php_libxml_ref_obj *document);
 void php_dom_throw_error(int error_code, int strict_error TSRMLS_DC);
@@ -111,7 +114,7 @@ void dom_set_old_ns(xmlDoc *doc, xmlNs *ns);
 xmlNsPtr dom_get_nsdecl(xmlNode *node, xmlChar *localName);
 void dom_normalize (xmlNodePtr nodep TSRMLS_DC);
 xmlNode *dom_get_elements_by_tag_name_ns_raw(xmlNodePtr nodep, char *ns, char *local, int *cur, int index);
-void php_dom_create_implementation(zval **retval  TSRMLS_DC);
+void php_dom_create_implementation(zval *retval TSRMLS_DC);
 int dom_hierarchy(xmlNodePtr parent, xmlNodePtr child);
 int dom_has_feature(char *feature, char *version);
 int dom_node_is_read_only(xmlNodePtr node);
@@ -127,12 +130,12 @@ int dom_set_doc_classmap(php_libxml_ref_obj *document, zend_class_entry *basece,
 #define REGISTER_DOM_CLASS(ce, name, parent_ce, funcs, entry) \
 INIT_CLASS_ENTRY(ce, name, funcs); \
 ce.create_object = dom_objects_new; \
-entry = zend_register_internal_class_ex(&ce, parent_ce, NULL TSRMLS_CC);
+entry = zend_register_internal_class_ex(&ce, parent_ce TSRMLS_CC);
 
 #define DOM_GET_OBJ(__ptr, __id, __prtype, __intern) { \
-	__intern = (dom_object *)zend_object_store_get_object(__id TSRMLS_CC); \
+	__intern = Z_DOMOBJ_P(__id); \
 	if (__intern->ptr == NULL || !(__ptr = (__prtype)((php_libxml_node_ptr *)__intern->ptr)->node)) { \
-  		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't fetch %s", __intern->std.ce->name);\
+  		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't fetch %s", __intern->std.ce->name->val);\
   		RETURN_NULL();\
   	} \
 }
diff --git a/ext/dom/processinginstruction.c b/ext/dom/processinginstruction.c
index 5a415efc80..36b159cc6e 100644
--- a/ext/dom/processinginstruction.c
+++ b/ext/dom/processinginstruction.c
@@ -50,7 +50,6 @@ const zend_function_entry php_dom_processinginstruction_class_functions[] = {
 /* {{{ proto void DOMProcessingInstruction::__construct(string name, [string value]); */
 PHP_METHOD(domprocessinginstruction, __construct)
 {
-
 	zval *id;
 	xmlNodePtr nodep = NULL, oldnode = NULL;
 	dom_object *intern;
@@ -79,14 +78,12 @@ PHP_METHOD(domprocessinginstruction, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
-	if (intern != NULL) {
-		oldnode = dom_object_get_node(intern);
-		if (oldnode != NULL) {
-			php_libxml_node_free_resource(oldnode  TSRMLS_CC);
-		}
-		php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
+	oldnode = dom_object_get_node(intern);
+	if (oldnode != NULL) {
+		php_libxml_node_free_resource(oldnode  TSRMLS_CC);
 	}
+	php_libxml_increment_node_ptr((php_libxml_node_object *)intern, nodep, (void *)intern TSRMLS_CC);
 }
 /* }}} end DOMProcessingInstruction::__construct */
 
@@ -95,19 +92,16 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-1478689192
 Since: 
 */
-int dom_processinginstruction_target_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_processinginstruction_target_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	xmlNodePtr nodep;
-
-	nodep = dom_object_get_node(obj);
+	xmlNodePtr nodep = dom_object_get_node(obj);
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-	ZVAL_STRING(*retval, (char *) (nodep->name), 1);
+	ZVAL_STRING(retval, (char *) (nodep->name));
 
 	return SUCCESS;
 }
@@ -119,7 +113,7 @@ readonly=no
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#ID-837822393
 Since: 
 */
-int dom_processinginstruction_data_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_processinginstruction_data_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNodePtr nodep;
 	xmlChar *content;
@@ -131,14 +125,11 @@ int dom_processinginstruction_data_read(dom_object *obj, zval **retval TSRMLS_DC
 		return FAILURE;
 	}
 
-	ALLOC_ZVAL(*retval);
-
-	
 	if ((content = xmlNodeGetContent(nodep)) != NULL) {
-		ZVAL_STRING(*retval, content, 1);
+		ZVAL_STRING(retval, content);
 		xmlFree(content);
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
@@ -146,31 +137,19 @@ int dom_processinginstruction_data_read(dom_object *obj, zval **retval TSRMLS_DC
 
 int dom_processinginstruction_data_write(dom_object *obj, zval *newval TSRMLS_DC)
 {
-	zval value_copy;
-	xmlNode *nodep;
-
-	nodep = dom_object_get_node(obj);
+	xmlNode *nodep = dom_object_get_node(obj);
+	zend_string *str;
 
 	if (nodep == NULL) {
 		php_dom_throw_error(INVALID_STATE_ERR, 0 TSRMLS_CC);
 		return FAILURE;
 	}
 
-	if (newval->type != IS_STRING) {
-		if(Z_REFCOUNT_P(newval) > 1) {
-			value_copy = *newval;
-			zval_copy_ctor(&value_copy);
-			newval = &value_copy;
-		}
-		convert_to_string(newval);
-	}
+	str = zval_get_string(newval);
 
-	xmlNodeSetContentLen(nodep, Z_STRVAL_P(newval), Z_STRLEN_P(newval) + 1);
-
-	if (newval == &value_copy) {
-		zval_dtor(newval);
-	}
+	xmlNodeSetContentLen(nodep, str->val, str->len + 1);
 
+	STR_RELEASE(str);
 	return SUCCESS;
 }
 
diff --git a/ext/dom/text.c b/ext/dom/text.c
index 212d040873..cccc44b311 100644
--- a/ext/dom/text.c
+++ b/ext/dom/text.c
@@ -86,7 +86,7 @@ PHP_METHOD(domtext, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_DOMOBJ_P(id);
 	if (intern != NULL) {
 		oldnode = dom_object_get_node(intern);
 		if (oldnode != NULL) {
@@ -102,7 +102,7 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#core-Text3-wholeText
 Since: DOM Level 3
 */
-int dom_text_whole_text_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_text_whole_text_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlNodePtr node;
 	xmlChar *wholetext = NULL;
@@ -125,12 +125,11 @@ int dom_text_whole_text_read(dom_object *obj, zval **retval TSRMLS_DC)
 		node = node->next;
 	}
 
-	ALLOC_ZVAL(*retval);
 	if (wholetext != NULL) {
-		ZVAL_STRING(*retval, wholetext, 1);
+		ZVAL_STRING(retval, wholetext);
 		xmlFree(wholetext);
 	} else {
-		ZVAL_EMPTY_STRING(*retval);
+		ZVAL_EMPTY_STRING(retval);
 	}
 
 	return SUCCESS;
@@ -151,7 +150,6 @@ PHP_FUNCTION(dom_text_split_text)
 	xmlNodePtr  node;
 	xmlNodePtr  nnode;
 	long        offset;
-	int         ret;
 	int         length;
 	dom_object	*intern;
 
@@ -196,7 +194,7 @@ PHP_FUNCTION(dom_text_split_text)
 		nnode->type = XML_TEXT_NODE;
 	}
 	
-	return_value = php_dom_create_object(nnode, &ret, return_value, intern TSRMLS_CC);
+	php_dom_create_object(nnode, return_value, intern TSRMLS_CC);
 }
 /* }}} end dom_text_split_text */
 
diff --git a/ext/dom/typeinfo.c b/ext/dom/typeinfo.c
index 3742780ab7..5a437dc332 100644
--- a/ext/dom/typeinfo.c
+++ b/ext/dom/typeinfo.c
@@ -46,10 +46,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#TypeInfo-typeName
 Since: 
 */
-int dom_typeinfo_type_name_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_typeinfo_type_name_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
@@ -60,10 +59,9 @@ readonly=yes
 URL: http://www.w3.org/TR/2003/WD-DOM-Level-3-Core-20030226/DOM3-Core.html#TypeInfo-typeNamespace
 Since: 
 */
-int dom_typeinfo_type_namespace_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_typeinfo_type_namespace_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
-	ALLOC_ZVAL(*retval);
-	ZVAL_NULL(*retval);
+	ZVAL_NULL(retval);
 	return SUCCESS;
 }
 
diff --git a/ext/dom/xml_common.h b/ext/dom/xml_common.h
index 61d9854e1d..17b3a5733e 100644
--- a/ext/dom/xml_common.h
+++ b/ext/dom/xml_common.h
@@ -27,13 +27,18 @@
 typedef libxml_doc_props *dom_doc_propsptr;
 
 typedef struct _dom_object {
-	zend_object  std;
 	void *ptr;
 	php_libxml_ref_obj *document;
 	HashTable *prop_handler;
-	zend_object_handle handle;
+	zend_object std;
 } dom_object;
 
+static inline dom_object *php_dom_obj_from_obj(zend_object *obj) {
+	return (dom_object*)((char*)(obj) - XtOffsetOf(dom_object, std));
+}
+
+#define Z_DOMOBJ_P(zv)  php_dom_obj_from_obj(Z_OBJ_P((zv)))
+
 #ifdef PHP_WIN32
 #	ifdef PHPAPI
 #		undef PHPAPI
@@ -54,7 +59,7 @@ typedef struct _dom_object {
 
 PHP_DOM_EXPORT extern zend_class_entry *dom_node_class_entry;
 PHP_DOM_EXPORT dom_object *php_dom_object_get_data(xmlNodePtr obj);
-PHP_DOM_EXPORT zval *php_dom_create_object(xmlNodePtr obj, int *found, zval* return_value, dom_object *domobj TSRMLS_DC);
+PHP_DOM_EXPORT zend_bool php_dom_create_object(xmlNodePtr obj, zval* return_value, dom_object *domobj TSRMLS_DC);
 PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj);
 
 #define DOM_XMLNS_NAMESPACE \
@@ -79,10 +84,7 @@ PHP_DOM_EXPORT xmlNodePtr dom_object_get_node(dom_object *obj);
 }
 
 #define DOM_RET_OBJ(obj, ret, domobject) \
-	if (!php_dom_create_object(obj, ret, return_value, domobject TSRMLS_CC)) { \
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object"); \
-		RETURN_FALSE; \
-	}
+	*ret = php_dom_create_object(obj, return_value, domobject TSRMLS_CC)
 
 #define DOM_GET_THIS(zval) \
 	if (NULL == (zval = getThis())) { \
diff --git a/ext/dom/xpath.c b/ext/dom/xpath.c
index a7540ba38d..3290a3a5e7 100644
--- a/ext/dom/xpath.c
+++ b/ext/dom/xpath.c
@@ -74,15 +74,13 @@ const zend_function_entry php_dom_xpath_class_functions[] = {
 
 static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs, int type) /* {{{ */
 {
-	zval **args = NULL;
-	zval *retval;
-	int result, i, ret;
+	zval retval;
+	int result, i;
 	int error = 0;
 	zend_fcall_info fci;
-	zval handler;
 	xmlXPathObjectPtr obj;
 	char *str;
-	char *callable = NULL;
+	zend_string *callable = NULL;
 	dom_xpath_object *intern;
 	
 	TSRMLS_FETCH();
@@ -115,36 +113,33 @@ static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs,
 		
 	fci.param_count = nargs - 1;
 	if (fci.param_count > 0) {
-		fci.params = safe_emalloc(fci.param_count, sizeof(zval**), 0);
-		args = safe_emalloc(fci.param_count, sizeof(zval *), 0);
+		fci.params = safe_emalloc(fci.param_count, sizeof(zval), 0);
 	}
 	/* Reverse order to pop values off ctxt stack */
 	for (i = nargs - 2; i >= 0; i--) {
 		obj = valuePop(ctxt);
-		MAKE_STD_ZVAL(args[i]);
 		switch (obj->type) {
 			case XPATH_STRING:
-				ZVAL_STRING(args[i],  (char *)obj->stringval, 1);
+				ZVAL_STRING(&fci.params[i],  (char *)obj->stringval);
 				break;
 			case XPATH_BOOLEAN:
-				ZVAL_BOOL(args[i],  obj->boolval);
+				ZVAL_BOOL(&fci.params[i],  obj->boolval);
 				break;
 			case XPATH_NUMBER:
-				ZVAL_DOUBLE(args[i], obj->floatval);
+				ZVAL_DOUBLE(&fci.params[i], obj->floatval);
 				break;
 			case XPATH_NODESET:
 				if (type == 1) {
 					str = (char *)xmlXPathCastToString(obj);
-					ZVAL_STRING(args[i], str, 1);
+					ZVAL_STRING(&fci.params[i], str);
 					xmlFree(str);
 				} else if (type == 2) {
 					int j;
-					array_init(args[i]);
+					array_init(&fci.params[i]);
 					if (obj->nodesetval && obj->nodesetval->nodeNr > 0) {
 						for (j = 0; j < obj->nodesetval->nodeNr; j++) {
 							xmlNodePtr node = obj->nodesetval->nodeTab[j];
-							zval *child;
-							MAKE_STD_ZVAL(child);
+							zval child;
 							/* not sure, if we need this... it's copied from xpath.c */
 							if (node->type == XML_NAMESPACE_DECL) {
 								xmlNsPtr curns;
@@ -164,17 +159,16 @@ static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs,
 								node->parent = nsparent;
 								node->ns = curns;
 							}
-							child = php_dom_create_object(node, &ret, child, (dom_object *)intern TSRMLS_CC);
-							add_next_index_zval(args[i], child);
+							php_dom_create_object(node, &child, &intern->dom TSRMLS_CC);
+							add_next_index_zval(&fci.params[i], &child);
 						}
 					}
 				}
 				break;
 			default:
-			ZVAL_STRING(args[i], (char *)xmlXPathCastToString(obj), 1);
+			ZVAL_STRING(&fci.params[i], (char *)xmlXPathCastToString(obj));
 		}
 		xmlXPathFreeObject(obj);
-		fci.params[i] = &args[i];
 	}
 	
 	fci.size = sizeof(fci);
@@ -186,70 +180,59 @@ static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs,
 		xmlXPathFreeObject(obj);
 		if (fci.param_count > 0) {
 			for (i = 0; i < nargs - 1; i++) {
-				zval_ptr_dtor(&args[i]);
+				zval_ptr_dtor(&fci.params[i]);
 			}
-			efree(args);
 			efree(fci.params);
 		}
 		return; 
 	}
-	INIT_PZVAL(&handler);
-	ZVAL_STRING(&handler, obj->stringval, 1);
+	ZVAL_STRING(&fci.function_name, obj->stringval);
 	xmlXPathFreeObject(obj);
 
-	fci.function_name = &handler;
 	fci.symbol_table = NULL;
-	fci.object_ptr = NULL;
-	fci.retval_ptr_ptr = &retval;
+	fci.object = NULL;
+	fci.retval = &retval;
 	fci.no_separation = 0;
 
-	if (!zend_make_callable(&handler, &callable TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", callable);
-		
-	} else if ( intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable, strlen(callable) + 1) == 0) { 
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not allowed to call handler '%s()'.", callable);
+	if (!zend_make_callable(&fci.function_name, &callable TSRMLS_CC)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", callable->val);
+	} else if (intern->registerPhpFunctions == 2 && zend_hash_exists(intern->registered_phpfunctions, callable) == 0) { 
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Not allowed to call handler '%s()'.", callable->val);
 		/* Push an empty string, so that we at least have an xslt result... */
 		valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
 	} else {
 		result = zend_call_function(&fci, NULL TSRMLS_CC);
-		if (result == FAILURE) {
-			if (Z_TYPE(handler) == IS_STRING) {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call handler %s()", Z_STRVAL_P(&handler));
-			}
-		/* retval is == NULL, when an exception occurred, don't report anything, because PHP itself will handle that */
-		} else if (retval == NULL) {
-		} else {
-			if (retval->type == IS_OBJECT && instanceof_function( Z_OBJCE_P(retval), dom_node_class_entry TSRMLS_CC)) {
+		if (result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+			if (Z_TYPE(retval) == IS_OBJECT && instanceof_function(Z_OBJCE(retval), dom_node_class_entry TSRMLS_CC)) {
 				xmlNode *nodep;
 				dom_object *obj;
 				if (intern->node_list == NULL) {
 					ALLOC_HASHTABLE(intern->node_list);
 					zend_hash_init(intern->node_list, 0, NULL, ZVAL_PTR_DTOR, 0);
 				}
-				zval_add_ref(&retval);
-				zend_hash_next_index_insert(intern->node_list, &retval, sizeof(zval *), NULL);
-				obj = (dom_object *)zend_object_store_get_object(retval TSRMLS_CC);
+				GC_REFCOUNT(&retval)++;
+				zend_hash_next_index_insert(intern->node_list, &retval);
+				obj = Z_XPATHOBJ_P(&retval);
 				nodep = dom_object_get_node(obj);
 				valuePush(ctxt, xmlXPathNewNodeSet(nodep));
-			} else if (retval->type == IS_BOOL) {
-				valuePush(ctxt, xmlXPathNewBoolean(retval->value.lval));
-			} else if (retval->type == IS_OBJECT) {
+			} else if (Z_TYPE(retval) == IS_BOOL) {
+				valuePush(ctxt, xmlXPathNewBoolean(Z_BVAL(retval)));
+			} else if (Z_TYPE(retval) == IS_OBJECT) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
 				valuePush(ctxt, xmlXPathNewString((xmlChar *)""));
 			} else {
 				convert_to_string_ex(&retval);
-				valuePush(ctxt, xmlXPathNewString( Z_STRVAL_P(retval)));
+				valuePush(ctxt, xmlXPathNewString(Z_STRVAL(retval)));
 			}
 			zval_ptr_dtor(&retval);
 		}
 	}
-	efree(callable);
-	zval_dtor(&handler);
+	STR_RELEASE(callable);
+	zval_dtor(&fci.function_name);
 	if (fci.param_count > 0) {
 		for (i = 0; i < nargs - 1; i++) {
-			zval_ptr_dtor(&args[i]);
+			zval_ptr_dtor(&fci.params[i]);
 		}
-		efree(args);
 		efree(fci.params);
 	}
 }
@@ -292,11 +275,11 @@ PHP_METHOD(domxpath, __construct)
 		RETURN_FALSE;
 	}
 
-	intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_XPATHOBJ_P(id);
 	if (intern != NULL) {
-		oldctx = (xmlXPathContextPtr)intern->ptr;
+		oldctx = (xmlXPathContextPtr)intern->dom.ptr;
 		if (oldctx != NULL) {
-			php_libxml_decrement_doc_ref((php_libxml_node_object *)intern TSRMLS_CC);
+			php_libxml_decrement_doc_ref((php_libxml_node_object *) &intern->dom TSRMLS_CC);
 			xmlXPathFreeContext(oldctx);
 		}
 
@@ -307,39 +290,25 @@ PHP_METHOD(domxpath, __construct)
 					   (const xmlChar *) "http://php.net/xpath",
 					   dom_xpath_ext_function_object_php);
 
-		intern->ptr = ctx;
+		intern->dom.ptr = ctx;
 		ctx->userData = (void *)intern;
-		intern->document = docobj->document;
-		php_libxml_increment_doc_ref((php_libxml_node_object *)intern, docp TSRMLS_CC);
+		intern->dom.document = docobj->document;
+		php_libxml_increment_doc_ref((php_libxml_node_object *) &intern->dom, docp TSRMLS_CC);
 	}
 }
 /* }}} end DOMXPath::__construct */
 
 /* {{{ document DOMDocument*/
-int dom_xpath_document_read(dom_object *obj, zval **retval TSRMLS_DC)
+int dom_xpath_document_read(dom_object *obj, zval *retval TSRMLS_DC)
 {
 	xmlDoc *docp = NULL;
-	xmlXPathContextPtr ctx;
-	int ret;
-	zval *tmp;
-
-	ctx = (xmlXPathContextPtr) obj->ptr;
+	xmlXPathContextPtr ctx = (xmlXPathContextPtr) obj->ptr;
 
 	if (ctx) {
 		docp = (xmlDocPtr) ctx->doc;
 	}
 
-	ALLOC_ZVAL(*retval);
-	tmp = *retval;
-
-	if (NULL == (*retval = php_dom_create_object((xmlNodePtr) docp, &ret, *retval, obj TSRMLS_CC))) {
-		FREE_ZVAL(tmp);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot create required DOM object");
-		return FAILURE;
-	}
-	if (tmp != *retval) {
-		FREE_ZVAL(tmp);
-	}
+	php_dom_create_object((xmlNodePtr) docp, retval, obj TSRMLS_CC);
 	return SUCCESS;
 }
 /* }}} */
@@ -357,9 +326,9 @@ PHP_FUNCTION(dom_xpath_register_ns)
 		return;
 	}
 
-	intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_XPATHOBJ_P(id);
 
-	ctxp = (xmlXPathContextPtr) intern->ptr;
+	ctxp = (xmlXPathContextPtr) intern->dom.ptr;
 	if (ctxp == NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid XPath Context");
 		RETURN_FALSE;
@@ -374,22 +343,20 @@ PHP_FUNCTION(dom_xpath_register_ns)
 
 static void dom_xpath_iter(zval *baseobj, dom_object *intern) /* {{{ */
 {
-	dom_nnodemap_object *mapptr;
+	dom_nnodemap_object *mapptr = (dom_nnodemap_object *) intern->ptr;
 
-	mapptr = (dom_nnodemap_object *)intern->ptr;
-	mapptr->baseobjptr = baseobj;
+	ZVAL_COPY_VALUE(&mapptr->baseobj_zv, baseobj);
 	mapptr->nodetype = DOM_NODESET;
-
 }
 /* }}} */
 
 static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
 {
-	zval *id, *retval, *context = NULL;
+	zval *id, retval, *context = NULL;
 	xmlXPathContextPtr ctxp;
 	xmlNodePtr nodep = NULL;
 	xmlXPathObjectPtr xpathobjp;
-	int expr_len, ret, nsnbr = 0, xpath_type;
+	int expr_len, nsnbr = 0, xpath_type;
 	dom_xpath_object *intern;
 	dom_object *nodeobj;
 	char *expr;
@@ -401,9 +368,9 @@ static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
 		return;
 	}
 
-	intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC);
+	intern = Z_XPATHOBJ_P(id);
 
-	ctxp = (xmlXPathContextPtr) intern->ptr;
+	ctxp = (xmlXPathContextPtr) intern->dom.ptr;
 	if (ctxp == NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid XPath Context");
 		RETURN_FALSE;
@@ -470,16 +437,13 @@ static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
 			int i;
 			xmlNodeSetPtr nodesetp;
 
-			MAKE_STD_ZVAL(retval);
-			array_init(retval);
+			array_init(&retval);
 
 			if (xpathobjp->type == XPATH_NODESET && NULL != (nodesetp = xpathobjp->nodesetval)) {
 
 				for (i = 0; i < nodesetp->nodeNr; i++) {
 					xmlNodePtr node = nodesetp->nodeTab[i];
-					zval *child;
-
-					MAKE_STD_ZVAL(child);
+					zval child;
 					
 					if (node->type == XML_NAMESPACE_DECL) {
 						xmlNsPtr curns;
@@ -499,13 +463,13 @@ static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
 						node->parent = nsparent;
 						node->ns = curns;
 					}
-					child = php_dom_create_object(node, &ret, child, (dom_object *)intern TSRMLS_CC);
-					add_next_index_zval(retval, child);
+					php_dom_create_object(node, &child, &intern->dom TSRMLS_CC);
+					add_next_index_zval(&retval, &child);
 				}
 			}
 			php_dom_create_interator(return_value, DOM_NODELIST TSRMLS_CC);
-			nodeobj = (dom_object *)zend_objects_get_address(return_value TSRMLS_CC);
-			dom_xpath_iter(retval, nodeobj);
+			nodeobj = Z_DOMOBJ_P(return_value);
+			dom_xpath_iter(&retval, nodeobj);
 			break;
 		}
 
@@ -518,7 +482,7 @@ static void php_xpath_eval(INTERNAL_FUNCTION_PARAMETERS, int type) /* {{{ */
 			break;
 
 		case XPATH_STRING:
-			RETVAL_STRING(xpathobjp->stringval, 1);
+			RETVAL_STRING(xpathobjp->stringval);
 			break;
 
 		default:
@@ -549,39 +513,32 @@ PHP_FUNCTION(dom_xpath_register_php_functions)
 {
 	zval *id;
 	dom_xpath_object *intern;
-	zval *array_value, **entry, *new_string;
-	int  name_len = 0;
-	char *name;
+	zval *array_value, *entry, new_string;
+	zend_string *name;
 
 	DOM_GET_THIS(id);
 	
 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "a",  &array_value) == SUCCESS) {
-		intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_XPATHOBJ_P(id);
 		zend_hash_internal_pointer_reset(Z_ARRVAL_P(array_value));
-
-		while (zend_hash_get_current_data(Z_ARRVAL_P(array_value), (void **)&entry) == SUCCESS) {
-			SEPARATE_ZVAL(entry);
-			convert_to_string_ex(entry);
-
-			MAKE_STD_ZVAL(new_string);
-			ZVAL_LONG(new_string,1);
-		
-			zend_hash_update(intern->registered_phpfunctions, Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, &new_string, sizeof(zval*), NULL);
+		while ((entry = zend_hash_get_current_data(Z_ARRVAL_P(array_value)))) {
+			zend_string *str = zval_get_string(entry);
+			ZVAL_LONG(&new_string,1);
+			zend_hash_update(intern->registered_phpfunctions, str, &new_string);
 			zend_hash_move_forward(Z_ARRVAL_P(array_value));
+			STR_RELEASE(str);
 		}
 		intern->registerPhpFunctions = 2;
 		RETURN_TRUE;
 
-	} else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "s",  &name, &name_len) == SUCCESS) {
-		intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC);
+	} else if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "S",  &name) == SUCCESS) {
+		intern = Z_XPATHOBJ_P(id);
 		
-		MAKE_STD_ZVAL(new_string);
-		ZVAL_LONG(new_string,1);
-		zend_hash_update(intern->registered_phpfunctions, name, name_len + 1, &new_string, sizeof(zval*), NULL);
+		ZVAL_LONG(&new_string, 1);
+		zend_hash_update(intern->registered_phpfunctions, name, &new_string);
 		intern->registerPhpFunctions = 2;
-		
 	} else {
-		intern = (dom_xpath_object *)zend_object_store_get_object(id TSRMLS_CC);
+		intern = Z_XPATHOBJ_P(id);
 		intern->registerPhpFunctions = 1;
 	}
 	
diff --git a/ext/enchant/enchant.c b/ext/enchant/enchant.c
index 6de2feac80..e577b37003 100644
--- a/ext/enchant/enchant.c
+++ b/ext/enchant/enchant.c
@@ -186,9 +186,9 @@ enumerate_providers_fn (const char * const name,
 	MAKE_STD_ZVAL(tmp_array);
 	array_init(tmp_array);
 
-	add_assoc_string(tmp_array, "name", (char *)name, 1);
-	add_assoc_string(tmp_array, "desc", (char *)desc, 1);
-	add_assoc_string(tmp_array, "file", (char *)file, 1);
+	add_assoc_string(tmp_array, "name", (char *)name);
+	add_assoc_string(tmp_array, "desc", (char *)desc);
+	add_assoc_string(tmp_array, "file", (char *)file);
 
 	if (Z_TYPE_P(zdesc)!=IS_ARRAY) {
 		array_init(zdesc);
@@ -207,10 +207,10 @@ describe_dict_fn (const char * const lang,
 {
 	zval *zdesc = (zval *) ud;
 	array_init(zdesc);
-	add_assoc_string(zdesc, "lang", (char *)lang, 1);
-	add_assoc_string(zdesc, "name", (char *)name, 1);
-	add_assoc_string(zdesc, "desc", (char *)desc, 1);
-	add_assoc_string(zdesc, "file", (char *)file, 1);
+	add_assoc_string(zdesc, "lang", (char *)lang);
+	add_assoc_string(zdesc, "name", (char *)name);
+	add_assoc_string(zdesc, "desc", (char *)desc);
+	add_assoc_string(zdesc, "file", (char *)file);
 }
 /* }}} */
 
@@ -223,10 +223,10 @@ static void php_enchant_list_dicts_fn( const char * const lang_tag,
 
 	MAKE_STD_ZVAL(tmp_array);
 	array_init(tmp_array);
-	add_assoc_string(tmp_array, "lang_tag", (char *)lang_tag, 1);
-	add_assoc_string(tmp_array, "provider_name", (char *)provider_name, 1);
-	add_assoc_string(tmp_array, "provider_desc", (char *)provider_desc, 1);
-	add_assoc_string(tmp_array, "provider_file", (char *)provider_file, 1);
+	add_assoc_string(tmp_array, "lang_tag", (char *)lang_tag);
+	add_assoc_string(tmp_array, "provider_name", (char *)provider_name);
+	add_assoc_string(tmp_array, "provider_desc", (char *)provider_desc);
+	add_assoc_string(tmp_array, "provider_file", (char *)provider_file);
 
 	if (Z_TYPE_P(zdesc) != IS_ARRAY) {
 		array_init(zdesc);
@@ -749,7 +749,7 @@ PHP_FUNCTION(enchant_dict_quick_check)
 		if (suggs && n_sugg) {
 			int i;
 			for (i = 0; i < n_sugg; i++) {
-				add_next_index_string(sugg, suggs[i], 1);
+				add_next_index_string(sugg, suggs[i]);
 			}
 			enchant_dict_free_suggestions(pdict->pdict, suggs);
 		}
@@ -805,7 +805,7 @@ PHP_FUNCTION(enchant_dict_suggest)
 
 		array_init(return_value);
 		for (i = 0; i < n_sugg; i++) {
-			add_next_index_string(return_value, suggs[i], 1);
+			add_next_index_string(return_value, suggs[i]);
 		}
 
 		enchant_dict_free_suggestions(pdict->pdict, suggs);
diff --git a/ext/ereg/ereg.c b/ext/ereg/ereg.c
index 20f967feb9..668f955105 100644
--- a/ext/ereg/ereg.c
+++ b/ext/ereg/ereg.c
@@ -105,14 +105,14 @@ ZEND_GET_MODULE(ereg)
 /* {{{ ereg_lru_cmp */
 static int ereg_lru_cmp(const void *a, const void *b TSRMLS_DC)
 {
-	Bucket *f = *((Bucket **) a);
-	Bucket *s = *((Bucket **) b);
+	Bucket *f = (Bucket *) a;
+	Bucket *s = (Bucket *) b;
 
-	if (((reg_cache *)f->pData)->lastuse <
-				((reg_cache *)s->pData)->lastuse) {
+	if (((reg_cache *)Z_PTR(f->val))->lastuse <
+				((reg_cache *)Z_PTR(s->val))->lastuse) {
 		return -1;
-	} else if (((reg_cache *)f->pData)->lastuse ==
-				((reg_cache *)s->pData)->lastuse) {
+	} else if (((reg_cache *)Z_PTR(f->val))->lastuse ==
+				((reg_cache *)Z_PTR(s->val))->lastuse) {
 		return 0;
 	} else {
 		return 1;
@@ -121,7 +121,7 @@ static int ereg_lru_cmp(const void *a, const void *b TSRMLS_DC)
 /* }}} */
 
 /* {{{ static ereg_clean_cache */
-static int ereg_clean_cache(void *data, void *arg TSRMLS_DC)
+static int ereg_clean_cache(zval *data, void *arg TSRMLS_DC)
 {
 	int *num_clean = (int *)arg;
 
@@ -153,7 +153,8 @@ static int _php_regcomp(regex_t *preg, const char *pattern, int cflags TSRMLS_DC
 		}
 	}
 
-	if(zend_hash_find(&EREG(ht_rc), (char *) pattern, patlen+1, (void **) &rc) == SUCCESS
+	rc = zend_hash_str_find_ptr(&EREG(ht_rc), pattern, patlen);
+	if (rc
 	   && rc->cflags == cflags) {
 #ifdef HAVE_REGEX_T_RE_MAGIC
 		/*
@@ -182,8 +183,8 @@ static int _php_regcomp(regex_t *preg, const char *pattern, int cflags TSRMLS_DC
 		 * it's good.
 		 */
 		if (!reg_magic) reg_magic = preg->re_magic;
-		zend_hash_update(&EREG(ht_rc), (char *) pattern, patlen+1,
-						 (void *) &rcp, sizeof(rcp), NULL);
+		zend_hash_str_update_mem(&EREG(ht_rc), pattern, patlen,
+			&rcp, sizeof(rcp));
 	}
 #else
 		memcpy(preg, &rc->preg, sizeof(*preg));
@@ -195,8 +196,8 @@ static int _php_regcomp(regex_t *preg, const char *pattern, int cflags TSRMLS_DC
 			rcp.cflags = cflags;
 			rcp.lastuse = ++(EREG(lru_counter));
 			memcpy(&rcp.preg, preg, sizeof(*preg));
-			zend_hash_update(&EREG(ht_rc), (char *) pattern, patlen+1,
-							 (void *) &rcp, sizeof(rcp), NULL);
+			zend_hash_str_update_mem(&EREG(ht_rc), pattern, patlen,
+				&rcp, sizeof(rcp));
 		}
 	}
 #endif
@@ -204,9 +205,11 @@ static int _php_regcomp(regex_t *preg, const char *pattern, int cflags TSRMLS_DC
 }
 /* }}} */
 
-static void _free_ereg_cache(reg_cache *rc) 
+static void _free_ereg_cache(zval *zv)
 {
+	reg_cache *rc = Z_PTR_P(zv);
 	regfree(&rc->preg);
+	free(rc);
 }
 
 #undef regfree
@@ -218,7 +221,7 @@ static void _free_ereg_cache(reg_cache *rc)
  */
 static PHP_GINIT_FUNCTION(ereg)
 {
-	zend_hash_init(&ereg_globals->ht_rc, 0, NULL, (void (*)(void *)) _free_ereg_cache, 1);
+	zend_hash_init(&ereg_globals->ht_rc, 0, NULL, _free_ereg_cache, 1);
 	ereg_globals->lru_counter = 0;
 }
 /* }}} */
@@ -279,8 +282,8 @@ static void php_ereg_eprint(int err, regex_t *re TSRMLS_DC) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
 	}
 
-	STR_FREE(buf);
-	STR_FREE(message);
+	if (buf) efree(buf);
+	if (message) efree(message);
 }
 /* }}} */
 
@@ -288,8 +291,8 @@ static void php_ereg_eprint(int err, regex_t *re TSRMLS_DC) {
  */
 static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
 {
-	zval **regex,			/* Regular expression */
-		**array = NULL;		/* Optional register array */
+	zval *regex,			/* Regular expression */
+		*array = NULL;		/* Optional register array */
 	char *findin;		/* String to apply expression to */
 	int findin_len;
 	regex_t re;
@@ -302,7 +305,7 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
 	char *string = NULL;
 	int   argc = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(argc TSRMLS_CC, "Zs|Z", &regex, &findin, &findin_len, &array) == FAILURE) {
+	if (zend_parse_parameters(argc TSRMLS_CC, "zs|z", &regex, &findin, &findin_len, &array) == FAILURE) {
 		return;
 	}
 
@@ -315,16 +318,16 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
 	}
 
 	/* compile the regular expression from the supplied regex */
-	if (Z_TYPE_PP(regex) == IS_STRING) {
-		err = regcomp(&re, Z_STRVAL_PP(regex), REG_EXTENDED | copts);
+	if (Z_TYPE_P(regex) == IS_STRING) {
+		err = regcomp(&re, Z_STRVAL_P(regex), REG_EXTENDED | copts);
 	} else {
 		/* we convert numbers to integers and treat them as a string */
-		if (Z_TYPE_PP(regex) == IS_DOUBLE) {
+		if (Z_TYPE_P(regex) == IS_DOUBLE) {
 			convert_to_long_ex(regex);	/* get rid of decimal places */
 		}
 		convert_to_string_ex(regex);
 		/* don't bother doing an extended regex with just a number */
-		err = regcomp(&re, Z_STRVAL_PP(regex), copts);
+		err = regcomp(&re, Z_STRVAL_P(regex), copts);
 	}
 
 	if (err) {
@@ -348,22 +351,26 @@ static void php_ereg(INTERNAL_FUNCTION_PARAMETERS, int icase)
 	}
 	match_len = 1;
 
+	if (array) {
+		ZVAL_DEREF(array);
+	}
+
 	if (array && err != REG_NOMATCH) {
 		match_len = (int) (subs[0].rm_eo - subs[0].rm_so);
 		string_len = findin_len + 1;
 
 		buf = emalloc(string_len);
 
-		zval_dtor(*array);	/* start with clean array */
-		array_init(*array);
+		zval_dtor(array);	/* start with clean array */
+		array_init(array);
 
 		for (i = 0; i <= re.re_nsub; i++) {
 			start = subs[i].rm_so;
 			end = subs[i].rm_eo;
 			if (start != -1 && end > 0 && start < string_len && end < string_len && start < end) {
-				add_index_stringl(*array, i, string+start, end-start, 1);
+				add_index_stringl(array, i, string+start, end-start);
 			} else {
-				add_index_bool(*array, i, 0);
+				add_index_bool(array, i, 0);
 			}
 		}
 		efree(buf);
@@ -549,62 +556,61 @@ PHP_EREG_API char *php_ereg_replace(const char *pattern, const char *replace, co
  */
 static void php_do_ereg_replace(INTERNAL_FUNCTION_PARAMETERS, int icase)
 {
-	zval **arg_pattern,
-		**arg_replace;
-	char *pattern, *arg_string;
-	char *string;
-	char *replace;
+	zval *arg_pattern,
+		*arg_replace;
+	zend_string *pattern, *arg_string;
+	zend_string *string;
+	zend_string *replace;
 	char *ret;
-	int arg_string_len;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZs", &arg_pattern, &arg_replace, &arg_string, &arg_string_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzS", &arg_pattern, &arg_replace, &arg_string) == FAILURE) {
 		return;
 	}
 
-	if (Z_TYPE_PP(arg_pattern) == IS_STRING) {
-		if (Z_STRVAL_PP(arg_pattern) && Z_STRLEN_PP(arg_pattern)) {
-			pattern = estrndup(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern));
+	if (Z_TYPE_P(arg_pattern) == IS_STRING) {
+		if (Z_STRVAL_P(arg_pattern) && Z_STRLEN_P(arg_pattern)) {
+			pattern = STR_COPY(Z_STR_P(arg_pattern));
 		} else {
 			pattern = STR_EMPTY_ALLOC();
 		}
 	} else {
 		convert_to_long_ex(arg_pattern);
-		pattern = emalloc(2);
-		pattern[0] = (char) Z_LVAL_PP(arg_pattern);
-		pattern[1] = '\0';
+		pattern = STR_ALLOC(1, 0);
+		pattern->val[0] = (char) Z_LVAL_P(arg_pattern);
+		pattern->val[1] = '\0';
 	}
 
-	if (Z_TYPE_PP(arg_replace) == IS_STRING) {
-		if (Z_STRVAL_PP(arg_replace) && Z_STRLEN_PP(arg_replace)) {
-			replace = estrndup(Z_STRVAL_PP(arg_replace), Z_STRLEN_PP(arg_replace));
+	if (Z_TYPE_P(arg_replace) == IS_STRING) {
+		if (Z_STRVAL_P(arg_replace) && Z_STRLEN_P(arg_replace)) {
+			replace = STR_COPY(Z_STR_P(arg_replace));
 		} else {
 			replace = STR_EMPTY_ALLOC();
 		}
 	} else {
 		convert_to_long_ex(arg_replace);
-		replace = emalloc(2);
-		replace[0] = (char) Z_LVAL_PP(arg_replace);
-		replace[1] = '\0';
+		replace = STR_ALLOC(1, 0);
+		replace->val[0] = (char) Z_LVAL_P(arg_replace);
+		replace->val[1] = '\0';
 	}
 
-	if (arg_string && arg_string_len) {
-		string = estrndup(arg_string, arg_string_len);
+	if (arg_string) {
+		string = STR_COPY(arg_string);
 	} else {
 		string = STR_EMPTY_ALLOC();
 	}
 
 	/* do the actual work */
-	ret = php_ereg_replace(pattern, replace, string, icase, 1 TSRMLS_CC);
+	ret = php_ereg_replace(pattern->val, replace->val, string->val, icase, 1 TSRMLS_CC);
 	if (ret == (char *) -1) {
 		RETVAL_FALSE;
 	} else {
-		RETVAL_STRING(ret, 1);
-		STR_FREE(ret);
+		RETVAL_STRING(ret);
+		efree(ret);
 	}
 
-	STR_FREE(string);
-	STR_FREE(replace);
-	STR_FREE(pattern);
+	STR_RELEASE(string);
+	STR_RELEASE(replace);
+	STR_RELEASE(pattern);
 }
 /* }}} */
 
@@ -658,7 +664,7 @@ static void php_split(INTERNAL_FUNCTION_PARAMETERS, int icase)
 	while ((count == -1 || count > 1) && !(err = regexec(&re, strp, 1, subs, 0))) {
 		if (subs[0].rm_so == 0 && subs[0].rm_eo) {
 			/* match is at start of string, return empty string */
-			add_next_index_stringl(return_value, "", 0, 1);
+			add_next_index_stringl(return_value, "", 0);
 			/* skip ahead the length of the regex match */
 			strp += subs[0].rm_eo;
 		} else if (subs[0].rm_so == 0 && subs[0].rm_eo == 0) {
@@ -668,7 +674,7 @@ static void php_split(INTERNAL_FUNCTION_PARAMETERS, int icase)
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Regular Expression");
 			
 			zend_hash_destroy(Z_ARRVAL_P(return_value));
-			efree(Z_ARRVAL_P(return_value));
+			efree(Z_ARR_P(return_value));
 			RETURN_FALSE;
 		} else {
 			/* On a real match */
@@ -677,7 +683,7 @@ static void php_split(INTERNAL_FUNCTION_PARAMETERS, int icase)
 			size = subs[0].rm_so;
 		
 			/* add it to the array */
-			add_next_index_stringl(return_value, strp, size, 1);
+			add_next_index_stringl(return_value, strp, size);
 
 			/* point at our new starting point */
 			strp = strp + subs[0].rm_eo;
@@ -695,14 +701,14 @@ static void php_split(INTERNAL_FUNCTION_PARAMETERS, int icase)
 		php_ereg_eprint(err, &re TSRMLS_CC);
 		regfree(&re);
 		zend_hash_destroy(Z_ARRVAL_P(return_value));
-		efree(Z_ARRVAL_P(return_value));
+		efree(Z_ARR_P(return_value));
 		RETURN_FALSE;
 	}
 
 	/* otherwise we just have one last element to add to the array */
 	size = endp - strp;
 	
-	add_next_index_stringl(return_value, strp, size, 1);
+	add_next_index_stringl(return_value, strp, size);
 
 	regfree(&re);
 }
@@ -754,7 +760,7 @@ PHP_EREG_API PHP_FUNCTION(sql_regcase)
 	}
 	tmp[j] = 0;
 
-	RETVAL_STRINGL(tmp, j, 1);
+	RETVAL_STRINGL(tmp, j);
 	efree(tmp);
 }
 /* }}} */
diff --git a/ext/exif/exif.c b/ext/exif/exif.c
index 0b28f1c260..7900998a81 100644
--- a/ext/exif/exif.c
+++ b/ext/exif/exif.c
@@ -1981,9 +1981,9 @@ static void add_assoc_image_info(zval *value, int sub_array, image_info_type *im
 					case TAG_FMT_SBYTE:
 					case TAG_FMT_UNDEFINED:
 						if (!info_value->s) {
-							add_assoc_stringl(tmpi, name, "", 0, 1);
+							add_assoc_stringl(tmpi, name, "", 0);
 						} else {
-							add_assoc_stringl(tmpi, name, info_value->s, info_data->length, 1);
+							add_assoc_stringl(tmpi, name, info_value->s, info_data->length);
 						}
 						break;
 
@@ -1992,9 +1992,9 @@ static void add_assoc_image_info(zval *value, int sub_array, image_info_type *im
 							val = "";
 						}
 						if (section_index==SECTION_COMMENT) {
-							add_index_string(tmpi, idx++, val, 1);
+							add_index_string(tmpi, idx++, val);
 						} else {
-							add_assoc_string(tmpi, name, val, 1);
+							add_assoc_string(tmpi, name, val);
 						}
 						break;
 
@@ -2039,9 +2039,9 @@ static void add_assoc_image_info(zval *value, int sub_array, image_info_type *im
 								case TAG_FMT_URATIONAL:
 									snprintf(buffer, sizeof(buffer), "%i/%i", info_value->ur.num, info_value->ur.den);
 									if (l==1) {
-										add_assoc_string(tmpi, name, buffer, 1);
+										add_assoc_string(tmpi, name, buffer);
 									} else {
-										add_index_string(array, ap, buffer, 1);
+										add_index_string(array, ap, buffer);
 									}
 									break;
 
@@ -2065,9 +2065,9 @@ static void add_assoc_image_info(zval *value, int sub_array, image_info_type *im
 								case TAG_FMT_SRATIONAL:
 									snprintf(buffer, sizeof(buffer), "%i/%i", info_value->sr.num, info_value->sr.den);
 									if (l==1) {
-										add_assoc_string(tmpi, name, buffer, 1);
+										add_assoc_string(tmpi, name, buffer);
 									} else {
-										add_index_string(array, ap, buffer, 1);
+										add_index_string(array, ap, buffer);
 									}
 									break;
 
diff --git a/ext/filter/callback_filter.c b/ext/filter/callback_filter.c
index 644807d0dd..37c0631d6f 100644
--- a/ext/filter/callback_filter.c
+++ b/ext/filter/callback_filter.c
@@ -41,7 +41,8 @@ void php_filter_callback(PHP_INPUT_FILTER_PARAM_DECL)
 	if (status == SUCCESS && retval_ptr != NULL) {
 		if (retval_ptr != value) {
 			zval_dtor(value);
-			COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
+			ZVAL_COPY_VALUE(value, retval_ptr);
+//???			COPY_PZVAL_TO_ZVAL(*value, retval_ptr);
 		} else {
 			zval_ptr_dtor(&retval_ptr);
 		}
diff --git a/ext/filter/filter.c b/ext/filter/filter.c
index 4d3899e089..9007a36c87 100644
--- a/ext/filter/filter.c
+++ b/ext/filter/filter.c
@@ -896,7 +896,7 @@ PHP_FUNCTION(filter_list)
 
 	array_init(return_value);
 	for (i = 0; i < size; ++i) {
-		add_next_index_string(return_value, (char *)filter_list[i].name, 1);
+		add_next_index_string(return_value, (char *)filter_list[i].name);
 	}
 }
 /* }}} */
diff --git a/ext/ftp/ftp.c b/ext/ftp/ftp.c
index 558463b845..2047193a94 100644
--- a/ext/ftp/ftp.c
+++ b/ext/ftp/ftp.c
@@ -479,7 +479,7 @@ ftp_raw(ftpbuf_t *ftp, const char *cmd, zval *return_value)
 	}
 	array_init(return_value);
 	while (ftp_readline(ftp)) {
-		add_next_index_string(return_value, ftp->inbuf, 1);
+		add_next_index_string(return_value, ftp->inbuf);
 		if (isdigit(ftp->inbuf[0]) && isdigit(ftp->inbuf[1]) && isdigit(ftp->inbuf[2]) && ftp->inbuf[3] == ' ') {
 			return;
 		}
diff --git a/ext/ftp/php_ftp.c b/ext/ftp/php_ftp.c
index 79c871f559..9856559552 100644
--- a/ext/ftp/php_ftp.c
+++ b/ext/ftp/php_ftp.c
@@ -673,7 +673,7 @@ PHP_FUNCTION(ftp_nlist)
 
 	array_init(return_value);
 	for (ptr = nlist; *ptr; ptr++) {
-		add_next_index_string(return_value, *ptr, 1);
+		add_next_index_string(return_value, *ptr);
 	}
 	efree(nlist);
 }
@@ -702,7 +702,7 @@ PHP_FUNCTION(ftp_rawlist)
 
 	array_init(return_value);
 	for (ptr = llist; *ptr; ptr++) {
-		add_next_index_string(return_value, *ptr, 1);
+		add_next_index_string(return_value, *ptr);
 	}
 	efree(llist);
 }
diff --git a/ext/gd/gd.c b/ext/gd/gd.c
index f54fb9ff8a..33416a23d9 100644
--- a/ext/gd/gd.c
+++ b/ext/gd/gd.c
@@ -1361,14 +1361,14 @@ PHP_FUNCTION(gd_info)
 
 	array_init(return_value);
 
-	add_assoc_string(return_value, "GD Version", PHP_GD_VERSION_STRING, 1);
+	add_assoc_string(return_value, "GD Version", PHP_GD_VERSION_STRING);
 
 #ifdef ENABLE_GD_TTF
 	add_assoc_bool(return_value, "FreeType Support", 1);
 #if HAVE_LIBFREETYPE
-	add_assoc_string(return_value, "FreeType Linkage", "with freetype", 1);
+	add_assoc_string(return_value, "FreeType Linkage", "with freetype");
 #else
-	add_assoc_string(return_value, "FreeType Linkage", "with unknown library", 1);
+	add_assoc_string(return_value, "FreeType Linkage", "with unknown library");
 #endif
 #else
 	add_assoc_bool(return_value, "FreeType Support", 0);
diff --git a/ext/hash/hash.c b/ext/hash/hash.c
index f14437d96f..63167b8d51 100644
--- a/ext/hash/hash.c
+++ b/ext/hash/hash.c
@@ -88,13 +88,8 @@ static struct mhash_bc_entry mhash_to_hash[MHASH_NUM_ALGOS] = {
 
 PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, int algo_len) /* {{{ */
 {
-	php_hash_ops *ops;
-	char *lower = estrndup(algo, algo_len);
-
-	zend_str_tolower(lower, algo_len);
-	if (SUCCESS != zend_hash_find(&php_hash_hashtable, lower, algo_len + 1, (void*)&ops)) {
-		ops = NULL;
-	}
+	char *lower = zend_str_tolower_dup(algo, algo_len);
+	php_hash_ops *ops = zend_hash_str_find_ptr(&php_hash_hashtable, lower, algo_len);
 	efree(lower);
 
 	return ops;
@@ -104,10 +99,8 @@ PHP_HASH_API const php_hash_ops *php_hash_fetch_ops(const char *algo, int algo_l
 PHP_HASH_API void php_hash_register_algo(const char *algo, const php_hash_ops *ops) /* {{{ */
 {
 	int algo_len = strlen(algo);
-	char *lower = estrndup(algo, algo_len);
-	
-	zend_str_tolower(lower, algo_len);
-	zend_hash_add(&php_hash_hashtable, lower, algo_len + 1, (void*)ops, sizeof(php_hash_ops), NULL);
+	char *lower = zend_str_tolower_dup(algo, algo_len);
+	zend_hash_str_add_ptr(&php_hash_hashtable, lower, algo_len, (void *) ops);
 	efree(lower);
 }
 /* }}} */
@@ -125,7 +118,8 @@ PHP_HASH_API int php_hash_copy(const void *ops, void *orig_context, void *dest_c
 
 static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
 {
-	char *algo, *data, *digest;
+	zend_string *digest;
+	char *algo, *data;
 	int algo_len, data_len;
 	zend_bool raw_output = raw_output_default;
 	const php_hash_ops *ops;
@@ -167,20 +161,20 @@ static void php_hash_do_hash(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_
 		ops->hash_update(context, (unsigned char *) data, data_len);
 	}
 
-	digest = emalloc(ops->digest_size + 1);
-	ops->hash_final((unsigned char *) digest, context);
+	digest = STR_ALLOC(ops->digest_size, 0);
+	ops->hash_final((unsigned char *) digest->val, context);
 	efree(context);
 
 	if (raw_output) {
-		digest[ops->digest_size] = 0;
-		RETURN_STRINGL(digest, ops->digest_size, 0);
+		digest->val[ops->digest_size] = 0;
+		RETURN_STR(digest);
 	} else {
-		char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);
+		zend_string *hex_digest = STR_SAFE_ALLOC(ops->digest_size, 2, 0, 0);
 
-		php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
-		hex_digest[2 * ops->digest_size] = 0;
-		efree(digest);
-		RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
+		php_hash_bin2hex(hex_digest->val, (unsigned char *) digest->val, ops->digest_size);
+		hex_digest->val[2 * ops->digest_size] = 0;
+		STR_RELEASE(digest);
+		RETURN_STR(hex_digest);
 	}
 }
 /* }}} */
@@ -240,7 +234,9 @@ static inline void php_hash_hmac_round(unsigned char *final, const php_hash_ops
 
 static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename, zend_bool raw_output_default) /* {{{ */
 {
-	char *algo, *data, *digest, *key, *K;
+	zend_string *digest;
+	char *algo, *data, *key;
+	unsigned char *K;
 	int algo_len, data_len, key_len;
 	zend_bool raw_output = raw_output_default;
 	const php_hash_ops *ops;
@@ -268,27 +264,27 @@ static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename,
 	context = emalloc(ops->context_size);
 
 	K = emalloc(ops->block_size);
-	digest = emalloc(ops->digest_size + 1);
+	digest = STR_ALLOC(ops->digest_size, 0);
 
-	php_hash_hmac_prep_key((unsigned char *) K, ops, context, (unsigned char *) key, key_len);		
+	php_hash_hmac_prep_key(K, ops, context, (unsigned char *) key, key_len);		
 
 	if (isfilename) {
 		char buf[1024];
 		int n;
 		ops->hash_init(context);
-		ops->hash_update(context, (unsigned char *) K, ops->block_size);
+		ops->hash_update(context, K, ops->block_size);
 		while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
 			ops->hash_update(context, (unsigned char *) buf, n);
 		}
 		php_stream_close(stream);
-		ops->hash_final((unsigned char *) digest, context);
+		ops->hash_final((unsigned char *) digest->val, context);
 	} else {
-		php_hash_hmac_round((unsigned char *) digest, ops, context, (unsigned char *) K, (unsigned char *) data, data_len);
+		php_hash_hmac_round((unsigned char *) digest->val, ops, context, K, (unsigned char *) data, data_len);
 	}
 
-	php_hash_string_xor_char((unsigned char *) K, (unsigned char *) K, 0x6A, ops->block_size);
+	php_hash_string_xor_char(K, K, 0x6A, ops->block_size);
 
-	php_hash_hmac_round((unsigned char *) digest, ops, context, (unsigned char *) K, (unsigned char *) digest, ops->digest_size);
+	php_hash_hmac_round((unsigned char *) digest->val, ops, context, K, (unsigned char *) digest->val, ops->digest_size);
 
 	/* Zero the key */
 	memset(K, 0, ops->block_size);
@@ -296,15 +292,15 @@ static void php_hash_do_hash_hmac(INTERNAL_FUNCTION_PARAMETERS, int isfilename,
 	efree(context);
 
 	if (raw_output) {
-		digest[ops->digest_size] = 0;
-		RETURN_STRINGL(digest, ops->digest_size, 0);
+		digest->val[ops->digest_size] = 0;
+		RETURN_STR(digest);
 	} else {
-		char *hex_digest = safe_emalloc(ops->digest_size, 2, 1);
+		zend_string *hex_digest = STR_SAFE_ALLOC(ops->digest_size, 2, 0, 0);
 
-		php_hash_bin2hex(hex_digest, (unsigned char *) digest, ops->digest_size);
-		hex_digest[2 * ops->digest_size] = 0;
-		efree(digest);
-		RETURN_STRINGL(hex_digest, 2 * ops->digest_size, 0);
+		php_hash_bin2hex(hex_digest->val, (unsigned char *) digest->val, ops->digest_size);
+		hex_digest->val[2 * ops->digest_size] = 0;
+		STR_RELEASE(digest);
+		RETURN_STR(hex_digest);
 	}
 }
 /* }}} */
@@ -406,7 +402,7 @@ PHP_FUNCTION(hash_update)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
+	ZEND_FETCH_RESOURCE(hash, php_hash_data*, zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
 
 	hash->ops->hash_update(hash->context, (unsigned char *) data, data_len);
 
@@ -427,8 +423,8 @@ PHP_FUNCTION(hash_update_stream)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
-	php_stream_from_zval(stream, &zstream);
+	ZEND_FETCH_RESOURCE(hash, php_hash_data*, zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
+	php_stream_from_zval(stream, zstream);
 
 	while (length) {
 		char buf[1024];
@@ -466,7 +462,7 @@ PHP_FUNCTION(hash_update_file)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
+	ZEND_FETCH_RESOURCE(hash, php_hash_data*, zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
 	context = php_stream_context_from_zval(zcontext, 0);
 
 	stream = php_stream_open_wrapper_ex(filename, "rb", REPORT_ERRORS, NULL, context);
@@ -491,19 +487,18 @@ PHP_FUNCTION(hash_final)
 	zval *zhash;
 	php_hash_data *hash;
 	zend_bool raw_output = 0;
-	zend_rsrc_list_entry *le;
-	char *digest;
+	zend_string *digest;
 	int digest_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|b", &zhash, &raw_output) == FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
+	ZEND_FETCH_RESOURCE(hash, php_hash_data*, zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
 
 	digest_len = hash->ops->digest_size;
-	digest = emalloc(digest_len + 1);
-	hash->ops->hash_final((unsigned char *) digest, hash->context);
+	digest = STR_ALLOC(digest_len, 0);
+	hash->ops->hash_final((unsigned char *) digest->val, hash->context);
 	if (hash->options & PHP_HASH_HMAC) {
 		int i;
 
@@ -514,36 +509,37 @@ PHP_FUNCTION(hash_final)
 
 		/* Feed this result into the outter hash */
 		hash->ops->hash_init(hash->context);
-		hash->ops->hash_update(hash->context, (unsigned char *) hash->key, hash->ops->block_size);
-		hash->ops->hash_update(hash->context, (unsigned char *) digest, hash->ops->digest_size);
-		hash->ops->hash_final((unsigned char *) digest, hash->context);
+		hash->ops->hash_update(hash->context, hash->key, hash->ops->block_size);
+		hash->ops->hash_update(hash->context, (unsigned char *) digest->val, hash->ops->digest_size);
+		hash->ops->hash_final((unsigned char *) digest->val, hash->context);
 
 		/* Zero the key */
 		memset(hash->key, 0, hash->ops->block_size);
 		efree(hash->key);
 		hash->key = NULL;
 	}
-	digest[digest_len] = 0;
+	digest->val[digest_len] = 0;
 	efree(hash->context);
 	hash->context = NULL;
 
-	/* zend_list_REAL_delete() */
-	if (zend_hash_index_find(&EG(regular_list), Z_RESVAL_P(zhash), (void *) &le)==SUCCESS) {
-		/* This is a hack to avoid letting the resource hide elsewhere (like in separated vars)
-			FETCH_RESOURCE is intelligent enough to handle dealing with any issues this causes */
-		le->refcount = 1;
-	} /* FAILURE is not an option */
-	zend_list_delete(Z_RESVAL_P(zhash));
+	//???
+	//??? /* zend_list_REAL_delete() */
+	//??? if (zend_hash_index_find(&EG(regular_list), Z_RESVAL_P(zhash), (void *) &le)==SUCCESS) {
+	//??? 	/* This is a hack to avoid letting the resource hide elsewhere (like in separated vars)
+	//??? 		FETCH_RESOURCE is intelligent enough to handle dealing with any issues this causes */
+	//??? 	le->refcount = 1;
+	//??? } /* FAILURE is not an option */
+	zend_list_close(Z_RES_P(zhash));
 
 	if (raw_output) {
-		RETURN_STRINGL(digest, digest_len, 0);
+		RETURN_STR(digest);
 	} else {
-		char *hex_digest = safe_emalloc(digest_len,2,1);
+		zend_string *hex_digest = STR_SAFE_ALLOC(digest_len, 2, 0, 0);
 
-		php_hash_bin2hex(hex_digest, (unsigned char *) digest, digest_len);
-		hex_digest[2 * digest_len] = 0;
-		efree(digest);
-		RETURN_STRINGL(hex_digest, 2 * digest_len, 0);		
+		php_hash_bin2hex(hex_digest->val, (unsigned char *) digest->val, digest_len);
+		hex_digest->val[2 * digest_len] = 0;
+		STR_RELEASE(digest);
+		RETURN_STR(hex_digest);
 	}
 }
 /* }}} */
@@ -561,7 +557,7 @@ PHP_FUNCTION(hash_copy)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(hash, php_hash_data*, &zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
+	ZEND_FETCH_RESOURCE(hash, php_hash_data*, zhash, -1, PHP_HASH_RESNAME, php_hash_le_hash);
 
 
 	context = emalloc(hash->ops->context_size);
@@ -589,18 +585,12 @@ PHP_FUNCTION(hash_copy)
 Return a list of registered hashing algorithms */
 PHP_FUNCTION(hash_algos)
 {
-	HashPosition pos;
-	char *str;
-	uint str_len;
-	long type;
-	ulong idx;
+	zend_string *str;
 
 	array_init(return_value);
-	for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
-		(type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, &str_len, &idx, 0, &pos)) != HASH_KEY_NON_EXISTENT;
-		zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
-		add_next_index_stringl(return_value, str, str_len-1, 1);
-	}
+	ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) {
+		add_next_index_str(return_value, STR_COPY(str));
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -609,10 +599,11 @@ Generate a PBKDF2 hash of the given password and salt
 Returns lowercase hexits by default */
 PHP_FUNCTION(hash_pbkdf2)
 {
-	char *returnval, *algo, *salt, *pass;
-	unsigned char *computed_salt, *digest, *temp, *result, *K1, *K2;
-	long loops, i, j, iterations, length = 0, digest_length;
-	int algo_len, pass_len, salt_len;
+	zend_string *returnval;
+	char *algo, *salt, *pass = NULL;
+	unsigned char *computed_salt, *digest, *temp, *result, *K1, *K2 = NULL;
+	long loops, i, j, algo_len, pass_len, iterations, length = 0, digest_length = 0;
+	int argc, salt_len = 0;
 	zend_bool raw_output = 0;
 	const php_hash_ops *ops;
 	void *context;
@@ -716,15 +707,15 @@ PHP_FUNCTION(hash_pbkdf2)
 	efree(digest);
 	efree(temp);
 
-	returnval = safe_emalloc(length, 1, 1);
+	returnval = STR_ALLOC(length, 0);
 	if (raw_output) {
-		memcpy(returnval, result, length);
+		memcpy(returnval->val, result, length);
 	} else {
-		php_hash_bin2hex(returnval, result, digest_length);
+		php_hash_bin2hex(returnval->val, result, digest_length);
 	}
-	returnval[length] = 0;
+	returnval->val[length] = 0;
 	efree(result);
-	RETURN_STRINGL(returnval, length, 0);
+	RETURN_STR(returnval);
 }
 /* }}} */
 
@@ -770,7 +761,7 @@ PHP_FUNCTION(hash_equals)
 
 /* Module Housekeeping */
 
-static void php_hash_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC) /* {{{ */
+static void php_hash_dtor(zend_resource *rsrc TSRMLS_DC) /* {{{ */
 {
 	php_hash_data *hash = (php_hash_data*)rsrc->ptr;
 
@@ -828,7 +819,7 @@ static void mhash_init(INIT_FUNC_ARGS)
 		}
 
 		len = slprintf(buf, 127, "MHASH_%s", algorithm.mhash_name, strlen(algorithm.mhash_name));
-		zend_register_long_constant(buf, len + 1, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
+		zend_register_long_constant(buf, len, algorithm.value, CONST_CS | CONST_PERSISTENT, module_number TSRMLS_CC);
 	}
 	zend_register_internal_module(&mhash_module_entry TSRMLS_CC);
 }
@@ -837,22 +828,22 @@ static void mhash_init(INIT_FUNC_ARGS)
    Hash data with hash */
 PHP_FUNCTION(mhash)
 {
-	zval **z_algorithm;
+	zval *z_algorithm;
 	long algorithm;
 
-	if (zend_parse_parameters(1 TSRMLS_CC, "Z", &z_algorithm) == FAILURE) {
+	if (zend_parse_parameters(1 TSRMLS_CC, "z", &z_algorithm) == FAILURE) {
 		return;
 	}
 
 	SEPARATE_ZVAL(z_algorithm);
 	convert_to_long_ex(z_algorithm);
-	algorithm = Z_LVAL_PP(z_algorithm);
+	algorithm = Z_LVAL_P(z_algorithm);
 
 	/* need to convert the first parameter from int constant to string algorithm name */
 	if (algorithm >= 0 && algorithm < MHASH_NUM_ALGOS) {
 		struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
 		if (algorithm_lookup.hash_name) {
-			ZVAL_STRING(*z_algorithm, algorithm_lookup.hash_name, 1);
+			ZVAL_STRING(z_algorithm, algorithm_lookup.hash_name);
 		}
 	}
 
@@ -879,7 +870,7 @@ PHP_FUNCTION(mhash_get_hash_name)
 	if (algorithm >= 0 && algorithm  < MHASH_NUM_ALGOS) {
 		struct mhash_bc_entry algorithm_lookup = mhash_to_hash[algorithm];
 		if (algorithm_lookup.mhash_name) {
-			RETURN_STRING(algorithm_lookup.mhash_name, 1);
+			RETURN_STRING(algorithm_lookup.mhash_name);
 		}
 	}
 	RETURN_FALSE;
@@ -982,7 +973,7 @@ PHP_FUNCTION(mhash_keygen_s2k)
 					memcpy( &key[i*block_size], digest, block_size);
 				}
 
-				RETVAL_STRINGL(key, bytes, 1);
+				RETVAL_STRINGL(key, bytes);
 				memset(key, 0, bytes);
 				efree(digest);
 				efree(context);
@@ -1077,17 +1068,13 @@ PHP_MSHUTDOWN_FUNCTION(hash)
  */
 PHP_MINFO_FUNCTION(hash)
 {
-	HashPosition pos;
 	char buffer[2048];
-	char *s = buffer, *e = s + sizeof(buffer), *str;
-	ulong idx;
-	long type;
-
-	for(zend_hash_internal_pointer_reset_ex(&php_hash_hashtable, &pos);
-		(type = zend_hash_get_current_key_ex(&php_hash_hashtable, &str, NULL, &idx, 0, &pos)) != HASH_KEY_NON_EXISTENT;
-		zend_hash_move_forward_ex(&php_hash_hashtable, &pos)) {
-		s += slprintf(s, e - s, "%s ", str);
-	}
+	zend_string *str;
+	char *s = buffer, *e = s + sizeof(buffer);
+
+	ZEND_HASH_FOREACH_STR_KEY(&php_hash_hashtable, str) {
+		s += slprintf(s, e - s, "%s ", str->val);
+	} ZEND_HASH_FOREACH_END();
 	*s = 0;
 
 	php_info_print_table_start();
diff --git a/ext/iconv/iconv.c b/ext/iconv/iconv.c
index 2df759f99b..6eeaab62fc 100644
--- a/ext/iconv/iconv.c
+++ b/ext/iconv/iconv.c
@@ -2420,9 +2420,9 @@ PHP_FUNCTION(iconv_mime_decode_headers)
 
 					elem = &new_elem;
 				}
-				add_next_index_stringl(*elem, header_value, header_value_len, 1);
+				add_next_index_stringl(*elem, header_value, header_value_len);
 			} else {
-				add_assoc_stringl_ex(return_value, header_name, header_name_len, header_value, header_value_len, 1);
+				add_assoc_stringl_ex(return_value, header_name, header_name_len, header_value, header_value_len);
 			}
 		}
 		encoded_str_len -= next_pos - encoded_str;
@@ -2516,9 +2516,9 @@ PHP_FUNCTION(iconv_get_encoding)
 
 	if (!strcasecmp("all", type)) {
 		array_init(return_value);
-		add_assoc_string(return_value, "input_encoding",    get_input_encoding(TSRMLS_C), 1);
-		add_assoc_string(return_value, "output_encoding",   get_output_encoding(TSRMLS_C), 1);
-		add_assoc_string(return_value, "internal_encoding", get_internal_encoding(TSRMLS_C), 1);
+		add_assoc_string(return_value, "input_encoding",    get_input_encoding(TSRMLS_C));
+		add_assoc_string(return_value, "output_encoding",   get_output_encoding(TSRMLS_C));
+		add_assoc_string(return_value, "internal_encoding", get_internal_encoding(TSRMLS_C));
 	} else if (!strcasecmp("input_encoding", type)) {
 		RETVAL_STRING(get_input_encoding(TSRMLS_C), 1);
 	} else if (!strcasecmp("output_encoding", type)) {
diff --git a/ext/imap/php_imap.c b/ext/imap/php_imap.c
index 0e8310a367..876be777a8 100644
--- a/ext/imap/php_imap.c
+++ b/ext/imap/php_imap.c
@@ -793,7 +793,7 @@ void mail_getacl(MAILSTREAM *stream, char *mailbox, ACLLIST *alist)
 
 	/* walk through the ACLLIST */
 	for(; alist; alist = alist->next) {
-		add_assoc_stringl(IMAPG(imap_acl_list), alist->identifier, alist->rights, strlen(alist->rights), 1);
+		add_assoc_stringl(IMAPG(imap_acl_list), alist->identifier, alist->rights, strlen(alist->rights));
 	}
 }
 /* }}} */
@@ -1667,7 +1667,7 @@ PHP_FUNCTION(imap_headers)
 		}
 		mail_fetchsubject(t = tmp + strlen(tmp), imap_le_struct->imap_stream, msgno, (long)25);
 		snprintf(t += strlen(t), sizeof(tmp) - strlen(tmp), " (%ld chars)", cache->rfc822_size);
-		add_next_index_string(return_value, tmp, 1);
+		add_next_index_string(return_value, tmp);
 	}
 }
 /* }}} */
@@ -1862,7 +1862,7 @@ PHP_FUNCTION(imap_list)
 	array_init(return_value);
 	cur=IMAPG(imap_folders);
 	while (cur != NIL) {
-		add_next_index_string(return_value, cur->LTEXT, 1);
+		add_next_index_string(return_value, cur->LTEXT);
 		cur=cur->next;
 	}
 	mail_free_stringlist (&IMAPG(imap_folders));
@@ -1904,14 +1904,14 @@ PHP_FUNCTION(imap_list_full)
 	while (cur != NIL) {
 		MAKE_STD_ZVAL(mboxob);
 		object_init(mboxob);
-		add_property_string(mboxob, "name", cur->LTEXT, 1);
+		add_property_string(mboxob, "name", cur->LTEXT);
 		add_property_long(mboxob, "attributes", cur->attributes);
 #ifdef IMAP41
 		delim[0] = (char)cur->delimiter;
 		delim[1] = 0;
-		add_property_string(mboxob, "delimiter", delim, 1);
+		add_property_string(mboxob, "delimiter", delim);
 #else
-		add_property_string(mboxob, "delimiter", cur->delimiter, 1);
+		add_property_string(mboxob, "delimiter", cur->delimiter);
 #endif
 		add_next_index_object(return_value, mboxob TSRMLS_CC);
 		cur=cur->next;
@@ -1947,7 +1947,7 @@ PHP_FUNCTION(imap_listscan)
 	array_init(return_value);
 	cur=IMAPG(imap_folders);
 	while (cur != NIL) {
-		add_next_index_string(return_value, cur->LTEXT, 1);
+		add_next_index_string(return_value, cur->LTEXT);
 		cur=cur->next;
 	}
 	mail_free_stringlist (&IMAPG(imap_folders));
@@ -1977,9 +1977,9 @@ PHP_FUNCTION(imap_check)
 	if (imap_le_struct->imap_stream && imap_le_struct->imap_stream->mailbox) {
 		rfc822_date(date);
 		object_init(return_value);
-		add_property_string(return_value, "Date", date, 1);
-		add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
-		add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
+		add_property_string(return_value, "Date", date);
+		add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name);
+		add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox);
 		add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
 		add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
 	} else {
@@ -2084,33 +2084,33 @@ PHP_FUNCTION(imap_headerinfo)
 
 	/* now run through properties that are only going to be returned
 	   from a server, not text headers */
-	add_property_string(return_value, "Recent", cache->recent ? (cache->seen ? "R": "N") : " ", 1);
-	add_property_string(return_value, "Unseen", (cache->recent | cache->seen) ? " " : "U", 1);
-	add_property_string(return_value, "Flagged", cache->flagged ? "F" : " ", 1);
-	add_property_string(return_value, "Answered", cache->answered ? "A" : " ", 1);
-	add_property_string(return_value, "Deleted", cache->deleted ? "D" : " ", 1);
-	add_property_string(return_value, "Draft", cache->draft ? "X" : " ", 1);
+	add_property_string(return_value, "Recent", cache->recent ? (cache->seen ? "R": "N") : " ");
+	add_property_string(return_value, "Unseen", (cache->recent | cache->seen) ? " " : "U");
+	add_property_string(return_value, "Flagged", cache->flagged ? "F" : " ");
+	add_property_string(return_value, "Answered", cache->answered ? "A" : " ");
+	add_property_string(return_value, "Deleted", cache->deleted ? "D" : " ");
+	add_property_string(return_value, "Draft", cache->draft ? "X" : " ");
 
 	snprintf(dummy, sizeof(dummy), "%4ld", cache->msgno);
-	add_property_string(return_value, "Msgno", dummy, 1);
+	add_property_string(return_value, "Msgno", dummy);
 
 	mail_date(dummy, cache);
-	add_property_string(return_value, "MailDate", dummy, 1);
+	add_property_string(return_value, "MailDate", dummy);
 
 	snprintf(dummy, sizeof(dummy), "%ld", cache->rfc822_size);
-	add_property_string(return_value, "Size", dummy, 1);
+	add_property_string(return_value, "Size", dummy);
 
 	add_property_long(return_value, "udate", mail_longdate(cache));
 
 	if (en->from && fromlength) {
 		fulladdress[0] = 0x00;
 		mail_fetchfrom(fulladdress, imap_le_struct->imap_stream, msgno, fromlength);
-		add_property_string(return_value, "fetchfrom", fulladdress, 1);
+		add_property_string(return_value, "fetchfrom", fulladdress);
 	}
 	if (en->subject && subjectlength) {
 		fulladdress[0] = 0x00;
 		mail_fetchsubject(fulladdress, imap_le_struct->imap_stream, msgno, subjectlength);
-		add_property_string(return_value, "fetchsubject", fulladdress, 1);
+		add_property_string(return_value, "fetchsubject", fulladdress);
 	}
 }
 /* }}} */
@@ -2169,7 +2169,7 @@ PHP_FUNCTION(imap_lsub)
 	array_init(return_value);
 	cur=IMAPG(imap_sfolders);
 	while (cur != NIL) {
-		add_next_index_string(return_value, cur->LTEXT, 1);
+		add_next_index_string(return_value, cur->LTEXT);
 		cur=cur->next;
 	}
 	mail_free_stringlist (&IMAPG(imap_sfolders));
@@ -2210,14 +2210,14 @@ PHP_FUNCTION(imap_lsub_full)
 	while (cur != NIL) {
 		MAKE_STD_ZVAL(mboxob);
 		object_init(mboxob);
-		add_property_string(mboxob, "name", cur->LTEXT, 1);
+		add_property_string(mboxob, "name", cur->LTEXT);
 		add_property_long(mboxob, "attributes", cur->attributes);
 #ifdef IMAP41
 		delim[0] = (char)cur->delimiter;
 		delim[1] = 0;
-		add_property_string(mboxob, "delimiter", delim, 1);
+		add_property_string(mboxob, "delimiter", delim);
 #else
-		add_property_string(mboxob, "delimiter", cur->delimiter, 1);
+		add_property_string(mboxob, "delimiter", cur->delimiter);
 #endif
 		add_next_index_object(return_value, mboxob TSRMLS_CC);
 		cur=cur->next;
@@ -2586,9 +2586,9 @@ PHP_FUNCTION(imap_mailboxmsginfo)
 	add_property_long(return_value, "Nmsgs", imap_le_struct->imap_stream->nmsgs);
 	add_property_long(return_value, "Size", msize);
 	rfc822_date(date);
-	add_property_string(return_value, "Date", date, 1);
-	add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name, 1);
-	add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox, 1);
+	add_property_string(return_value, "Date", date);
+	add_property_string(return_value, "Driver", imap_le_struct->imap_stream->dtb->name);
+	add_property_string(return_value, "Mailbox", imap_le_struct->imap_stream->mailbox);
 	add_property_long(return_value, "Recent", imap_le_struct->imap_stream->recent);
 }
 /* }}} */
@@ -2662,16 +2662,16 @@ PHP_FUNCTION(imap_rfc822_parse_adrlist)
 		MAKE_STD_ZVAL(tovals);
 		object_init(tovals);
 		if (addresstmp->mailbox) {
-			add_property_string(tovals, "mailbox", addresstmp->mailbox, 1);
+			add_property_string(tovals, "mailbox", addresstmp->mailbox);
 		}
 		if (addresstmp->host) {
-			add_property_string(tovals, "host", addresstmp->host, 1);
+			add_property_string(tovals, "host", addresstmp->host);
 		}
 		if (addresstmp->personal) {
-			add_property_string(tovals, "personal", addresstmp->personal, 1);
+			add_property_string(tovals, "personal", addresstmp->personal);
 		}
 		if (addresstmp->adl) {
-			add_property_string(tovals, "adl", addresstmp->adl, 1);
+			add_property_string(tovals, "adl", addresstmp->adl);
 		}
 		add_next_index_object(return_value, tovals TSRMLS_CC);
 	} while ((addresstmp = addresstmp->next));
@@ -3303,20 +3303,20 @@ PHP_FUNCTION(imap_bodystruct)
 
 	if (body->subtype) {
 		add_property_long(return_value, "ifsubtype", 1);
-		add_property_string(return_value, "subtype", body->subtype, 1);
+		add_property_string(return_value, "subtype", body->subtype);
 	} else {
 		add_property_long(return_value, "ifsubtype", 0);
 	}
 
 	if (body->description) {
 		add_property_long(return_value, "ifdescription", 1);
-		add_property_string(return_value, "description", body->description, 1);
+		add_property_string(return_value, "description", body->description);
 	} else {
 		add_property_long(return_value, "ifdescription", 0);
 	}
 	if (body->id) {
 		add_property_long(return_value, "ifid", 1);
-		add_property_string(return_value, "id", body->id, 1);
+		add_property_string(return_value, "id", body->id);
 	} else {
 		add_property_long(return_value, "ifid", 0);
 	}
@@ -3330,7 +3330,7 @@ PHP_FUNCTION(imap_bodystruct)
 #ifdef IMAP41
 	if (body->disposition.type) {
 		add_property_long(return_value, "ifdisposition", 1);
-		add_property_string(return_value, "disposition", body->disposition.type, 1);
+		add_property_string(return_value, "disposition", body->disposition.type);
 	} else {
 		add_property_long(return_value, "ifdisposition", 0);
 	}
@@ -3343,8 +3343,8 @@ PHP_FUNCTION(imap_bodystruct)
 		do {
 			MAKE_STD_ZVAL(dparam);
 			object_init(dparam);
-			add_property_string(dparam, "attribute", dpar->attribute, 1);
-			add_property_string(dparam, "value", dpar->value, 1);
+			add_property_string(dparam, "attribute", dpar->attribute);
+			add_property_string(dparam, "value", dpar->value);
 			add_next_index_object(dparametres, dparam TSRMLS_CC);
 		} while ((dpar = dpar->next));
 		add_assoc_object(return_value, "dparameters", dparametres TSRMLS_CC);
@@ -3362,10 +3362,10 @@ PHP_FUNCTION(imap_bodystruct)
 			MAKE_STD_ZVAL(param);
 			object_init(param);
 			if (par->attribute) {
-				add_property_string(param, "attribute", par->attribute, 1);
+				add_property_string(param, "attribute", par->attribute);
 			}
 			if (par->value) {
-				add_property_string(param, "value", par->value, 1);
+				add_property_string(param, "value", par->value);
 			}
 
 			add_next_index_object(parametres, param TSRMLS_CC);
@@ -3421,33 +3421,37 @@ PHP_FUNCTION(imap_fetch_overview)
 				MAKE_STD_ZVAL(myoverview);
 				object_init(myoverview);
 				if (env->subject) {
-					add_property_string(myoverview, "subject", env->subject, 1);
+					add_property_string(myoverview, "subject", env->subject);
 				}
 				if (env->from) {
 					env->from->next=NULL;
 					address =_php_rfc822_write_address(env->from TSRMLS_CC);
 					if (address) {
-						add_property_string(myoverview, "from", address, 0);
+						// TODO: avoid reallocation ???
+						add_property_string(myoverview, "from", address);
+						efree(address);
 					}
 				}
 				if (env->to) {
 					env->to->next = NULL;
 					address = _php_rfc822_write_address(env->to TSRMLS_CC);
 					if (address) {
-						add_property_string(myoverview, "to", address, 0);
+						// TODO: avoid reallocation ???
+						add_property_string(myoverview, "to", address);
+						efree(address);
 					}
 				}
 				if (env->date) {
-					add_property_string(myoverview, "date", env->date, 1);
+					add_property_string(myoverview, "date", env->date);
 				}
 				if (env->message_id) {
-					add_property_string(myoverview, "message_id", env->message_id, 1);
+					add_property_string(myoverview, "message_id", env->message_id);
 				}
 				if (env->references) {
-					add_property_string(myoverview, "references", env->references, 1);
+					add_property_string(myoverview, "references", env->references);
 				}
 				if (env->in_reply_to) {
-					add_property_string(myoverview, "in_reply_to", env->in_reply_to, 1);
+					add_property_string(myoverview, "in_reply_to", env->in_reply_to);
 				}
 				add_property_long(myoverview, "size", elt->rfc822_size);
 				add_property_long(myoverview, "uid", mail_uid(imap_le_struct->imap_stream, i));
@@ -4147,7 +4151,7 @@ PHP_FUNCTION(imap_alerts)
 
 	cur = IMAPG(imap_alertstack);
 	while (cur != NIL) {
-		add_next_index_string(return_value, cur->LTEXT, 1);
+		add_next_index_string(return_value, cur->LTEXT);
 		cur = cur->next;
 	}
 	mail_free_stringlist(&IMAPG(imap_alertstack));
@@ -4174,7 +4178,7 @@ PHP_FUNCTION(imap_errors)
 
 	cur = IMAPG(imap_errorstack);
 	while (cur != NIL) {
-		add_next_index_string(return_value, cur->LTEXT, 1);
+		add_next_index_string(return_value, cur->LTEXT);
 		cur = cur->next;
 	}
 	mail_free_errorlist(&IMAPG(imap_errorstack));
@@ -4238,8 +4242,8 @@ PHP_FUNCTION(imap_mime_header_decode)
 				text[charset_token - offset] = 0x00;
 				MAKE_STD_ZVAL(myobject);
 				object_init(myobject);
-				add_property_string(myobject, "charset", "default", 1);
-				add_property_string(myobject, "text", text, 1);
+				add_property_string(myobject, "charset", "default");
+				add_property_string(myobject, "text", text);
 				zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
 			}
 			if ((encoding_token = (long)php_memnstr(&string[charset_token+2], "?", 1, string+end))) {		/* Find token for encoding */
@@ -4265,8 +4269,8 @@ PHP_FUNCTION(imap_mime_header_decode)
 					}
 					MAKE_STD_ZVAL(myobject);
 					object_init(myobject);
-					add_property_string(myobject, "charset", charset, 1);
-					add_property_string(myobject, "text", decode, 1);
+					add_property_string(myobject, "charset", charset);
+					add_property_string(myobject, "text", decode);
 					zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
 
 					/* only free decode if it was allocated by rfc822_qprint or rfc822_base64 */
@@ -4295,8 +4299,8 @@ PHP_FUNCTION(imap_mime_header_decode)
 		text[end - charset_token] = 0x00;
 		MAKE_STD_ZVAL(myobject);
 		object_init(myobject);
-		add_property_string(myobject, "charset", "default", 1);
-		add_property_string(myobject, "text", text, 1);
+		add_property_string(myobject, "charset", "default");
+		add_property_string(myobject, "text", text);
 		zend_hash_next_index_insert(Z_ARRVAL_P(return_value), (void *)&myobject, sizeof(zval *), NULL);
 
 		offset = end;	/* We have reached the end of the string. */
@@ -4432,10 +4436,10 @@ static char* _php_imap_parse_address (ADDRESS *addresslist, zval *paddress TSRML
 	do {
 		MAKE_STD_ZVAL(tmpvals);
 		object_init(tmpvals);
-		if (addresstmp->personal) add_property_string(tmpvals, "personal", addresstmp->personal, 1);
-		if (addresstmp->adl) add_property_string(tmpvals, "adl", addresstmp->adl, 1);
-		if (addresstmp->mailbox) add_property_string(tmpvals, "mailbox", addresstmp->mailbox, 1);
-		if (addresstmp->host) add_property_string(tmpvals, "host", addresstmp->host, 1);
+		if (addresstmp->personal) add_property_string(tmpvals, "personal", addresstmp->personal);
+		if (addresstmp->adl) add_property_string(tmpvals, "adl", addresstmp->adl);
+		if (addresstmp->mailbox) add_property_string(tmpvals, "mailbox", addresstmp->mailbox);
+		if (addresstmp->host) add_property_string(tmpvals, "host", addresstmp->host);
 		add_next_index_object(paddress, tmpvals TSRMLS_CC);
 	} while ((addresstmp = addresstmp->next));
 	return fulladdress;
@@ -4451,23 +4455,25 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 
 	object_init(myzvalue);
 
-	if (en->remail) add_property_string(myzvalue, "remail", en->remail, 1);
-	if (en->date) add_property_string(myzvalue, "date", en->date, 1);
-	if (en->date) add_property_string(myzvalue, "Date", en->date, 1);
-	if (en->subject) add_property_string(myzvalue, "subject", en->subject, 1);
-	if (en->subject) add_property_string(myzvalue, "Subject", en->subject, 1);
-	if (en->in_reply_to) add_property_string(myzvalue, "in_reply_to", en->in_reply_to, 1);
-	if (en->message_id) add_property_string(myzvalue, "message_id", en->message_id, 1);
-	if (en->newsgroups) add_property_string(myzvalue, "newsgroups", en->newsgroups, 1);
-	if (en->followup_to) add_property_string(myzvalue, "followup_to", en->followup_to, 1);
-	if (en->references) add_property_string(myzvalue, "references", en->references, 1);
+	if (en->remail) add_property_string(myzvalue, "remail", en->remail);
+	if (en->date) add_property_string(myzvalue, "date", en->date);
+	if (en->date) add_property_string(myzvalue, "Date", en->date);
+	if (en->subject) add_property_string(myzvalue, "subject", en->subject);
+	if (en->subject) add_property_string(myzvalue, "Subject", en->subject);
+	if (en->in_reply_to) add_property_string(myzvalue, "in_reply_to", en->in_reply_to);
+	if (en->message_id) add_property_string(myzvalue, "message_id", en->message_id);
+	if (en->newsgroups) add_property_string(myzvalue, "newsgroups", en->newsgroups);
+	if (en->followup_to) add_property_string(myzvalue, "followup_to", en->followup_to);
+	if (en->references) add_property_string(myzvalue, "references", en->references);
 
 	if (en->to) {
 		MAKE_STD_ZVAL(paddress);
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->to, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "toaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "toaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "to", paddress TSRMLS_CC);
 	}
@@ -4477,7 +4483,9 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->from, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "fromaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "fromaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "from", paddress TSRMLS_CC);
 	}
@@ -4487,7 +4495,9 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->cc, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "ccaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "ccaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "cc", paddress TSRMLS_CC);
 	}
@@ -4497,7 +4507,9 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->bcc, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "bccaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "bccaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "bcc", paddress TSRMLS_CC);
 	}
@@ -4507,7 +4519,9 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->reply_to, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "reply_toaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "reply_toaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "reply_to", paddress TSRMLS_CC);
 	}
@@ -4517,7 +4531,9 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->sender, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "senderaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "senderaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "sender", paddress TSRMLS_CC);
 	}
@@ -4527,7 +4543,9 @@ static void _php_make_header_object(zval *myzvalue, ENVELOPE *en TSRMLS_DC)
 		array_init(paddress);
 		fulladdress = _php_imap_parse_address(en->return_path, paddress TSRMLS_CC);
 		if (fulladdress) {
-			add_property_string(myzvalue, "return_pathaddress", fulladdress, 0);
+			// TODO: avoid reallocation ???
+			add_property_string(myzvalue, "return_pathaddress", fulladdress);
+			efree(fulladdress);
 		}
 		add_assoc_object(myzvalue, "return_path", paddress TSRMLS_CC);
 	}
@@ -4552,21 +4570,21 @@ void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC)
 
 	if (body->subtype) {
 		add_property_long(arg, "ifsubtype", 1);
-		add_property_string(arg, "subtype", body->subtype, 1);
+		add_property_string(arg, "subtype", body->subtype);
 	} else {
 		add_property_long(arg, "ifsubtype", 0);
 	}
 
 	if (body->description) {
 		add_property_long(arg, "ifdescription", 1);
-		add_property_string(arg, "description", body->description, 1);
+		add_property_string(arg, "description", body->description);
 	} else {
 		add_property_long(arg, "ifdescription", 0);
 	}
 
 	if (body->id) {
 		add_property_long(arg, "ifid", 1);
-		add_property_string(arg, "id", body->id, 1);
+		add_property_string(arg, "id", body->id);
 	} else {
 		add_property_long(arg, "ifid", 0);
 	}
@@ -4582,7 +4600,7 @@ void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC)
 #ifdef IMAP41
 	if (body->disposition.type) {
 		add_property_long(arg, "ifdisposition", 1);
-		add_property_string(arg, "disposition", body->disposition.type, 1);
+		add_property_string(arg, "disposition", body->disposition.type);
 	} else {
 		add_property_long(arg, "ifdisposition", 0);
 	}
@@ -4595,8 +4613,8 @@ void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC)
 		do {
 			MAKE_STD_ZVAL(dparam);
 			object_init(dparam);
-			add_property_string(dparam, "attribute", dpar->attribute, 1);
-			add_property_string(dparam, "value", dpar->value, 1);
+			add_property_string(dparam, "attribute", dpar->attribute);
+			add_property_string(dparam, "value", dpar->value);
 			add_next_index_object(dparametres, dparam TSRMLS_CC);
 		} while ((dpar = dpar->next));
 		add_assoc_object(arg, "dparameters", dparametres TSRMLS_CC);
@@ -4614,10 +4632,10 @@ void _php_imap_add_body(zval *arg, BODY *body TSRMLS_DC)
 			MAKE_STD_ZVAL(param);
 			object_init(param);
 			if (par->attribute) {
-				add_property_string(param, "attribute", par->attribute, 1);
+				add_property_string(param, "attribute", par->attribute);
 			}
 			if (par->value) {
-				add_property_string(param, "value", par->value, 1);
+				add_property_string(param, "value", par->value);
 			}
 
 			add_next_index_object(parametres, param TSRMLS_CC);
diff --git a/ext/interbase/ibase_query.c b/ext/interbase/ibase_query.c
index 892745044f..4914dcd596 100644
--- a/ext/interbase/ibase_query.c
+++ b/ext/interbase/ibase_query.c
@@ -1916,18 +1916,18 @@ static void _php_ibase_field_info(zval *return_value, XSQLVAR *var) /* {{{ */
 
 	array_init(return_value);
 
-	add_index_stringl(return_value, 0, var->sqlname, var->sqlname_length, 1);
-	add_assoc_stringl(return_value, "name", var->sqlname, var->sqlname_length, 1);
+	add_index_stringl(return_value, 0, var->sqlname, var->sqlname_length);
+	add_assoc_stringl(return_value, "name", var->sqlname, var->sqlname_length);
 
-	add_index_stringl(return_value, 1, var->aliasname, var->aliasname_length, 1);
-	add_assoc_stringl(return_value, "alias", var->aliasname, var->aliasname_length, 1);
+	add_index_stringl(return_value, 1, var->aliasname, var->aliasname_length);
+	add_assoc_stringl(return_value, "alias", var->aliasname, var->aliasname_length);
 
-	add_index_stringl(return_value, 2, var->relname, var->relname_length, 1);
-	add_assoc_stringl(return_value, "relation", var->relname, var->relname_length, 1);
+	add_index_stringl(return_value, 2, var->relname, var->relname_length);
+	add_assoc_stringl(return_value, "relation", var->relname, var->relname_length);
 
 	len = slprintf(buf, 16, "%d", var->sqllen);
-	add_index_stringl(return_value, 3, buf, len, 1);
-	add_assoc_stringl(return_value, "length", buf, len, 1);
+	add_index_stringl(return_value, 3, buf, len);
+	add_assoc_stringl(return_value, "length", buf, len);
 
 	if (var->sqlscale < 0) {
 		unsigned short precision = 0;
@@ -1945,8 +1945,8 @@ static void _php_ibase_field_info(zval *return_value, XSQLVAR *var) /* {{{ */
 				break;
 		}
 		len = slprintf(buf, 16, "NUMERIC(%d,%d)", precision, -var->sqlscale);
-		add_index_stringl(return_value, 4, s, len, 1);
-		add_assoc_stringl(return_value, "type", s, len, 1);
+		add_index_stringl(return_value, 4, s, len);
+		add_assoc_stringl(return_value, "type", s, len);
 	} else {
 		switch (var->sqltype & ~1) {
 			case SQL_TEXT:
@@ -1990,8 +1990,8 @@ static void _php_ibase_field_info(zval *return_value, XSQLVAR *var) /* {{{ */
 				s = "QUAD";
 				break;
 		}
-		add_index_string(return_value, 4, s, 1);
-		add_assoc_string(return_value, "type", s, 1);
+		add_index_string(return_value, 4, s);
+		add_assoc_string(return_value, "type", s);
 	}
 }
 /* }}} */
diff --git a/ext/interbase/ibase_service.c b/ext/interbase/ibase_service.c
index e4e190d50d..2de77bc353 100644
--- a/ext/interbase/ibase_service.c
+++ b/ext/interbase/ibase_service.c
@@ -351,7 +351,7 @@ query_loop:
 
 						case isc_spb_dbname:
 							len = isc_vax_integer(result,2);
-							add_next_index_stringl(return_value, result +2, len, 1);
+							add_next_index_stringl(return_value, result +2, len);
 							result += len+2;
 					}
 				} while (*result != isc_info_flag_end);
@@ -373,25 +373,25 @@ query_loop:
 							add_next_index_zval(return_value, user);
 
 							len = isc_vax_integer(result,2);
-							add_assoc_stringl(user, "user_name", result +2, len, 1);
+							add_assoc_stringl(user, "user_name", result +2, len);
 							result += len+2;
 							break;
 
 						case isc_spb_sec_firstname:
 							len = isc_vax_integer(result,2);
-							add_assoc_stringl(user, "first_name", result +2, len, 1);
+							add_assoc_stringl(user, "first_name", result +2, len);
 							result += len+2;
 							break;
 
 						case isc_spb_sec_middlename:
 							len = isc_vax_integer(result,2);
-							add_assoc_stringl(user, "middle_name", result +2, len, 1);
+							add_assoc_stringl(user, "middle_name", result +2, len);
 							result += len+2;
 							break;
 
 						case isc_spb_sec_lastname:
 							len = isc_vax_integer(result,2);
-							add_assoc_stringl(user, "last_name", result +2, len, 1);
+							add_assoc_stringl(user, "last_name", result +2, len);
 							result += len+2;
 							break;
 
diff --git a/ext/intl/breakiterator/breakiterator_class.cpp b/ext/intl/breakiterator/breakiterator_class.cpp
index 7ca7e94c95..181d0e03b9 100644
--- a/ext/intl/breakiterator/breakiterator_class.cpp
+++ b/ext/intl/breakiterator/breakiterator_class.cpp
@@ -165,7 +165,7 @@ static HashTable *BreakIterator_get_debug_info(zval *object, int *is_temp TSRMLS
 	}
 
 	add_assoc_string_ex(&zv, "type", sizeof("type"),
-			const_cast<char*>(typeid(*biter).name()), 1);
+			const_cast<char*>(typeid(*biter).name()));
 
 	return Z_ARRVAL(zv);
 }
@@ -386,12 +386,12 @@ U_CFUNC void breakiterator_register_BreakIterator_class(TSRMLS_D)
 	INIT_CLASS_ENTRY(ce, "IntlRuleBasedBreakIterator",
 			RuleBasedBreakIterator_class_functions);
 	RuleBasedBreakIterator_ce_ptr = zend_register_internal_class_ex(&ce,
-			BreakIterator_ce_ptr, NULL TSRMLS_CC);
+			BreakIterator_ce_ptr TSRMLS_CC);
 
 	/* Create and register 'CodePointBreakIterator' class. */
 	INIT_CLASS_ENTRY(ce, "IntlCodePointBreakIterator",
 			CodePointBreakIterator_class_functions);
 	CodePointBreakIterator_ce_ptr = zend_register_internal_class_ex(&ce,
-			BreakIterator_ce_ptr, NULL TSRMLS_CC);
+			BreakIterator_ce_ptr TSRMLS_CC);
 }
 /* }}} */
diff --git a/ext/intl/breakiterator/breakiterator_iterators.cpp b/ext/intl/breakiterator/breakiterator_iterators.cpp
index 3748991aed..55112c1f5a 100644
--- a/ext/intl/breakiterator/breakiterator_iterators.cpp
+++ b/ext/intl/breakiterator/breakiterator_iterators.cpp
@@ -323,7 +323,7 @@ U_CFUNC void breakiterator_register_IntlPartsIterator_class(TSRMLS_D)
 	/* Create and register 'BreakIterator' class. */
 	INIT_CLASS_ENTRY(ce, "IntlPartsIterator", IntlPartsIterator_class_functions);
 	IntlPartsIterator_ce_ptr = zend_register_internal_class_ex(&ce,
-			IntlIterator_ce_ptr, NULL TSRMLS_CC);
+			IntlIterator_ce_ptr TSRMLS_CC);
 	IntlPartsIterator_ce_ptr->create_object = IntlPartsIterator_object_create;
 
 	memcpy(&IntlPartsIterator_handlers, &IntlIterator_handlers,
diff --git a/ext/intl/calendar/calendar_class.cpp b/ext/intl/calendar/calendar_class.cpp
index e13425097d..99828c43ea 100644
--- a/ext/intl/calendar/calendar_class.cpp
+++ b/ext/intl/calendar/calendar_class.cpp
@@ -168,7 +168,7 @@ static HashTable *Calendar_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 	add_assoc_bool_ex(&zv, "valid", sizeof("valid"), 1);
 
 	add_assoc_string_ex(&zv, "type", sizeof("type"),
-		const_cast<char*>(cal->getType()), 1);
+		const_cast<char*>(cal->getType()));
 
 	{
 		zval		   ztz = zval_used_for_init,
@@ -191,10 +191,10 @@ static HashTable *Calendar_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 		Locale		locale	= cal->getLocale(ULOC_VALID_LOCALE, uec);
 		if (U_SUCCESS(uec)) {
 			add_assoc_string_ex(&zv, "locale", sizeof("locale"),
-				const_cast<char*>(locale.getName()), 1);
+				const_cast<char*>(locale.getName()));
 		} else {
 			add_assoc_string_ex(&zv, "locale", sizeof("locale"),
-				const_cast<char*>(u_errorName(uec)), 1);
+				const_cast<char*>(u_errorName(uec)));
 		}
 	}
 
@@ -210,7 +210,7 @@ static HashTable *Calendar_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 		if (U_SUCCESS(uec)) {
 			add_assoc_long(zfields, name, (long)res);
 		} else {
-			add_assoc_string(zfields, name, const_cast<char*>(u_errorName(uec)), 1);
+			add_assoc_string(zfields, name, const_cast<char*>(u_errorName(uec)));
 		}
 	}
 
@@ -490,7 +490,7 @@ void calendar_register_IntlCalendar_class(TSRMLS_D)
 	/* Create and register 'IntlGregorianCalendar' class. */
 	INIT_CLASS_ENTRY(ce, "IntlGregorianCalendar", GregorianCalendar_class_functions);
 	GregorianCalendar_ce_ptr = zend_register_internal_class_ex(&ce,
-		Calendar_ce_ptr, NULL TSRMLS_CC);
+		Calendar_ce_ptr TSRMLS_CC);
 	if (!GregorianCalendar_ce_ptr) {
 		//can't happen know without bigger problems before
 		php_error_docref0(NULL TSRMLS_CC, E_ERROR,
diff --git a/ext/intl/calendar/calendar_methods.cpp b/ext/intl/calendar/calendar_methods.cpp
index ae7d0093f7..179602d8fa 100644
--- a/ext/intl/calendar/calendar_methods.cpp
+++ b/ext/intl/calendar/calendar_methods.cpp
@@ -210,7 +210,7 @@ U_CFUNC PHP_FUNCTION(intlcal_get_available_locales)
 	array_init(return_value);
 	for (int i = 0; i < count; i++) {
 		Locale locale = availLocales[i];
-		add_next_index_string(return_value, locale.getName(), 1);
+		add_next_index_string(return_value, locale.getName());
 	}
 }
 
diff --git a/ext/intl/collator/collator_sort.c b/ext/intl/collator/collator_sort.c
index 04a24f013e..24c8daf7fe 100644
--- a/ext/intl/collator/collator_sort.c
+++ b/ext/intl/collator/collator_sort.c
@@ -215,8 +215,8 @@ static int collator_compare_func( const void* a, const void* b TSRMLS_DC )
 	zval *first;
 	zval *second;
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
 
 	first = *((zval **) f->pData);
 	second = *((zval **) s->pData);
diff --git a/ext/intl/converter/converter.c b/ext/intl/converter/converter.c
index a3381bf78e..0e45f31d2d 100644
--- a/ext/intl/converter/converter.c
+++ b/ext/intl/converter/converter.c
@@ -559,7 +559,7 @@ static void php_converter_resolve_callback(zval *zobj,
 	array_init(&caller);
 	Z_ADDREF_P(zobj);
 	add_index_zval(&caller, 0, zobj);
-	add_index_string(&caller, 1, callback_name, 1);
+	add_index_string(&caller, 1, callback_name);
 	if (zend_fcall_info_init(&caller, 0, finfo, fcache, NULL, &errstr TSRMLS_CC) == FAILURE) {
 		php_converter_throw_failure(objval, U_INTERNAL_PROGRAM_ERROR TSRMLS_CC, "Error setting converter callback: %s", errstr);
 	}
@@ -923,7 +923,7 @@ static PHP_METHOD(UConverter, getAvailable) {
 	array_init(return_value);
 	for(i = 0; i < count; i++) {
 		const char *name = ucnv_getAvailableName(i);
-		add_next_index_string(return_value, name, 1);
+		add_next_index_string(return_value, name);
 	}
 }
 /* }}} */
@@ -962,7 +962,7 @@ static PHP_METHOD(UConverter, getAliases) {
 			zval_dtor(return_value);
 			RETURN_NULL();
 		}
-		add_next_index_string(return_value, alias, 1);
+		add_next_index_string(return_value, alias);
 	}
 }
 /* }}} */
@@ -990,7 +990,7 @@ static PHP_METHOD(UConverter, getStandards) {
 			zval_dtor(return_value);
 			RETURN_NULL();
 		}
-		add_next_index_string(return_value, name, 1);
+		add_next_index_string(return_value, name);
 	}
 }
 /* }}} */
diff --git a/ext/intl/intl_error.c b/ext/intl/intl_error.c
index 99b1c6001c..c76591ba56 100644
--- a/ext/intl/intl_error.c
+++ b/ext/intl/intl_error.c
@@ -240,7 +240,7 @@ void intl_register_IntlException_class( TSRMLS_D )
 	/* Create and register 'IntlException' class. */
 	INIT_CLASS_ENTRY_EX( ce, "IntlException", sizeof( "IntlException" ) - 1, NULL );
 	IntlException_ce_ptr = zend_register_internal_class_ex( &ce,
-		default_exception_ce, NULL TSRMLS_CC );
+		default_exception_ce TSRMLS_CC );
 	IntlException_ce_ptr->create_object = default_exception_ce->create_object;
 }
 
diff --git a/ext/intl/locale/locale_methods.c b/ext/intl/locale/locale_methods.c
index 21b5847f2d..f5be81f74a 100644
--- a/ext/intl/locale/locale_methods.c
+++ b/ext/intl/locale/locale_methods.c
@@ -724,7 +724,9 @@ PHP_FUNCTION( locale_get_keywords )
         		RETURN_FALSE;
 			}
 
-       		add_assoc_stringl( return_value, (char *)kw_key, kw_value , kw_value_len, 0);
+			// TODO: avoid reallocation ???
+       		add_assoc_stringl( return_value, (char *)kw_key, kw_value , kw_value_len);
+       		efree(kw_value);
 		} /* end of while */
 
 	} /* end of if e!=NULL */
@@ -1047,11 +1049,11 @@ static int add_array_entry(const char* loc_name, zval* hash_arr, char* key_name
 			}
 			cur_key_name = (char*)ecalloc( 25,  25);
 			sprintf( cur_key_name , "%s%d", key_name , cnt++);	
-			add_assoc_string( hash_arr, cur_key_name , token ,TRUE );
+			add_assoc_string( hash_arr, cur_key_name , token);
 			/* tokenize on the "_" or "-" and stop  at singleton if any */
 			while( (token = php_strtok_r(NULL , DELIMITER , &last_ptr)) && (strlen(token)>1) ){
 				sprintf( cur_key_name , "%s%d", key_name , cnt++);	
-				add_assoc_string( hash_arr, cur_key_name , token , TRUE );
+				add_assoc_string( hash_arr, cur_key_name , token);
 			}
 /*
 			if( strcmp(key_name, LOC_PRIVATE_TAG) == 0 ){
@@ -1060,7 +1062,7 @@ static int add_array_entry(const char* loc_name, zval* hash_arr, char* key_name
 		}
 	} else {
 		if( result == 1 ){
-			add_assoc_string( hash_arr, key_name , key_value , TRUE );
+			add_assoc_string( hash_arr, key_name , key_value);
 			cur_result = 1;
 		}
 	}
@@ -1107,7 +1109,7 @@ PHP_FUNCTION(locale_parse)
 
 	grOffset =  findOffset( LOC_GRANDFATHERED , loc_name );
 	if( grOffset >= 0 ){
-		add_assoc_string( return_value , LOC_GRANDFATHERED_LANG_TAG , estrdup(loc_name) ,FALSE );
+		add_assoc_string( return_value , LOC_GRANDFATHERED_LANG_TAG , loc_name);
 	}
 	else{
 		/* Not grandfathered */
@@ -1164,10 +1166,10 @@ PHP_FUNCTION(locale_get_all_variants)
 		if( result > 0 && variant){
 			/* Tokenize on the "_" or "-" */
 			token = php_strtok_r( variant , DELIMITER , &saved_ptr);	
-			add_next_index_stringl( return_value, token , strlen(token) ,TRUE );
+			add_next_index_stringl( return_value, token , strlen(token));
 			/* tokenize on the "_" or "-" and stop  at singleton if any	*/
 			while( (token = php_strtok_r(NULL , DELIMITER, &saved_ptr)) && (strlen(token)>1) ){
- 				add_next_index_stringl( return_value, token , strlen(token) ,TRUE );
+ 				add_next_index_stringl( return_value, token , strlen(token));
 			}
 		}
 		if( variant ){
diff --git a/ext/intl/resourcebundle/resourcebundle_class.c b/ext/intl/resourcebundle/resourcebundle_class.c
index dc1212431a..ca1828cd37 100644
--- a/ext/intl/resourcebundle/resourcebundle_class.c
+++ b/ext/intl/resourcebundle/resourcebundle_class.c
@@ -340,7 +340,7 @@ PHP_FUNCTION( resourcebundle_locales )
 
 	array_init( return_value );
 	while ((entry = uenum_next( icuenum, &entry_len, &icuerror ))) {
-		add_next_index_stringl( return_value, (char *) entry, entry_len, 1 );
+		add_next_index_stringl( return_value, (char *) entry, entry_len);
 	}
 	uenum_close( icuenum );
 }
diff --git a/ext/intl/timezone/timezone_class.cpp b/ext/intl/timezone/timezone_class.cpp
index 374b163851..fa08af8503 100644
--- a/ext/intl/timezone/timezone_class.cpp
+++ b/ext/intl/timezone/timezone_class.cpp
@@ -311,7 +311,9 @@ static HashTable *TimeZone_get_debug_info(zval *object, int *is_temp TSRMLS_DC)
 	if (U_FAILURE(uec)) {
 		return Z_ARRVAL(zv);
 	}
-	add_assoc_stringl_ex(&zv, "id", sizeof("id"), str, str_len, 0);
+	// TODO: avoid reallocation ???
+	add_assoc_stringl_ex(&zv, "id", sizeof("id"), str, str_len);
+	efree(str);
 
 	int32_t rawOffset, dstOffset;
 	UDate now = Calendar::getNow();
diff --git a/ext/intl/transliterator/transliterator_methods.c b/ext/intl/transliterator/transliterator_methods.c
index 1aa39c54b9..4b77508ff0 100644
--- a/ext/intl/transliterator/transliterator_methods.c
+++ b/ext/intl/transliterator/transliterator_methods.c
@@ -277,7 +277,9 @@ PHP_FUNCTION( transliterator_list_ids )
 		}
 		else
 		{
-			add_next_index_stringl( return_value, el_char, el_len, 0 );
+		    // TODO: avoid reallocation ???
+			add_next_index_stringl( return_value, el_char, el_len);
+			efree(el_char);
 		}
 	}
 	uenum_close( en );
diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
index 50055a25a7..6e698640f7 100644
--- a/ext/ldap/ldap.c
+++ b/ext/ldap/ldap.c
@@ -991,13 +991,13 @@ PHP_FUNCTION(ldap_get_entries)
 			array_init(tmp2);
 			add_assoc_long(tmp2, "count", num_values);
 			for (i = 0; i < num_values; i++) {
-				add_index_stringl(tmp2, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len, 1);
+				add_index_stringl(tmp2, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len);
 			}	
 			ldap_value_free_len(ldap_value);
 
 			attr_len = strlen(attribute);
 			zend_hash_update(Z_ARRVAL_P(tmp1), php_strtolower(attribute, attr_len), attr_len+1, (void *) &tmp2, sizeof(zval *), NULL);
-			add_index_string(tmp1, num_attrib, attribute, 1);
+			add_index_string(tmp1, num_attrib, attribute);
 
 			num_attrib++;
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
@@ -1013,7 +1013,7 @@ PHP_FUNCTION(ldap_get_entries)
 
 		add_assoc_long(tmp1, "count", num_attrib);
 		dn = ldap_get_dn(ldap, ldap_result_entry);
-		add_assoc_string(tmp1, "dn", dn, 1);
+		add_assoc_string(tmp1, "dn", dn);
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
 		ldap_memfree(dn);
 #else
@@ -1130,12 +1130,12 @@ PHP_FUNCTION(ldap_get_attributes)
 		array_init(tmp);
 		add_assoc_long(tmp, "count", num_values);
 		for (i = 0; i < num_values; i++) {
-			add_index_stringl(tmp, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len, 1);
+			add_index_stringl(tmp, i, ldap_value[i]->bv_val, ldap_value[i]->bv_len);
 		}
 		ldap_value_free_len(ldap_value);
 
 		zend_hash_update(Z_ARRVAL_P(return_value), attribute, strlen(attribute)+1, (void *) &tmp, sizeof(zval *), NULL);
-		add_index_string(return_value, num_attrib, attribute, 1);
+		add_index_string(return_value, num_attrib, attribute);
 
 		num_attrib++;
 #if (LDAP_API_VERSION > 2000) || HAVE_NSLDAP || HAVE_ORALDAP || WINDOWS
@@ -1180,7 +1180,7 @@ PHP_FUNCTION(ldap_get_values_len)
 	array_init(return_value);
 	
 	for (i=0; i<num_values; i++) {
-		add_next_index_stringl(return_value, ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len, 1);
+		add_next_index_stringl(return_value, ldap_value_len[i]->bv_val, ldap_value_len[i]->bv_len);
 	}
 	
 	add_assoc_long(return_value, "count", num_values);
@@ -1244,7 +1244,7 @@ PHP_FUNCTION(ldap_explode_dn)
 
 	add_assoc_long(return_value, "count", count);
 	for (i = 0; i<count; i++) {
-		add_index_string(return_value, i, ldap_value[i], 1);
+		add_index_string(return_value, i, ldap_value[i]);
 	}
 
 	ldap_value_free(ldap_value);
@@ -2235,7 +2235,7 @@ PHP_FUNCTION(ldap_parse_result)
 			if (lreferrals != NULL) {
 				refp = lreferrals;
 				while (*refp) {
-					add_next_index_string(referrals, *refp, 1);
+					add_next_index_string(referrals, *refp);
 					refp++;
 				}
 				ldap_value_free(lreferrals);
@@ -2346,7 +2346,7 @@ PHP_FUNCTION(ldap_parse_reference)
 	if (lreferrals != NULL) {
 		refp = lreferrals;
 		while (*refp) {
-			add_next_index_string(referrals, *refp, 1);
+			add_next_index_string(referrals, *refp);
 			refp++;
 		}
 		ldap_value_free(lreferrals);
@@ -2713,9 +2713,9 @@ PHP_FUNCTION(ldap_control_paged_result)
 		/* return a PHP control object */
 		array_init(return_value);
 
-		add_assoc_string(return_value, "oid", ctrl.ldctl_oid, 1);
+		add_assoc_string(return_value, "oid", ctrl.ldctl_oid);
 		if (ctrl.ldctl_value.bv_len) {
-			add_assoc_stringl(return_value, "value", ctrl.ldctl_value.bv_val, ctrl.ldctl_value.bv_len, 1);
+			add_assoc_stringl(return_value, "value", ctrl.ldctl_value.bv_val, ctrl.ldctl_value.bv_len);
 		}
 		if (ctrl.ldctl_iscritical) {
 			add_assoc_bool(return_value, "iscritical", ctrl.ldctl_iscritical);
diff --git a/ext/libxml/libxml.c b/ext/libxml/libxml.c
index 3114b25199..c7efa13c27 100644
--- a/ext/libxml/libxml.c
+++ b/ext/libxml/libxml.c
@@ -86,6 +86,7 @@ ZEND_GET_MODULE(libxml)
 /* {{{ function prototypes */
 static PHP_MINIT_FUNCTION(libxml);
 static PHP_RINIT_FUNCTION(libxml);
+static PHP_RSHUTDOWN_FUNCTION(libxml);
 static PHP_MSHUTDOWN_FUNCTION(libxml);
 static PHP_MINFO_FUNCTION(libxml);
 static int php_libxml_post_deactivate(void);
@@ -138,7 +139,7 @@ zend_module_entry libxml_module_entry = {
 	PHP_MINIT(libxml),       /* extension-wide startup function */
 	PHP_MSHUTDOWN(libxml),   /* extension-wide shutdown function */
 	PHP_RINIT(libxml),       /* per-request startup function */
-	NULL,                    /* per-request shutdown function */
+	PHP_RSHUTDOWN(libxml),   /* per-request shutdown function */
 	PHP_MINFO(libxml),       /* information function */
 	NO_VERSION_YET,
 	PHP_MODULE_GLOBALS(libxml), /* globals descriptor */
@@ -267,22 +268,24 @@ static void php_libxml_node_free_list(xmlNodePtr node TSRMLS_DC)
 /* {{{ startup, shutdown and info functions */
 static PHP_GINIT_FUNCTION(libxml)
 {
-	libxml_globals->stream_context = NULL;
-	libxml_globals->error_buffer.c = NULL;
+	ZVAL_UNDEF(&libxml_globals->stream_context);
+	libxml_globals->error_buffer.s = NULL;
 	libxml_globals->error_list = NULL;
+	ZVAL_UNDEF(&libxml_globals->entity_loader.object);
 	libxml_globals->entity_loader.fci.size = 0;
 	libxml_globals->entity_loader_disabled = 0;
 }
 
-static void _php_libxml_destroy_fci(zend_fcall_info *fci)
+static void _php_libxml_destroy_fci(zend_fcall_info *fci, zval *object)
 {
 	if (fci->size > 0) {
 		zval_ptr_dtor(&fci->function_name);
-		if (fci->object_ptr != NULL) {
-			zval_ptr_dtor(&fci->object_ptr);
-		}
 		fci->size = 0;
 	}
+	if (!ZVAL_IS_UNDEF(object)) {
+		zval_ptr_dtor(object);
+		ZVAL_UNDEF(object);
+	}
 }
 
 /* Channel libxml file io layer through the PHP streams subsystem.
@@ -334,7 +337,7 @@ static void *php_libxml_streams_IO_open_wrapper(const char *filename, const char
 		}
 	}
 
-	context = php_stream_context_from_zval(LIBXML(stream_context), 0);
+	context = php_stream_context_from_zval(ZVAL_IS_UNDEF(&LIBXML(stream_context))? NULL : &LIBXML(stream_context), 0);
 	
 	ret_val = php_stream_open_wrapper_ex(path_to_open, (char *)mode, REPORT_ERRORS, NULL, context);
 	if (isescaped) {
@@ -475,7 +478,7 @@ static void _php_list_set_error_structure(xmlErrorPtr error, const char *msg)
 		error_copy.int1 = 0;
 		error_copy.int2 = 0;
 		error_copy.ctxt = NULL;
-		error_copy.message = xmlStrdup(msg);
+		error_copy.message = (char*)xmlStrdup((xmlChar*)msg);
 		error_copy.file = NULL;
 		error_copy.str1 = NULL;
 		error_copy.str2 = NULL;
@@ -534,17 +537,17 @@ static void php_libxml_internal_error_handler(int error_type, void *ctx, const c
 
 	if (output == 1) {
 		if (LIBXML(error_list)) {
-			_php_list_set_error_structure(NULL, LIBXML(error_buffer).c);
+			_php_list_set_error_structure(NULL, LIBXML(error_buffer).s->val);
 		} else {
 			switch (error_type) {
 				case PHP_LIBXML_CTX_ERROR:
-					php_libxml_ctx_error_level(E_WARNING, ctx, LIBXML(error_buffer).c TSRMLS_CC);
+					php_libxml_ctx_error_level(E_WARNING, ctx, LIBXML(error_buffer).s->val TSRMLS_CC);
 					break;
 				case PHP_LIBXML_CTX_WARNING:
-					php_libxml_ctx_error_level(E_NOTICE, ctx, LIBXML(error_buffer).c TSRMLS_CC);
+					php_libxml_ctx_error_level(E_NOTICE, ctx, LIBXML(error_buffer).s->val TSRMLS_CC);
 					break;
 				default:
-					php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", LIBXML(error_buffer).c);
+					php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", LIBXML(error_buffer).s->val);
 			}
 		}
 		smart_str_free(&LIBXML(error_buffer));
@@ -556,12 +559,9 @@ static xmlParserInputPtr _php_libxml_external_entity_loader(const char *URL,
 {
 	xmlParserInputPtr	ret			= NULL;
 	const char			*resource	= NULL;
-	zval				*public		= NULL,
-						*system		= NULL,
-						*ctxzv		= NULL,
-						**params[]	= {&public, &system, &ctxzv},
-						*retval_ptr	= NULL;
-	int					retval;
+	zval 				*ctxzv, retval;
+	zval				params[3];
+	int					status;
 	zend_fcall_info		*fci;
 	TSRMLS_FETCH();
 
@@ -572,23 +572,25 @@ static xmlParserInputPtr _php_libxml_external_entity_loader(const char *URL,
 		return _php_libxml_default_entity_loader(URL, ID, context);
 	}
 
-	ALLOC_INIT_ZVAL(public);
 	if (ID != NULL) {
-		ZVAL_STRING(public, ID, 1);
+		ZVAL_STRING(&params[0], ID);
+	} else {
+		ZVAL_UNDEF(&params[0]);
 	}
-	ALLOC_INIT_ZVAL(system);
 	if (URL != NULL) {
-		ZVAL_STRING(system, URL, 1);
+		ZVAL_STRING(&params[1], URL);
+	} else {
+		ZVAL_UNDEF(&params[1]);
 	}
-	MAKE_STD_ZVAL(ctxzv);
+	ctxzv = &params[2];
 	array_init_size(ctxzv, 4);
 
 #define ADD_NULL_OR_STRING_KEY(memb) \
 	if (context->memb == NULL) { \
-		add_assoc_null_ex(ctxzv, #memb, sizeof(#memb)); \
+		add_assoc_null_ex(ctxzv, #memb, sizeof(#memb) - 1); \
 	} else { \
-		add_assoc_string_ex(ctxzv, #memb, sizeof(#memb), \
-				(char *)context->memb, 1); \
+		add_assoc_string_ex(ctxzv, #memb, sizeof(#memb) - 1, \
+				(char *)context->memb); \
 	}
 	
 	ADD_NULL_OR_STRING_KEY(directory)
@@ -598,34 +600,35 @@ static xmlParserInputPtr _php_libxml_external_entity_loader(const char *URL,
 	
 #undef ADD_NULL_OR_STRING_KEY
 	
-	fci->retval_ptr_ptr	= &retval_ptr;
-	fci->params			= params;
-	fci->param_count	= sizeof(params)/sizeof(*params);
+	fci->retval	= &retval;
+	fci->params	= params;
+	fci->param_count = sizeof(params)/sizeof(*params);
 	fci->no_separation	= 1;
 	
-	retval = zend_call_function(fci, &LIBXML(entity_loader).fcc TSRMLS_CC);
-	if (retval != SUCCESS || fci->retval_ptr_ptr == NULL) {
+	status = zend_call_function(fci, &LIBXML(entity_loader).fcc TSRMLS_CC);
+	if (status != SUCCESS || ZVAL_IS_UNDEF(&retval)) {
 		php_libxml_ctx_error(context,
 				"Call to user entity loader callback '%s' has failed",
-				fci->function_name);
+				Z_STRVAL(fci->function_name));
 	} else {
+		/*
 		retval_ptr = *fci->retval_ptr_ptr;
 		if (retval_ptr == NULL) {
 			php_libxml_ctx_error(context,
 					"Call to user entity loader callback '%s' has failed; "
 					"probably it has thrown an exception",
 					fci->function_name);
-		} else if (Z_TYPE_P(retval_ptr) == IS_STRING) {
+		} else */ if (Z_TYPE(retval) == IS_STRING) {
 is_string:
-			resource = Z_STRVAL_P(retval_ptr);
-		} else if (Z_TYPE_P(retval_ptr) == IS_RESOURCE) {
+			resource = Z_STRVAL(retval);
+		} else if (Z_TYPE(retval) == IS_RESOURCE) {
 			php_stream *stream;
-			php_stream_from_zval_no_verify(stream, &retval_ptr);
+			php_stream_from_zval_no_verify(stream, &retval);
 			if (stream == NULL) {
 				php_libxml_ctx_error(context,
 						"The user entity loader callback '%s' has returned a "
 						"resource, but it is not a stream",
-						fci->function_name);
+						Z_STRVAL(fci->function_name));
 			} else {
 				/* TODO: allow storing the encoding in the stream context? */
 				xmlCharEncoding enc = XML_CHAR_ENCODING_NONE;
@@ -635,7 +638,7 @@ is_string:
 							"input buffer");
 				} else {
 					/* make stream not being closed when the zval is freed */
-					zend_list_addref(stream->rsrc_id);
+					++GC_REFCOUNT(stream->res);
 					pib->context = stream;
 					pib->readcallback = php_libxml_streams_IO_read;
 					pib->closecallback = php_libxml_streams_IO_close;
@@ -646,10 +649,10 @@ is_string:
 					}
 				}
 			}
-		} else if (Z_TYPE_P(retval_ptr) != IS_NULL) {
+		} else if (Z_TYPE(retval) != IS_NULL) {
 			/* retval not string nor resource nor null; convert to string */
-			SEPARATE_ZVAL(&retval_ptr);
-			convert_to_string(retval_ptr);
+			SEPARATE_ZVAL(&retval);
+			convert_to_string(&retval);
 			goto is_string;
 		} /* else is null; don't try anything */
 	}
@@ -667,12 +670,10 @@ is_string:
 		}
 	}
 
-	zval_ptr_dtor(&public);
-	zval_ptr_dtor(&system);
-	zval_ptr_dtor(&ctxzv);
-	if (retval_ptr != NULL) {
-		zval_ptr_dtor(&retval_ptr);
-	}
+	zval_ptr_dtor(&params[0]);
+	zval_ptr_dtor(&params[1]);
+	zval_ptr_dtor(&params[2]);
+	zval_ptr_dtor(&retval);
 	return ret;
 }
 
@@ -728,6 +729,10 @@ PHP_LIBXML_API void php_libxml_error_handler(void *ctx, const char *msg, ...)
 	va_end(args);
 }
 
+static void php_libxml_exports_dtor(zval *zv)
+{
+	free(Z_PTR_P(zv));
+}
 
 PHP_LIBXML_API void php_libxml_initialize(void)
 {
@@ -738,7 +743,7 @@ PHP_LIBXML_API void php_libxml_initialize(void)
 		_php_libxml_default_entity_loader = xmlGetExternalEntityLoader();
 		xmlSetExternalEntityLoader(_php_libxml_pre_ext_ent_loader);
 
-		zend_hash_init(&php_libxml_exports, 0, NULL, NULL, 1);
+		zend_hash_init(&php_libxml_exports, 0, NULL, php_libxml_exports_dtor, 1);
 
 		_php_libxml_initialized = 1;
 	}
@@ -758,14 +763,10 @@ PHP_LIBXML_API void php_libxml_shutdown(void)
 	}
 }
 
-PHP_LIBXML_API zval *php_libxml_switch_context(zval *context TSRMLS_DC)
+PHP_LIBXML_API void php_libxml_switch_context(zval *context, zval *oldcontext TSRMLS_DC)
 {
-	zval *oldcontext;
-
-	oldcontext = LIBXML(stream_context);
-	LIBXML(stream_context) = context;
-	return oldcontext;
-
+	ZVAL_COPY_VALUE(oldcontext, &LIBXML(stream_context));
+	ZVAL_COPY_VALUE(&LIBXML(stream_context), context);
 }
 
 static PHP_MINIT_FUNCTION(libxml)
@@ -862,6 +863,12 @@ static PHP_RINIT_FUNCTION(libxml)
 	return SUCCESS;
 }
 
+static PHP_RSHUTDOWN_FUNCTION(libxml)
+{
+	_php_libxml_destroy_fci(&LIBXML(entity_loader).fci, &LIBXML(entity_loader).object);
+
+	return SUCCESS;
+}
 
 static PHP_MSHUTDOWN_FUNCTION(libxml)
 {
@@ -888,11 +895,8 @@ static int php_libxml_post_deactivate(void)
 	}
 	xmlSetStructuredErrorFunc(NULL, NULL);
 
-	if (LIBXML(stream_context)) {
-		/* the steam_context resource will be released by resource list destructor */
-		efree(LIBXML(stream_context));
-		LIBXML(stream_context) = NULL;
-	}
+	/* the steam_context resource will be released by resource list destructor */
+	ZVAL_UNDEF(&LIBXML(stream_context));
 	smart_str_free(&LIBXML(error_buffer));
 	if (LIBXML(error_list)) {
 		zend_llist_destroy(LIBXML(error_list));
@@ -901,8 +905,6 @@ static int php_libxml_post_deactivate(void)
 	}
 	xmlResetLastError();
 	
-	_php_libxml_destroy_fci(&LIBXML(entity_loader).fci);
-
 	return SUCCESS;
 }
 
@@ -927,12 +929,11 @@ static PHP_FUNCTION(libxml_set_streams_context)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg) == FAILURE) {
 		return;
 	}
-	if (LIBXML(stream_context)) {
+	if (!ZVAL_IS_UNDEF(&LIBXML(stream_context))) {
 		zval_ptr_dtor(&LIBXML(stream_context));
-		LIBXML(stream_context) = NULL;
+		ZVAL_UNDEF(&LIBXML(stream_context));
 	}
-	Z_ADDREF_P(arg);
-	LIBXML(stream_context) = arg;
+	ZVAL_COPY(&LIBXML(stream_context), arg);
 }
 /* }}} */
 
@@ -990,14 +991,14 @@ static PHP_FUNCTION(libxml_get_last_error)
 		add_property_long(return_value, "code", error->code);
 		add_property_long(return_value, "column", error->int2);
 		if (error->message) {
-			add_property_string(return_value, "message", error->message, 1);
+			add_property_string(return_value, "message", error->message);
 		} else {
-			add_property_stringl(return_value, "message", "", 0, 1);
+			add_property_stringl(return_value, "message", "", 0);
 		}
 		if (error->file) {
-			add_property_string(return_value, "file", error->file, 1);
+			add_property_string(return_value, "file", error->file);
 		} else {
-			add_property_stringl(return_value, "file", "", 0, 1);
+			add_property_stringl(return_value, "file", "", 0);
 		}
 		add_property_long(return_value, "line", error->line);
 	} else {
@@ -1022,25 +1023,24 @@ static PHP_FUNCTION(libxml_get_errors)
 		error = zend_llist_get_first(LIBXML(error_list));
 
 		while (error != NULL) {
-			zval *z_error;
-			MAKE_STD_ZVAL(z_error);
+			zval z_error;
 
-			object_init_ex(z_error, libxmlerror_class_entry);
-			add_property_long(z_error, "level", error->level);
-			add_property_long(z_error, "code", error->code);
-			add_property_long(z_error, "column", error->int2);
+			object_init_ex(&z_error, libxmlerror_class_entry);
+			add_property_long(&z_error, "level", error->level);
+			add_property_long(&z_error, "code", error->code);
+			add_property_long(&z_error, "column", error->int2);
 			if (error->message) {
-				add_property_string(z_error, "message", error->message, 1);
+				add_property_string(&z_error, "message", error->message);
 			} else {
-				add_property_stringl(z_error, "message", "", 0, 1);
+				add_property_stringl(&z_error, "message", "", 0);
 			}
 			if (error->file) {
-				add_property_string(z_error, "file", error->file, 1);
+				add_property_string(&z_error, "file", error->file);
 			} else {
-				add_property_stringl(z_error, "file", "", 0, 1);
+				add_property_stringl(&z_error, "file", "", 0);
 			}
-			add_property_long(z_error, "line", error->line);
-			add_next_index_zval(return_value, z_error);
+			add_property_long(&z_error, "line", error->line);
+			add_next_index_zval(return_value, &z_error);
 
 			error = zend_llist_get_next(LIBXML(error_list));
 		}
@@ -1059,13 +1059,13 @@ static PHP_FUNCTION(libxml_clear_errors)
 }
 /* }}} */
 
-PHP_LIBXML_API zend_bool php_libxml_disable_entity_loader(zend_bool disable TSRMLS_DC)
+PHP_LIBXML_API zend_bool php_libxml_disable_entity_loader(zend_bool disable TSRMLS_DC) /* {{{ */
 {
 	zend_bool old = LIBXML(entity_loader_disabled);
 
 	LIBXML(entity_loader_disabled) = disable;
 	return old;
-}
+} /* }}} */
 
 /* {{{ proto bool libxml_disable_entity_loader([boolean disable]) 
    Disable/Enable ability to load external entities */
@@ -1092,13 +1092,14 @@ static PHP_FUNCTION(libxml_set_external_entity_loader)
 		return;
 	}
 	
-	_php_libxml_destroy_fci(&LIBXML(entity_loader).fci);
+	_php_libxml_destroy_fci(&LIBXML(entity_loader).fci, &LIBXML(entity_loader).object);
 	
 	if (fci.size > 0) { /* argument not null */
 		LIBXML(entity_loader).fci = fci;
-		Z_ADDREF_P(fci.function_name);
-		if (fci.object_ptr != NULL) {
-			Z_ADDREF_P(fci.object_ptr);
+		Z_ADDREF(fci.function_name);
+		if (fci.object != NULL) {
+			ZVAL_OBJ(&LIBXML(entity_loader).object, fci.object);
+			Z_ADDREF(LIBXML(entity_loader).object);
 		}
 		LIBXML(entity_loader).fcc = fcc;
 	}
@@ -1134,7 +1135,7 @@ int php_libxml_xmlCheckUTF8(const unsigned char *s)
 	return 1;
 }
 
-int php_libxml_register_export(zend_class_entry *ce, php_libxml_export_node export_function)
+zval *php_libxml_register_export(zend_class_entry *ce, php_libxml_export_node export_function)
 {
 	php_libxml_func_handler export_hnd;
 	
@@ -1142,7 +1143,7 @@ int php_libxml_register_export(zend_class_entry *ce, php_libxml_export_node expo
 	php_libxml_initialize();
 	export_hnd.export_func = export_function;
 
-	return zend_hash_add(&php_libxml_exports, ce->name, ce->name_length + 1, &export_hnd, sizeof(export_hnd), NULL);
+	return zend_hash_add_mem(&php_libxml_exports, ce->name, &export_hnd, sizeof(export_hnd));
 }
 
 PHP_LIBXML_API xmlNodePtr php_libxml_import_node(zval *object TSRMLS_DC)
@@ -1151,12 +1152,12 @@ PHP_LIBXML_API xmlNodePtr php_libxml_import_node(zval *object TSRMLS_DC)
 	xmlNodePtr node = NULL;
 	php_libxml_func_handler *export_hnd;
 
-	if (object->type == IS_OBJECT) {
+	if (Z_TYPE_P(object) == IS_OBJECT) {
 		ce = Z_OBJCE_P(object);
 		while (ce->parent != NULL) {
 			ce = ce->parent;
 		}
-		if (zend_hash_find(&php_libxml_exports, ce->name, ce->name_length + 1, (void **) &export_hnd)  == SUCCESS) {
+		if ((export_hnd = zend_hash_find_ptr(&php_libxml_exports, ce->name))) {
 			node = export_hnd->export_func(object TSRMLS_CC);
 		}
 	}
diff --git a/ext/libxml/php_libxml.h b/ext/libxml/php_libxml.h
index 901e321aac..246994ddf8 100644
--- a/ext/libxml/php_libxml.h
+++ b/ext/libxml/php_libxml.h
@@ -40,10 +40,11 @@ extern zend_module_entry libxml_module_entry;
 #define LIBXML_SAVE_NOEMPTYTAG 1<<2
 
 ZEND_BEGIN_MODULE_GLOBALS(libxml)
-	zval *stream_context;
+	zval stream_context;
 	smart_str error_buffer;
 	zend_llist *error_list;
 	struct _php_libxml_entity_resolver {
+		zval                    object;
 		zend_fcall_info			fci;
 		zend_fcall_info_cache	fcc;
 	} entity_loader;
@@ -74,10 +75,10 @@ typedef struct _php_libxml_node_ptr {
 } php_libxml_node_ptr;
 
 typedef struct _php_libxml_node_object {
-	zend_object  std;
 	php_libxml_node_ptr *node;
 	php_libxml_ref_obj *document;
 	HashTable *properties;
+	zend_object  std;
 } php_libxml_node_object;
 
 typedef void * (*php_libxml_export_node) (zval *object TSRMLS_DC);
@@ -87,7 +88,7 @@ PHP_LIBXML_API int php_libxml_decrement_node_ptr(php_libxml_node_object *object
 PHP_LIBXML_API int php_libxml_increment_doc_ref(php_libxml_node_object *object, xmlDocPtr docp TSRMLS_DC);
 PHP_LIBXML_API int php_libxml_decrement_doc_ref(php_libxml_node_object *object TSRMLS_DC);
 PHP_LIBXML_API xmlNodePtr php_libxml_import_node(zval *object TSRMLS_DC);
-PHP_LIBXML_API int php_libxml_register_export(zend_class_entry *ce, php_libxml_export_node export_function);
+PHP_LIBXML_API zval *php_libxml_register_export(zend_class_entry *ce, php_libxml_export_node export_function);
 /* When an explicit freeing of node and children is required */
 PHP_LIBXML_API void php_libxml_node_free_resource(xmlNodePtr node TSRMLS_DC);
 /* When object dtor is called as node may still be referenced */
@@ -96,7 +97,7 @@ PHP_LIBXML_API void php_libxml_error_handler(void *ctx, const char *msg, ...);
 PHP_LIBXML_API void php_libxml_ctx_warning(void *ctx, const char *msg, ...);
 PHP_LIBXML_API void php_libxml_ctx_error(void *ctx, const char *msg, ...);
 PHP_LIBXML_API int php_libxml_xmlCheckUTF8(const unsigned char *s);
-PHP_LIBXML_API zval *php_libxml_switch_context(zval *context TSRMLS_DC);
+PHP_LIBXML_API void php_libxml_switch_context(zval *context, zval *oldcontext TSRMLS_DC);
 PHP_LIBXML_API void php_libxml_issue_error(int level, const char *msg TSRMLS_DC);
 PHP_LIBXML_API zend_bool php_libxml_disable_entity_loader(zend_bool disable TSRMLS_DC);
 
diff --git a/ext/libxml/tests/libxml_set_external_entity_loader_basic.phpt b/ext/libxml/tests/libxml_set_external_entity_loader_basic.phpt
index 51ab777052..938229ff86 100644
--- a/ext/libxml/tests/libxml_set_external_entity_loader_basic.phpt
+++ b/ext/libxml/tests/libxml_set_external_entity_loader_basic.phpt
@@ -31,6 +31,7 @@ var_dump($dd->validate());
 
 echo "Done.\n";
 
+?>
 --EXPECT--
 string(10) "-//FOO/BAR"
 string(25) "http://example.com/foobar"
diff --git a/ext/mbstring/mb_gpc.c b/ext/mbstring/mb_gpc.c
index 8036485d6d..a2dd62da53 100644
--- a/ext/mbstring/mb_gpc.c
+++ b/ext/mbstring/mb_gpc.c
@@ -55,7 +55,7 @@ MBSTRING_API SAPI_TREAT_DATA_FUNC(mbstr_treat_data)
 {
 	char *res = NULL, *separator=NULL;
 	const char *c_var;
-	zval *array_ptr;
+	zval v_array;
 	int free_buffer=0;
 	const mbfl_encoding *detected;
 	php_mb_encoding_handler_info_t info;
@@ -74,28 +74,26 @@ MBSTRING_API SAPI_TREAT_DATA_FUNC(mbstr_treat_data)
 		case PARSE_POST:
 		case PARSE_GET:
 		case PARSE_COOKIE:
-			ALLOC_ZVAL(array_ptr);
-			array_init(array_ptr);
-			INIT_PZVAL(array_ptr);
+			array_init(&v_array);
 			switch (arg) {
 				case PARSE_POST:
-					PG(http_globals)[TRACK_VARS_POST] = array_ptr;
+					ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_POST], &v_array);
 					break;
 				case PARSE_GET:
-					PG(http_globals)[TRACK_VARS_GET] = array_ptr;
+					ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_GET], &v_array);
 					break;
 				case PARSE_COOKIE:
-					PG(http_globals)[TRACK_VARS_COOKIE] = array_ptr;
+					ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_COOKIE], &v_array);
 					break;
 			}
 			break;
 		default:
-			array_ptr=destArray;
+			ZVAL_COPY_VALUE(&v_array, destArray);
 			break;
 	}
 
-	if (arg==PARSE_POST) { 
-		sapi_handle_post(array_ptr TSRMLS_CC);
+	if (arg == PARSE_POST) { 
+		sapi_handle_post(&v_array TSRMLS_CC);
 		return;
 	}
 
@@ -125,29 +123,29 @@ MBSTRING_API SAPI_TREAT_DATA_FUNC(mbstr_treat_data)
 	}
 
 	switch (arg) {
-	case PARSE_POST:
-	case PARSE_GET:
-	case PARSE_STRING:
-		separator = (char *) estrdup(PG(arg_separator).input);
-		break;
-	case PARSE_COOKIE:
-		separator = ";\0";
-		break;
+		case PARSE_POST:
+		case PARSE_GET:
+		case PARSE_STRING:
+			separator = (char *) estrdup(PG(arg_separator).input);
+			break;
+		case PARSE_COOKIE:
+			separator = ";\0";
+			break;
 	}
 	
-	switch(arg) {
-	case PARSE_POST:
-		MBSTRG(http_input_identify_post) = NULL;
-		break;
-	case PARSE_GET:
-		MBSTRG(http_input_identify_get) = NULL;
-		break;
-	case PARSE_COOKIE:
-		MBSTRG(http_input_identify_cookie) = NULL;
-		break;
-	case PARSE_STRING:
-		MBSTRG(http_input_identify_string) = NULL;
-		break;
+	switch (arg) {
+		case PARSE_POST:
+			MBSTRG(http_input_identify_post) = NULL;
+			break;
+		case PARSE_GET:
+			MBSTRG(http_input_identify_get) = NULL;
+			break;
+		case PARSE_COOKIE:
+			MBSTRG(http_input_identify_cookie) = NULL;
+			break;
+		case PARSE_STRING:
+			MBSTRG(http_input_identify_string) = NULL;
+			break;
 	}
 
 	info.data_type              = arg;
@@ -161,7 +159,7 @@ MBSTRING_API SAPI_TREAT_DATA_FUNC(mbstr_treat_data)
 
 	MBSTRG(illegalchars) = 0;
 
-	detected = _php_mb_encoding_handler_ex(&info, array_ptr, res TSRMLS_CC);
+	detected = _php_mb_encoding_handler_ex(&info, &v_array, res TSRMLS_CC);
 	MBSTRG(http_input_identify) = detected;
 
 	if (detected) {
@@ -364,7 +362,7 @@ SAPI_POST_HANDLER_FUNC(php_mb_post_handler)
 {
 	const mbfl_encoding *detected;
 	php_mb_encoding_handler_info_t info;
-	char *post_data_str = NULL;
+	zend_string *post_data_str = NULL;
 
 	MBSTRG(http_input_identify_post) = NULL;
 
@@ -378,9 +376,9 @@ SAPI_POST_HANDLER_FUNC(php_mb_post_handler)
 	info.from_language          = MBSTRG(language);
 
 	php_stream_rewind(SG(request_info).request_body);
-	php_stream_copy_to_mem(SG(request_info).request_body, &post_data_str, PHP_STREAM_COPY_ALL, 0);
-	detected = _php_mb_encoding_handler_ex(&info, arg, post_data_str TSRMLS_CC);
-	STR_FREE(post_data_str);
+	post_data_str = php_stream_copy_to_mem(SG(request_info).request_body, PHP_STREAM_COPY_ALL, 0);
+	detected = _php_mb_encoding_handler_ex(&info, arg, post_data_str->val TSRMLS_CC);
+	STR_RELEASE(post_data_str);
 
 	MBSTRG(http_input_identify) = detected;
 	if (detected) {
diff --git a/ext/mbstring/mbstring.c b/ext/mbstring/mbstring.c
index 7d4eacf14d..741e0e3f07 100644
--- a/ext/mbstring/mbstring.c
+++ b/ext/mbstring/mbstring.c
@@ -56,7 +56,6 @@
 #include "ext/standard/php_string.h"
 #include "ext/standard/php_mail.h"
 #include "ext/standard/exec.h"
-#include "ext/standard/php_smart_str.h"
 #include "ext/standard/url.h"
 #include "main/php_output.h"
 #include "ext/standard/info.h"
@@ -721,7 +720,7 @@ php_mb_parse_encoding_list(const char *value, size_t value_length, const mbfl_en
 		endp = tmpstr + value_length;
 		n = 1;
 		p1 = tmpstr;
-		while ((p2 = php_memnstr(p1, ",", 1, endp)) != NULL) {
+		while ((p2 = (char*)php_memnstr(p1, ",", 1, endp)) != NULL) {
 			p1 = p2 + 1;
 			n++;
 		}
@@ -734,7 +733,7 @@ php_mb_parse_encoding_list(const char *value, size_t value_length, const mbfl_en
 			bauto = 0;
 			p1 = tmpstr;
 			do {
-				p2 = p = php_memnstr(p1, ",", 1, endp);
+				p2 = p = (char*)php_memnstr(p1, ",", 1, endp);
 				if (p == NULL) {
 					p = endp;
 				}
@@ -811,7 +810,7 @@ php_mb_parse_encoding_list(const char *value, size_t value_length, const mbfl_en
 static int
 php_mb_parse_encoding_array(zval *array, const mbfl_encoding ***return_list, size_t *return_size, int persistent TSRMLS_DC)
 {
-	zval **hash_entry;
+	zval *hash_entry;
 	HashTable *target_hash;
 	int i, n, size, bauto, ret = SUCCESS;
 	const mbfl_encoding **list, **entry;
@@ -828,11 +827,11 @@ php_mb_parse_encoding_array(zval *array, const mbfl_encoding ***return_list, siz
 			bauto = 0;
 			n = 0;
 			while (i > 0) {
-				if (zend_hash_get_current_data(target_hash, (void **) &hash_entry) == FAILURE) {
+				if ((hash_entry = zend_hash_get_current_data(target_hash)) == NULL) {
 					break;
 				}
 				convert_to_string_ex(hash_entry);
-				if (strcasecmp(Z_STRVAL_PP(hash_entry), "auto") == 0) {
+				if (strcasecmp(Z_STRVAL_P(hash_entry), "auto") == 0) {
 					if (!bauto) {
 						const enum mbfl_no_encoding *src = MBSTRG(default_detect_order_list);
 						const size_t identify_list_size = MBSTRG(default_detect_order_list_size);
@@ -845,7 +844,7 @@ php_mb_parse_encoding_array(zval *array, const mbfl_encoding ***return_list, siz
 						}
 					}
 				} else {
-					const mbfl_encoding *encoding = mbfl_name2encoding(Z_STRVAL_PP(hash_entry));
+					const mbfl_encoding *encoding = mbfl_name2encoding(Z_STRVAL_P(hash_entry));
 					if (encoding) {
 						*entry++ = encoding;
 						n++;
@@ -1627,19 +1626,19 @@ PHP_RINIT_FUNCTION(mbstring)
 		
 		while (p->type > 0) {
 			if ((MBSTRG(func_overload) & p->type) == p->type && 
-				zend_hash_find(EG(function_table), p->save_func,
-					strlen(p->save_func)+1, (void **)&orig) != SUCCESS) {
+				(orig = zend_hash_str_find_ptr(EG(function_table), p->save_func,
+					strlen(p->save_func))) == NULL) {
 
-				zend_hash_find(EG(function_table), p->ovld_func, strlen(p->ovld_func)+1 , (void **)&func);
+				func = zend_hash_str_find_ptr(EG(function_table), p->ovld_func, strlen(p->ovld_func));
 				
-				if (zend_hash_find(EG(function_table), p->orig_func, strlen(p->orig_func)+1, (void **)&orig) != SUCCESS) {
+				if ((orig = zend_hash_str_find_ptr(EG(function_table), p->orig_func, strlen(p->orig_func))) == NULL) {
 					php_error_docref("ref.mbstring" TSRMLS_CC, E_WARNING, "mbstring couldn't find function %s.", p->orig_func);
 					return FAILURE;
 				} else {
-					zend_hash_add(EG(function_table), p->save_func, strlen(p->save_func)+1, orig, sizeof(zend_function), NULL);
+					ZEND_ASSERT(orig->type == ZEND_INTERNAL_FUNCTION);
+					zend_hash_str_add_mem(EG(function_table), p->save_func, strlen(p->save_func), orig, sizeof(zend_internal_function));
 
-					if (zend_hash_update(EG(function_table), p->orig_func, strlen(p->orig_func)+1, func, sizeof(zend_function), 
-						NULL) == FAILURE) {
+					if (zend_hash_str_update_mem(EG(function_table), p->orig_func, strlen(p->orig_func), func, sizeof(zend_internal_function)) == NULL) {
 						php_error_docref("ref.mbstring" TSRMLS_CC, E_WARNING, "mbstring couldn't replace function %s.", p->orig_func);
 						return FAILURE;
 					}
@@ -1686,11 +1685,10 @@ PHP_RSHUTDOWN_FUNCTION(mbstring)
 		p = &(mb_ovld[0]);
 		while (p->type > 0) {
 			if ((MBSTRG(func_overload) & p->type) == p->type && 
-				zend_hash_find(EG(function_table), p->save_func,
-							   strlen(p->save_func)+1, (void **)&orig) == SUCCESS) {
+				(orig = zend_hash_str_find_ptr(EG(function_table), p->save_func, strlen(p->save_func)))) {
 				
-				zend_hash_update(EG(function_table), p->orig_func, strlen(p->orig_func)+1, orig, sizeof(zend_function), NULL);
-				zend_hash_del(EG(function_table), p->save_func, strlen(p->save_func)+1);
+				zend_hash_str_update_mem(EG(function_table), p->orig_func, strlen(p->orig_func), orig, sizeof(zend_internal_function));
+				zend_hash_str_del(EG(function_table), p->save_func, strlen(p->save_func));
 			}
 			p++;
 		}
@@ -1741,16 +1739,16 @@ PHP_FUNCTION(mb_language)
 		return;
 	}
 	if (name == NULL) {
-		RETVAL_STRING((char *)mbfl_no_language2name(MBSTRG(language)), 1);
+		RETVAL_STRING((char *)mbfl_no_language2name(MBSTRG(language)));
 	} else {
-		if (FAILURE == zend_alter_ini_entry(
-				"mbstring.language", sizeof("mbstring.language"),
-				name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME)) {
+		zend_string *ini_name = STR_INIT("mbstring.language", sizeof("mbstring.language") - 1, 0);
+		if (FAILURE == zend_alter_ini_entry(ini_name, name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown language \"%s\"", name);
 			RETVAL_FALSE;
 		} else {
 			RETVAL_TRUE;
 		}
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -1764,12 +1762,12 @@ PHP_FUNCTION(mb_internal_encoding)
 	const mbfl_encoding *encoding;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &name, &name_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 	if (name == NULL) {
 		name = MBSTRG(current_internal_encoding) ? MBSTRG(current_internal_encoding)->name: NULL;
 		if (name != NULL) {
-			RETURN_STRING(name, 1);
+			RETURN_STRING(name);
 		} else {
 			RETURN_FALSE;
 		}
@@ -1798,7 +1796,7 @@ PHP_FUNCTION(mb_http_input)
 
 	retname = 1;
  	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &typ, &typ_len) == FAILURE) {
- 		RETURN_FALSE;
+		return;
  	}
  	if (typ == NULL) {
  		result = MBSTRG(http_input_identify);
@@ -1828,7 +1826,7 @@ PHP_FUNCTION(mb_http_input)
 				size_t i;
 				array_init(return_value);
 				for (i = 0; i < n; i++) {
-					add_next_index_string(return_value, (*entry)->name, 1);
+					add_next_index_string(return_value, (*entry)->name);
 					entry++;
 				}
 				retname = 0;
@@ -1858,7 +1856,8 @@ PHP_FUNCTION(mb_http_input)
 			if (!list) {
 				RETURN_FALSE;
 			}
-			RETVAL_STRING(list, 0);
+			RETVAL_STRING(list);
+			efree(list);
 			retname = 0;
 			break;
 		default:
@@ -1869,7 +1868,7 @@ PHP_FUNCTION(mb_http_input)
 
 	if (retname) {
 		if (result) {
-			RETVAL_STRING(result->name, 1);
+			RETVAL_STRING(result->name);
 		} else {
 			RETVAL_FALSE;
 		}
@@ -1885,14 +1884,14 @@ PHP_FUNCTION(mb_http_output)
 	int name_len;
 	const mbfl_encoding *encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", (char **)&name, &name_len) == FAILURE) {
-		RETURN_FALSE;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &name, &name_len) == FAILURE) {
+		return;
 	}
 
 	if (name == NULL) {
 		name = MBSTRG(current_http_output_encoding) ? MBSTRG(current_http_output_encoding)->name: NULL;
 		if (name != NULL) {
-			RETURN_STRING(name, 1);
+			RETURN_STRING(name);
 		} else {
 			RETURN_FALSE;
 		}
@@ -1913,9 +1912,9 @@ PHP_FUNCTION(mb_http_output)
    Sets the current detect_order or Return the current detect_order as a array */
 PHP_FUNCTION(mb_detect_order)
 {
-	zval **arg1 = NULL;
+	zval *arg1 = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Z", &arg1) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg1) == FAILURE) {
 		return;
 	}
 
@@ -1925,30 +1924,30 @@ PHP_FUNCTION(mb_detect_order)
 		const mbfl_encoding **entry = MBSTRG(current_detect_order_list);
 		array_init(return_value);
 		for (i = 0; i < n; i++) {
-			add_next_index_string(return_value, (*entry)->name, 1);
+			add_next_index_string(return_value, (*entry)->name);
 			entry++;
 		}
 	} else {
 		const mbfl_encoding **list = NULL;
 		size_t size = 0;
-		switch (Z_TYPE_PP(arg1)) {
-		case IS_ARRAY:
-			if (FAILURE == php_mb_parse_encoding_array(*arg1, &list, &size, 0 TSRMLS_CC)) {
-				if (list) {
-					efree(list);
+		switch (Z_TYPE_P(arg1)) {
+			case IS_ARRAY:
+				if (FAILURE == php_mb_parse_encoding_array(arg1, &list, &size, 0 TSRMLS_CC)) {
+					if (list) {
+						efree(list);
+					}
+					RETURN_FALSE;
 				}
-				RETURN_FALSE;
-			}
-			break;
-		default:
-			convert_to_string_ex(arg1);
-			if (FAILURE == php_mb_parse_encoding_list(Z_STRVAL_PP(arg1), Z_STRLEN_PP(arg1), &list, &size, 0 TSRMLS_CC)) {
-				if (list) {
-					efree(list);
+				break;
+			default:
+				convert_to_string_ex(arg1);
+				if (FAILURE == php_mb_parse_encoding_list(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), &list, &size, 0 TSRMLS_CC)) {
+					if (list) {
+						efree(list);
+					}
+					RETURN_FALSE;
 				}
-				RETURN_FALSE;
-			}
-			break;
+				break;
 		}
 
 		if (list == NULL) {
@@ -1969,55 +1968,55 @@ PHP_FUNCTION(mb_detect_order)
    Sets the current substitute_character or returns the current substitute_character */
 PHP_FUNCTION(mb_substitute_character)
 {
-	zval **arg1 = NULL;
+	zval *arg1 = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|Z", &arg1) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg1) == FAILURE) {
 		return;
 	}
 
 	if (!arg1) {
 		if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
-			RETURN_STRING("none", 1);
+			RETURN_STRING("none");
 		} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG) {
-			RETURN_STRING("long", 1);
+			RETURN_STRING("long");
 		} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY) {
-			RETURN_STRING("entity", 1);
+			RETURN_STRING("entity");
 		} else {
 			RETURN_LONG(MBSTRG(current_filter_illegal_substchar));
 		}
 	} else {
 		RETVAL_TRUE;
 
-		switch (Z_TYPE_PP(arg1)) {
-		case IS_STRING:
-			if (strncasecmp("none", Z_STRVAL_PP(arg1), Z_STRLEN_PP(arg1)) == 0) {
-				MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE;
-			} else if (strncasecmp("long", Z_STRVAL_PP(arg1), Z_STRLEN_PP(arg1)) == 0) {
-				MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG;
-			} else if (strncasecmp("entity", Z_STRVAL_PP(arg1), Z_STRLEN_PP(arg1)) == 0) {
-				MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY;
-			} else {
-				convert_to_long_ex(arg1);
+		switch (Z_TYPE_P(arg1)) {
+			case IS_STRING:
+				if (strncasecmp("none", Z_STRVAL_P(arg1), Z_STRLEN_P(arg1)) == 0) {
+					MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE;
+				} else if (strncasecmp("long", Z_STRVAL_P(arg1), Z_STRLEN_P(arg1)) == 0) {
+					MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG;
+				} else if (strncasecmp("entity", Z_STRVAL_P(arg1), Z_STRLEN_P(arg1)) == 0) {
+					MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY;
+				} else {
+					convert_to_long_ex(arg1);
 
-				if (Z_LVAL_PP(arg1) < 0xffff && Z_LVAL_PP(arg1) > 0x0) {
+					if (Z_LVAL_P(arg1) < 0xffff && Z_LVAL_P(arg1) > 0x0) {
+						MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
+						MBSTRG(current_filter_illegal_substchar) = Z_LVAL_P(arg1);
+					} else {
+						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown character.");
+						RETURN_FALSE;
+					}
+				}
+				break;
+			default:
+				convert_to_long_ex(arg1);
+				if (Z_LVAL_P(arg1) < 0xffff && Z_LVAL_P(arg1) > 0x0) {
 					MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
-					MBSTRG(current_filter_illegal_substchar) = Z_LVAL_PP(arg1);
+					MBSTRG(current_filter_illegal_substchar) = Z_LVAL_P(arg1);
 				} else {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown character.");
 					RETURN_FALSE;
 				}
-			}
-			break;
-		default:
-			convert_to_long_ex(arg1);
-			if (Z_LVAL_PP(arg1) < 0xffff && Z_LVAL_PP(arg1) > 0x0) {
-				MBSTRG(current_filter_illegal_mode) = MBFL_OUTPUTFILTER_ILLEGAL_MODE_CHAR;
-				MBSTRG(current_filter_illegal_substchar) = Z_LVAL_PP(arg1);
-			} else {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown character.");
-				RETURN_FALSE;
-			}
-			break;
+				break;
 		}
 	}
 }
@@ -2044,7 +2043,7 @@ PHP_FUNCTION(mb_preferred_mime_name)
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "No MIME preferred name corresponding to \"%s\"", name);
 				RETVAL_FALSE;
 			} else {
-				RETVAL_STRING((char *)preferred_name, 1);
+				RETVAL_STRING((char *)preferred_name);
 			}
 		}
 	}
@@ -2071,6 +2070,7 @@ PHP_FUNCTION(mb_parse_str)
 
 	if (track_vars_array != NULL) {
 		/* Clear out the array */
+		ZVAL_DEREF(track_vars_array);
 		zval_dtor(track_vars_array);
 		array_init(track_vars_array);
 	}
@@ -2093,7 +2093,7 @@ PHP_FUNCTION(mb_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));
 		detected = _php_mb_encoding_handler_ex(&info, &tmp, encstr TSRMLS_CC);		
 	}
 
@@ -2135,7 +2135,7 @@ PHP_FUNCTION(mb_output_handler)
  			MBSTRG(outconv) = NULL;
   		}
 		if (encoding == &mbfl_encoding_pass) {
-			RETURN_STRINGL(arg_string, arg_string_len, 1);
+			RETURN_STRINGL(arg_string, arg_string_len);
 		}
 
 		/* analyze mime type */
@@ -2173,7 +2173,7 @@ PHP_FUNCTION(mb_output_handler)
 
  	/* just return if the converter is not activated. */
  	if (MBSTRG(outconv) == NULL) {
-		RETURN_STRINGL(arg_string, arg_string_len, 1);
+		RETURN_STRINGL(arg_string, arg_string_len);
 	}
 
  	/* flag */
@@ -2196,7 +2196,9 @@ PHP_FUNCTION(mb_output_handler)
 	} 
  	/* get the converter output, and return it */
  	mbfl_buffer_converter_result(MBSTRG(outconv), &result);
- 	RETVAL_STRINGL((char *)result.val, result.len, 0);		/* the string is already strdup()'ed */
+	// TODO: avoid reallocation ???
+ 	RETVAL_STRINGL((char *)result.val, result.len);		/* the string is already strdup()'ed */
+	efree(result.val);
  
  	/* delete the converter if it is the last feed. */
  	if (last_feed) {
@@ -2219,7 +2221,7 @@ PHP_FUNCTION(mb_strlen)
 	mbfl_string_init(&string);
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", (char **)&string.val, &string.len, &enc_name, &enc_name_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	string.no_language = MBSTRG(language);
@@ -2261,7 +2263,7 @@ PHP_FUNCTION(mb_strpos)
 	offset = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &offset, &enc_name, &enc_name_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	if (enc_name != NULL) {
@@ -2314,7 +2316,7 @@ PHP_FUNCTION(mb_strrpos)
 	mbfl_string haystack, needle;
 	char *enc_name = NULL;
 	int enc_name_len;
-	zval **zoffset = NULL;
+	zval *zoffset = NULL;
 	long offset = 0, str_flg;
 	char *enc_name2 = NULL;
 	int enc_name_len2;
@@ -2326,48 +2328,48 @@ PHP_FUNCTION(mb_strrpos)
 	needle.no_language = MBSTRG(language);
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|Zs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &zoffset, &enc_name, &enc_name_len) == FAILURE) {
-		RETURN_FALSE;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|zs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &zoffset, &enc_name, &enc_name_len) == FAILURE) {
+		return;
 	}
 
 	if (zoffset) {
-		if (Z_TYPE_PP(zoffset) == IS_STRING) {
-			enc_name2     = Z_STRVAL_PP(zoffset);
-			enc_name_len2 = Z_STRLEN_PP(zoffset);
+		if (Z_TYPE_P(zoffset) == IS_STRING) {
+			enc_name2     = Z_STRVAL_P(zoffset);
+			enc_name_len2 = Z_STRLEN_P(zoffset);
 			str_flg       = 1;
 
 			if (enc_name2 != NULL) {
 				switch (*enc_name2) {
-				case '0':
-				case '1':
-				case '2':
-				case '3':
-				case '4':
-				case '5':
-				case '6':
-				case '7':
-				case '8':
-				case '9':
-				case ' ':
-				case '-':
-				case '.':
-					break;
-				default :
-					str_flg = 0;
-					break;
+					case '0':
+					case '1':
+					case '2':
+					case '3':
+					case '4':
+					case '5':
+					case '6':
+					case '7':
+					case '8':
+					case '9':
+					case ' ':
+					case '-':
+					case '.':
+						break;
+					default :
+						str_flg = 0;
+						break;
 				}
 			}
 
 			if (str_flg) {
 				convert_to_long_ex(zoffset);
-				offset   = Z_LVAL_PP(zoffset);
+				offset   = Z_LVAL_P(zoffset);
 			} else {
 				enc_name     = enc_name2;
 				enc_name_len = enc_name_len2;
 			}
 		} else {
 			convert_to_long_ex(zoffset);
-			offset = Z_LVAL_PP(zoffset);
+			offset = Z_LVAL_P(zoffset);
 		}
 	}
 
@@ -2417,7 +2419,7 @@ PHP_FUNCTION(mb_stripos)
 	offset = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", (char **)&haystack.val, (int *)&haystack.len, (char **)&needle.val, (int *)&needle.len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 	if (needle.len == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter");
@@ -2446,7 +2448,7 @@ PHP_FUNCTION(mb_strripos)
 	offset = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ls", (char **)&haystack.val, (int *)&haystack.len, (char **)&needle.val, (int *)&needle.len, &offset, &from_encoding, &from_encoding_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	n = php_mb_stripos(1, (char *)haystack.val, haystack.len, (char *)needle.val, needle.len, offset, from_encoding TSRMLS_CC);
@@ -2477,7 +2479,7 @@ PHP_FUNCTION(mb_strstr)
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|bs", (char **)&haystack.val, (int *)&haystack.len, (char **)&needle.val, (int *)&needle.len, &part, &enc_name, &enc_name_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	if (enc_name != NULL) {
@@ -2498,7 +2500,9 @@ PHP_FUNCTION(mb_strstr)
 		if (part) {
 			ret = mbfl_substr(&haystack, &result, 0, n);
 			if (ret != NULL) {
-				RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+				// TODO: avoid reallocation ???
+				RETVAL_STRINGL((char *)ret->val, ret->len);
+				efree(ret->val);
 			} else {
 				RETVAL_FALSE;
 			}
@@ -2506,7 +2510,9 @@ PHP_FUNCTION(mb_strstr)
 			len = (mblen - n);
 			ret = mbfl_substr(&haystack, &result, n, len);
 			if (ret != NULL) {
-				RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+				// TODO: avoid reallocation ???
+				RETVAL_STRINGL((char *)ret->val, ret->len);
+				efree(ret->val);
 			} else {
 				RETVAL_FALSE;
 			}
@@ -2535,7 +2541,7 @@ PHP_FUNCTION(mb_strrchr)
 	needle.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &enc_name, &enc_name_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	if (enc_name != NULL) {
@@ -2558,7 +2564,9 @@ PHP_FUNCTION(mb_strrchr)
 		if (part) {
 			ret = mbfl_substr(&haystack, &result, 0, n);
 			if (ret != NULL) {
-				RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+				// TODO: avoid reallocation ???
+				RETVAL_STRINGL((char *)ret->val, ret->len);
+				efree(ret->val);
 			} else {
 				RETVAL_FALSE;
 			}
@@ -2566,7 +2574,9 @@ PHP_FUNCTION(mb_strrchr)
 			len = (mblen - n);
 			ret = mbfl_substr(&haystack, &result, n, len);
 			if (ret != NULL) {
-				RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+				// TODO: avoid reallocation ???
+				RETVAL_STRINGL((char *)ret->val, ret->len);
+				efree(ret->val);
 			} else {
 				RETVAL_FALSE;
 			}
@@ -2595,7 +2605,7 @@ PHP_FUNCTION(mb_stristr)
 
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	if (!needle.len) {
@@ -2620,7 +2630,9 @@ PHP_FUNCTION(mb_stristr)
 	if (part) {
 		ret = mbfl_substr(&haystack, &result, 0, n);
 		if (ret != NULL) {
-			RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+			// TODO: avoid reallocation ???
+			RETVAL_STRINGL((char *)ret->val, ret->len);
+			efree(ret->val);
 		} else {
 			RETVAL_FALSE;
 		}
@@ -2628,7 +2640,9 @@ PHP_FUNCTION(mb_stristr)
 		len = (mblen - n);
 		ret = mbfl_substr(&haystack, &result, n, len);
 		if (ret != NULL) {
-			RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+			// TODO: avoid reallocaton ???
+			RETVAL_STRINGL((char *)ret->val, ret->len);
+			efree(ret->val);
 		} else {
 			RETVAL_FALSE;
 		}
@@ -2653,7 +2667,7 @@ PHP_FUNCTION(mb_strrichr)
 
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|bs", (char **)&haystack.val, &haystack.len, (char **)&needle.val, &needle.len, &part, &from_encoding, &from_encoding_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	haystack.no_encoding = needle.no_encoding = mbfl_name2no_encoding(from_encoding);
@@ -2673,7 +2687,9 @@ PHP_FUNCTION(mb_strrichr)
 	if (part) {
 		ret = mbfl_substr(&haystack, &result, 0, n);
 		if (ret != NULL) {
-			RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+			// TODO: avoid reallocation ???
+			RETVAL_STRINGL((char *)ret->val, ret->len);
+			efree(ret->val);
 		} else {
 			RETVAL_FALSE;
 		}
@@ -2681,7 +2697,9 @@ PHP_FUNCTION(mb_strrichr)
 		len = (mblen - n);
 		ret = mbfl_substr(&haystack, &result, n, len);
 		if (ret != NULL) {
-			RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+			// TODO: avoid reallocation ???
+			RETVAL_STRINGL((char *)ret->val, ret->len);
+			efree(ret->val);
 		} else {
 			RETVAL_FALSE;
 		}
@@ -2739,10 +2757,10 @@ PHP_FUNCTION(mb_substr)
 	char *str, *encoding;
 	long from, len;
 	int mblen, str_len, encoding_len;
-	zval **z_len = NULL;
+	zval *z_len = NULL;
 	mbfl_string string, result, *ret;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|Zs", &str, &str_len, &from, &z_len, &encoding, &encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|zs", &str, &str_len, &from, &z_len, &encoding, &encoding_len) == FAILURE) {
 		return;
 	}
 
@@ -2761,11 +2779,11 @@ PHP_FUNCTION(mb_substr)
 	string.val = (unsigned char *)str;
 	string.len = str_len;
 
-	if (argc < 3 || Z_TYPE_PP(z_len) == IS_NULL) {
+	if (argc < 3 || Z_TYPE_P(z_len) == IS_NULL) {
 		len = str_len;
 	} else {
 		convert_to_long_ex(z_len);
-		len = Z_LVAL_PP(z_len);
+		len = Z_LVAL_P(z_len);
 	}
 
 	/* measures length */
@@ -2804,7 +2822,9 @@ PHP_FUNCTION(mb_substr)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL((char *)ret->val, ret->len, 0); /* the string is already strdup()'ed */
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */
+	efree(ret->val);
 }
 /* }}} */
 
@@ -2816,14 +2836,14 @@ PHP_FUNCTION(mb_strcut)
 	char *encoding;
 	long from, len;
 	int encoding_len;
-	zval **z_len = NULL;
+	zval *z_len = NULL;
 	mbfl_string string, result, *ret;
 
 	mbfl_string_init(&string);
 	string.no_language = MBSTRG(language);
 	string.no_encoding = MBSTRG(current_internal_encoding)->no_encoding;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|Zs", (char **)&string.val, (int **)&string.len, &from, &z_len, &encoding, &encoding_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|zs", (char **)&string.val, (int **)&string.len, &from, &z_len, &encoding, &encoding_len) == FAILURE) {
 		return;
 	}
 
@@ -2835,11 +2855,11 @@ PHP_FUNCTION(mb_strcut)
 		}
 	}
 
-	if (argc < 3 || Z_TYPE_PP(z_len) == IS_NULL) {
+	if (argc < 3 || Z_TYPE_P(z_len) == IS_NULL) {
 		len = string.len;
 	} else {
 		convert_to_long_ex(z_len);
-		len = Z_LVAL_PP(z_len);
+		len = Z_LVAL_P(z_len);
 	}
 
 	/* if "from" position is negative, count start position from the end
@@ -2871,7 +2891,9 @@ PHP_FUNCTION(mb_strcut)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL((char *)ret->val, ret->len, 0); /* the string is already strdup()'ed */
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */
+	efree(ret->val);
 }
 /* }}} */
 
@@ -2963,8 +2985,9 @@ PHP_FUNCTION(mb_strimwidth)
 	if (ret == NULL) {
 		RETURN_FALSE;
 	}
-
-	RETVAL_STRINGL((char *)ret->val, ret->len, 0); /* the string is already strdup()'ed */
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL((char *)ret->val, ret->len); /* the string is already strdup()'ed */
+	efree(ret->val);
 }
 /* }}} */
 
@@ -3066,7 +3089,7 @@ PHP_FUNCTION(mb_convert_encoding)
 	size_t size, l, n;
 	char *_from_encodings = NULL, *ret, *s_free = NULL;
 
-	zval **hash_entry;
+	zval *hash_entry;
 	HashTable *target_hash;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z", &arg_str, &str_len, &arg_new, &new_len, &arg_old) == FAILURE) {
@@ -3075,50 +3098,52 @@ PHP_FUNCTION(mb_convert_encoding)
 
 	if (ZEND_NUM_ARGS() == 3) {
 		switch (Z_TYPE_P(arg_old)) {
-		case IS_ARRAY:
-			target_hash = Z_ARRVAL_P(arg_old);
-			zend_hash_internal_pointer_reset(target_hash);
-			i = zend_hash_num_elements(target_hash);
-			_from_encodings = NULL;
+			case IS_ARRAY:
+				target_hash = Z_ARRVAL_P(arg_old);
+				zend_hash_internal_pointer_reset(target_hash);
+				i = zend_hash_num_elements(target_hash);
+				_from_encodings = NULL;
 
-			while (i > 0) {
-				if (zend_hash_get_current_data(target_hash, (void **) &hash_entry) == FAILURE) {
-					break;
-				}
+				while (i > 0) {
+					if ((hash_entry = zend_hash_get_current_data(target_hash)) == NULL) {
+						break;
+					}
 
-				convert_to_string_ex(hash_entry);
+					convert_to_string_ex(hash_entry);
 
-				if ( _from_encodings) {
-					l = strlen(_from_encodings);
-					n = strlen(Z_STRVAL_PP(hash_entry));
-					_from_encodings = erealloc(_from_encodings, l+n+2);
-					strcpy(_from_encodings+l, ",");
-					strcpy(_from_encodings+l+1, Z_STRVAL_PP(hash_entry));
-				} else {
-					_from_encodings = estrdup(Z_STRVAL_PP(hash_entry));
-				}
+					if ( _from_encodings) {
+						l = strlen(_from_encodings);
+						n = strlen(Z_STRVAL_P(hash_entry));
+						_from_encodings = erealloc(_from_encodings, l+n+2);
+						memcpy(_from_encodings + l, ",", 1);
+						memcpy(_from_encodings + l + 1, Z_STRVAL_P(hash_entry), Z_STRLEN_P(hash_entry) + 1);
+					} else {
+						_from_encodings = estrdup(Z_STRVAL_P(hash_entry));
+					}
 
-				zend_hash_move_forward(target_hash);
-				i--;
-			}
+					zend_hash_move_forward(target_hash);
+					i--;
+				}
 
-			if (_from_encodings != NULL && !strlen(_from_encodings)) {
-				efree(_from_encodings);
-				_from_encodings = NULL;
+				if (_from_encodings != NULL && !strlen(_from_encodings)) {
+					efree(_from_encodings);
+					_from_encodings = NULL;
+				}
+				s_free = _from_encodings;
+				break;
+			default:
+				convert_to_string(arg_old);
+				_from_encodings = Z_STRVAL_P(arg_old);
+				break;
 			}
-			s_free = _from_encodings;
-			break;
-		default:
-			convert_to_string(arg_old);
-			_from_encodings = Z_STRVAL_P(arg_old);
-			break;
-		}
 	}
 
 	/* new encoding */
 	ret = php_mb_convert_encoding(arg_str, str_len, arg_new, _from_encodings, &size TSRMLS_CC);
 	if (ret != NULL) {
-		RETVAL_STRINGL(ret, size, 0);		/* the string is already strdup()'ed */
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL(ret, size);		/* the string is already strdup()'ed */
+		efree(ret);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -3142,13 +3167,16 @@ PHP_FUNCTION(mb_convert_case)
 
 	RETVAL_FALSE;
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|s!", &str, &str_len,
-				&case_mode, &from_encoding, &from_encoding_len) == FAILURE)
-		RETURN_FALSE;
+				&case_mode, &from_encoding, &from_encoding_len) == FAILURE) {
+		return;
+	}
 
 	newstr = php_unicode_convert_case(case_mode, str, (size_t) str_len, &ret_len, from_encoding TSRMLS_CC);
 
 	if (newstr) {
-		RETVAL_STRINGL(newstr, ret_len, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL(newstr, ret_len);
+		efree(newstr);
 	}	
 }
 /* }}} */
@@ -3171,7 +3199,10 @@ PHP_FUNCTION(mb_strtoupper)
 	newstr = php_unicode_convert_case(PHP_UNICODE_CASE_UPPER, str, (size_t) str_len, &ret_len, from_encoding TSRMLS_CC);
 
 	if (newstr) {
-		RETURN_STRINGL(newstr, ret_len, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL(newstr, ret_len);
+		efree(newstr);
+		return;
 	}
 	RETURN_FALSE;
 }
@@ -3195,7 +3226,10 @@ PHP_FUNCTION(mb_strtolower)
 	newstr = php_unicode_convert_case(PHP_UNICODE_CASE_LOWER, str, (size_t) str_len, &ret_len, from_encoding TSRMLS_CC);
 
 	if (newstr) {
-		RETURN_STRINGL(newstr, ret_len, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL(newstr, ret_len);
+		efree(newstr);
+		return;
 	}
 	RETURN_FALSE;
 }
@@ -3274,7 +3308,7 @@ PHP_FUNCTION(mb_detect_encoding)
 		RETURN_FALSE;
 	}
 
-	RETVAL_STRING((char *)ret->name, 1);
+	RETVAL_STRING((char *)ret->name);
 }
 /* }}} */
 
@@ -3290,7 +3324,7 @@ PHP_FUNCTION(mb_list_encodings)
 	i = 0;
 	encodings = mbfl_get_supported_encodings();
 	while ((encoding = encodings[i++]) != NULL) {
-		add_next_index_string(return_value, (char *) encoding->name, 1);
+		add_next_index_string(return_value, (char *) encoding->name);
 	}
 }
 /* }}} */
@@ -3304,7 +3338,7 @@ PHP_FUNCTION(mb_encoding_aliases)
 	int name_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	encoding = mbfl_name2encoding(name);
@@ -3317,7 +3351,7 @@ PHP_FUNCTION(mb_encoding_aliases)
 	if (encoding->aliases != NULL) {
 		const char **alias;
 		for (alias = *encoding->aliases; *alias; ++alias) {
-			add_next_index_string(return_value, (char *)*alias, 1);
+			add_next_index_string(return_value, (char *)*alias);
 		}
 	}
 }
@@ -3373,7 +3407,9 @@ PHP_FUNCTION(mb_encode_mimeheader)
 	mbfl_string_init(&result);
 	ret = mbfl_mime_header_encode(&string, &result, charset, transenc, linefeed, indent);
 	if (ret != NULL) {
-		RETVAL_STRINGL((char *)ret->val, ret->len, 0);	/* the string is already strdup()'ed */
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL((char *)ret->val, ret->len);	/* the string is already strdup()'ed */
+		efree(ret->val);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -3397,7 +3433,9 @@ PHP_FUNCTION(mb_decode_mimeheader)
 	mbfl_string_init(&result);
 	ret = mbfl_mime_header_decode(&string, &result, MBSTRG(current_internal_encoding)->no_encoding);
 	if (ret != NULL) {
-		RETVAL_STRINGL((char *)ret->val, ret->len, 0);	/* the string is already strdup()'ed */
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL((char *)ret->val, ret->len);	/* the string is already strdup()'ed */
+		efree(ret->val);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -3500,7 +3538,9 @@ PHP_FUNCTION(mb_convert_kana)
 
 	ret = mbfl_ja_jp_hantozen(&string, &result, opt);
 	if (ret != NULL) {
-		RETVAL_STRINGL((char *)ret->val, ret->len, 0);		/* the string is already strdup()'ed */
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL((char *)ret->val, ret->len);		/* the string is already strdup()'ed */
+		efree(ret->val);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -3513,7 +3553,7 @@ PHP_FUNCTION(mb_convert_kana)
    Converts the string resource in variables to desired encoding */
 PHP_FUNCTION(mb_convert_variables)
 {
-	zval ***args, ***stack, **var, **hash_entry, **zfrom_enc;
+	zval *args, *stack, *var, *hash_entry, *hash_entry_ptr, *zfrom_enc;
 	HashTable *target_hash;
 	mbfl_string string, result, *ret;
 	const mbfl_encoding *from_encoding, *to_encoding;
@@ -3525,7 +3565,7 @@ PHP_FUNCTION(mb_convert_variables)
 	char *to_enc;
 	void *ptmp;	
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ+", &to_enc, &to_enc_len, &zfrom_enc, &args, &argc) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz+", &to_enc, &to_enc_len, &zfrom_enc, &args, &argc) == FAILURE) {
 		return;
 	}
 
@@ -3533,7 +3573,6 @@ PHP_FUNCTION(mb_convert_variables)
 	to_encoding = mbfl_name2encoding(to_enc);
 	if (!to_encoding) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown encoding \"%s\"", to_enc);
-		efree(args);
 		RETURN_FALSE;
 	}
 
@@ -3547,15 +3586,16 @@ PHP_FUNCTION(mb_convert_variables)
 	/* pre-conversion encoding */
 	elist = NULL;
 	elistsz = 0;
-	switch (Z_TYPE_PP(zfrom_enc)) {
-	case IS_ARRAY:
-		php_mb_parse_encoding_array(*zfrom_enc, &elist, &elistsz, 0 TSRMLS_CC);
-		break;
-	default:
-		convert_to_string_ex(zfrom_enc);
-		php_mb_parse_encoding_list(Z_STRVAL_PP(zfrom_enc), Z_STRLEN_PP(zfrom_enc), &elist, &elistsz, 0 TSRMLS_CC);
-		break;
+	switch (Z_TYPE_P(zfrom_enc)) {
+		case IS_ARRAY:
+			php_mb_parse_encoding_array(zfrom_enc, &elist, &elistsz, 0 TSRMLS_CC);
+			break;
+		default:
+			convert_to_string_ex(zfrom_enc);
+			php_mb_parse_encoding_list(Z_STRVAL_P(zfrom_enc), Z_STRLEN_P(zfrom_enc), &elist, &elistsz, 0 TSRMLS_CC);
+			break;
 	}
+
 	if (elistsz <= 0) {
 		from_encoding = &mbfl_encoding_pass;
 	} else if (elistsz == 1) {
@@ -3564,55 +3604,60 @@ PHP_FUNCTION(mb_convert_variables)
 		/* auto detect */
 		from_encoding = NULL;
 		stack_max = PHP_MBSTR_STACK_BLOCK_SIZE;
-		stack = (zval ***)safe_emalloc(stack_max, sizeof(zval **), 0);
+		stack = (zval *)safe_emalloc(stack_max, sizeof(zval), 0);
 		stack_level = 0;
 		identd = mbfl_encoding_detector_new2(elist, elistsz, MBSTRG(strict_detection));
 		if (identd != NULL) {
 			n = 0;
 			while (n < argc || stack_level > 0) {
 				if (stack_level <= 0) {
-					var = args[n++];
-					if (Z_TYPE_PP(var) == IS_ARRAY || Z_TYPE_PP(var) == IS_OBJECT) {
-						target_hash = HASH_OF(*var);
+					var = &args[n++];
+					ZVAL_DEREF(var);
+					if (Z_TYPE_P(var) == IS_ARRAY || Z_TYPE_P(var) == IS_OBJECT) {
+						target_hash = HASH_OF(var);
 						if (target_hash != NULL) {
 							zend_hash_internal_pointer_reset(target_hash);
 						}
 					}
 				} else {
 					stack_level--;
-					var = stack[stack_level];
+					var = &stack[stack_level];
 				}
-				if (Z_TYPE_PP(var) == IS_ARRAY || Z_TYPE_PP(var) == IS_OBJECT) {
-					target_hash = HASH_OF(*var);
+				if (Z_TYPE_P(var) == IS_ARRAY || Z_TYPE_P(var) == IS_OBJECT) {
+					target_hash = HASH_OF(var);
 					if (target_hash != NULL) {
-						while (zend_hash_get_current_data(target_hash, (void **) &hash_entry) != FAILURE) {
+						while ((hash_entry = zend_hash_get_current_data(target_hash)) != NULL) {
 							zend_hash_move_forward(target_hash);
-							if (Z_TYPE_PP(hash_entry) == IS_ARRAY || Z_TYPE_PP(hash_entry) == IS_OBJECT) {
+							if (Z_TYPE_P(hash_entry) == IS_INDIRECT) {
+								hash_entry = Z_INDIRECT_P(hash_entry);
+							}
+							ZVAL_DEREF(hash_entry);
+							if (Z_TYPE_P(hash_entry) == IS_ARRAY || Z_TYPE_P(hash_entry) == IS_OBJECT) {
 								if (stack_level >= stack_max) {
 									stack_max += PHP_MBSTR_STACK_BLOCK_SIZE;
-									ptmp = erealloc(stack, sizeof(zval **)*stack_max);
-									stack = (zval ***)ptmp;
+									ptmp = erealloc(stack, sizeof(zval) * stack_max);
+									stack = (zval *)ptmp;
 								}
-								stack[stack_level] = var;
+								ZVAL_COPY_VALUE(&stack[stack_level], var);
 								stack_level++;
 								var = hash_entry;
-								target_hash = HASH_OF(*var);
+								target_hash = HASH_OF(var);
 								if (target_hash != NULL) {
 									zend_hash_internal_pointer_reset(target_hash);
 									continue;
 								}
-							} else if (Z_TYPE_PP(hash_entry) == IS_STRING) {
-								string.val = (unsigned char *)Z_STRVAL_PP(hash_entry);
-								string.len = Z_STRLEN_PP(hash_entry);
+							} else if (Z_TYPE_P(hash_entry) == IS_STRING) {
+								string.val = (unsigned char *)Z_STRVAL_P(hash_entry);
+								string.len = Z_STRLEN_P(hash_entry);
 								if (mbfl_encoding_detector_feed(identd, &string)) {
 									goto detect_end;		/* complete detecting */
 								}
 							}
 						}
 					}
-				} else if (Z_TYPE_PP(var) == IS_STRING) {
-					string.val = (unsigned char *)Z_STRVAL_PP(var);
-					string.len = Z_STRLEN_PP(var);
+				} else if (Z_TYPE_P(var) == IS_STRING) {
+					string.val = (unsigned char *)Z_STRVAL_P(var);
+					string.len = Z_STRLEN_P(var);
 					if (mbfl_encoding_detector_feed(identd, &string)) {
 						goto detect_end;		/* complete detecting */
 					}
@@ -3647,65 +3692,70 @@ detect_end:
 	/* convert */
 	if (convd != NULL) {
 		stack_max = PHP_MBSTR_STACK_BLOCK_SIZE;
-		stack = (zval ***)safe_emalloc(stack_max, sizeof(zval **), 0);
+		stack = (zval*)safe_emalloc(stack_max, sizeof(zval), 0);
 		stack_level = 0;
 		n = 0;
 		while (n < argc || stack_level > 0) {
 			if (stack_level <= 0) {
-				var = args[n++];
-				if (Z_TYPE_PP(var) == IS_ARRAY || Z_TYPE_PP(var) == IS_OBJECT) {
-					target_hash = HASH_OF(*var);
+				var = &args[n++];
+				ZVAL_DEREF(var);
+				if (Z_TYPE_P(var) == IS_ARRAY || Z_TYPE_P(var) == IS_OBJECT) {
+					target_hash = HASH_OF(var);
 					if (target_hash != NULL) {
 						zend_hash_internal_pointer_reset(target_hash);
 					}
 				}
 			} else {
 				stack_level--;
-				var = stack[stack_level];
+				var = &stack[stack_level];
 			}
-			if (Z_TYPE_PP(var) == IS_ARRAY || Z_TYPE_PP(var) == IS_OBJECT) {
-				target_hash = HASH_OF(*var);
+			if (Z_TYPE_P(var) == IS_ARRAY || Z_TYPE_P(var) == IS_OBJECT) {
+				target_hash = HASH_OF(var);
 				if (target_hash != NULL) {
-					while (zend_hash_get_current_data(target_hash, (void **) &hash_entry) != FAILURE) {
+					while ((hash_entry_ptr = zend_hash_get_current_data(target_hash)) != NULL) {
 						zend_hash_move_forward(target_hash);
-						if (Z_TYPE_PP(hash_entry) == IS_ARRAY || Z_TYPE_PP(hash_entry) == IS_OBJECT) {
+						if (Z_TYPE_P(hash_entry_ptr) == IS_INDIRECT) {
+							hash_entry_ptr = Z_INDIRECT_P(hash_entry_ptr);
+						}
+						hash_entry = hash_entry_ptr;
+						ZVAL_DEREF(hash_entry);
+						if (Z_TYPE_P(hash_entry) == IS_ARRAY || Z_TYPE_P(hash_entry) == IS_OBJECT) {
 							if (stack_level >= stack_max) {
 								stack_max += PHP_MBSTR_STACK_BLOCK_SIZE;
-								ptmp = erealloc(stack, sizeof(zval **)*stack_max);
-								stack = (zval ***)ptmp;
+								ptmp = erealloc(stack, sizeof(zval) * stack_max);
+								stack = (zval *)ptmp;
 							}
-							stack[stack_level] = var;
+							ZVAL_COPY_VALUE(&stack[stack_level], var);
 							stack_level++;
 							var = hash_entry;
 							SEPARATE_ZVAL(hash_entry);
-							target_hash = HASH_OF(*var);
+							target_hash = HASH_OF(var);
 							if (target_hash != NULL) {
 								zend_hash_internal_pointer_reset(target_hash);
 								continue;
 							}
-						} else if (Z_TYPE_PP(hash_entry) == IS_STRING) {
-							string.val = (unsigned char *)Z_STRVAL_PP(hash_entry);
-							string.len = Z_STRLEN_PP(hash_entry);
+						} else if (Z_TYPE_P(hash_entry) == IS_STRING) {
+							string.val = (unsigned char *)Z_STRVAL_P(hash_entry);
+							string.len = Z_STRLEN_P(hash_entry);
 							ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
 							if (ret != NULL) {
-								if (Z_REFCOUNT_PP(hash_entry) > 1) {
-									Z_DELREF_PP(hash_entry);
-									MAKE_STD_ZVAL(*hash_entry);
-								} else {
-									zval_dtor(*hash_entry);
-								}
-							ZVAL_STRINGL(*hash_entry, (char *)ret->val, ret->len, 0);
+								zval_ptr_dtor(hash_entry_ptr);
+								// TODO: avoid reallocation ???
+								ZVAL_STRINGL(hash_entry_ptr, (char *)ret->val, ret->len);
+								efree(ret->val);
+							}
 						}
 					}
 				}
-			}
-		} else if (Z_TYPE_PP(var) == IS_STRING) {
-			string.val = (unsigned char *)Z_STRVAL_PP(var);
-			string.len = Z_STRLEN_PP(var);
-			ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
-			if (ret != NULL) {
-				zval_dtor(*var);
-				ZVAL_STRINGL(*var, (char *)ret->val, ret->len, 0);
+			} else if (Z_TYPE_P(var) == IS_STRING) {
+				string.val = (unsigned char *)Z_STRVAL_P(var);
+				string.len = Z_STRLEN_P(var);
+				ret = mbfl_buffer_converter_feed_result(convd, &string, &result);
+				if (ret != NULL) {
+					zval_ptr_dtor(var);
+					// TODO: avoid reallocation ???
+					ZVAL_STRINGL(var, (char *)ret->val, ret->len);
+					efree(ret->val);
 				}
 			}
 		}
@@ -3715,10 +3765,8 @@ detect_end:
 		mbfl_buffer_converter_delete(convd);
 	}
 
-	efree(args);
-
 	if (from_encoding) {
-		RETURN_STRING(from_encoding->name, 1);
+		RETURN_STRING(from_encoding->name);
 	} else {
 		RETURN_FALSE;
 	}
@@ -3732,7 +3780,7 @@ php_mb_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type)
 {
 	char *str, *encoding;
 	int str_len, encoding_len;
-	zval *zconvmap, **hash_entry;
+	zval *zconvmap, *hash_entry;
 	HashTable *target_hash;
 	size_t argc = ZEND_NUM_ARGS();
 	int i, *convmap, *mapelm, mapsize=0;
@@ -3778,11 +3826,11 @@ php_mb_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type)
 			mapelm = convmap;
 			mapsize = 0;
 			while (i > 0) {
-				if (zend_hash_get_current_data(target_hash, (void **) &hash_entry) == FAILURE) {
+				if ((hash_entry = zend_hash_get_current_data(target_hash)) == NULL) {
 					break;
 				}
 				convert_to_long_ex(hash_entry);
-				*mapelm++ = Z_LVAL_PP(hash_entry);
+				*mapelm++ = Z_LVAL_P(hash_entry);
 				mapsize++;
 				i--;
 				zend_hash_move_forward(target_hash);
@@ -3796,7 +3844,9 @@ php_mb_numericentity_exec(INTERNAL_FUNCTION_PARAMETERS, int type)
 
 	ret = mbfl_html_numeric_entity(&string, &result, convmap, mapsize, type);
 	if (ret != NULL) {
-		RETVAL_STRINGL((char *)ret->val, ret->len, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL((char *)ret->val, ret->len);
+		efree(ret->val);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -3841,46 +3891,19 @@ PHP_FUNCTION(mb_decode_numericentity)
 		*pp = ' ';				\
 	}						\
 
-#define APPEND_ONE_CHAR(ch) do { \
-	if (token.a > 0) { \
-		smart_str_appendc(&token, ch); \
-	} else {\
-		token.len++; \
-	} \
-} while (0)
-
-#define SEPARATE_SMART_STR(str) do {\
-	if ((str)->a == 0) { \
-		char *tmp_ptr; \
-		(str)->a = 1; \
-		while ((str)->a < (str)->len) { \
-			(str)->a <<= 1; \
-		} \
-		tmp_ptr = emalloc((str)->a + 1); \
-		memcpy(tmp_ptr, (str)->c, (str)->len); \
-		(str)->c = tmp_ptr; \
-	} \
-} while (0)
-
-static void my_smart_str_dtor(smart_str *s)
-{
-	if (s->a > 0) {
-		smart_str_free(s);
-	}
-}
-
 static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t str_len)
 {
 	const char *ps;
 	size_t icnt;
 	int state = 0;
 	int crlf_state = -1;
-
-	smart_str token = { 0, 0, 0 };
-	smart_str fld_name = { 0, 0, 0 }, fld_val = { 0, 0, 0 };
+	char *token;
+	size_t token_pos;
+	zend_string *fld_name, *fld_val;
 
 	ps = str;
 	icnt = str_len;
+	fld_name = fld_val = NULL;
 
 	/*
 	 *             C o n t e n t - T y p e :   t e x t / h t m l \r\n
@@ -3897,15 +3920,15 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 		switch (*ps) {
 			case ':':
 				if (crlf_state == 1) {
-					APPEND_ONE_CHAR('\r');
+					token_pos++;
 				}
 
 				if (state == 0 || state == 1) {
-					fld_name = token;
+					fld_name = STR_INIT(token, token_pos, 0);
 
 					state = 2;
 				} else {
-					APPEND_ONE_CHAR(*ps);
+					token_pos++;
 				}
 
 				crlf_state = 0;
@@ -3920,7 +3943,7 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 
 			case '\r':
 				if (crlf_state == 1) {
-					APPEND_ONE_CHAR('\r');
+					token_pos++;
 				} else {
 					crlf_state = 1;
 				}
@@ -3930,7 +3953,6 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 				if (crlf_state == -1) {
 					if (state == 3) {
 						/* continuing from the previous line */
-						SEPARATE_SMART_STR(&token);
 						state = 4;
 					} else {
 						/* simply skipping this new line */
@@ -3938,10 +3960,10 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 					}
 				} else {
 					if (crlf_state == 1) {
-						APPEND_ONE_CHAR('\r');
+						token_pos++;
 					}
 					if (state == 1 || state == 3) {
-						APPEND_ONE_CHAR(*ps);
+						token_pos++;
 					}
 				}
 				crlf_state = 0;
@@ -3950,17 +3972,15 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 			default:
 				switch (state) {
 					case 0:
-						token.c = (char *)ps;
-						token.len = 0;
-						token.a = 0;
+						token = (char*)ps;
+						token_pos = 0;
 						state = 1;
 						break;
 					
 					case 2:
 						if (crlf_state != -1) {
-							token.c = (char *)ps;
-							token.len = 0;
-							token.a = 0;
+							token = (char*)ps;
+							token_pos = 0;
 
 							state = 3;
 							break;
@@ -3969,43 +3989,39 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 
 					case 3:
 						if (crlf_state == -1) {
-							fld_val = token;
-
-							if (fld_name.c != NULL && fld_val.c != NULL) {
-								char *dummy;
+							fld_val = STR_INIT(token, token_pos, 0);
 
+							if (fld_name != NULL && fld_val != NULL) {
+								zval val;
 								/* FIXME: some locale free implementation is
 								 * really required here,,, */
-								SEPARATE_SMART_STR(&fld_name);
-								php_strtoupper(fld_name.c, fld_name.len);
+								php_strtoupper(fld_name->val, fld_name->len);
+								ZVAL_STR(&val, fld_val);
 
-								zend_hash_update(ht, (char *)fld_name.c, fld_name.len, &fld_val, sizeof(smart_str), (void **)&dummy);
+								zend_hash_update(ht, fld_name, &val);
 
-								my_smart_str_dtor(&fld_name);
+								STR_RELEASE(fld_name);
 							}
 
-							memset(&fld_name, 0, sizeof(smart_str));
-							memset(&fld_val, 0, sizeof(smart_str));
-
-							token.c = (char *)ps;
-							token.len = 0;
-							token.a = 0;
+							fld_name = fld_val = NULL;
+							token = (char*)ps;
+							token_pos = 0;
 
 							state = 1;
 						}
 						break;
 
 					case 4:
-						APPEND_ONE_CHAR(' ');
+						token_pos++;
 						state = 3;
 						break;
 				}
 
 				if (crlf_state == 1) {
-					APPEND_ONE_CHAR('\r');
+					token_pos++;
 				}
 
-				APPEND_ONE_CHAR(*ps);
+				token_pos++;
 
 				crlf_state = 0;
 				break;
@@ -4014,26 +4030,24 @@ static int _php_mbstr_parse_mail_headers(HashTable *ht, const char *str, size_t
 	}
 out:
 	if (state == 2) {
-		token.c = "";
-		token.len = 0;
-		token.a = 0;
+		token = "";
+		token_pos = 0;
 
 		state = 3;
 	}
 	if (state == 3) {
-		fld_val = token;
-
-		if (fld_name.c != NULL && fld_val.c != NULL) {
-			void *dummy;
+		fld_val = STR_INIT(token, 0, 0);
 
+		if (fld_name != NULL && fld_val != NULL) {
+			zval val;
 			/* FIXME: some locale free implementation is
 			 * really required here,,, */
-			SEPARATE_SMART_STR(&fld_name);
-			php_strtoupper(fld_name.c, fld_name.len);
+			php_strtoupper(fld_name->val, fld_name->len);
+			ZVAL_STR(&val, fld_val);
 
-			zend_hash_update(ht, (char *)fld_name.c, fld_name.len, &fld_val, sizeof(smart_str), (void **)&dummy);
+			zend_hash_update(ht, fld_name, &val);
 
-			my_smart_str_dtor(&fld_name);
+			STR_RELEASE(fld_name);
 		}
 	}
 	return state;
@@ -4049,9 +4063,8 @@ PHP_FUNCTION(mb_send_mail)
 	char *headers = NULL;
 	int headers_len;
 	char *subject = NULL;
+	zend_string *extra_cmd = NULL;
 	int subject_len;
-	char *extra_cmd = NULL;
-	int extra_cmd_len;
 	int i;
 	char *to_r = NULL;
 	char *force_extra_parameters = INI_STR("mail.force_extra_parameters");
@@ -4071,7 +4084,7 @@ PHP_FUNCTION(mb_send_mail)
 	const mbfl_language *lang;
 	int err = 0;
 	HashTable ht_headers;
-	smart_str *s;
+	zval *s;
 	extern void mbfl_memory_device_unput(mbfl_memory_device *device);
 	char *pp, *ee;
 
@@ -4091,7 +4104,7 @@ PHP_FUNCTION(mb_send_mail)
 		body_enc = lang->mail_body_encoding;
 	}
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|ss", &to, &to_len, &subject, &subject_len, &message, &message_len, &headers, &headers_len, &extra_cmd, &extra_cmd_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|sS", &to, &to_len, &subject, &subject_len, &message, &message_len, &headers, &headers_len, &extra_cmd) == FAILURE) {
 		return;
 	}
 
@@ -4103,24 +4116,21 @@ PHP_FUNCTION(mb_send_mail)
 		MAIL_ASCIIZ_CHECK_MBSTRING(headers, headers_len);
 	}
 	if (extra_cmd) {
-		MAIL_ASCIIZ_CHECK_MBSTRING(extra_cmd, extra_cmd_len);
+		MAIL_ASCIIZ_CHECK_MBSTRING(extra_cmd->val, extra_cmd->len);
 	}
 
-	zend_hash_init(&ht_headers, 0, NULL, (dtor_func_t) my_smart_str_dtor, 0);
+	zend_hash_init(&ht_headers, 0, NULL, ZVAL_PTR_DTOR, 0);
 
 	if (headers != NULL) {
 		_php_mbstr_parse_mail_headers(&ht_headers, headers, headers_len);
 	}
 
-	if (zend_hash_find(&ht_headers, "CONTENT-TYPE", sizeof("CONTENT-TYPE") - 1, (void **)&s) == SUCCESS) {
+	if ((s = zend_hash_str_find_ptr(&ht_headers, "CONTENT-TYPE", sizeof("CONTENT-TYPE") - 1))) {
 		char *tmp;
 		char *param_name;
 		char *charset = NULL;
 
-		SEPARATE_SMART_STR(s);
-		smart_str_0(s);
-
-		p = strchr(s->c, ';');
+		p = strchr(Z_STRVAL_P(s), ';');
 
 		if (p != NULL) {
 			/* skipping the padded spaces */
@@ -4150,12 +4160,10 @@ PHP_FUNCTION(mb_send_mail)
 		suppressed_hdrs.cnt_type = 1;
 	}
 
-	if (zend_hash_find(&ht_headers, "CONTENT-TRANSFER-ENCODING", sizeof("CONTENT-TRANSFER-ENCODING") - 1, (void **)&s) == SUCCESS) {
+	if ((s = zend_hash_str_find_ptr(&ht_headers, "CONTENT-TRANSFER-ENCODING", sizeof("CONTENT-TRANSFER-ENCODING") - 1))) {
 		enum mbfl_no_encoding _body_enc;
-		SEPARATE_SMART_STR(s);
-		smart_str_0(s);
 
-		_body_enc = mbfl_name2no_encoding(s->c);
+		_body_enc = mbfl_name2no_encoding(Z_STRVAL_P(s));
 		switch (_body_enc) {
 			case mbfl_no_encoding_base64:
 			case mbfl_no_encoding_7bit:
@@ -4164,7 +4172,7 @@ PHP_FUNCTION(mb_send_mail)
 				break;
 
 			default:
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported transfer encoding \"%s\" - will be regarded as 8bit", s->c); 
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unsupported transfer encoding \"%s\" - will be regarded as 8bit", Z_STRVAL_P(s)); 
 				body_enc =	mbfl_no_encoding_8bit;
 				break;
 		}
@@ -4264,7 +4272,7 @@ PHP_FUNCTION(mb_send_mail)
 		}
 	}
 
-	if (!zend_hash_exists(&ht_headers, "MIME-VERSION", sizeof("MIME-VERSION") - 1)) {
+	if (!zend_hash_str_exists(&ht_headers, "MIME-VERSION", sizeof("MIME-VERSION") - 1)) {
 		mbfl_memory_device_strncat(&device, PHP_MBSTR_MAIL_MIME_HEADER1, sizeof(PHP_MBSTR_MAIL_MIME_HEADER1) - 1);
 		mbfl_memory_device_strncat(&device, "\n", 1);
 	}
@@ -4296,18 +4304,19 @@ PHP_FUNCTION(mb_send_mail)
 	if (force_extra_parameters) {
 		extra_cmd = php_escape_shell_cmd(force_extra_parameters);
 	} else if (extra_cmd) {
-		extra_cmd = php_escape_shell_cmd(extra_cmd);
+		extra_cmd = php_escape_shell_cmd(extra_cmd->val);
 	} 
 
-	if (!err && php_mail(to_r, subject, message, headers, extra_cmd TSRMLS_CC)) {
+	if (!err && php_mail(to_r, subject, message, headers, extra_cmd ? extra_cmd->val : NULL TSRMLS_CC)) {
 		RETVAL_TRUE;
 	} else {
 		RETVAL_FALSE;
 	}
 
 	if (extra_cmd) {
-		efree(extra_cmd);
+		STR_RELEASE(extra_cmd);
 	}
+
 	if (to_r != to) {
 		efree(to_r);
 	}
@@ -4323,8 +4332,6 @@ PHP_FUNCTION(mb_send_mail)
 
 #undef SKIP_LONG_HEADER_SEP_MBSTRING
 #undef MAIL_ASCIIZ_CHECK_MBSTRING
-#undef APPEND_ONE_CHAR
-#undef SEPARATE_SMART_STR
 #undef PHP_MBSTR_MAIL_MIME_HEADER1
 #undef PHP_MBSTR_MAIL_MIME_HEADER2
 #undef PHP_MBSTR_MAIL_MIME_HEADER3
@@ -4340,104 +4347,102 @@ PHP_FUNCTION(mb_get_info)
 	size_t n;
 	char *name;
 	const struct mb_overload_def *over_func;
-	zval *row1, *row2;
+	zval row1, row2;
 	const mbfl_language *lang = mbfl_no2language(MBSTRG(language));
 	const mbfl_encoding **entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &typ, &typ_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	if (!typ || !strcasecmp("all", typ)) {
 		array_init(return_value);
 		if (MBSTRG(current_internal_encoding)) {
-			add_assoc_string(return_value, "internal_encoding", (char *)MBSTRG(current_internal_encoding)->name, 1);
+			add_assoc_string(return_value, "internal_encoding", (char *)MBSTRG(current_internal_encoding)->name);
 		}
 		if (MBSTRG(http_input_identify)) {
-			add_assoc_string(return_value, "http_input", (char *)MBSTRG(http_input_identify)->name, 1);
+			add_assoc_string(return_value, "http_input", (char *)MBSTRG(http_input_identify)->name);
 		}
 		if (MBSTRG(current_http_output_encoding)) {
-			add_assoc_string(return_value, "http_output", (char *)MBSTRG(current_http_output_encoding)->name, 1);
+			add_assoc_string(return_value, "http_output", (char *)MBSTRG(current_http_output_encoding)->name);
 		}
-		if ((name = (char *)zend_ini_string("mbstring.http_output_conv_mimetypes", sizeof("mbstring.http_output_conv_mimetypes"), 0)) != NULL) {
-			add_assoc_string(return_value, "http_output_conv_mimetypes", name, 1);
+		if ((name = (char *)zend_ini_string("mbstring.http_output_conv_mimetypes", sizeof("mbstring.http_output_conv_mimetypes") - 1, 0)) != NULL) {
+			add_assoc_string(return_value, "http_output_conv_mimetypes", name);
 		}
 		add_assoc_long(return_value, "func_overload", MBSTRG(func_overload));
 		if (MBSTRG(func_overload)){
 			over_func = &(mb_ovld[0]);
-			MAKE_STD_ZVAL(row1);
-			array_init(row1);
+			array_init(&row1);
 			while (over_func->type > 0) {
 				if ((MBSTRG(func_overload) & over_func->type) == over_func->type ) {
-					add_assoc_string(row1, over_func->orig_func, over_func->ovld_func, 1);
+					add_assoc_string(&row1, over_func->orig_func, over_func->ovld_func);
 				}
 				over_func++;
 			}
-			add_assoc_zval(return_value, "func_overload_list", row1);
+			add_assoc_zval(return_value, "func_overload_list", &row1);
 		} else {
-			add_assoc_string(return_value, "func_overload_list", "no overload", 1);
+			add_assoc_string(return_value, "func_overload_list", "no overload");
  		}
 		if (lang != NULL) {
 			if ((name = (char *)mbfl_no_encoding2name(lang->mail_charset)) != NULL) {
-				add_assoc_string(return_value, "mail_charset", name, 1);
+				add_assoc_string(return_value, "mail_charset", name);
 			}
 			if ((name = (char *)mbfl_no_encoding2name(lang->mail_header_encoding)) != NULL) {
-				add_assoc_string(return_value, "mail_header_encoding", name, 1);
+				add_assoc_string(return_value, "mail_header_encoding", name);
 			}
 			if ((name = (char *)mbfl_no_encoding2name(lang->mail_body_encoding)) != NULL) {
-				add_assoc_string(return_value, "mail_body_encoding", name, 1);
+				add_assoc_string(return_value, "mail_body_encoding", name);
 			}
 		}
 		add_assoc_long(return_value, "illegal_chars", MBSTRG(illegalchars));
 		if (MBSTRG(encoding_translation)) {
-			add_assoc_string(return_value, "encoding_translation", "On", 1);
+			add_assoc_string(return_value, "encoding_translation", "On");
 		} else {
-			add_assoc_string(return_value, "encoding_translation", "Off", 1);
+			add_assoc_string(return_value, "encoding_translation", "Off");
 		}
 		if ((name = (char *)mbfl_no_language2name(MBSTRG(language))) != NULL) {
-			add_assoc_string(return_value, "language", name, 1);
+			add_assoc_string(return_value, "language", name);
 		}		
 		n = MBSTRG(current_detect_order_list_size);
 		entry = MBSTRG(current_detect_order_list);
 		if (n > 0) {
 			size_t i;
-			MAKE_STD_ZVAL(row2);
-			array_init(row2);
+			array_init(&row2);
 			for (i = 0; i < n; i++) {
-				add_next_index_string(row2, (*entry)->name, 1);
+				add_next_index_string(&row2, (*entry)->name);
 				entry++;
 			}
-			add_assoc_zval(return_value, "detect_order", row2);
+			add_assoc_zval(return_value, "detect_order", &row2);
 		}
 		if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
-			add_assoc_string(return_value, "substitute_character", "none", 1);
+			add_assoc_string(return_value, "substitute_character", "none");
 		} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG) {
-			add_assoc_string(return_value, "substitute_character", "long", 1);
+			add_assoc_string(return_value, "substitute_character", "long");
 		} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY) {
-			add_assoc_string(return_value, "substitute_character", "entity", 1);
+			add_assoc_string(return_value, "substitute_character", "entity");
 		} else {
 			add_assoc_long(return_value, "substitute_character", MBSTRG(current_filter_illegal_substchar));
 		}
 		if (MBSTRG(strict_detection)) {
-			add_assoc_string(return_value, "strict_detection", "On", 1);
+			add_assoc_string(return_value, "strict_detection", "On");
 		} else {
-			add_assoc_string(return_value, "strict_detection", "Off", 1);
+			add_assoc_string(return_value, "strict_detection", "Off");
 		}
 	} else if (!strcasecmp("internal_encoding", typ)) {
 		if (MBSTRG(current_internal_encoding)) {
-			RETVAL_STRING((char *)MBSTRG(current_internal_encoding)->name, 1);
+			RETVAL_STRING((char *)MBSTRG(current_internal_encoding)->name);
 		}		
 	} else if (!strcasecmp("http_input", typ)) {
 		if (MBSTRG(http_input_identify)) {
-			RETVAL_STRING((char *)MBSTRG(http_input_identify)->name, 1);
+			RETVAL_STRING((char *)MBSTRG(http_input_identify)->name);
 		}		
 	} else if (!strcasecmp("http_output", typ)) {
 		if (MBSTRG(current_http_output_encoding)) {
-			RETVAL_STRING((char *)MBSTRG(current_http_output_encoding)->name, 1);
+			RETVAL_STRING((char *)MBSTRG(current_http_output_encoding)->name);
 		}		
 	} else if (!strcasecmp("http_output_conv_mimetypes", typ)) {
-		if ((name = (char *)zend_ini_string("mbstring.http_output_conv_mimetypes", sizeof("mbstring.http_output_conv_mimetypes"), 0)) != NULL) {
-			RETVAL_STRING(name, 1);
+		if ((name = (char *)zend_ini_string("mbstring.http_output_conv_mimetypes", sizeof("mbstring.http_output_conv_mimetypes") - 1, 0)) != NULL) {
+			RETVAL_STRING(name);
 		}
 	} else if (!strcasecmp("func_overload", typ)) {
  		RETVAL_LONG(MBSTRG(func_overload));
@@ -4447,36 +4452,36 @@ PHP_FUNCTION(mb_get_info)
 				array_init(return_value);
 				while (over_func->type > 0) {
 					if ((MBSTRG(func_overload) & over_func->type) == over_func->type ) {
-						add_assoc_string(return_value, over_func->orig_func, over_func->ovld_func, 1);
+						add_assoc_string(return_value, over_func->orig_func, over_func->ovld_func);
 					}
 					over_func++;
 				}
 		} else {
-			RETVAL_STRING("no overload", 1);
+			RETVAL_STRING("no overload");
 		}
 	} else if (!strcasecmp("mail_charset", typ)) {
 		if (lang != NULL && (name = (char *)mbfl_no_encoding2name(lang->mail_charset)) != NULL) {
-			RETVAL_STRING(name, 1);
+			RETVAL_STRING(name);
 		}
 	} else if (!strcasecmp("mail_header_encoding", typ)) {
 		if (lang != NULL && (name = (char *)mbfl_no_encoding2name(lang->mail_header_encoding)) != NULL) {
-			RETVAL_STRING(name, 1);
+			RETVAL_STRING(name);
 		}
 	} else if (!strcasecmp("mail_body_encoding", typ)) {
 		if (lang != NULL && (name = (char *)mbfl_no_encoding2name(lang->mail_body_encoding)) != NULL) {
-			RETVAL_STRING(name, 1);
+			RETVAL_STRING(name);
 		}
 	} else if (!strcasecmp("illegal_chars", typ)) {
 		RETVAL_LONG(MBSTRG(illegalchars));
 	} else if (!strcasecmp("encoding_translation", typ)) {
 		if (MBSTRG(encoding_translation)) {
-			RETVAL_STRING("On", 1);
+			RETVAL_STRING("On");
 		} else {
-			RETVAL_STRING("Off", 1);
+			RETVAL_STRING("Off");
 		}
 	} else if (!strcasecmp("language", typ)) {
 		if ((name = (char *)mbfl_no_language2name(MBSTRG(language))) != NULL) {
-			RETVAL_STRING(name, 1);
+			RETVAL_STRING(name);
 		}		
 	} else if (!strcasecmp("detect_order", typ)) {
 		n = MBSTRG(current_detect_order_list_size);
@@ -4485,25 +4490,25 @@ PHP_FUNCTION(mb_get_info)
 			size_t i;
 			array_init(return_value);
 			for (i = 0; i < n; i++) {
-				add_next_index_string(return_value, (*entry)->name, 1);
+				add_next_index_string(return_value, (*entry)->name);
 				entry++;
 			}
 		}
 	} else if (!strcasecmp("substitute_character", typ)) {
 		if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_NONE) {
-			RETVAL_STRING("none", 1);
+			RETVAL_STRING("none");
 		} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_LONG) {
-			RETVAL_STRING("long", 1);
+			RETVAL_STRING("long");
 		} else if (MBSTRG(current_filter_illegal_mode) == MBFL_OUTPUTFILTER_ILLEGAL_MODE_ENTITY) {
-			RETVAL_STRING("entity", 1);
+			RETVAL_STRING("entity");
 		} else {
 			RETVAL_LONG(MBSTRG(current_filter_illegal_substchar));
 		}
 	} else if (!strcasecmp("strict_detection", typ)) {
 		if (MBSTRG(strict_detection)) {
-			RETVAL_STRING("On", 1);
+			RETVAL_STRING("On");
 		} else {
-			RETVAL_STRING("Off", 1);
+			RETVAL_STRING("Off");
 		}
 	} else {
 		RETURN_FALSE;
@@ -4525,7 +4530,7 @@ PHP_FUNCTION(mb_check_encoding)
 	long illegalchars = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|ss", &var, &var_len, &enc, &enc_len) == FAILURE) {
-		RETURN_FALSE;
+		return;
 	}
 
 	if (var == NULL) {
@@ -4568,7 +4573,6 @@ PHP_FUNCTION(mb_check_encoding)
 }
 /* }}} */
 
-
 /* {{{ php_mb_populate_current_detect_order_list */
 static void php_mb_populate_current_detect_order_list(TSRMLS_D)
 {
@@ -4595,6 +4599,7 @@ static void php_mb_populate_current_detect_order_list(TSRMLS_D)
 	MBSTRG(current_detect_order_list) = entry;
 	MBSTRG(current_detect_order_list_size) = nentries;
 }
+/* }}} */
 
 /* {{{ static int php_mb_encoding_translation() */
 static int php_mb_encoding_translation(TSRMLS_D) 
diff --git a/ext/mbstring/php_mbregex.c b/ext/mbstring/php_mbregex.c
index 4b1b924d06..223ecffc2a 100644
--- a/ext/mbstring/php_mbregex.c
+++ b/ext/mbstring/php_mbregex.c
@@ -43,7 +43,7 @@ struct _zend_mb_regex_globals {
 	OnigEncoding default_mbctype;
 	OnigEncoding current_mbctype;
 	HashTable ht_rc;
-	zval *search_str;
+	zval search_str;
 	zval *search_str_val;
 	unsigned int search_pos;
 	php_mb_regex_t *search_re;
@@ -55,9 +55,8 @@ struct _zend_mb_regex_globals {
 #define MBREX(g) (MBSTRG(mb_regex_globals)->g)
 
 /* {{{ static void php_mb_regex_free_cache() */
-static void php_mb_regex_free_cache(php_mb_regex_t **pre) 
-{
-	onig_free(*pre);
+static void php_mb_regex_free_cache(zval *el) {
+	onig_free((php_mb_regex_t *)Z_PTR_P(el));
 }
 /* }}} */
 
@@ -66,8 +65,8 @@ static int _php_mb_regex_globals_ctor(zend_mb_regex_globals *pglobals TSRMLS_DC)
 {
 	pglobals->default_mbctype = ONIG_ENCODING_EUC_JP;
 	pglobals->current_mbctype = ONIG_ENCODING_EUC_JP;
-	zend_hash_init(&(pglobals->ht_rc), 0, NULL, (void (*)(void *)) php_mb_regex_free_cache, 1);
-	pglobals->search_str = (zval*) NULL;
+	zend_hash_init(&(pglobals->ht_rc), 0, NULL, php_mb_regex_free_cache, 1);
+	ZVAL_UNDEF(&pglobals->search_str);
 	pglobals->search_re = (php_mb_regex_t*)NULL;
 	pglobals->search_pos = 0;
 	pglobals->search_regs = (OnigRegion*)NULL;
@@ -139,9 +138,9 @@ PHP_RSHUTDOWN_FUNCTION(mb_regex)
 {
 	MBREX(current_mbctype) = MBREX(default_mbctype);
 
-	if (MBREX(search_str) != NULL) {
+	if (!ZVAL_IS_UNDEF(&MBREX(search_str))) {
 		zval_ptr_dtor(&MBREX(search_str));
-		MBREX(search_str) = (zval *)NULL;
+		ZVAL_UNDEF(&MBREX(search_str));
 	}
 	MBREX(search_pos) = 0;
 
@@ -448,22 +447,21 @@ const char *php_mb_regex_get_default_mbctype(TSRMLS_D)
 static php_mb_regex_t *php_mbregex_compile_pattern(const char *pattern, int patlen, OnigOptionType options, OnigEncoding enc, OnigSyntaxType *syntax TSRMLS_DC)
 {
 	int err_code = 0;
-	int found = 0;
-	php_mb_regex_t *retval = NULL, **rc = NULL;
+	php_mb_regex_t *retval = NULL, *rc = NULL;
 	OnigErrorInfo err_info;
 	OnigUChar err_str[ONIG_MAX_ERROR_MESSAGE_LEN];
 
-	found = zend_hash_find(&MBREX(ht_rc), (char *)pattern, patlen+1, (void **) &rc);
-	if (found == FAILURE || (*rc)->options != options || (*rc)->enc != enc || (*rc)->syntax != syntax) {
+	rc = zend_hash_str_find_ptr(&MBREX(ht_rc), (char *)pattern, patlen);
+	if (!rc || rc->options != options || rc->enc != enc || rc->syntax != syntax) {
 		if ((err_code = onig_new(&retval, (OnigUChar *)pattern, (OnigUChar *)(pattern + patlen), options, enc, syntax, &err_info)) != ONIG_NORMAL) {
 			onig_error_code_to_str(err_str, err_code, err_info);
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "mbregex compile err: %s", err_str);
 			retval = NULL;
 			goto out;
 		}
-		zend_hash_update(&MBREX(ht_rc), (char *) pattern, patlen + 1, (void *) &retval, sizeof(retval), NULL);
-	} else if (found == SUCCESS) {
-		retval = *rc;
+		zend_hash_str_update_ptr(&MBREX(ht_rc), (char *)pattern, patlen, retval);
+	} else if (rc) {
+		retval = rc;
 	}
 out:
 	return retval; 
@@ -671,7 +669,7 @@ PHP_FUNCTION(mb_regex_encoding)
 			RETURN_FALSE;
 		}
 
-		RETURN_STRING((char *)retval, 1);
+		RETURN_STRING((char *)retval);
 	} else if (argc == 1) {
 		mbctype = _php_mb_regex_name2mbctype(encoding);
 
@@ -689,7 +687,7 @@ PHP_FUNCTION(mb_regex_encoding)
 /* {{{ _php_mb_regex_ereg_exec */
 static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
 {
-	zval **arg_pattern, *array;
+	zval *arg_pattern, *array;
 	char *string;
 	int string_len;
 	php_mb_regex_t *re;
@@ -700,7 +698,7 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
 
 	array = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs|z", &arg_pattern, &string, &string_len, &array) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs|z", &arg_pattern, &string, &string_len, &array) == FAILURE) {
 		RETURN_FALSE;
 	}
 
@@ -710,22 +708,22 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
 	}
 
 	/* compile the regular expression from the supplied regex */
-	if (Z_TYPE_PP(arg_pattern) != IS_STRING) {
+	if (Z_TYPE_P(arg_pattern) != IS_STRING) {
 		/* we convert numbers to integers and treat them as a string */
-		if (Z_TYPE_PP(arg_pattern) == IS_DOUBLE) {
+		if (Z_TYPE_P(arg_pattern) == IS_DOUBLE) {
 			convert_to_long_ex(arg_pattern);	/* get rid of decimal places */
 		}
 		convert_to_string_ex(arg_pattern);
 		/* don't bother doing an extended regex with just a number */
 	}
 
-	if (!Z_STRVAL_PP(arg_pattern) || Z_STRLEN_PP(arg_pattern) == 0) {
+	if (!Z_STRVAL_P(arg_pattern) || Z_STRLEN_P(arg_pattern) == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "empty pattern");
 		RETVAL_FALSE;
 		goto out;
 	}
 
-	re = php_mbregex_compile_pattern(Z_STRVAL_PP(arg_pattern), Z_STRLEN_PP(arg_pattern), options, MBREX(current_mbctype), MBREX(regex_default_syntax) TSRMLS_CC);
+	re = php_mbregex_compile_pattern(Z_STRVAL_P(arg_pattern), Z_STRLEN_P(arg_pattern), options, MBREX(current_mbctype), MBREX(regex_default_syntax) TSRMLS_CC);
 	if (re == NULL) {
 		RETVAL_FALSE;
 		goto out;
@@ -742,14 +740,16 @@ static void _php_mb_regex_ereg_exec(INTERNAL_FUNCTION_PARAMETERS, int icase)
 	match_len = 1;
 	str = string;
 	if (array != NULL) {
-		match_len = regs->end[0] - regs->beg[0];
+		ZVAL_DEREF(array);
 		zval_dtor(array);
 		array_init(array);
+
+		match_len = regs->end[0] - regs->beg[0];
 		for (i = 0; i < regs->num_regs; i++) {
 			beg = regs->beg[i];
 			end = regs->end[i];
 			if (beg >= 0 && beg < end && end <= string_len) {
-				add_index_stringl(array, i, (char *)&str[beg], end - beg, 1);
+				add_index_stringl(array, i, (char *)&str[beg], end - beg);
 			} else {
 				add_index_bool(array, i, 0);
 			}
@@ -786,7 +786,7 @@ PHP_FUNCTION(mb_eregi)
 /* {{{ _php_mb_regex_ereg_replace_exec */
 static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOptionType options, int is_callable)
 {
-	zval **arg_pattern_zval;
+	zval *arg_pattern_zval;
 
 	char *arg_pattern;
 	int arg_pattern_len;
@@ -804,8 +804,8 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 	php_mb_regex_t *re;
 	OnigSyntaxType *syntax;
 	OnigRegion *regs = NULL;
-	smart_str out_buf = { 0 };
-	smart_str eval_buf = { 0 };
+	smart_str out_buf = {0};
+	smart_str eval_buf = {0};
 	smart_str *pbuf;
 	int i, err, eval, n;
 	OnigUChar *pos;
@@ -830,7 +830,7 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 		int option_str_len = 0;
 
 		if (!is_callable) {
-			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zss|s",
+			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zss|s",
 						&arg_pattern_zval,
 						&replace, &replace_len,
 						&string, &string_len,
@@ -838,7 +838,7 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 				RETURN_FALSE;
 			}
 		} else {
-			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zfs|s",
+			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zfs|s",
 						&arg_pattern_zval,
 						&arg_replace_fci, &arg_replace_fci_cache,
 						&string, &string_len,
@@ -854,13 +854,13 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 			syntax = MBREX(regex_default_syntax);
 		}
 	}
-	if (Z_TYPE_PP(arg_pattern_zval) == IS_STRING) {
-		arg_pattern = Z_STRVAL_PP(arg_pattern_zval);
-		arg_pattern_len = Z_STRLEN_PP(arg_pattern_zval);
+	if (Z_TYPE_P(arg_pattern_zval) == IS_STRING) {
+		arg_pattern = Z_STRVAL_P(arg_pattern_zval);
+		arg_pattern_len = Z_STRLEN_P(arg_pattern_zval);
 	} else {
 		/* FIXME: this code is not multibyte aware! */
 		convert_to_long_ex(arg_pattern_zval);
-		pat_buf[0] = (char)Z_LVAL_PP(arg_pattern_zval);	
+		pat_buf[0] = (char)Z_LVAL_P(arg_pattern_zval);	
 		pat_buf[1] = '\0';
 
 		arg_pattern = pat_buf;
@@ -940,9 +940,9 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 				/* null terminate buffer */
 				smart_str_0(&eval_buf);
 				/* do eval */
-				if (zend_eval_stringl(eval_buf.c, eval_buf.len, &v, description TSRMLS_CC) == FAILURE) {
+				if (zend_eval_stringl(eval_buf.s->val, eval_buf.s->len, &v, description TSRMLS_CC) == FAILURE) {
 					efree(description);
-					php_error_docref(NULL TSRMLS_CC,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, eval_buf.c);
+					php_error_docref(NULL TSRMLS_CC,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, eval_buf.s->val);
 					/* zend_error() does not return in this case */
 				}
 
@@ -950,33 +950,33 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 				convert_to_string(&v);
 				smart_str_appendl(&out_buf, Z_STRVAL(v), Z_STRLEN(v));
 				/* Clean up */
-				eval_buf.len = 0;
+				eval_buf.s->len = 0;
 				zval_dtor(&v);
 			} else if (is_callable) {
-				zval *retval_ptr;
-				zval **args[1];
-				zval *subpats;
+				zval args[1];
+				zval subpats, retval;
 				int i;
 				
-				MAKE_STD_ZVAL(subpats);
-				array_init(subpats);
-				
+				array_init(&subpats);
 				for (i = 0; i < regs->num_regs; i++) {
-					add_next_index_stringl(subpats, string + regs->beg[i], regs->end[i] - regs->beg[i], 1);
+					add_next_index_stringl(&subpats, string + regs->beg[i], regs->end[i] - regs->beg[i]);
 				}				
 				
-				args[0] = &subpats;
+				ZVAL_COPY_VALUE(&args[0], &subpats);
 				/* null terminate buffer */
 				smart_str_0(&eval_buf);
 				
 				arg_replace_fci.param_count = 1;
 				arg_replace_fci.params = args;
-				arg_replace_fci.retval_ptr_ptr = &retval_ptr;
-				if (zend_call_function(&arg_replace_fci, &arg_replace_fci_cache TSRMLS_CC) == SUCCESS && arg_replace_fci.retval_ptr_ptr) {
-					convert_to_string_ex(&retval_ptr);
-					smart_str_appendl(&out_buf, Z_STRVAL_P(retval_ptr), Z_STRLEN_P(retval_ptr));
-					eval_buf.len = 0;
-					zval_ptr_dtor(&retval_ptr);
+				arg_replace_fci.retval = &retval;
+				if (zend_call_function(&arg_replace_fci, &arg_replace_fci_cache TSRMLS_CC) == SUCCESS &&
+						!ZVAL_IS_UNDEF(&retval)) {
+					convert_to_string_ex(&retval);
+					smart_str_appendl(&out_buf, Z_STRVAL(retval), Z_STRLEN(retval));
+					if (eval_buf.s) {
+						eval_buf.s->len = 0;
+					}
+					zval_ptr_dtor(&retval);
 				} else {
 					efree(description);
 					if (!EG(exception)) {
@@ -1015,9 +1015,11 @@ static void _php_mb_regex_ereg_replace_exec(INTERNAL_FUNCTION_PARAMETERS, OnigOp
 	if (err <= -2) {
 		smart_str_free(&out_buf);	
 		RETVAL_FALSE;
+	} else if (out_buf.s) {
+		smart_str_0(&out_buf);
+		RETVAL_STR(out_buf.s);
 	} else {
-		smart_str_appendc(&out_buf, '\0');
-		RETVAL_STRINGL((char *)out_buf.c, out_buf.len - 1, 0);
+		RETVAL_EMPTY_STRING();
 	}
 }
 /* }}} */
@@ -1090,7 +1092,7 @@ PHP_FUNCTION(mb_split)
 		/* add it to the array */
 		if ((pos - (OnigUChar *)string) < end) {
 			if (beg < string_len && beg >= (chunk_pos - (OnigUChar *)string)) {
-				add_next_index_stringl(return_value, (char *)chunk_pos, ((OnigUChar *)(string + beg) - chunk_pos), 1);
+				add_next_index_stringl(return_value, (char *)chunk_pos, ((OnigUChar *)(string + beg) - chunk_pos));
 				--count;
 			} else {
 				err = -2;
@@ -1118,9 +1120,9 @@ PHP_FUNCTION(mb_split)
 	/* otherwise we just have one last element to add to the array */
 	n = ((OnigUChar *)(string + string_len) - chunk_pos);
 	if (n > 0) {
-		add_next_index_stringl(return_value, (char *)chunk_pos, n, 1);
+		add_next_index_stringl(return_value, (char *)chunk_pos, n);
 	} else {
-		add_next_index_stringl(return_value, "", 0, 1);
+		add_next_index_stringl(return_value, "", 0);
 	}
 }
 /* }}} */
@@ -1206,9 +1208,9 @@ _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
 	pos = MBREX(search_pos);
 	str = NULL;
 	len = 0;
-	if (MBREX(search_str) != NULL && Z_TYPE_P(MBREX(search_str)) == IS_STRING){
-		str = (OnigUChar *)Z_STRVAL_P(MBREX(search_str));
-		len = Z_STRLEN_P(MBREX(search_str));
+	if (!ZVAL_IS_UNDEF(&MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING){
+		str = (OnigUChar *)Z_STRVAL(MBREX(search_str));
+		len = Z_STRLEN(MBREX(search_str));
 	}
 
 	if (MBREX(search_re) == NULL) {
@@ -1254,7 +1256,7 @@ _php_mb_regex_ereg_search_exec(INTERNAL_FUNCTION_PARAMETERS, int mode)
 				beg = MBREX(search_regs)->beg[i];
 				end = MBREX(search_regs)->end[i];
 				if (beg >= 0 && beg <= end && end <= len) {
-					add_index_stringl(return_value, i, (char *)&str[beg], end - beg, 1);
+					add_index_stringl(return_value, i, (char *)&str[beg], end - beg);
 				} else {
 					add_index_bool(return_value, i, 0);
 				}
@@ -1338,20 +1340,18 @@ PHP_FUNCTION(mb_ereg_search_init)
 		}
 	}
 
-	if (MBREX(search_str) != NULL) {
+	if (!ZVAL_IS_NULL(&MBREX(search_str))) {
 		zval_ptr_dtor(&MBREX(search_str));
-		MBREX(search_str) = (zval *)NULL;
 	}
 
-	MBREX(search_str) = arg_str;
-	Z_ADDREF_P(MBREX(search_str));
+	ZVAL_COPY(&MBREX(search_str), arg_str);
 	SEPARATE_ZVAL_IF_NOT_REF(&MBREX(search_str));
 
 	MBREX(search_pos) = 0;
 
 	if (MBREX(search_regs) != NULL) {
 		onig_region_free(MBREX(search_regs), 1);
-		MBREX(search_regs) = (OnigRegion *) NULL;
+		MBREX(search_regs) = NULL;
 	}
 
 	RETURN_TRUE;
@@ -1365,17 +1365,17 @@ PHP_FUNCTION(mb_ereg_search_getregs)
 	int n, i, len, beg, end;
 	OnigUChar *str;
 
-	if (MBREX(search_regs) != NULL && Z_TYPE_P(MBREX(search_str)) == IS_STRING && Z_STRVAL_P(MBREX(search_str)) != NULL) {
+	if (MBREX(search_regs) != NULL && Z_TYPE(MBREX(search_str)) == IS_STRING) {
 		array_init(return_value);
 
-		str = (OnigUChar *)Z_STRVAL_P(MBREX(search_str));
-		len = Z_STRLEN_P(MBREX(search_str));
+		str = (OnigUChar *)Z_STRVAL(MBREX(search_str));
+		len = Z_STRLEN(MBREX(search_str));
 		n = MBREX(search_regs)->num_regs;
 		for (i = 0; i < n; i++) {
 			beg = MBREX(search_regs)->beg[i];
 			end = MBREX(search_regs)->end[i];
 			if (beg >= 0 && beg <= end && end <= len) {
-				add_index_stringl(return_value, i, (char *)&str[beg], end - beg, 1);
+				add_index_stringl(return_value, i, (char *)&str[beg], end - beg);
 			} else {
 				add_index_bool(return_value, i, 0);
 			}
@@ -1404,7 +1404,7 @@ PHP_FUNCTION(mb_ereg_search_setpos)
 		return;
 	}
 
-	if (position < 0 || (MBREX(search_str) != NULL && Z_TYPE_P(MBREX(search_str)) == IS_STRING && position >= Z_STRLEN_P(MBREX(search_str)))) {
+	if (position < 0 || (!ZVAL_IS_UNDEF(&MBREX(search_str)) && Z_TYPE(MBREX(search_str)) == IS_STRING && position >= Z_STRLEN(MBREX(search_str)))) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Position is out of range");
 		MBREX(search_pos) = 0;
 		RETURN_FALSE;
@@ -1454,7 +1454,7 @@ PHP_FUNCTION(mb_regex_set_options)
 	}
 	_php_mb_regex_get_option_string(buf, sizeof(buf), opt, syntax);
 
-	RETVAL_STRING(buf, 1);
+	RETVAL_STRING(buf);
 }
 /* }}} */
 
diff --git a/ext/mbstring/tests/bug26639.phpt b/ext/mbstring/tests/bug26639.phpt
index a87e912ba6..3f5b8e5acd 100644
--- a/ext/mbstring/tests/bug26639.phpt
+++ b/ext/mbstring/tests/bug26639.phpt
@@ -70,54 +70,54 @@ unset($a);
 unset($b);
 unset($c);
 ?>
---EXPECT--
-string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(2)
-string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(2)
-string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(1)
-string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(1)
-array(1) refcount(2){
+--EXPECTF--
+string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(%d)
+string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
+string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
+string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
+array(1) refcount(%d){
   [0]=>
-  string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(2)
+  string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(%d)
 }
-array(1) refcount(2){
+array(1) refcount(%d){
   [0]=>
-  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(1)
+  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
 }
-array(1) refcount(2){
+array(1) refcount(%d){
   [0]=>
-  &string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(2)
+  &string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(%d)
 }
-array(1) refcount(2){
+array(1) refcount(%d){
   [0]=>
-  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(1)
+  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
 }
-array(1) refcount(1){
+array(1) refcount(%d){
   [0]=>
-  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(2)
+  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
 }
-array(1) refcount(1){
+array(1) refcount(%d){
   [0]=>
-  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(2)
+  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
 }
-array(1) refcount(1){
+array(1) refcount(%d){
   [0]=>
-  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(2)
+  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
 }
-array(1) refcount(1){
+array(1) refcount(%d){
   [0]=>
-  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(2)
+  string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
 }
-array(1) refcount(3){
+array(1) refcount(%d){
   [0]=>
-  array(1) refcount(1){
+  array(1) refcount(%d){
     [0]=>
-    string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(1)
+    string(10) "‚ ‚¢‚¤‚¦‚¨" refcount(%d)
   }
 }
-array(1) refcount(2){
+array(1) refcount(%d){
   [0]=>
-  array(1) refcount(1){
+  array(1) refcount(%d){
     [0]=>
-    string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(1)
+    string(10) "¤¢¤¤¤¦¤¨¤ª" refcount(%d)
   }
 }
diff --git a/ext/mbstring/tests/mb_http_output.phpt b/ext/mbstring/tests/mb_http_output.phpt
index 6f149bfc9f..a6cac3fb35 100644
--- a/ext/mbstring/tests/mb_http_output.phpt
+++ b/ext/mbstring/tests/mb_http_output.phpt
@@ -49,12 +49,12 @@ $enc = mb_http_output();
 print "$enc\n";
 
 $r = mb_http_output($t_ary);
-($r === FALSE) ? print "OK_BAD_ARY_SET\n" : print "NG_BAD_ARY_SET\n";
+($r === NULL) ? print "OK_BAD_ARY_SET\n" : print "NG_BAD_ARY_SET\n";
 $enc = mb_http_output();
 print "$enc\n";
 
 $r = mb_http_output($t_obj);
-($r === FALSE) ? print "OK_BAD_OBJ_SET\n" : print "NG_BAD_OBJ_SET\n";
+($r === NULL) ? print "OK_BAD_OBJ_SET\n" : print "NG_BAD_OBJ_SET\n";
 $enc = mb_http_output();
 print "$enc\n";
 
diff --git a/ext/mbstring/tests/mb_internal_encoding.phpt b/ext/mbstring/tests/mb_internal_encoding.phpt
index e1b99c3ba2..acb3c6fbb6 100644
--- a/ext/mbstring/tests/mb_internal_encoding.phpt
+++ b/ext/mbstring/tests/mb_internal_encoding.phpt
@@ -32,17 +32,17 @@ print "== INVALID PARAMETER ==\n";
 
 // Note: Other than string type, PHP raises Warning
 $r = mb_internal_encoding('BAD');
-($r === FALSE) ? print "OK_BAD_SET\n" : print "NG_BAD_SET\n";
+($r === false) ? print "OK_BAD_SET\n" : print "NG_BAD_SET\n";
 $enc = mb_internal_encoding();
 print "$enc\n";
 
 $r = mb_internal_encoding($t_ary);
-($r === FALSE) ? print "OK_BAD_ARY_SET\n" : print "NG_BAD_ARY_SET\n";
+($r === NULL) ? print "OK_BAD_ARY_SET\n" : print "NG_BAD_ARY_SET\n";
 $enc = mb_internal_encoding();
 print "$enc\n";
 
 $r = mb_internal_encoding($t_obj);
-($r === FALSE) ? print "OK_BAD_OBJ_SET\n" : print "NG_BAD_OBJ_SET\n";
+($r === NULL) ? print "OK_BAD_OBJ_SET\n" : print "NG_BAD_OBJ_SET\n";
 $enc = mb_internal_encoding();
 print "$enc\n";
 
diff --git a/ext/mbstring/tests/mb_internal_encoding_error1.phpt b/ext/mbstring/tests/mb_internal_encoding_error1.phpt
index 61f133a44a..ce824e6a2f 100644
--- a/ext/mbstring/tests/mb_internal_encoding_error1.phpt
+++ b/ext/mbstring/tests/mb_internal_encoding_error1.phpt
@@ -32,5 +32,5 @@ echo "Done";
 -- Testing mb_internal_encoding() function with more than expected no. of arguments --
 
 Warning: mb_internal_encoding() expects at most 1 parameter, 2 given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_internal_encoding_variation1.phpt b/ext/mbstring/tests/mb_internal_encoding_variation1.phpt
index 94bb0cfd43..581df06414 100644
--- a/ext/mbstring/tests/mb_internal_encoding_variation1.phpt
+++ b/ext/mbstring/tests/mb_internal_encoding_variation1.phpt
@@ -213,5 +213,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_internal_encoding() expects parameter 1 to be string, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_stripos.phpt b/ext/mbstring/tests/mb_stripos.phpt
index c21cdf3a59..4ea8cfa6d6 100644
--- a/ext/mbstring/tests/mb_stripos.phpt
+++ b/ext/mbstring/tests/mb_stripos.phpt
@@ -106,13 +106,13 @@ $r = mb_stripos($euc_jp,b"\n");
 echo "== INVALID PARAMETER TEST ==\n";
 
 $r = mb_stripos($euc_jp,'','EUC-JP');
-($r === FALSE) ? print("OK_NULL\n") : print("NG_NULL\n");
+($r === NULL) ? print("OK_NULL\n") : print("NG_NULL\n");
 $r = mb_stripos($euc_jp, $t_ary, 'EUC-JP');
-($r === FALSE) ? print("OK_ARRAY\n") : print("NG_ARRAY\n");
+($r === NULL) ? print("OK_ARRAY\n") : print("NG_ARRAY\n");
 $r = mb_stripos($euc_jp, $t_obj, 'EUC-JP');
-($r === FALSE) ? print("OK_OBJECT\n") : print("NG_OBJECT\n");
+($r === NULL) ? print("OK_OBJECT\n") : print("NG_OBJECT\n");
 $r = mb_stripos($euc_jp, $t_obj, 'BAD_ENCODING');
-($r === FALSE) ? print("OK_BAD_ENCODING\n") : print("NG_BAD_ENCODING\n");
+($r === NULL) ? print("OK_BAD_ENCODING\n") : print("NG_BAD_ENCODING\n");
 
 
 ?>
diff --git a/ext/mbstring/tests/mb_stripos_error1.phpt b/ext/mbstring/tests/mb_stripos_error1.phpt
index c4ea5d7714..832a8661bd 100644
--- a/ext/mbstring/tests/mb_stripos_error1.phpt
+++ b/ext/mbstring/tests/mb_stripos_error1.phpt
@@ -42,10 +42,10 @@ echo "Done";
 -- Testing mb_stripos() function with more than expected no. of arguments --
 
 Warning: mb_stripos() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_stripos() function with less than expected no. of arguments --
 
 Warning: mb_stripos() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_stripos_variation1.phpt b/ext/mbstring/tests/mb_stripos_variation1.phpt
index ab7f75ee5a..2fe5c022f2 100644
--- a/ext/mbstring/tests/mb_stripos_variation1.phpt
+++ b/ext/mbstring/tests/mb_stripos_variation1.phpt
@@ -179,5 +179,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_stripos() expects parameter 1 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_stripos_variation2.phpt b/ext/mbstring/tests/mb_stripos_variation2.phpt
index 1b5263aa8a..95c2d08957 100644
--- a/ext/mbstring/tests/mb_stripos_variation2.phpt
+++ b/ext/mbstring/tests/mb_stripos_variation2.phpt
@@ -195,6 +195,6 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_stripos() expects parameter 2 to be string, resource given in %s on line %d
-bool(false)
+NULL
 Done
 
diff --git a/ext/mbstring/tests/mb_stripos_variation3.phpt b/ext/mbstring/tests/mb_stripos_variation3.phpt
index 41a365abfd..decf02e883 100644
--- a/ext/mbstring/tests/mb_stripos_variation3.phpt
+++ b/ext/mbstring/tests/mb_stripos_variation3.phpt
@@ -163,32 +163,32 @@ int(8)
 -- Iteration 16 --
 
 Warning: mb_stripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 17 --
 
 Warning: mb_stripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 18 --
 
 Warning: mb_stripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 19 --
 
 Warning: mb_stripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 20 --
 
 Warning: mb_stripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 21 --
 
 Warning: mb_stripos() expects parameter 3 to be long, object given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 22 --
 int(8)
@@ -199,5 +199,5 @@ int(8)
 -- Iteration 24 --
 
 Warning: mb_stripos() expects parameter 3 to be long, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_stripos_variation4.phpt b/ext/mbstring/tests/mb_stripos_variation4.phpt
index f330bbdae8..a8d36f9e45 100644
--- a/ext/mbstring/tests/mb_stripos_variation4.phpt
+++ b/ext/mbstring/tests/mb_stripos_variation4.phpt
@@ -219,5 +219,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_stripos() expects parameter 4 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_stristr_error1.phpt b/ext/mbstring/tests/mb_stristr_error1.phpt
index 3c766c4fad..8c81b0766d 100644
--- a/ext/mbstring/tests/mb_stristr_error1.phpt
+++ b/ext/mbstring/tests/mb_stristr_error1.phpt
@@ -38,10 +38,10 @@ var_dump( mb_stristr($haystack) );
 -- Testing mb_stristr() function with more than expected no. of arguments --
 
 Warning: mb_stristr() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_stristr() function with less than expected no. of arguments --
 
 Warning: mb_stristr() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_stristr_variation1.phpt b/ext/mbstring/tests/mb_stristr_variation1.phpt
index fc69bd065e..9483c379e0 100644
--- a/ext/mbstring/tests/mb_stristr_variation1.phpt
+++ b/ext/mbstring/tests/mb_stristr_variation1.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_stristr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_stristr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_stristr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_stristr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 bool(false)
@@ -193,7 +193,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_stristr() expects parameter 1 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 bool(false)
@@ -203,6 +203,6 @@ bool(false)
 
 --resource--
 Error: 2 - mb_stristr() expects parameter 1 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
 
diff --git a/ext/mbstring/tests/mb_stristr_variation2.phpt b/ext/mbstring/tests/mb_stristr_variation2.phpt
index bfa1835eed..0aeea8e68c 100644
--- a/ext/mbstring/tests/mb_stristr_variation2.phpt
+++ b/ext/mbstring/tests/mb_stristr_variation2.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_stristr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_stristr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_stristr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_stristr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 Error: 2 - mb_stristr(): Empty delimiter, %s(%d)
@@ -199,7 +199,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_stristr() expects parameter 2 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 Error: 2 - mb_stristr(): Empty delimiter, %s(%d)
@@ -211,6 +211,6 @@ bool(false)
 
 --resource--
 Error: 2 - mb_stristr() expects parameter 2 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
 
diff --git a/ext/mbstring/tests/mb_stristr_variation3.phpt b/ext/mbstring/tests/mb_stristr_variation3.phpt
index 30a7e4989b..d06ad15070 100644
--- a/ext/mbstring/tests/mb_stristr_variation3.phpt
+++ b/ext/mbstring/tests/mb_stristr_variation3.phpt
@@ -118,7 +118,7 @@ $inputs = array(
 foreach($inputs as $key =>$value) {
       echo "\n--$key--\n";
       $res = mb_stristr($haystack, $needle, $value, $encoding);
-      if ($res === false) {
+      if ($res === NULL) {
          var_dump($res);
       }
       else {
@@ -162,19 +162,19 @@ string(12) "737472696e67"
 
 --empty array--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 string(8) "5f76616c"
@@ -214,11 +214,11 @@ string(12) "737472696e67"
 
 --instance of classWithToString--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --instance of classWithoutToString--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 string(8) "5f76616c"
@@ -228,5 +228,5 @@ string(8) "5f76616c"
 
 --resource--
 Error: 2 - mb_stristr() expects parameter 3 to be boolean, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_stristr_variation4.phpt b/ext/mbstring/tests/mb_stristr_variation4.phpt
index d547543aed..c735e0c7a7 100644
--- a/ext/mbstring/tests/mb_stristr_variation4.phpt
+++ b/ext/mbstring/tests/mb_stristr_variation4.phpt
@@ -159,19 +159,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_stristr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_stristr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_stristr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_stristr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 Error: 2 - mb_stristr(): Unknown encoding "", %s(%d)
@@ -211,7 +211,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_stristr() expects parameter 4 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 Error: 2 - mb_stristr(): Unknown encoding "", %s(%d)
@@ -223,5 +223,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_stristr() expects parameter 4 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strlen_error1.phpt b/ext/mbstring/tests/mb_strlen_error1.phpt
index 8fcd87ec3a..aff78d60f3 100644
--- a/ext/mbstring/tests/mb_strlen_error1.phpt
+++ b/ext/mbstring/tests/mb_strlen_error1.phpt
@@ -37,10 +37,10 @@ echo "Done";
 -- Testing mb_strlen() function with Zero arguments --
 
 Warning: mb_strlen() expects at least 1 parameter, 0 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strlen() function with more than expected no. of arguments --
 
 Warning: mb_strlen() expects at most 2 parameters, 3 given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strlen_variation1.phpt b/ext/mbstring/tests/mb_strlen_variation1.phpt
index 3c9cfe3c84..9388c0547d 100644
--- a/ext/mbstring/tests/mb_strlen_variation1.phpt
+++ b/ext/mbstring/tests/mb_strlen_variation1.phpt
@@ -176,5 +176,5 @@ int(0)
 -- Iteration 24 --
 
 Warning: mb_strlen() expects parameter 1 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strlen_variation2.phpt b/ext/mbstring/tests/mb_strlen_variation2.phpt
index 8504bbc5a0..276731ce92 100644
--- a/ext/mbstring/tests/mb_strlen_variation2.phpt
+++ b/ext/mbstring/tests/mb_strlen_variation2.phpt
@@ -216,5 +216,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strlen() expects parameter 2 to be string, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strpos.phpt b/ext/mbstring/tests/mb_strpos.phpt
index 1d613e9c78..e1222ca6dd 100644
--- a/ext/mbstring/tests/mb_strpos.phpt
+++ b/ext/mbstring/tests/mb_strpos.phpt
@@ -103,13 +103,13 @@ $r = mb_strpos($euc_jp, b"\n");
 echo "== INVALID PARAMETER TEST ==\n";
 
 $r = mb_strpos($euc_jp,'','EUC-JP');
-($r === FALSE) ? print("OK_NULL\n") : print("NG_NULL\n");
+($r === NULL) ? print("OK_NULL\n") : print("NG_NULL\n");
 $r = mb_strpos($euc_jp, $t_ary, 'EUC-JP');
-($r === FALSE) ? print("OK_ARRAY\n") : print("NG_ARRAY\n");
+($r === NULL) ? print("OK_ARRAY\n") : print("NG_ARRAY\n");
 $r = mb_strpos($euc_jp, $t_obj, 'EUC-JP');
-($r === FALSE) ? print("OK_OBJECT\n") : print("NG_OBJECT\n");
+($r === NULL) ? print("OK_OBJECT\n") : print("NG_OBJECT\n");
 $r = mb_strpos($euc_jp, $t_obj, 'BAD_ENCODING');
-($r === FALSE) ? print("OK_BAD_ENCODING\n") : print("NG_BAD_ENCODING\n");
+($r === NULL) ? print("OK_BAD_ENCODING\n") : print("NG_BAD_ENCODING\n");
 
 
 ?>
diff --git a/ext/mbstring/tests/mb_strpos_error1.phpt b/ext/mbstring/tests/mb_strpos_error1.phpt
index 8f5ba85423..ef0cbafeff 100644
--- a/ext/mbstring/tests/mb_strpos_error1.phpt
+++ b/ext/mbstring/tests/mb_strpos_error1.phpt
@@ -41,10 +41,10 @@ echo "Done";
 -- Testing mb_strpos() function with more than expected no. of arguments --
 
 Warning: mb_strpos() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strpos() function with less than expected no. of arguments --
 
 Warning: mb_strpos() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strpos_variation1.phpt b/ext/mbstring/tests/mb_strpos_variation1.phpt
index d665f8f7ef..0684724b5c 100644
--- a/ext/mbstring/tests/mb_strpos_variation1.phpt
+++ b/ext/mbstring/tests/mb_strpos_variation1.phpt
@@ -178,5 +178,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strpos() expects parameter 1 to be string, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strpos_variation2.phpt b/ext/mbstring/tests/mb_strpos_variation2.phpt
index d6feb49231..486b2bb3e5 100644
--- a/ext/mbstring/tests/mb_strpos_variation2.phpt
+++ b/ext/mbstring/tests/mb_strpos_variation2.phpt
@@ -194,5 +194,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strpos() expects parameter 2 to be string, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strpos_variation3.phpt b/ext/mbstring/tests/mb_strpos_variation3.phpt
index 65572b5f04..ff69b8c6f8 100644
--- a/ext/mbstring/tests/mb_strpos_variation3.phpt
+++ b/ext/mbstring/tests/mb_strpos_variation3.phpt
@@ -162,32 +162,32 @@ int(8)
 -- Iteration 16 --
 
 Warning: mb_strpos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 17 --
 
 Warning: mb_strpos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 18 --
 
 Warning: mb_strpos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 19 --
 
 Warning: mb_strpos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 20 --
 
 Warning: mb_strpos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 21 --
 
 Warning: mb_strpos() expects parameter 3 to be long, object given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 22 --
 int(8)
@@ -198,5 +198,5 @@ int(8)
 -- Iteration 24 --
 
 Warning: mb_strpos() expects parameter 3 to be long, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strpos_variation4.phpt b/ext/mbstring/tests/mb_strpos_variation4.phpt
index 0fca8bb1f2..4051646ae4 100644
--- a/ext/mbstring/tests/mb_strpos_variation4.phpt
+++ b/ext/mbstring/tests/mb_strpos_variation4.phpt
@@ -218,5 +218,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strpos() expects parameter 4 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strrchr_error1.phpt b/ext/mbstring/tests/mb_strrchr_error1.phpt
index 5ebb3d06f6..bb6ff0fab0 100644
--- a/ext/mbstring/tests/mb_strrchr_error1.phpt
+++ b/ext/mbstring/tests/mb_strrchr_error1.phpt
@@ -38,10 +38,10 @@ var_dump( mb_strrchr($haystack) );
 -- Testing mb_strrchr() function with more than expected no. of arguments --
 
 Warning: mb_strrchr() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strrchr() function with less than expected no. of arguments --
 
 Warning: mb_strrchr() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrchr_variation1.phpt b/ext/mbstring/tests/mb_strrchr_variation1.phpt
index 18eb52ea28..a0952a87ea 100644
--- a/ext/mbstring/tests/mb_strrchr_variation1.phpt
+++ b/ext/mbstring/tests/mb_strrchr_variation1.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strrchr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrchr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrchr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrchr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 bool(false)
@@ -193,7 +193,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrchr() expects parameter 1 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 bool(false)
@@ -203,5 +203,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strrchr() expects parameter 1 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrchr_variation2.phpt b/ext/mbstring/tests/mb_strrchr_variation2.phpt
index f9b7107830..c368bd8c9d 100644
--- a/ext/mbstring/tests/mb_strrchr_variation2.phpt
+++ b/ext/mbstring/tests/mb_strrchr_variation2.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strrchr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrchr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrchr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrchr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 bool(false)
@@ -193,7 +193,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrchr() expects parameter 2 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 bool(false)
@@ -203,5 +203,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strrchr() expects parameter 2 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrchr_variation3.phpt b/ext/mbstring/tests/mb_strrchr_variation3.phpt
index 4a16f55b48..ad9c4e356d 100644
--- a/ext/mbstring/tests/mb_strrchr_variation3.phpt
+++ b/ext/mbstring/tests/mb_strrchr_variation3.phpt
@@ -118,7 +118,7 @@ $inputs = array(
 foreach($inputs as $key =>$value) {
       echo "\n--$key--\n";
       $res = mb_strrchr($haystack, $needle, $value, $encoding);
-      if ($res === false) {
+      if ($res === NULL) {
          var_dump($res);
       }
       else {
@@ -162,19 +162,19 @@ string(12) "737472696e67"
 
 --empty array--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 string(8) "5f76616c"
@@ -214,11 +214,11 @@ string(12) "737472696e67"
 
 --instance of classWithToString--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 string(8) "5f76616c"
@@ -228,5 +228,5 @@ string(8) "5f76616c"
 
 --resource--
 Error: 2 - mb_strrchr() expects parameter 3 to be boolean, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrchr_variation4.phpt b/ext/mbstring/tests/mb_strrchr_variation4.phpt
index b9e014706c..f9dadab5f0 100644
--- a/ext/mbstring/tests/mb_strrchr_variation4.phpt
+++ b/ext/mbstring/tests/mb_strrchr_variation4.phpt
@@ -159,19 +159,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strrchr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrchr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrchr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrchr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 Error: 2 - mb_strrchr(): Unknown encoding "", %s(%d)
@@ -211,7 +211,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrchr() expects parameter 4 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 Error: 2 - mb_strrchr(): Unknown encoding "", %s(%d)
@@ -223,5 +223,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strrchr() expects parameter 4 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrichr_error1.phpt b/ext/mbstring/tests/mb_strrichr_error1.phpt
index 2c2ed61149..01d33f342f 100644
--- a/ext/mbstring/tests/mb_strrichr_error1.phpt
+++ b/ext/mbstring/tests/mb_strrichr_error1.phpt
@@ -38,10 +38,10 @@ var_dump( mb_strrichr($haystack) );
 -- Testing mb_strrichr() function with more than expected no. of arguments --
 
 Warning: mb_strrichr() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strrichr() function with less than expected no. of arguments --
 
 Warning: mb_strrichr() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrichr_variation1.phpt b/ext/mbstring/tests/mb_strrichr_variation1.phpt
index d826ccf407..e350718e77 100644
--- a/ext/mbstring/tests/mb_strrichr_variation1.phpt
+++ b/ext/mbstring/tests/mb_strrichr_variation1.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strrichr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrichr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrichr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrichr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 bool(false)
@@ -193,7 +193,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrichr() expects parameter 1 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 bool(false)
@@ -203,5 +203,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strrichr() expects parameter 1 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrichr_variation2.phpt b/ext/mbstring/tests/mb_strrichr_variation2.phpt
index 1a4a73fe44..3300ea5a61 100644
--- a/ext/mbstring/tests/mb_strrichr_variation2.phpt
+++ b/ext/mbstring/tests/mb_strrichr_variation2.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strrichr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrichr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrichr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrichr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 bool(false)
@@ -193,7 +193,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrichr() expects parameter 2 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 bool(false)
@@ -203,5 +203,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strrichr() expects parameter 2 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrichr_variation3.phpt b/ext/mbstring/tests/mb_strrichr_variation3.phpt
index 68e8083bdc..b57f309022 100644
--- a/ext/mbstring/tests/mb_strrichr_variation3.phpt
+++ b/ext/mbstring/tests/mb_strrichr_variation3.phpt
@@ -118,7 +118,7 @@ $inputs = array(
 foreach($inputs as $key =>$value) {
       echo "\n--$key--\n";
       $res = mb_strrichr($haystack, $needle, $value, $encoding);
-      if ($res === false) {
+      if ($res === NULL) {
          var_dump($res);
       }
       else {
@@ -162,19 +162,19 @@ string(12) "737472696e67"
 
 --empty array--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 string(8) "5f76616c"
@@ -214,11 +214,11 @@ string(12) "737472696e67"
 
 --instance of classWithToString--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 string(8) "5f76616c"
@@ -228,5 +228,5 @@ string(8) "5f76616c"
 
 --resource--
 Error: 2 - mb_strrichr() expects parameter 3 to be boolean, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strrichr_variation4.phpt b/ext/mbstring/tests/mb_strrichr_variation4.phpt
index d2e5754c1d..2d04665884 100644
--- a/ext/mbstring/tests/mb_strrichr_variation4.phpt
+++ b/ext/mbstring/tests/mb_strrichr_variation4.phpt
@@ -159,19 +159,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strrichr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strrichr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strrichr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strrichr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 Error: 2 - mb_strrichr(): Unknown encoding "", %s(%d)
@@ -211,7 +211,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strrichr() expects parameter 4 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 Error: 2 - mb_strrichr(): Unknown encoding "", %s(%d)
@@ -223,5 +223,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strrichr() expects parameter 4 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strripos_error1.phpt b/ext/mbstring/tests/mb_strripos_error1.phpt
index 9d114d55a4..955482b66f 100644
--- a/ext/mbstring/tests/mb_strripos_error1.phpt
+++ b/ext/mbstring/tests/mb_strripos_error1.phpt
@@ -42,10 +42,10 @@ echo "Done";
 -- Testing mb_strripos() function with more than expected no. of arguments --
 
 Warning: mb_strripos() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strripos() function with less than expected no. of arguments --
 
 Warning: mb_strripos() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strripos_variation1.phpt b/ext/mbstring/tests/mb_strripos_variation1.phpt
index 704b501778..858705afc2 100644
--- a/ext/mbstring/tests/mb_strripos_variation1.phpt
+++ b/ext/mbstring/tests/mb_strripos_variation1.phpt
@@ -179,5 +179,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strripos() expects parameter 1 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strripos_variation2.phpt b/ext/mbstring/tests/mb_strripos_variation2.phpt
index 61196f007e..d16c250078 100644
--- a/ext/mbstring/tests/mb_strripos_variation2.phpt
+++ b/ext/mbstring/tests/mb_strripos_variation2.phpt
@@ -179,5 +179,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strripos() expects parameter 2 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strripos_variation3_Bug45923.phpt b/ext/mbstring/tests/mb_strripos_variation3_Bug45923.phpt
index c8fb933363..8f4370f4b8 100644
--- a/ext/mbstring/tests/mb_strripos_variation3_Bug45923.phpt
+++ b/ext/mbstring/tests/mb_strripos_variation3_Bug45923.phpt
@@ -165,32 +165,32 @@ int(8)
 -- Iteration 16 --
 
 Warning: mb_strripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 17 --
 
 Warning: mb_strripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 18 --
 
 Warning: mb_strripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 19 --
 
 Warning: mb_strripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 20 --
 
 Warning: mb_strripos() expects parameter 3 to be long, string given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 21 --
 
 Warning: mb_strripos() expects parameter 3 to be long, object given in %s on line %d
-bool(false)
+NULL
 
 -- Iteration 22 --
 int(8)
@@ -201,6 +201,6 @@ int(8)
 -- Iteration 24 --
 
 Warning: mb_strripos() expects parameter 3 to be long, resource given in %s on line %d
-bool(false)
+NULL
 Done
 
diff --git a/ext/mbstring/tests/mb_strripos_variation4.phpt b/ext/mbstring/tests/mb_strripos_variation4.phpt
index d617872efb..c58568b697 100644
--- a/ext/mbstring/tests/mb_strripos_variation4.phpt
+++ b/ext/mbstring/tests/mb_strripos_variation4.phpt
@@ -219,5 +219,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strripos() expects parameter 4 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strrpos_error1.phpt b/ext/mbstring/tests/mb_strrpos_error1.phpt
index 15228fec81..892599acc2 100644
--- a/ext/mbstring/tests/mb_strrpos_error1.phpt
+++ b/ext/mbstring/tests/mb_strrpos_error1.phpt
@@ -41,10 +41,10 @@ echo "Done";
 -- Testing mb_strrpos() function with more than expected no. of arguments --
 
 Warning: mb_strrpos() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strrpos() function with less than expected no. of arguments --
 
 Warning: mb_strrpos() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strrpos_variation1.phpt b/ext/mbstring/tests/mb_strrpos_variation1.phpt
index 2d2db9003c..8b1713f9f1 100644
--- a/ext/mbstring/tests/mb_strrpos_variation1.phpt
+++ b/ext/mbstring/tests/mb_strrpos_variation1.phpt
@@ -177,5 +177,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strrpos() expects parameter 1 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strrpos_variation2.phpt b/ext/mbstring/tests/mb_strrpos_variation2.phpt
index 1566b5cb5f..c2855e0f81 100644
--- a/ext/mbstring/tests/mb_strrpos_variation2.phpt
+++ b/ext/mbstring/tests/mb_strrpos_variation2.phpt
@@ -179,5 +179,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strrpos() expects parameter 2 to be string, resource given in %s on line %d
-bool(false)
+NULL
 Done
diff --git a/ext/mbstring/tests/mb_strrpos_variation4.phpt b/ext/mbstring/tests/mb_strrpos_variation4.phpt
index 198ce8fc70..9d9a5f2358 100644
--- a/ext/mbstring/tests/mb_strrpos_variation4.phpt
+++ b/ext/mbstring/tests/mb_strrpos_variation4.phpt
@@ -218,5 +218,5 @@ bool(false)
 -- Iteration 24 --
 
 Warning: mb_strrpos() expects parameter 4 to be string, resource given in %s on line %d
-bool(false)
-Done
\ No newline at end of file
+NULL
+Done
diff --git a/ext/mbstring/tests/mb_strstr_error1.phpt b/ext/mbstring/tests/mb_strstr_error1.phpt
index f38d5c9ccd..ffbb636160 100644
--- a/ext/mbstring/tests/mb_strstr_error1.phpt
+++ b/ext/mbstring/tests/mb_strstr_error1.phpt
@@ -38,10 +38,10 @@ var_dump( mb_strstr($haystack) );
 -- Testing mb_strstr() function with more than expected no. of arguments --
 
 Warning: mb_strstr() expects at most 4 parameters, 5 given in %s on line %d
-bool(false)
+NULL
 
 -- Testing mb_strstr() function with less than expected no. of arguments --
 
 Warning: mb_strstr() expects at least 2 parameters, 1 given in %s on line %d
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strstr_variation1.phpt b/ext/mbstring/tests/mb_strstr_variation1.phpt
index 48e7c537ee..826014feae 100644
--- a/ext/mbstring/tests/mb_strstr_variation1.phpt
+++ b/ext/mbstring/tests/mb_strstr_variation1.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strstr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strstr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strstr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strstr() expects parameter 1 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 bool(false)
@@ -193,7 +193,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strstr() expects parameter 1 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 bool(false)
@@ -203,5 +203,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strstr() expects parameter 1 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strstr_variation2.phpt b/ext/mbstring/tests/mb_strstr_variation2.phpt
index f70bb67ada..18820bab0f 100644
--- a/ext/mbstring/tests/mb_strstr_variation2.phpt
+++ b/ext/mbstring/tests/mb_strstr_variation2.phpt
@@ -150,19 +150,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strstr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strstr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strstr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strstr() expects parameter 2 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 Error: 2 - mb_strstr(): Empty delimiter, %s(%d)
@@ -199,7 +199,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strstr() expects parameter 2 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 Error: 2 - mb_strstr(): Empty delimiter, %s(%d)
@@ -211,5 +211,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strstr() expects parameter 2 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strstr_variation3.phpt b/ext/mbstring/tests/mb_strstr_variation3.phpt
index 55c8f31d96..7a8b7c6757 100644
--- a/ext/mbstring/tests/mb_strstr_variation3.phpt
+++ b/ext/mbstring/tests/mb_strstr_variation3.phpt
@@ -118,7 +118,7 @@ $inputs = array(
 foreach($inputs as $key =>$value) {
       echo "\n--$key--\n";
       $res = mb_strstr($haystack, $needle, $value, $encoding);
-      if ($res === false) {
+      if ($res === NULL) {
          var_dump($res);
       }
       else {
@@ -162,19 +162,19 @@ string(12) "737472696e67"
 
 --empty array--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 string(8) "5f76616c"
@@ -214,11 +214,11 @@ string(12) "737472696e67"
 
 --instance of classWithToString--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --instance of classWithoutToString--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 string(8) "5f76616c"
@@ -228,5 +228,5 @@ string(8) "5f76616c"
 
 --resource--
 Error: 2 - mb_strstr() expects parameter 3 to be boolean, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/mb_strstr_variation4.phpt b/ext/mbstring/tests/mb_strstr_variation4.phpt
index 3a208d3122..e13428f633 100644
--- a/ext/mbstring/tests/mb_strstr_variation4.phpt
+++ b/ext/mbstring/tests/mb_strstr_variation4.phpt
@@ -159,19 +159,19 @@ bool(false)
 
 --empty array--
 Error: 2 - mb_strstr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --int indexed array--
 Error: 2 - mb_strstr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --associative array--
 Error: 2 - mb_strstr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --nested arrays--
 Error: 2 - mb_strstr() expects parameter 4 to be string, array given, %s(%d)
-bool(false)
+NULL
 
 --uppercase NULL--
 Error: 2 - mb_strstr(): Unknown encoding "", %s(%d)
@@ -211,7 +211,7 @@ bool(false)
 
 --instance of classWithoutToString--
 Error: 2 - mb_strstr() expects parameter 4 to be string, object given, %s(%d)
-bool(false)
+NULL
 
 --undefined var--
 Error: 2 - mb_strstr(): Unknown encoding "", %s(%d)
@@ -223,5 +223,5 @@ bool(false)
 
 --resource--
 Error: 2 - mb_strstr() expects parameter 4 to be string, resource given, %s(%d)
-bool(false)
+NULL
 ===DONE===
diff --git a/ext/mbstring/tests/zend_multibyte-02.phpt b/ext/mbstring/tests/zend_multibyte-02.phpt
index ebc10b48be..8a1a572804 100644
--- a/ext/mbstring/tests/zend_multibyte-02.phpt
+++ b/ext/mbstring/tests/zend_multibyte-02.phpt
@@ -1,7 +1,5 @@
 --TEST--
 zend multibyte (2)
---XFAIL--
-https://bugs.php.net/bug.php?id=66582
 --INI--
 zend.multibyte=On
 zend.script_encoding=UTF-8
diff --git a/ext/mbstring/tests/zend_multibyte-06.phpt b/ext/mbstring/tests/zend_multibyte-06.phpt
index e0b4ead545..1b8adb5186 100644
--- a/ext/mbstring/tests/zend_multibyte-06.phpt
+++ b/ext/mbstring/tests/zend_multibyte-06.phpt
@@ -1,7 +1,5 @@
 --TEST--
 zend multibyte (6)
---XFAIL--
-https://bugs.php.net/bug.php?id=66582
 --INI--
 zend.multibyte=On
 zend.script_encoding=EUC-JP
diff --git a/ext/mbstring/tests/zend_multibyte-12.phpt b/ext/mbstring/tests/zend_multibyte-12.phpt
index 90968e8820..bbfa25d97f 100644
--- a/ext/mbstring/tests/zend_multibyte-12.phpt
+++ b/ext/mbstring/tests/zend_multibyte-12.phpt
@@ -1,6 +1,5 @@
 --TEST--
 zend multibyte (12)
---SKIPIF--
 --INI--
 zend.multibyte=1
 --FILE--
diff --git a/ext/mcrypt/mcrypt.c b/ext/mcrypt/mcrypt.c
index 5fc632b050..1418235bc3 100644
--- a/ext/mcrypt/mcrypt.c
+++ b/ext/mcrypt/mcrypt.c
@@ -963,7 +963,7 @@ PHP_FUNCTION(mcrypt_list_algorithms)
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No algorithms found in module dir");
 	}
 	for (i = 0; i < count; i++) {
-		add_index_string(return_value, i, modules[i], 1);
+		add_index_string(return_value, i, modules[i]);
 	}
 	mcrypt_free_p(modules, count);
 }
@@ -990,7 +990,7 @@ PHP_FUNCTION(mcrypt_list_modes)
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "No modes found in module dir");
 	}
 	for (i = 0; i < count; i++) {
-		add_index_string(return_value, i, modules[i], 1);
+		add_index_string(return_value, i, modules[i]);
 	}
 	mcrypt_free_p(modules, count);
 }
diff --git a/ext/mssql/php_mssql.c b/ext/mssql/php_mssql.c
index eef472aa3f..340f55b421 100644
--- a/ext/mssql/php_mssql.c
+++ b/ext/mssql/php_mssql.c
@@ -1538,11 +1538,11 @@ static void php_mssql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, int result_type)
 				data_len = Z_STRLEN(result->data[result->cur_row][i]);
 
 				if (result_type & MSSQL_NUM) {
-					add_index_stringl(return_value, i, data, data_len, 1);
+					add_index_stringl(return_value, i, data, data_len);
 				}
 				
 				if (result_type & MSSQL_ASSOC) {
-					add_assoc_stringl(return_value, result->fields[i].name, data, data_len, 1);
+					add_assoc_stringl(return_value, result->fields[i].name, data, data_len);
 				}
 			}
 			else if (Z_TYPE(result->data[result->cur_row][i]) == IS_LONG) {
@@ -1718,11 +1718,11 @@ PHP_FUNCTION(mssql_fetch_field)
 
 	object_init(return_value);
 
-	add_property_string(return_value, "name",result->fields[field_offset].name, 1);
+	add_property_string(return_value, "name",result->fields[field_offset].name);
 	add_property_long(return_value, "max_length",result->fields[field_offset].max_length);
-	add_property_string(return_value, "column_source",result->fields[field_offset].column_source, 1);
+	add_property_string(return_value, "column_source",result->fields[field_offset].column_source);
 	add_property_long(return_value, "numeric", result->fields[field_offset].numeric);
-	add_property_string(return_value, "type", php_mssql_get_field_name(Z_TYPE(result->fields[field_offset])), 1);
+	add_property_string(return_value, "type", php_mssql_get_field_name(Z_TYPE(result->fields[field_offset])));
 }
 /* }}} */
 
diff --git a/ext/mysql/php_mysql.c b/ext/mysql/php_mysql.c
index 56e48a0a67..56dcf7b373 100644
--- a/ext/mysql/php_mysql.c
+++ b/ext/mysql/php_mysql.c
@@ -121,7 +121,7 @@ static PHP_GINIT_FUNCTION(mysql);
 
 typedef struct _php_mysql_conn {
 	MYSQL *conn;
-	int active_result_id;
+	zend_resource *active_result_res;
 	int multi_query;
 } php_mysql_conn;
 
@@ -363,46 +363,49 @@ ZEND_GET_MODULE(mysql)
 
 void timeout(int sig);
 
-#define CHECK_LINK(link) { if (link==-1) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "A link to the server could not be established"); RETURN_FALSE; } }
+#define CHECK_LINK(link) { if (link == NULL) { php_error_docref(NULL TSRMLS_CC, E_WARNING, "A link to the server could not be established"); RETURN_FALSE; } }
 
 #if defined(MYSQL_USE_MYSQLND)
-#define PHPMY_UNBUFFERED_QUERY_CHECK() \
-{\
-	if (mysql->active_result_id) { \
-		do {					\
-			int type;			\
-			MYSQL_RES *_mysql_result;	\
-							\
-			_mysql_result = (MYSQL_RES *) zend_list_find(mysql->active_result_id, &type);	\
-			if (_mysql_result && type==le_result) {						\
-				if (mysql_result_is_unbuffered(_mysql_result) && !mysql_eof(_mysql_result)) { \
-					php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Function called without first fetching all rows from a previous unbuffered query");	\
-				}						\
-				zend_list_delete(mysql->active_result_id);	\
-				mysql->active_result_id = 0;			\
-			} \
-		} while(0); \
-	}\
+#define PHPMY_UNBUFFERED_QUERY_CHECK() 									\
+{																		\
+	if (mysql->active_result_res) { 									\
+		do {															\
+			MYSQL_RES *_mysql_result;									\
+			_mysql_result = (MYSQL_RES *)mysql->active_result_res->ptr;	\
+			if (_mysql_result &&										\
+					mysql->active_result_res->type == le_result) {		\
+				if (mysql_result_is_unbuffered(_mysql_result) &&		\
+						!mysql_eof(_mysql_result)) { 					\
+					php_error_docref(NULL TSRMLS_CC, E_NOTICE,			\
+						"Function called without first fetching all"	\
+					   	"rows from a previous unbuffered query");		\
+				}														\
+				zend_list_close(mysql->active_result_res);				\
+				mysql->active_result_res = NULL;						\
+			} 															\
+		} while(0); 													\
+	}																	\
 }
 #else
-#define PHPMY_UNBUFFERED_QUERY_CHECK()			\
-{							\
-	if (mysql->active_result_id) {			\
-		do {					\
-			int type;			\
-			MYSQL_RES *mysql_result;	\
-							\
-			mysql_result = (MYSQL_RES *) zend_list_find(mysql->active_result_id, &type);	\
-			if (mysql_result && type==le_result) {						\
-				if (!mysql_eof(mysql_result)) {						\
-					php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Function called without first fetching all rows from a previous unbuffered query");	\
-					while (mysql_fetch_row(mysql_result));	\
-				}						\
-				zend_list_delete(mysql->active_result_id);	\
-				mysql->active_result_id = 0;			\
-			}							\
-		} while(0);							\
-	}									\
+#define PHPMY_UNBUFFERED_QUERY_CHECK()									\
+{																		\
+	if (mysql->active_result_res) {										\
+		do {															\
+			MYSQL_RES *mysql_result;									\
+			mysql_result = (MYSQL_RES *) mysql->active_result_res->ptr;	\
+			if (mysql_result &&											\
+					mysql->active_result_res->type == le_result) {		\
+				if (!mysql_eof(mysql_result)) {							\
+					php_error_docref(NULL TSRMLS_CC, E_NOTICE, 			\
+						"Function called without first fetching "		\
+						"all rows from a previous unbuffered query");	\
+					while (mysql_fetch_row(mysql_result));				\
+				}														\
+				zend_list_close(mysql->active_result_res);				\
+				mysql->active_result_res = NULL;						\
+			}															\
+		} while(0);														\
+	}																	\
 }
 #endif
 
@@ -410,7 +413,7 @@ void timeout(int sig);
  * This wrapper is required since mysql_free_result() returns an integer, and
  * thus, cannot be used directly
  */
-static void _free_mysql_result(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void _free_mysql_result(zend_resource *rsrc TSRMLS_DC)
 {
 	MYSQL_RES *mysql_result = (MYSQL_RES *)rsrc->ptr;
 
@@ -421,13 +424,15 @@ static void _free_mysql_result(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 
 /* {{{ php_mysql_set_default_link
  */
-static void php_mysql_set_default_link(int id TSRMLS_DC)
+static void php_mysql_set_default_link(zend_resource *link TSRMLS_DC)
 {
-	if (MySG(default_link) != -1) {
-		zend_list_delete(MySG(default_link));
+	if (MySG(default_link) != NULL) {
+		if (--GC_REFCOUNT((MySG(default_link))) == 0) {
+			zend_list_delete(MySG(default_link));
+		}
 	}
-	MySG(default_link) = id;
-	zend_list_addref(id);
+	++GC_REFCOUNT(link);
+	MySG(default_link) = link;
 }
 /* }}} */
 
@@ -447,10 +452,10 @@ static int php_mysql_select_db(php_mysql_conn *mysql, char *db TSRMLS_DC)
 
 /* {{{ _close_mysql_link
  */
-static void _close_mysql_link(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void _close_mysql_link(zend_resource *rsrc TSRMLS_DC)
 {
 	php_mysql_conn *link = (php_mysql_conn *)rsrc->ptr;
-	void (*handler) (int);
+	void (*handler)(int);
 
 	handler = signal(SIGPIPE, SIG_IGN);
 	mysql_close(link->conn);
@@ -462,7 +467,7 @@ static void _close_mysql_link(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 
 /* {{{ _close_mysql_plink
  */
-static void _close_mysql_plink(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void _close_mysql_plink(zend_resource *rsrc TSRMLS_DC)
 {
 	php_mysql_conn *link = (php_mysql_conn *)rsrc->ptr;
 	void (*handler) (int);
@@ -531,7 +536,7 @@ static PHP_GINIT_FUNCTION(mysql)
 
 #ifdef MYSQL_USE_MYSQLND
 #include "ext/mysqlnd/mysqlnd_reverse_api.h"
-static MYSQLND * mysql_convert_zv_to_mysqlnd(zval * zv TSRMLS_DC)
+static MYSQLND *mysql_convert_zv_to_mysqlnd(zval *zv TSRMLS_DC)
 {
 	php_mysql_conn *mysql;
 
@@ -540,7 +545,7 @@ static MYSQLND * mysql_convert_zv_to_mysqlnd(zval * zv TSRMLS_DC)
 		return NULL;
 	}
 
-	mysql = (php_mysql_conn *)zend_fetch_resource(&zv TSRMLS_CC, -1, "MySQL-Link", NULL, 2, le_link, le_plink);
+	mysql = zend_fetch_resource(zv TSRMLS_CC, -1, "MySQL-Link", NULL, 2, le_link, le_plink);
 
 	if (!mysql) {
 		return NULL;
@@ -563,7 +568,7 @@ ZEND_MODULE_STARTUP_D(mysql)
 	le_result = zend_register_list_destructors_ex(_free_mysql_result, NULL, "mysql result", module_number);
 	le_link = zend_register_list_destructors_ex(_close_mysql_link, NULL, "mysql link", module_number);
 	le_plink = zend_register_list_destructors_ex(NULL, _close_mysql_plink, "mysql link persistent", module_number);
-	Z_TYPE(mysql_module_entry) = type;
+	mysql_module_entry.type = type;
 
 	REGISTER_LONG_CONSTANT("MYSQL_ASSOC", MYSQL_ASSOC, CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("MYSQL_NUM", MYSQL_NUM, CONST_CS | CONST_PERSISTENT);
@@ -626,7 +631,7 @@ PHP_RINIT_FUNCTION(mysql)
 		return FAILURE;
 	}
 #endif
-	MySG(default_link)=-1;
+	MySG(default_link) = NULL;
 	MySG(num_links) = MySG(num_persistent);
 	/* Reset connect error/errno on every request */
 	MySG(connect_error) = NULL;
@@ -637,10 +642,11 @@ PHP_RINIT_FUNCTION(mysql)
 }
 /* }}} */
 
-
 #if defined(A0) && defined(MYSQL_USE_MYSQLND)
-static int php_mysql_persistent_helper(zend_rsrc_list_entry *le TSRMLS_DC)
+static int php_mysql_persistent_helper(zval *el;zend_rsrc_list_entry *le TSRMLS_DC)
 {
+	//???
+	//zend_rsrc_list_entry *le = (zend_rsrc_list_entry*)Z_PTR_P(el);
 	if (le->type == le_plink) {
 		mysqlnd_end_psession(((php_mysql_conn *) le->ptr)->conn);
 	}
@@ -719,17 +725,19 @@ PHP_MINFO_FUNCTION(mysql)
 
 static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 {
-	char *user=NULL, *passwd=NULL, *host_and_port=NULL, *socket=NULL, *tmp=NULL, *host=NULL;
-	int  user_len = 0, passwd_len = 0, host_len = 0;
-	char *hashed_details=NULL;
-	int hashed_details_length, port = MYSQL_PORT;
+	char *user = NULL, *passwd = NULL;
+   	char *host_and_port = NULL, *socket = NULL;
+	char *tmp = NULL, *host = NULL;
+	int user_len = 0, passwd_len = 0, host_len = 0;
+	int port = MYSQL_PORT;
 	long client_flags = 0;
-	php_mysql_conn *mysql=NULL;
+	php_mysql_conn *mysql = NULL;
 #if MYSQL_VERSION_ID <= 32230
 	void (*handler) (int);
 #endif
-	zend_bool free_host=0, new_link=0;
 	long connect_timeout;
+	zend_string *hashed_details = NULL;
+	zend_bool free_host = 0, new_link = 0;
 
     php_error_docref(NULL TSRMLS_CC,
                      E_DEPRECATED,
@@ -754,10 +762,10 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 
 		MySG(default_port) = MYSQL_PORT;
 		if ((serv_ptr = getservbyname("mysql", "tcp"))) {
-			MySG(default_port) = (uint) ntohs((ushort) serv_ptr->s_port);
+			MySG(default_port) = (uint)ntohs((ushort)serv_ptr->s_port);
 		}
 		if ((env = getenv("MYSQL_TCP_PORT"))) {
-			MySG(default_port) = (uint) atoi(env);
+			MySG(default_port) = (uint)atoi(env);
 		}
 #else
 		MySG(default_port) = MYSQL_PORT;
@@ -768,9 +776,9 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 		if (ZEND_NUM_ARGS()>0) {
 			php_error_docref(NULL TSRMLS_CC, E_NOTICE, "SQL safe mode in effect - ignoring host/user/password information");
 		}
-		host_and_port=passwd=NULL;
-		user=php_get_current_user(TSRMLS_C);
-		hashed_details_length = spprintf(&hashed_details, 0, "mysql__%s_", user);
+		user = php_get_current_user(TSRMLS_C);
+		hashed_details = STR_ALLOC(sizeof("mysql___") + strlen(user) - 1, 0);
+		snprintf(hashed_details->val, hashed_details->len + 1, "mysql__%s_", user);
 		client_flags = CLIENT_INTERACTIVE;
 	} else {
 		/* mysql_pconnect does not support new_link parameter */
@@ -814,13 +822,15 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 #ifdef CLIENT_MULTI_STATEMENTS
 		client_flags &= ~CLIENT_MULTI_STATEMENTS;   /* don't allow multi_queries via connect parameter */
 #endif
-		hashed_details_length = spprintf(&hashed_details, 0, "mysql_%s_%s_%s_%ld", SAFE_STRING(host_and_port), SAFE_STRING(user), SAFE_STRING(passwd), client_flags);
+		hashed_details = STR_ALLOC(sizeof("mysql____") + (host_and_port? strlen(host_and_port) : 0)
+				+ (user? strlen(user) : 0) + (passwd? strlen(passwd) : 0) + MAX_LENGTH_OF_LONG - 1, 0);
+		hashed_details->len = snprintf(hashed_details->val, hashed_details->len + 1, "mysql_%s_%s_%s_%ld", SAFE_STRING(host_and_port), SAFE_STRING(user), SAFE_STRING(passwd), client_flags);
 	}
 
 	/* We cannot use mysql_port anymore in windows, need to use
 	 * mysql_real_connect() to set the port.
 	 */
-	if (host_and_port && (tmp=strchr(host_and_port, ':'))) {
+	if (host_and_port && (tmp = strchr(host_and_port, ':'))) {
 		host = estrndup(host_and_port, tmp-host_and_port);
 		free_host = 1;
 		tmp++;
@@ -843,31 +853,35 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 #endif
 
 	if (!MySG(allow_persistent)) {
-		persistent=0;
+		persistent = 0;
 	}
+
 	if (persistent) {
-		zend_rsrc_list_entry *le;
+		zend_resource *le;
+		zend_string *phashed;
 
 		/* try to find if we already have this link in our persistent list */
-		if (zend_hash_find(&EG(persistent_list), hashed_details, hashed_details_length+1, (void **) &le)==FAILURE) {  /* we don't */
-			zend_rsrc_list_entry new_le;
+		if ((le = zend_hash_find_ptr(&EG(persistent_list), hashed_details)) == NULL) { /* we don't */
+			zval new_le;
 
 			if (MySG(max_links) != -1 && MySG(num_links) >= MySG(max_links)) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%ld)", MySG(num_links));
-				efree(hashed_details);
+				STR_RELEASE(hashed_details);
 				MYSQL_DO_CONNECT_RETURN_FALSE();
 			}
+
 			if (MySG(max_persistent) != -1 && MySG(num_persistent) >= MySG(max_persistent)) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open persistent links (%ld)", MySG(num_persistent));
-				efree(hashed_details);
+				STR_RELEASE(hashed_details);
 				MYSQL_DO_CONNECT_RETURN_FALSE();
 			}
 			/* create the link */
-			mysql = (php_mysql_conn *) malloc(sizeof(php_mysql_conn));
+			mysql = (php_mysql_conn *)malloc(sizeof(php_mysql_conn));
 			if (!mysql) {
-				php_error_docref(NULL TSRMLS_CC, E_ERROR, "Out of memory while allocating memory for a persistent link");
+				php_error_docref(NULL TSRMLS_CC, E_ERROR,
+						"Out of memory while allocating memory for a persistent link");
 			}
-			mysql->active_result_id = 0;
+			mysql->active_result_res = NULL;
 #ifdef CLIENT_MULTI_STATEMENTS
 			mysql->multi_query = client_flags & CLIENT_MULTI_STATEMENTS? 1:0;
 #else
@@ -893,33 +907,38 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 				if (MySG(connect_error) != NULL) {
 					efree(MySG(connect_error));
 				}
+
 				MySG(connect_error) = estrdup(mysql_error(mysql->conn));
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", MySG(connect_error));
 #if defined(HAVE_MYSQL_ERRNO)
 				MySG(connect_errno) = mysql_errno(mysql->conn);
 #endif
 				free(mysql);
-				efree(hashed_details);
+				STR_RELEASE(hashed_details);
 				MYSQL_DO_CONNECT_RETURN_FALSE();
 			}
 			mysql_options(mysql->conn, MYSQL_OPT_LOCAL_INFILE, (char *)&MySG(allow_local_infile));
 
 			/* hash it up */
-			Z_TYPE(new_le) = le_plink;
-			new_le.ptr = mysql;
-			if (zend_hash_update(&EG(persistent_list), hashed_details, hashed_details_length+1, (void *) &new_le, sizeof(zend_rsrc_list_entry), NULL)==FAILURE) {
+			ZVAL_NEW_PERSISTENT_RES(&new_le, -1, mysql, le_plink);
+			
+			/* avoid bogus memleak report */
+			phashed = STR_INIT(hashed_details->val, hashed_details->len, 1);
+			if (zend_hash_update(&EG(persistent_list), phashed, &new_le) == NULL) {
+				STR_RELEASE(phashed);
 				free(mysql);
-				efree(hashed_details);
+				STR_RELEASE(hashed_details);
 				MYSQL_DO_CONNECT_RETURN_FALSE();
 			}
+			STR_RELEASE(phashed);
 			MySG(num_persistent)++;
 			MySG(num_links)++;
 		} else {  /* The link is in our list of persistent connections */
-			if (Z_TYPE_P(le) != le_plink) {
+			if (le->type != le_plink) {
 				MYSQL_DO_CONNECT_RETURN_FALSE();
 			}
-			mysql = (php_mysql_conn *) le->ptr;
-			mysql->active_result_id = 0;
+			mysql = (php_mysql_conn *)le->ptr;
+			mysql->active_result_res = NULL;
 #ifdef CLIENT_MULTI_STATEMENTS
 			mysql->multi_query = client_flags & CLIENT_MULTI_STATEMENTS? 1:0;
 #else
@@ -938,8 +957,8 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 #endif
 					{
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Link to server lost, unable to reconnect");
-						zend_hash_del(&EG(persistent_list), hashed_details, hashed_details_length+1);
-						efree(hashed_details);
+						zend_hash_del(&EG(persistent_list), hashed_details);
+						STR_RELEASE(hashed_details);
 						MYSQL_DO_CONNECT_RETURN_FALSE();
 					}
 					mysql_options(mysql->conn, MYSQL_OPT_LOCAL_INFILE, (char *)&MySG(allow_local_infile));
@@ -952,43 +971,42 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 		}
 		ZEND_REGISTER_RESOURCE(return_value, mysql, le_plink);
 	} else { /* non persistent */
-		zend_rsrc_list_entry *index_ptr, new_index_ptr;
+		zend_resource *index_ptr;
+		zval new_index_ptr;
 
 		/* first we check the hash for the hashed_details key.  if it exists,
 		 * it should point us to the right offset where the actual mysql link sits.
 		 * if it doesn't, open a new mysql link, add it to the resource list,
 		 * and add a pointer to it with hashed_details as the key.
 		 */
-		if (!new_link && zend_hash_find(&EG(regular_list), hashed_details, hashed_details_length+1,(void **) &index_ptr)==SUCCESS) {
-			int type;
-			long link;
-			void *ptr;
+		if (!new_link && (index_ptr = zend_hash_find_ptr(&EG(regular_list), hashed_details))) {
+			zend_resource *link;
 
-			if (Z_TYPE_P(index_ptr) != le_index_ptr) {
+			if (index_ptr->type != le_index_ptr) {
 				MYSQL_DO_CONNECT_RETURN_FALSE();
 			}
-			link = (long) index_ptr->ptr;
-			ptr = zend_list_find(link,&type);   /* check if the link is still there */
-			if (ptr && (type==le_link || type==le_plink)) {
-				zend_list_addref(link);
-				Z_LVAL_P(return_value) = link;
+
+			link = (zend_resource *)index_ptr->ptr;
+			if (link && (link->type == le_link || link->type == le_plink)) {
+				GC_REFCOUNT(link)++;
+				ZVAL_RES(return_value, link);
 				php_mysql_set_default_link(link TSRMLS_CC);
-				Z_TYPE_P(return_value) = IS_RESOURCE;
-				efree(hashed_details);
+				STR_RELEASE(hashed_details);
 				MYSQL_DO_CONNECT_CLEANUP();
 				return;
 			} else {
-				zend_hash_del(&EG(regular_list), hashed_details, hashed_details_length+1);
+				zend_hash_del(&EG(regular_list), hashed_details);
 			}
 		}
+
 		if (MySG(max_links) != -1 && MySG(num_links) >= MySG(max_links)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too many open links (%ld)", MySG(num_links));
-			efree(hashed_details);
+			STR_RELEASE(hashed_details);
 			MYSQL_DO_CONNECT_RETURN_FALSE();
 		}
 
 		mysql = (php_mysql_conn *) emalloc(sizeof(php_mysql_conn));
-		mysql->active_result_id = 0;
+		mysql->active_result_res = NULL;
 #ifdef CLIENT_MULTI_STATEMENTS
 		mysql->multi_query = 1;
 #endif
@@ -1001,7 +1019,7 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 		if (!mysql->conn) {
 			MySG(connect_error) = estrdup("OOM");
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "OOM");
-			efree(hashed_details);
+			STR_RELEASE(hashed_details);
 			efree(mysql);
 			MYSQL_DO_CONNECT_RETURN_FALSE();
 		}
@@ -1029,7 +1047,7 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 #ifdef MYSQL_USE_MYSQLND
 			mysqlnd_close(mysql->conn, MYSQLND_CLOSE_DISCONNECTED);
 #endif
-			efree(hashed_details);
+			STR_RELEASE(hashed_details);
 			efree(mysql);
 			MYSQL_DO_CONNECT_RETURN_FALSE();
 		}
@@ -1039,27 +1057,28 @@ static void php_mysql_do_connect(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 		ZEND_REGISTER_RESOURCE(return_value, mysql, le_link);
 
 		/* add it to the hash */
-		new_index_ptr.ptr = (void *) Z_LVAL_P(return_value);
-		Z_TYPE(new_index_ptr) = le_index_ptr;
-		if (zend_hash_update(&EG(regular_list), hashed_details, hashed_details_length+1,(void *) &new_index_ptr, sizeof(zend_rsrc_list_entry), NULL)==FAILURE) {
-			efree(hashed_details);
+		ZVAL_NEW_RES(&new_index_ptr, -1, Z_RES_P(return_value), le_index_ptr);		
+		if (zend_hash_update(&EG(regular_list), hashed_details, &new_index_ptr) == NULL) {
+			zval_ptr_dtor(return_value);
+			STR_RELEASE(hashed_details);
 			MYSQL_DO_CONNECT_RETURN_FALSE();
 		}
+		Z_ADDREF_P(return_value);
 		MySG(num_links)++;
 	}
 
-	efree(hashed_details);
-	php_mysql_set_default_link(Z_LVAL_P(return_value) TSRMLS_CC);
+	STR_RELEASE(hashed_details);
+	php_mysql_set_default_link(Z_RES_P(return_value) TSRMLS_CC);
 	MYSQL_DO_CONNECT_CLEANUP();
 }
 /* }}} */
 
 /* {{{ php_mysql_get_default_link
  */
-static int php_mysql_get_default_link(INTERNAL_FUNCTION_PARAMETERS)
+static zend_resource *php_mysql_get_default_link(INTERNAL_FUNCTION_PARAMETERS)
 {
-	if (MySG(default_link)==-1) { /* no link opened yet, implicitly open one */
-		ht = 0;
+	if (MySG(default_link) == NULL) { /* no link opened yet, implicitly open one */
+		ZEND_NUM_ARGS() = 0;
 		php_mysql_do_connect(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
 	}
 	return MySG(default_link);
@@ -1086,8 +1105,8 @@ PHP_FUNCTION(mysql_pconnect)
    Close a MySQL connection */
 PHP_FUNCTION(mysql_close)
 {
-	int resource_id;
-	zval *mysql_link=NULL;
+	zend_resource *res;
+	zval *mysql_link = NULL;
 	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
@@ -1095,29 +1114,28 @@ PHP_FUNCTION(mysql_close)
 	}
 
 	if (mysql_link) {
-		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, -1, "MySQL-Link", le_link, le_plink);
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	} else {
-		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, NULL, MySG(default_link), "MySQL-Link", le_link, le_plink);
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, NULL, MySG(default_link)? MySG(default_link)->handle : -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	resource_id = mysql_link ? Z_RESVAL_P(mysql_link) : MySG(default_link);
+	res = mysql_link ? Z_RES_P(mysql_link) : MySG(default_link);
 	PHPMY_UNBUFFERED_QUERY_CHECK();
+	if (res) {
 #ifdef MYSQL_USE_MYSQLND
-	{
-		int tmp;
-		if ((mysql = zend_list_find(resource_id, &tmp)) && tmp == le_plink) {
+		if (res->type == le_plink) {
 			mysqlnd_end_psession(mysql->conn);
 		}
-	}
 #endif
-	zend_list_delete(resource_id);
-
-	if (!mysql_link
-		|| (mysql_link && Z_RESVAL_P(mysql_link)==MySG(default_link))) {
-		MySG(default_link) = -1;
-		if (mysql_link) {
-			/* on an explicit close of the default connection it had a refcount of 2 so we need one more call */
-			zend_list_delete(resource_id);
+		if (!mysql_link) {
+			--GC_REFCOUNT(res);
+			MySG(default_link) = NULL;
+		} else if (mysql_link && Z_RES_P(mysql_link) == MySG(default_link)) {
+			--GC_REFCOUNT(res);
+			MySG(default_link) = NULL;
+			zend_list_close(res);
+		} else {
+			zend_list_close(res);
 		}
 	}
 
@@ -1131,21 +1149,21 @@ PHP_FUNCTION(mysql_select_db)
 {
 	char *db;
 	int db_len;
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &db, &db_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	if (php_mysql_select_db(mysql, db TSRMLS_CC)) {
 		RETURN_TRUE;
 	} else {
@@ -1164,7 +1182,7 @@ PHP_FUNCTION(mysql_get_client_info)
 		return;
 	}
 
-	RETURN_STRING((char *)mysql_get_client_info(),1);
+	RETURN_STRING((char *)mysql_get_client_info());
 }
 /* }}} */
 
@@ -1173,7 +1191,6 @@ PHP_FUNCTION(mysql_get_client_info)
 PHP_FUNCTION(mysql_get_host_info)
 {
 	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
@@ -1181,13 +1198,14 @@ PHP_FUNCTION(mysql_get_host_info)
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
-	RETURN_STRING((char *)mysql_get_host_info(mysql->conn),1);
+	RETURN_STRING((char *)mysql_get_host_info(mysql->conn));
 }
 /* }}} */
 
@@ -1196,7 +1214,6 @@ PHP_FUNCTION(mysql_get_host_info)
 PHP_FUNCTION(mysql_get_proto_info)
 {
 	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
@@ -1204,12 +1221,13 @@ PHP_FUNCTION(mysql_get_proto_info)
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	RETURN_LONG(mysql_get_proto_info(mysql->conn));
 }
 /* }}} */
@@ -1219,7 +1237,6 @@ PHP_FUNCTION(mysql_get_proto_info)
 PHP_FUNCTION(mysql_get_server_info)
 {
 	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
@@ -1227,13 +1244,14 @@ PHP_FUNCTION(mysql_get_server_info)
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
-	RETURN_STRING((char *)mysql_get_server_info(mysql->conn),1);
+	RETURN_STRING((char *)mysql_get_server_info(mysql->conn));
 }
 /* }}} */
 
@@ -1241,24 +1259,24 @@ PHP_FUNCTION(mysql_get_server_info)
    Returns a string containing information about the most recent query */
 PHP_FUNCTION(mysql_info)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	char *str;
+	zval *mysql_link = NULL;
 	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
-
-	if (ZEND_NUM_ARGS() == 0) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	if ((str = (char *)mysql_info(mysql->conn))) {
-		RETURN_STRING(str,1);
+		RETURN_STRING(str);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1270,18 +1288,19 @@ PHP_FUNCTION(mysql_info)
 PHP_FUNCTION(mysql_thread_id)
 {
 	zval *mysql_link = NULL;
-	int  id = -1;
 	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_NUM_ARGS() == 0) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
 
 	RETURN_LONG((long) mysql_thread_id(mysql->conn));
 }
@@ -1291,9 +1310,8 @@ PHP_FUNCTION(mysql_thread_id)
 	Returns a string containing status information */
 PHP_FUNCTION(mysql_stat)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 	char *stat;
 #ifdef MYSQL_USE_MYSQLND
 	uint stat_len;
@@ -1303,19 +1321,23 @@ PHP_FUNCTION(mysql_stat)
 		return;
 	}
 
-	if (ZEND_NUM_ARGS() == 0) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
 
 	PHPMY_UNBUFFERED_QUERY_CHECK();
 #ifndef MYSQL_USE_MYSQLND
 	if ((stat = (char *)mysql_stat(mysql->conn))) {
-		RETURN_STRING(stat, 1);
+		RETURN_STRING(stat);
 #else
 	if (mysqlnd_stat(mysql->conn, &stat, &stat_len) == PASS) {
-		RETURN_STRINGL(stat, stat_len, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL(stat, stat_len);
+		efree(stat);
 #endif
 	} else {
 		RETURN_FALSE;
@@ -1327,21 +1349,22 @@ PHP_FUNCTION(mysql_stat)
 	Returns the default character set for the current connection */
 PHP_FUNCTION(mysql_client_encoding)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_NUM_ARGS() == 0) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-	RETURN_STRING((char *)mysql_character_set_name(mysql->conn), 1);
+	RETURN_STRING((char *)mysql_character_set_name(mysql->conn));
 }
 /* }}} */
 #endif
@@ -1351,22 +1374,23 @@ PHP_FUNCTION(mysql_client_encoding)
    sets client character set */
 PHP_FUNCTION(mysql_set_charset)
 {
-	zval *mysql_link = NULL;
 	char *csname;
-	int id = -1, csname_len;
+	int csname_len;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &csname, &csname_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_NUM_ARGS() == 1) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	if (!mysql_set_character_set(mysql->conn, csname)) {
 		RETURN_TRUE;
 	} else {
@@ -1384,21 +1408,21 @@ PHP_FUNCTION(mysql_create_db)
 {
 	char *db;
 	int db_len;
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &db, &db_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	PHPMY_UNBUFFERED_QUERY_CHECK();
 
 	if (mysql_create_db(mysql->conn, db)==0) {
@@ -1415,21 +1439,21 @@ PHP_FUNCTION(mysql_drop_db)
 {
 	char *db;
 	int db_len;
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &db, &db_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	if (mysql_drop_db(mysql->conn, db)==0) {
 		RETURN_TRUE;
 	} else {
@@ -1442,13 +1466,10 @@ PHP_FUNCTION(mysql_drop_db)
 
 /* {{{ php_mysql_do_query_general
  */
-static void php_mysql_do_query_general(char *query, int query_len, zval *mysql_link, int link_id, char *db, int use_store, zval *return_value TSRMLS_DC)
+static void php_mysql_do_query_general(php_mysql_conn *mysql, char *query, int query_len, char *db, int use_store, zval *return_value TSRMLS_DC)
 {
-	php_mysql_conn *mysql;
 	MYSQL_RES *mysql_result;
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, link_id, "MySQL-Link", le_link, le_plink);
-
 	if (db) {
 		if (!php_mysql_select_db(mysql, db TSRMLS_CC)) {
 			RETURN_FALSE;
@@ -1466,7 +1487,7 @@ static void php_mysql_do_query_general(char *query, int query_len, zval *mysql_l
 			MYSQL_ROW 	row;
 
 			char *newquery;
-			int newql = spprintf (&newquery, 0, "EXPLAIN %s", query);
+			int newql = spprintf(&newquery, 0, "EXPLAIN %s", query);
 			mysql_real_query(mysql->conn, newquery, newql);
 			efree (newquery);
 			if (mysql_errno(mysql->conn)) {
@@ -1511,9 +1532,9 @@ static void php_mysql_do_query_general(char *query, int query_len, zval *mysql_l
 	}
 #endif
 	if(use_store == MYSQL_USE_RESULT) {
-		mysql_result=mysql_use_result(mysql->conn);
+		mysql_result = mysql_use_result(mysql->conn);
 	} else {
-		mysql_result=mysql_store_result(mysql->conn);
+		mysql_result = mysql_store_result(mysql->conn);
 	}
 	if (!mysql_result) {
 		if (PHP_MYSQL_VALID_RESULT(mysql->conn)) { /* query should have returned rows */
@@ -1526,7 +1547,8 @@ static void php_mysql_do_query_general(char *query, int query_len, zval *mysql_l
 	MySG(result_allocated)++;
 	ZEND_REGISTER_RESOURCE(return_value, mysql_result, le_result);
 	if (use_store == MYSQL_USE_RESULT) {
-		mysql->active_result_id = Z_LVAL_P(return_value);
+		mysql->active_result_res = Z_RES_P(return_value);
+		Z_ADDREF_P(return_value);
 	}
 }
 /* }}} */
@@ -1538,18 +1560,21 @@ static void php_mysql_do_query(INTERNAL_FUNCTION_PARAMETERS, int use_store)
 	char *query;
 	int query_len;
 	zval *mysql_link = NULL;
-	int id = -1;
+	php_mysql_conn *mysql;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &query, &query_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	php_mysql_do_query_general(query, query_len, mysql_link, id, NULL, use_store, return_value TSRMLS_CC);
+	php_mysql_do_query_general(mysql, query, query_len, NULL, use_store, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -1561,7 +1586,6 @@ PHP_FUNCTION(mysql_query)
 }
 /* }}} */
 
-
 /* {{{ proto resource mysql_unbuffered_query(string query [, int link_identifier])
    Sends an SQL query to MySQL, without fetching and buffering the result rows */
 PHP_FUNCTION(mysql_unbuffered_query)
@@ -1570,75 +1594,75 @@ PHP_FUNCTION(mysql_unbuffered_query)
 }
 /* }}} */
 
-
 /* {{{ proto resource mysql_db_query(string database_name, string query [, int link_identifier])
    Sends an SQL query to MySQL */
 PHP_FUNCTION(mysql_db_query)
 {
 	char *db, *query;
 	int db_len, query_len;
+	php_mysql_conn *mysql;
 	zval *mysql_link = NULL;
-	int id = -1;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|r", &db, &db_len, &query, &query_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
 	php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "This function is deprecated; use mysql_query() instead");
 
-	php_mysql_do_query_general(query, query_len, mysql_link, id, db, MYSQL_STORE_RESULT, return_value TSRMLS_CC);
+	php_mysql_do_query_general(mysql, query, query_len, db, MYSQL_STORE_RESULT, return_value TSRMLS_CC);
 }
 /* }}} */
 
-
 /* {{{ proto resource mysql_list_dbs([int link_identifier])
    List databases available on a MySQL server */
 PHP_FUNCTION(mysql_list_dbs)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
 	MYSQL_RES *mysql_result;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
-	php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "This function is deprecated; use mysql_query() with SHOW DATABASES instead");
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
+	php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "This function is deprecated; use mysql_query() with SHOW DATABASES instead");
 
 	PHPMY_UNBUFFERED_QUERY_CHECK();
 
-
-	if ((mysql_result=mysql_list_dbs(mysql->conn, NULL))==NULL) {
+	if ((mysql_result = mysql_list_dbs(mysql->conn, NULL))==NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to save MySQL query result");
 		RETURN_FALSE;
 	}
+
 	MySG(result_allocated)++;
 	ZEND_REGISTER_RESOURCE(return_value, mysql_result, le_result);
 }
 /* }}} */
 
-
 /* {{{ proto resource mysql_list_tables(string database_name [, int link_identifier])
    List tables in a MySQL database */
 PHP_FUNCTION(mysql_list_tables)
 {
 	char *db;
 	int db_len;
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 	MYSQL_RES *mysql_result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &db, &db_len, &mysql_link) == FAILURE) {
@@ -1646,19 +1670,20 @@ PHP_FUNCTION(mysql_list_tables)
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	if (!php_mysql_select_db(mysql, db TSRMLS_CC)) {
 		RETURN_FALSE;
 	}
 
 	PHPMY_UNBUFFERED_QUERY_CHECK();
 
-	if ((mysql_result=mysql_list_tables(mysql->conn, NULL))==NULL) {
+	if ((mysql_result = mysql_list_tables(mysql->conn, NULL))==NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to save MySQL query result");
 		RETURN_FALSE;
 	}
@@ -1667,7 +1692,6 @@ PHP_FUNCTION(mysql_list_tables)
 }
 /* }}} */
 
-
 /* {{{ proto resource mysql_list_fields(string database_name, string table_name [, int link_identifier])
    List MySQL result fields */
 PHP_FUNCTION(mysql_list_fields)
@@ -1675,7 +1699,6 @@ PHP_FUNCTION(mysql_list_fields)
 	char *db, *table;
 	int db_len, table_len;
 	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
 	MYSQL_RES *mysql_result;
 
@@ -1684,12 +1707,13 @@ PHP_FUNCTION(mysql_list_fields)
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	if (!php_mysql_select_db(mysql, db TSRMLS_CC)) {
 		RETURN_FALSE;
 	}
@@ -1709,22 +1733,22 @@ PHP_FUNCTION(mysql_list_fields)
 	Returns a result set describing the current server threads */
 PHP_FUNCTION(mysql_list_processes)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 	MYSQL_RES *mysql_result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_NUM_ARGS() == 0) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	PHPMY_UNBUFFERED_QUERY_CHECK();
 
 	mysql_result = mysql_list_processes(mysql->conn);
@@ -1738,101 +1762,95 @@ PHP_FUNCTION(mysql_list_processes)
 }
 /* }}} */
 
-
 /* {{{ proto string mysql_error([int link_identifier])
    Returns the text of the error message from previous MySQL operation */
 PHP_FUNCTION(mysql_error)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = MySG(default_link);
-		if (id==-1) {
-			if (MySG(connect_error)!=NULL){
-				RETURN_STRING(MySG(connect_error),1);
+		if (MySG(default_link) == NULL) {
+			if (MySG(connect_error) != NULL){
+				RETURN_STRING(MySG(connect_error));
 			} else {
 				RETURN_FALSE;
 			}
 		}
+		mysql = (php_mysql_conn*)MySG(default_link)->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
-	RETURN_STRING((char *)mysql_error(mysql->conn), 1);
+	RETURN_STRING((char *)mysql_error(mysql->conn));
 }
 /* }}} */
 
-
 /* {{{ proto int mysql_errno([int link_identifier])
    Returns the number of the error message from previous MySQL operation */
 #ifdef HAVE_MYSQL_ERRNO
 PHP_FUNCTION(mysql_errno)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = MySG(default_link);
-		if (id==-1) {
-		  	if (MySG(connect_errno)!=0){
+		if (MySG(default_link) == NULL) {
+			if (MySG(connect_error) != NULL){
 				RETURN_LONG(MySG(connect_errno));
 			} else {
 				RETURN_FALSE;
 			}
 		}
+		mysql = (php_mysql_conn*)MySG(default_link)->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	RETURN_LONG(mysql_errno(mysql->conn));
 }
 #endif
 /* }}} */
 
-
 /* {{{ proto int mysql_affected_rows([int link_identifier])
    Gets number of affected rows in previous MySQL operation */
 PHP_FUNCTION(mysql_affected_rows)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	/* conversion from int64 to long happing here */
-	Z_LVAL_P(return_value) = (long) mysql_affected_rows(mysql->conn);
-	Z_TYPE_P(return_value) = IS_LONG;
+	RETURN_LONG((long)mysql_affected_rows(mysql->conn));
 }
 /* }}} */
 
-
 /* {{{ proto string mysql_escape_string(string to_be_escaped)
    Escape string for mysql query */
 PHP_FUNCTION(mysql_escape_string)
 {
 	char *str;
 	int str_len;
+	zend_string *escaped_str;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
 		return;
@@ -1842,12 +1860,11 @@ PHP_FUNCTION(mysql_escape_string)
 	 * we don't realloc() down to the real size since it'd most probably not
 	 * be worth it
 	 */
-
-	Z_STRVAL_P(return_value) = (char *) safe_emalloc(str_len, 2, 1);
-	Z_STRLEN_P(return_value) = mysql_escape_string(Z_STRVAL_P(return_value), str, str_len);
-	Z_TYPE_P(return_value) = IS_STRING;
+	escaped_str = STR_ALLOC(str_len * 2, 0);
+	escaped_str->len = mysql_escape_string(escaped_str->val, str, str_len);
 
 	php_error_docref("function.mysql-real-escape-string" TSRMLS_CC, E_DEPRECATED, "This function is deprecated; use mysql_real_escape_string() instead.");
+	RETURN_STR(escaped_str);
 }
 /* }}} */
 
@@ -1855,29 +1872,32 @@ PHP_FUNCTION(mysql_escape_string)
 	Escape special characters in a string for use in a SQL statement, taking into account the current charset of the connection */
 PHP_FUNCTION(mysql_real_escape_string)
 {
-	zval *mysql_link = NULL;
 	char *str;
-	char *new_str;
-	int id = -1, str_len, new_str_len;
+	int str_len;
+	zend_string *new_str;
 	php_mysql_conn *mysql;
-
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|r", &str, &str_len, &mysql_link) == FAILURE) {
 		return;
 	}
 
-	if (ZEND_NUM_ARGS() == 1) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
-	new_str = safe_emalloc(str_len, 2, 1);
-	new_str_len = mysql_real_escape_string(mysql->conn, new_str, str, str_len);
-	new_str = erealloc(new_str, new_str_len + 1);
+	/* assume worst case situation, which is 2x of the original string.
+	 * we don't realloc() down to the real size since it'd most probably not
+	 * be worth it
+	 */
+	new_str = STR_ALLOC(str_len * 2, 0);
+	new_str->len = mysql_real_escape_string(mysql->conn, new_str->val, str, str_len);
 
-	RETURN_STRINGL(new_str, new_str_len, 0);
+	RETURN_NEW_STR(new_str);
 }
 /* }}} */
 
@@ -1885,28 +1905,26 @@ PHP_FUNCTION(mysql_real_escape_string)
    Gets the ID generated from the previous INSERT operation */
 PHP_FUNCTION(mysql_insert_id)
 {
-	zval *mysql_link = NULL;
-	int id = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link) == FAILURE) {
 		return;
 	}
 
 	if (!mysql_link) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
-
 	/* conversion from int64 to long happing here */
-	Z_LVAL_P(return_value) = (long) mysql_insert_id(mysql->conn);
-	Z_TYPE_P(return_value) = IS_LONG;
+	RETURN_LONG((long)mysql_insert_id(mysql->conn));
 }
 /* }}} */
 
-
 /* {{{ proto mixed mysql_result(resource result, int row [, mixed field])
    Gets result data */
 PHP_FUNCTION(mysql_result)
@@ -1929,30 +1947,30 @@ Q: String or long first?
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
-	if (row<0 || row>=(int)mysql_num_rows(mysql_result)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to jump to row %ld on MySQL result index %ld", row, Z_LVAL_P(result));
+	if (row < 0 || row >= (int)mysql_num_rows(mysql_result)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to jump to row %ld on MySQL result index %ld", row, Z_RES_P(result)->handle);
 		RETURN_FALSE;
 	}
 	mysql_data_seek(mysql_result, row);
 
 	if (field) {
-		switch(Z_TYPE_P(field)) {
+		switch (Z_TYPE_P(field)) {
 			case IS_STRING: {
-					int i=0;
+					int i = 0;
 					const MYSQL_FIELD *tmp_field;
 					char *table_name, *field_name, *tmp;
 
-					if ((tmp=strchr(Z_STRVAL_P(field), '.'))) {
+					if ((tmp = strchr(Z_STRVAL_P(field), '.'))) {
 						table_name = estrndup(Z_STRVAL_P(field), tmp-Z_STRVAL_P(field));
-						field_name = estrdup(tmp+1);
+						field_name = estrdup(tmp + 1);
 					} else {
 						table_name = NULL;
 						field_name = estrndup(Z_STRVAL_P(field),Z_STRLEN_P(field));
 					}
 					mysql_field_seek(mysql_result, 0);
-					while ((tmp_field=mysql_fetch_field(mysql_result))) {
+					while ((tmp_field = mysql_fetch_field(mysql_result))) {
 						if ((!table_name || !strcasecmp(tmp_field->table, table_name)) && !strcasecmp(tmp_field->name, field_name)) {
 							field_offset = i;
 							break;
@@ -1961,7 +1979,7 @@ Q: String or long first?
 					}
 					if (!tmp_field) { /* no match found */
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s%s%s not found in MySQL result index %ld",
-									(table_name?table_name:""), (table_name?".":""), field_name, Z_LVAL_P(result));
+									(table_name?table_name:""), (table_name?".":""), field_name, Z_RES_P(result)->handle);
 						efree(field_name);
 						if (table_name) {
 							efree(table_name);
@@ -1975,9 +1993,9 @@ Q: String or long first?
 				}
 				break;
 			default:
-				convert_to_long_ex(&field);
+				convert_to_long_ex(field);
 				field_offset = Z_LVAL_P(field);
-				if (field_offset<0 || field_offset>=(int)mysql_num_fields(mysql_result)) {
+				if (field_offset < 0 || field_offset >= (int)mysql_num_fields(mysql_result)) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad column offset specified");
 					RETURN_FALSE;
 				}
@@ -1986,25 +2004,22 @@ Q: String or long first?
 	}
 
 #ifndef MYSQL_USE_MYSQLND
-	if ((sql_row=mysql_fetch_row(mysql_result))==NULL
-		|| (sql_row_lengths=mysql_fetch_lengths(mysql_result))==NULL) { /* shouldn't happen? */
+	if ((sql_row = mysql_fetch_row(mysql_result)) == NULL
+		|| (sql_row_lengths=mysql_fetch_lengths(mysql_result)) == NULL) { /* shouldn't happen? */
 		RETURN_FALSE;
 	}
 	if (sql_row[field_offset]) {
-		Z_TYPE_P(return_value) = IS_STRING;
-
 #if PHP_API_VERSION < 20100412
 		if (PG(magic_quotes_runtime)) {
-			Z_STRVAL_P(return_value) = php_addslashes(sql_row[field_offset], sql_row_lengths[field_offset],&Z_STRLEN_P(return_value), 0 TSRMLS_CC);
+			RETVAL_STR(php_addslashes(sql_row[field_offset], sql_row_lengths[field_offset], 0 TSRMLS_CC));
 		} else {
 #endif
-			Z_STRLEN_P(return_value) = sql_row_lengths[field_offset];
-			Z_STRVAL_P(return_value) = (char *) safe_estrndup(sql_row[field_offset], Z_STRLEN_P(return_value));
+			RETVAL_STRINGL(sql_row[field_offset], sql_row_lengths[field_offset]);
 #if PHP_API_VERSION < 20100412
 		}
 #endif
 	} else {
-		Z_TYPE_P(return_value) = IS_NULL;
+		RETURN_NULL();
 	}
 #else
 	mysqlnd_result_fetch_field_data(mysql_result, field_offset, return_value);
@@ -2012,7 +2027,6 @@ Q: String or long first?
 }
 /* }}} */
 
-
 /* {{{ proto int mysql_num_rows(resource result)
    Gets number of rows in a result */
 PHP_FUNCTION(mysql_num_rows)
@@ -2024,11 +2038,10 @@ PHP_FUNCTION(mysql_num_rows)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
 	/* conversion from int64 to long happing here */
-	Z_LVAL_P(return_value) = (long) mysql_num_rows(mysql_result);
-	Z_TYPE_P(return_value) = IS_LONG;
+	RETURN_LONG((long) mysql_num_rows(mysql_result));
 }
 /* }}} */
 
@@ -2043,10 +2056,9 @@ PHP_FUNCTION(mysql_num_fields)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
-	Z_LVAL_P(return_value) = mysql_num_fields(mysql_result);
-	Z_TYPE_P(return_value) = IS_LONG;
+	RETURN_LONG(mysql_num_fields(mysql_result));
 }
 /* }}} */
 
@@ -2055,7 +2067,7 @@ PHP_FUNCTION(mysql_num_fields)
 static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type, int expected_args, int into_object)
 {
 	MYSQL_RES *mysql_result;
-	zval            *res, *ctor_params = NULL;
+	zval *res, *ctor_params = NULL;
 	zend_class_entry *ce = NULL;
 #ifndef MYSQL_USE_MYSQLND
 	int i;
@@ -2066,20 +2078,19 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 
 #ifdef ZEND_ENGINE_2
 	if (into_object) {
-		char *class_name = NULL;
-		int class_name_len = 0;
+		zend_string *class_name = NULL;
 
-		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|sz", &res, &class_name, &class_name_len, &ctor_params) == FAILURE) {
+		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|Sz", &res, &class_name, &ctor_params) == FAILURE) {
 			return;
 		}
 
 		if (ZEND_NUM_ARGS() < 2) {
 			ce = zend_standard_class_def;
 		} else {
-			ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
+			ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
 		}
 		if (!ce) {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not find class '%s'", class_name);
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not find class '%s'", class_name->val);
 			return;
 		}
 		result_type = MYSQL_ASSOC;
@@ -2100,7 +2111,7 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 		result_type = MYSQL_BOTH;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &res, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, res, -1, "MySQL result", le_result);
 
 #ifndef MYSQL_USE_MYSQLND
 	if ((mysql_row = mysql_fetch_row(mysql_result)) == NULL  ||
@@ -2116,29 +2127,26 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 		 mysql_field = mysql_fetch_field(mysql_result), i++)
 	{
 		if (mysql_row[i]) {
-			zval *data;
-
-			MAKE_STD_ZVAL(data);
+			zval data;
 
 #if PHP_API_VERSION < 20100412
 			if (PG(magic_quotes_runtime)) {
-				Z_TYPE_P(data) = IS_STRING;
-				Z_STRVAL_P(data) = php_addslashes(mysql_row[i], mysql_row_lengths[i], &Z_STRLEN_P(data), 0 TSRMLS_CC);
+				ZVAL_STR(&data, php_addslashes(mysql_row[i], mysql_row_lengths[i], 0 TSRMLS_CC));
 			} else {
 #endif
-				ZVAL_STRINGL(data, mysql_row[i], mysql_row_lengths[i], 1);
+				ZVAL_STRINGL(&data, mysql_row[i], mysql_row_lengths[i]);
 #if PHP_API_VERSION < 20100412
 			}
 #endif
 
 			if (result_type & MYSQL_NUM) {
-				add_index_zval(return_value, i, data);
+				add_index_zval(return_value, i, &data);
 			}
 			if (result_type & MYSQL_ASSOC) {
 				if (result_type & MYSQL_NUM) {
-					Z_ADDREF_P(data);
+					Z_ADDREF_P(&data);
 				}
-				add_assoc_zval(return_value, mysql_field->name, data);
+				add_assoc_zval(return_value, mysql_field->name, &data);
 			}
 		} else {
 			/* NULL value. */
@@ -2158,21 +2166,23 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 #ifdef ZEND_ENGINE_2
 	/* mysqlnd might return FALSE if no more rows */
 	if (into_object && Z_TYPE_P(return_value) != IS_BOOL) {
-		zval dataset = *return_value;
+		zval dataset;
 		zend_fcall_info fci;
 		zend_fcall_info_cache fcc;
-		zval *retval_ptr;
+		zval retval;
 
+		ZVAL_COPY_VALUE(&dataset, return_value);
 		object_and_properties_init(return_value, ce, NULL);
-		zend_merge_properties(return_value, Z_ARRVAL(dataset), 1 TSRMLS_CC);
+		zend_merge_properties(return_value, Z_ARRVAL(dataset), 0 TSRMLS_CC);
+		zval_dtor(&dataset);
 
 		if (ce->constructor) {
 			fci.size = sizeof(fci);
 			fci.function_table = &ce->function_table;
-			fci.function_name = NULL;
+			ZVAL_UNDEF(&fci.function_name);
 			fci.symbol_table = NULL;
-			fci.object_ptr = return_value;
-			fci.retval_ptr_ptr = &retval_ptr;
+			fci.object = Z_OBJ_P(return_value);
+			fci.retval = &retval;
 			fci.params = NULL;
 			fci.param_count = 0;
 			fci.no_separation = 1;
@@ -2194,20 +2204,20 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 			fcc.function_handler = ce->constructor;
 			fcc.calling_scope = EG(scope);
 			fcc.called_scope = Z_OBJCE_P(return_value);
-			fcc.object_ptr = return_value;
+			fcc.object = Z_OBJ_P(return_value);
 
 			if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
-				zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Could not execute %s::%s()", ce->name, ce->constructor->common.function_name);
+				zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Could not execute %s::%s()", ce->name->val, ce->constructor->common.function_name->val);
 			} else {
-				if (retval_ptr) {
-					zval_ptr_dtor(&retval_ptr);
+				if (!ZVAL_IS_UNDEF(&retval)) {
+					zval_ptr_dtor(&retval);
 				}
 			}
 			if (fci.params) {
 				efree(fci.params);
 			}
 		} else if (ctor_params) {
-			zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Class %s does not have a constructor hence you cannot use ctor_params", ce->name);
+			zend_throw_exception_ex(zend_exception_get_default(TSRMLS_C), 0 TSRMLS_CC, "Class %s does not have a constructor hence you cannot use ctor_params", ce->name->val);
 		}
 	}
 #endif
@@ -2223,7 +2233,6 @@ PHP_FUNCTION(mysql_fetch_row)
 }
 /* }}} */
 
-
 /* {{{ proto object mysql_fetch_object(resource result [, string class_name [, NULL|array ctor_params]])
    Fetch a result row as an object */
 PHP_FUNCTION(mysql_fetch_object)
@@ -2236,7 +2245,6 @@ PHP_FUNCTION(mysql_fetch_object)
 }
 /* }}} */
 
-
 /* {{{ proto array mysql_fetch_array(resource result [, int result_type])
    Fetch a result row as an array (associative, numeric or both) */
 PHP_FUNCTION(mysql_fetch_array)
@@ -2245,7 +2253,6 @@ PHP_FUNCTION(mysql_fetch_array)
 }
 /* }}} */
 
-
 /* {{{ proto array mysql_fetch_assoc(resource result)
    Fetch a result row as an associative array */
 PHP_FUNCTION(mysql_fetch_assoc)
@@ -2266,10 +2273,10 @@ PHP_FUNCTION(mysql_data_seek)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
-	if (offset<0 || offset>=(int)mysql_num_rows(mysql_result)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset %ld is invalid for MySQL result index %ld (or the query data is unbuffered)", offset, Z_LVAL_P(result));
+	if (offset < 0 || offset >= (int)mysql_num_rows(mysql_result)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Offset %ld is invalid for MySQL result index %ld (or the query data is unbuffered)", offset, Z_RES_P(result)->handle);
 		RETURN_FALSE;
 	}
 	mysql_data_seek(mysql_result, offset);
@@ -2277,7 +2284,6 @@ PHP_FUNCTION(mysql_data_seek)
 }
 /* }}} */
 
-
 /* {{{ proto array mysql_fetch_lengths(resource result)
    Gets max data size of each column in a result */
 PHP_FUNCTION(mysql_fetch_lengths)
@@ -2292,7 +2298,7 @@ PHP_FUNCTION(mysql_fetch_lengths)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
 	if ((lengths=mysql_fetch_lengths(mysql_result))==NULL) {
 		RETURN_FALSE;
@@ -2395,37 +2401,36 @@ PHP_FUNCTION(mysql_fetch_field)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
 	if (ZEND_NUM_ARGS() > 1) {
-		if (field<0 || field>=(int)mysql_num_fields(mysql_result)) {
+		if (field<0 || field >= (int)mysql_num_fields(mysql_result)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Bad field offset");
 			RETURN_FALSE;
 		}
 		mysql_field_seek(mysql_result, field);
 	}
-	if ((mysql_field=mysql_fetch_field(mysql_result))==NULL) {
+	if ((mysql_field = mysql_fetch_field(mysql_result)) == NULL) {
 		RETURN_FALSE;
 	}
 	object_init(return_value);
 
-	add_property_string(return_value, "name",(mysql_field->name?mysql_field->name:""), 1);
-	add_property_string(return_value, "table",(mysql_field->table?mysql_field->table:""), 1);
-	add_property_string(return_value, "def",(mysql_field->def?mysql_field->def:""), 1);
+	add_property_string(return_value, "name", (mysql_field->name?mysql_field->name:""));
+	add_property_string(return_value, "table", (mysql_field->table?mysql_field->table:""));
+	add_property_string(return_value, "def", (mysql_field->def?mysql_field->def:""));
 	add_property_long(return_value, "max_length", mysql_field->max_length);
 	add_property_long(return_value, "not_null", IS_NOT_NULL(mysql_field->flags)?1:0);
 	add_property_long(return_value, "primary_key", IS_PRI_KEY(mysql_field->flags)?1:0);
-	add_property_long(return_value, "multiple_key",(mysql_field->flags&MULTIPLE_KEY_FLAG?1:0));
-	add_property_long(return_value, "unique_key",(mysql_field->flags&UNIQUE_KEY_FLAG?1:0));
-	add_property_long(return_value, "numeric", IS_NUM(Z_TYPE_P(mysql_field))?1:0);
+	add_property_long(return_value, "multiple_key", (mysql_field->flags&MULTIPLE_KEY_FLAG?1:0));
+	add_property_long(return_value, "unique_key", (mysql_field->flags&UNIQUE_KEY_FLAG?1:0));
+	add_property_long(return_value, "numeric", IS_NUM(mysql_field->type)?1:0);
 	add_property_long(return_value, "blob", IS_BLOB(mysql_field->flags)?1:0);
-	add_property_string(return_value, "type", php_mysql_get_field_name(Z_TYPE_P(mysql_field)), 1);
-	add_property_long(return_value, "unsigned",(mysql_field->flags&UNSIGNED_FLAG?1:0));
-	add_property_long(return_value, "zerofill",(mysql_field->flags&ZEROFILL_FLAG?1:0));
+	add_property_string(return_value, "type", php_mysql_get_field_name(mysql_field->type));
+	add_property_long(return_value, "unsigned", (mysql_field->flags&UNSIGNED_FLAG?1:0));
+	add_property_long(return_value, "zerofill", (mysql_field->flags&ZEROFILL_FLAG?1:0));
 }
 /* }}} */
 
-
 /* {{{ proto bool mysql_field_seek(resource result, int field_offset)
    Sets result pointer to a specific field offset */
 PHP_FUNCTION(mysql_field_seek)
@@ -2437,10 +2442,10 @@ PHP_FUNCTION(mysql_field_seek)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl", &result, &offset) == FAILURE) {
 		return;
 	}
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
-	if (offset<0 || offset>=(int)mysql_num_fields(mysql_result)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field %ld is invalid for MySQL result index %ld", offset, Z_LVAL_P(result));
+	if (offset < 0 || offset >= (int)mysql_num_fields(mysql_result)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field %ld is invalid for MySQL result index %ld", offset, Z_RES_P(result)->handle);
 		RETURN_FALSE;
 	}
 	mysql_field_seek(mysql_result, offset);
@@ -2448,7 +2453,6 @@ PHP_FUNCTION(mysql_field_seek)
 }
 /* }}} */
 
-
 #define PHP_MYSQL_FIELD_NAME 1
 #define PHP_MYSQL_FIELD_TABLE 2
 #define PHP_MYSQL_FIELD_LEN 3
@@ -2470,10 +2474,10 @@ static void php_mysql_field_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
-	if (field<0 || field>=(int)mysql_num_fields(mysql_result)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field %ld is invalid for MySQL result index %ld", field, Z_LVAL_P(result));
+	if (field < 0 || field >= (int)mysql_num_fields(mysql_result)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Field %ld is invalid for MySQL result index %ld", field, Z_RES_P(result)->handle);
 		RETURN_FALSE;
 	}
 	mysql_field_seek(mysql_result, field);
@@ -2483,24 +2487,16 @@ static void php_mysql_field_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
 
 	switch (entry_type) {
 		case PHP_MYSQL_FIELD_NAME:
-			Z_STRLEN_P(return_value) = strlen(mysql_field->name);
-			Z_STRVAL_P(return_value) = estrndup(mysql_field->name, Z_STRLEN_P(return_value));
-			Z_TYPE_P(return_value) = IS_STRING;
+			RETVAL_STRING(mysql_field->name);
 			break;
 		case PHP_MYSQL_FIELD_TABLE:
-			Z_STRLEN_P(return_value) = strlen(mysql_field->table);
-			Z_STRVAL_P(return_value) = estrndup(mysql_field->table, Z_STRLEN_P(return_value));
-			Z_TYPE_P(return_value) = IS_STRING;
+			RETVAL_STRING(mysql_field->table);
 			break;
 		case PHP_MYSQL_FIELD_LEN:
-			Z_LVAL_P(return_value) = mysql_field->length;
-			Z_TYPE_P(return_value) = IS_LONG;
+			RETVAL_LONG(mysql_field->length);
 			break;
 		case PHP_MYSQL_FIELD_TYPE:
-			Z_STRVAL_P(return_value) = php_mysql_get_field_name(Z_TYPE_P(mysql_field));
-			Z_STRLEN_P(return_value) = strlen(Z_STRVAL_P(return_value));
-			Z_STRVAL_P(return_value) = estrndup(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value));
-			Z_TYPE_P(return_value) = IS_STRING;
+			RETVAL_STRING(php_mysql_get_field_name(mysql_field->type));
 			break;
 		case PHP_MYSQL_FIELD_FLAGS:
 			memcpy(buf, "", sizeof(""));
@@ -2571,9 +2567,7 @@ static void php_mysql_field_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type)
 				len--;
 			}
 
-	   		Z_STRLEN_P(return_value) = len;
-   			Z_STRVAL_P(return_value) = estrndup(buf, len);
-   			Z_TYPE_P(return_value) = IS_STRING;
+			RETVAL_STRINGL(buf, len);
 			break;
 
 		default:
@@ -2590,7 +2584,6 @@ PHP_FUNCTION(mysql_field_name)
 }
 /* }}} */
 
-
 /* {{{ proto string mysql_field_table(resource result, int field_offset)
    Gets name of the table the specified field is in */
 PHP_FUNCTION(mysql_field_table)
@@ -2599,7 +2592,6 @@ PHP_FUNCTION(mysql_field_table)
 }
 /* }}} */
 
-
 /* {{{ proto int mysql_field_len(resource result, int field_offset)
    Returns the length of the specified field */
 PHP_FUNCTION(mysql_field_len)
@@ -2608,7 +2600,6 @@ PHP_FUNCTION(mysql_field_len)
 }
 /* }}} */
 
-
 /* {{{ proto string mysql_field_type(resource result, int field_offset)
    Gets the type of the specified field in a result */
 PHP_FUNCTION(mysql_field_type)
@@ -2617,7 +2608,6 @@ PHP_FUNCTION(mysql_field_type)
 }
 /* }}} */
 
-
 /* {{{ proto string mysql_field_flags(resource result, int field_offset)
    Gets the flags associated with the specified field in a result */
 PHP_FUNCTION(mysql_field_flags)
@@ -2626,7 +2616,6 @@ PHP_FUNCTION(mysql_field_flags)
 }
 /* }}} */
 
-
 /* {{{ proto bool mysql_free_result(resource result)
    Free result memory */
 PHP_FUNCTION(mysql_free_result)
@@ -2638,13 +2627,9 @@ PHP_FUNCTION(mysql_free_result)
 		return;
 	}
 
-	if (Z_LVAL_P(result)==0) {
-		RETURN_FALSE;
-	}
-
-	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, &result, -1, "MySQL result", le_result);
+	ZEND_FETCH_RESOURCE(mysql_result, MYSQL_RES *, result, -1, "MySQL result", le_result);
 
-	zend_list_delete(Z_LVAL_P(result));
+	zend_list_close(Z_RES_P(result));
 	RETURN_TRUE;
 }
 /* }}} */
@@ -2653,22 +2638,24 @@ PHP_FUNCTION(mysql_free_result)
    Ping a server connection. If no connection then reconnect. */
 PHP_FUNCTION(mysql_ping)
 {
-	zval           *mysql_link = NULL;
-	int             id         = -1;
 	php_mysql_conn *mysql;
+	zval *mysql_link = NULL;
 
-	if (0 == ZEND_NUM_ARGS()) {
-		id = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
-		CHECK_LINK(id);
-	} else if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &mysql_link)==FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|r", &mysql_link)==FAILURE) {
 		return;
 	}
 
-	ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, &mysql_link, id, "MySQL-Link", le_link, le_plink);
+	if (!mysql_link) {
+		zend_resource *res = php_mysql_get_default_link(INTERNAL_FUNCTION_PARAM_PASSTHRU);
+		CHECK_LINK(res);
+		mysql = (php_mysql_conn*)res->ptr;
+	} else {
+		ZEND_FETCH_RESOURCE2(mysql, php_mysql_conn *, mysql_link, -1, "MySQL-Link", le_link, le_plink);
+	}
 
 	PHPMY_UNBUFFERED_QUERY_CHECK();
 
-	RETURN_BOOL(! mysql_ping(mysql->conn));
+	RETURN_BOOL(!mysql_ping(mysql->conn));
 }
 /* }}} */
 
diff --git a/ext/mysql/php_mysql_structs.h b/ext/mysql/php_mysql_structs.h
index ee1286d989..0e8ab482a1 100644
--- a/ext/mysql/php_mysql_structs.h
+++ b/ext/mysql/php_mysql_structs.h
@@ -111,7 +111,7 @@ PHP_FUNCTION(mysql_set_charset);
 #endif
 
 ZEND_BEGIN_MODULE_GLOBALS(mysql)
-	long default_link;
+	zend_resource *default_link;
 	long num_links,num_persistent;
 	long max_links,max_persistent;
 	long allow_persistent;
diff --git a/ext/mysql/tests/bug55473.phpt b/ext/mysql/tests/bug55473.phpt
index 98fd0091dc..7d149dc6fd 100644
--- a/ext/mysql/tests/bug55473.phpt
+++ b/ext/mysql/tests/bug55473.phpt
@@ -8,6 +8,9 @@ if (defined('PHP_WINDOWS_VERSION_MAJOR')) {
 	die("skip Test doesn't work on Windows");
 }
 
+if (!$IS_MYSQLND)
+    die("skip mysqlnd only, libmysql does not warning about server gone away");
+
 if (!($output = @exec("lsof -np " . getmypid())))
 	die("skip Test can't find command line tool lsof");
 ?>
diff --git a/ext/mysql/tests/mysql_data_seek.phpt b/ext/mysql/tests/mysql_data_seek.phpt
index 72d3e63274..268e145842 100644
--- a/ext/mysql/tests/mysql_data_seek.phpt
+++ b/ext/mysql/tests/mysql_data_seek.phpt
@@ -75,5 +75,5 @@ Warning: mysql_data_seek(): Offset -1 is invalid for MySQL result index %d (or t
 
 Warning: mysql_data_seek(): Offset 3 is invalid for MySQL result index %d (or the query data is unbuffered) in %s on line %d
 
-Warning: mysql_data_seek(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_data_seek(): supplied resource is not a valid MySQL result resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_db_name.phpt b/ext/mysql/tests/mysql_db_name.phpt
index 92878e994d..9321701337 100644
--- a/ext/mysql/tests/mysql_db_name.phpt
+++ b/ext/mysql/tests/mysql_db_name.phpt
@@ -64,5 +64,5 @@ Warning: mysql_db_name(): Unable to jump to row -1 on MySQL result index %d in %
 
 Warning: mysql_db_name(): Unable to jump to row %d on MySQL result index %d in %s on line %d
 
-Warning: mysql_db_name(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_db_name(): supplied resource is not a valid MySQL result resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_errno.phpt b/ext/mysql/tests/mysql_errno.phpt
index c9c2956290..83aa7327bd 100644
--- a/ext/mysql/tests/mysql_errno.phpt
+++ b/ext/mysql/tests/mysql_errno.phpt
@@ -59,6 +59,6 @@ Deprecated: mysql_connect(): The mysql extension is deprecated and will be remov
 int(0)
 int(%d)
 
-Warning: mysql_errno(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_errno(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_error.phpt b/ext/mysql/tests/mysql_error.phpt
index a2cf7e0034..82a43fb7b4 100644
--- a/ext/mysql/tests/mysql_error.phpt
+++ b/ext/mysql/tests/mysql_error.phpt
@@ -64,6 +64,6 @@ require_once("clean_table.inc");
 --EXPECTF--
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 
-Warning: mysql_error(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_error(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_fetch_array.phpt b/ext/mysql/tests/mysql_fetch_array.phpt
index 8ccefd0242..1b1852d932 100644
--- a/ext/mysql/tests/mysql_fetch_array.phpt
+++ b/ext/mysql/tests/mysql_fetch_array.phpt
@@ -357,5 +357,5 @@ array(11) {
 
 Warning: mysql_fetch_array(): The result type should be either MYSQL_NUM, MYSQL_ASSOC or MYSQL_BOTH in %s on line %d
 
-Warning: mysql_fetch_array(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_fetch_array(): supplied resource is not a valid MySQL result resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_fetch_assoc.phpt b/ext/mysql/tests/mysql_fetch_assoc.phpt
index 048613a6be..936c7c6f23 100644
--- a/ext/mysql/tests/mysql_fetch_assoc.phpt
+++ b/ext/mysql/tests/mysql_fetch_assoc.phpt
@@ -87,7 +87,7 @@ array(5) {
   %unicode|string%(1) "1"
 }
 
-Warning: mysql_fetch_assoc(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_fetch_assoc(): supplied resource is not a valid MySQL result resource in %s on line %d
 
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 [010]
diff --git a/ext/mysql/tests/mysql_fetch_field.phpt b/ext/mysql/tests/mysql_fetch_field.phpt
index 85c1fd6f7e..6855fc52dc 100644
--- a/ext/mysql/tests/mysql_fetch_field.phpt
+++ b/ext/mysql/tests/mysql_fetch_field.phpt
@@ -217,7 +217,7 @@ bool(false)
 
 Warning: mysql_fetch_field(): Bad field offset in %s on line %d
 
-Warning: mysql_fetch_field(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_fetch_field(): supplied resource is not a valid MySQL result resource in %s on line %d
 object(stdClass)#%d (13) {
   [%u|b%"name"]=>
   %unicode|string%(2) "id"
diff --git a/ext/mysql/tests/mysql_fetch_lengths.phpt b/ext/mysql/tests/mysql_fetch_lengths.phpt
index f0fbbb7bb8..f59833e918 100644
--- a/ext/mysql/tests/mysql_fetch_lengths.phpt
+++ b/ext/mysql/tests/mysql_fetch_lengths.phpt
@@ -48,6 +48,6 @@ array(2) {
 }
 bool(false)
 
-Warning: mysql_fetch_lengths(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_fetch_lengths(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_fetch_object.phpt b/ext/mysql/tests/mysql_fetch_object.phpt
index 666d0ee821..5038863458 100644
--- a/ext/mysql/tests/mysql_fetch_object.phpt
+++ b/ext/mysql/tests/mysql_fetch_object.phpt
@@ -147,7 +147,7 @@ bool(false)
 bool(false)
 bool(false)
 
-Warning: mysql_fetch_object(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_fetch_object(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 
 Fatal error: Class 'this_class_does_not_exist' not found in %s on line %d
diff --git a/ext/mysql/tests/mysql_fetch_row.phpt b/ext/mysql/tests/mysql_fetch_row.phpt
index 0ed932e2c0..d26f7a4d82 100644
--- a/ext/mysql/tests/mysql_fetch_row.phpt
+++ b/ext/mysql/tests/mysql_fetch_row.phpt
@@ -52,6 +52,6 @@ array(2) {
 [005]
 bool(false)
 
-Warning: mysql_fetch_row(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_fetch_row(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_field_flags.phpt b/ext/mysql/tests/mysql_field_flags.phpt
index 5f8eb0995f..cd9e4b5671 100644
--- a/ext/mysql/tests/mysql_field_flags.phpt
+++ b/ext/mysql/tests/mysql_field_flags.phpt
@@ -152,6 +152,6 @@ Warning: mysql_field_flags(): Field -1 is invalid for MySQL result index %d in %
 
 Warning: mysql_field_flags(): Field 2 is invalid for MySQL result index %d in %s on line %d
 
-Warning: mysql_field_flags(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_field_flags(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_field_len.phpt b/ext/mysql/tests/mysql_field_len.phpt
index 119d352164..a7b4cabee3 100644
--- a/ext/mysql/tests/mysql_field_len.phpt
+++ b/ext/mysql/tests/mysql_field_len.phpt
@@ -55,6 +55,6 @@ Warning: mysql_field_len(): Field -1 is invalid for MySQL result index %d in %s
 
 Warning: mysql_field_len(): Field 2 is invalid for MySQL result index %d in %s on line %d
 
-Warning: mysql_field_len(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_field_len(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_field_name.phpt b/ext/mysql/tests/mysql_field_name.phpt
index 85f6c42d93..1ef613babe 100644
--- a/ext/mysql/tests/mysql_field_name.phpt
+++ b/ext/mysql/tests/mysql_field_name.phpt
@@ -55,6 +55,6 @@ Warning: mysql_field_name(): Field -1 is invalid for MySQL result index %d in %s
 
 Warning: mysql_field_name(): Field 2 is invalid for MySQL result index %d in %s on line %d
 
-Warning: mysql_field_name(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_field_name(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_field_seek.phpt b/ext/mysql/tests/mysql_field_seek.phpt
index 8487493a88..a9eab70bca 100644
--- a/ext/mysql/tests/mysql_field_seek.phpt
+++ b/ext/mysql/tests/mysql_field_seek.phpt
@@ -139,6 +139,6 @@ Warning: mysql_field_seek(): Field %d is invalid for MySQL result index %d in %s
 bool(false)
 bool(false)
 
-Warning: mysql_field_seek(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_field_seek(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_field_table.phpt b/ext/mysql/tests/mysql_field_table.phpt
index 826651a855..d95be96ee5 100644
--- a/ext/mysql/tests/mysql_field_table.phpt
+++ b/ext/mysql/tests/mysql_field_table.phpt
@@ -55,6 +55,6 @@ Warning: mysql_field_table(): Field -1 is invalid for MySQL result index %d in %
 
 Warning: mysql_field_table(): Field 2 is invalid for MySQL result index %d in %s on line %d
 
-Warning: mysql_field_table(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_field_table(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_field_type.phpt b/ext/mysql/tests/mysql_field_type.phpt
index c767cab6f1..e4b774a691 100644
--- a/ext/mysql/tests/mysql_field_type.phpt
+++ b/ext/mysql/tests/mysql_field_type.phpt
@@ -55,6 +55,6 @@ Warning: mysql_field_type(): Field -1 is invalid for MySQL result index %d in %s
 
 Warning: mysql_field_type(): Field 2 is invalid for MySQL result index %d in %s on line %d
 
-Warning: mysql_field_type(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_field_type(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_free_result.phpt b/ext/mysql/tests/mysql_free_result.phpt
index 90498bd59a..582297c80f 100644
--- a/ext/mysql/tests/mysql_free_result.phpt
+++ b/ext/mysql/tests/mysql_free_result.phpt
@@ -47,6 +47,6 @@ require_once("clean_table.inc");
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 bool(true)
 
-Warning: mysql_free_result(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_free_result(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_insert_id.phpt b/ext/mysql/tests/mysql_insert_id.phpt
index b69a96ae9b..93319dad23 100644
--- a/ext/mysql/tests/mysql_insert_id.phpt
+++ b/ext/mysql/tests/mysql_insert_id.phpt
@@ -68,6 +68,6 @@ require_once("clean_table.inc");
 --EXPECTF--
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 
-Warning: mysql_insert_id(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_insert_id(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_num_fields.phpt b/ext/mysql/tests/mysql_num_fields.phpt
index 4621dc91f8..f65f8ec165 100644
--- a/ext/mysql/tests/mysql_num_fields.phpt
+++ b/ext/mysql/tests/mysql_num_fields.phpt
@@ -54,5 +54,5 @@ require_once("clean_table.inc");
 --EXPECTF--
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 
-Warning: mysql_num_fields(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_num_fields(): supplied resource is not a valid MySQL result resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_num_rows.phpt b/ext/mysql/tests/mysql_num_rows.phpt
index 5a803d41f9..2b69e939be 100644
--- a/ext/mysql/tests/mysql_num_rows.phpt
+++ b/ext/mysql/tests/mysql_num_rows.phpt
@@ -85,5 +85,5 @@ Warning: mysql_num_rows() expects parameter 1 to be resource, boolean given in %
 
 Warning: mysql_free_result() expects parameter 1 to be resource, boolean given in %s on line %d
 
-Warning: mysql_num_rows(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_num_rows(): supplied resource is not a valid MySQL result resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_ping.phpt b/ext/mysql/tests/mysql_ping.phpt
index 0308df3396..2f2c38cd90 100644
--- a/ext/mysql/tests/mysql_ping.phpt
+++ b/ext/mysql/tests/mysql_ping.phpt
@@ -47,5 +47,5 @@ bool(true)
 bool(true)
 bool(true)
 
-Warning: mysql_ping(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_ping(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_query.phpt b/ext/mysql/tests/mysql_query.phpt
index 01b14ee284..80b985e099 100644
--- a/ext/mysql/tests/mysql_query.phpt
+++ b/ext/mysql/tests/mysql_query.phpt
@@ -124,5 +124,5 @@ array(1) {
 }
 %unicode|string%(1) "a"
 
-Warning: mysql_query(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_query(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_result.phpt b/ext/mysql/tests/mysql_result.phpt
index 0a58b9b883..ae1983fe04 100644
--- a/ext/mysql/tests/mysql_result.phpt
+++ b/ext/mysql/tests/mysql_result.phpt
@@ -111,6 +111,6 @@ bool(false)
 Warning: mysql_result(): test.label not found in MySQL result index %d in %s on line %d
 bool(false)
 
-Warning: mysql_result(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_result(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_select_db.phpt b/ext/mysql/tests/mysql_select_db.phpt
index e9bc99aa73..6e0bf9e505 100644
--- a/ext/mysql/tests/mysql_select_db.phpt
+++ b/ext/mysql/tests/mysql_select_db.phpt
@@ -70,5 +70,5 @@ Deprecated: mysql_connect(): The mysql extension is deprecated and will be remov
 %unicode|string%(%d) "%s"
 bool(false)
 
-Warning: mysql_select_db(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_select_db(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_stat.phpt b/ext/mysql/tests/mysql_stat.phpt
index d6a34df581..ef5bb45105 100644
--- a/ext/mysql/tests/mysql_stat.phpt
+++ b/ext/mysql/tests/mysql_stat.phpt
@@ -46,5 +46,5 @@ print "done!";
 --EXPECTF--
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 
-Warning: mysql_stat(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_stat(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_tablename.phpt b/ext/mysql/tests/mysql_tablename.phpt
index 4bbe54d443..76007fde46 100644
--- a/ext/mysql/tests/mysql_tablename.phpt
+++ b/ext/mysql/tests/mysql_tablename.phpt
@@ -51,6 +51,6 @@ Warning: mysql_tablename(): Unable to jump to row -1 on MySQL result index %d in
 
 Warning: mysql_tablename(): Unable to jump to row 2 on MySQL result index %d in %s on line %d
 
-Warning: mysql_tablename(): %d is not a valid MySQL result resource in %s on line %d
+Warning: mysql_tablename(): supplied resource is not a valid MySQL result resource in %s on line %d
 bool(false)
 done!
diff --git a/ext/mysql/tests/mysql_thread_id.phpt b/ext/mysql/tests/mysql_thread_id.phpt
index aa95d31944..a2e0f934c2 100644
--- a/ext/mysql/tests/mysql_thread_id.phpt
+++ b/ext/mysql/tests/mysql_thread_id.phpt
@@ -37,5 +37,5 @@ print "done!";
 --EXPECTF--
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 
-Warning: mysql_thread_id(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_thread_id(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/mysql_trace_mode.phpt b/ext/mysql/tests/mysql_trace_mode.phpt
index 7655975d70..73872de1db 100644
--- a/ext/mysql/tests/mysql_trace_mode.phpt
+++ b/ext/mysql/tests/mysql_trace_mode.phpt
@@ -31,7 +31,7 @@ require_once("clean_table.inc");
 --EXPECTF--
 Deprecated: mysql_connect(): The mysql extension is deprecated and will be removed in the future: use mysqli or PDO instead in %s on line %d
 I don\'t mind character sets, do I?\n
-Warning: mysql_query(): You have an error in your SQL syntax; check the manual that corresponds to your MySQL server version for the right syntax to use near 'BOGUS_SQL' at line 1 in %s on line %d
+Warning: mysql_query(): You have an error in your SQL syntax; check the manual that corresponds to your %s server version for the right syntax to use near 'BOGUS_SQL' at line 1 in %s on line %d
 done!
 
 Warning: Unknown: 1 result set(s) not freed. Use mysql_free_result to free result sets which were requested using mysql_query() in %s on line %d
diff --git a/ext/mysql/tests/mysql_unbuffered_query.phpt b/ext/mysql/tests/mysql_unbuffered_query.phpt
index 8754b58b59..5b10cc41d9 100644
--- a/ext/mysql/tests/mysql_unbuffered_query.phpt
+++ b/ext/mysql/tests/mysql_unbuffered_query.phpt
@@ -118,5 +118,5 @@ int(0)
 
 Notice: mysql_close(): Function called without first fetching all rows from a previous unbuffered query in %s on line %d
 
-Warning: mysql_unbuffered_query(): %d is not a valid MySQL-Link resource in %s on line %d
+Warning: mysql_unbuffered_query(): supplied resource is not a valid MySQL-Link resource in %s on line %d
 done!
diff --git a/ext/mysql/tests/setupdefault.inc b/ext/mysql/tests/setupdefault.inc
index 6d25c20840..b13402ec14 100644
--- a/ext/mysql/tests/setupdefault.inc
+++ b/ext/mysql/tests/setupdefault.inc
@@ -3,7 +3,7 @@
 // copy variables from connect.inc into mysql default connection ini settings, so that implicit mysql_connect() behaviour can be tested where needed
 // must be loaded AFTER connect.inc
 
-ini_set('mysql.default_host',		$host);
+ini_set('mysql.default_host',		$host . ":" . $port);
 ini_set('mysql.default_user',		$user);
 ini_set('mysql.default_password',	$passwd);
 
diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c
index b23d7e3139..c3162f6f8f 100644
--- a/ext/mysqli/mysqli.c
+++ b/ext/mysqli/mysqli.c
@@ -639,9 +639,9 @@ PHP_MINIT_FUNCTION(mysqli)
 
 	INIT_CLASS_ENTRY(cex, "mysqli_sql_exception", mysqli_exception_methods);
 #ifdef HAVE_SPL
-	mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException, NULL TSRMLS_CC);
+	mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException TSRMLS_CC);
 #else
-	mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
+	mysqli_exception_class_entry = zend_register_internal_class_ex(&cex, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
 #endif
 	mysqli_exception_class_entry->ce_flags |= ZEND_ACC_FINAL;
 	zend_declare_property_long(mysqli_exception_class_entry, "code", sizeof("code")-1, 0, ZEND_ACC_PROTECTED TSRMLS_CC);
diff --git a/ext/mysqli/mysqli_api.c b/ext/mysqli/mysqli_api.c
index 309d9b9f06..766eeda59b 100644
--- a/ext/mysqli/mysqli_api.c
+++ b/ext/mysqli/mysqli_api.c
@@ -1183,18 +1183,18 @@ PHP_FUNCTION(mysqli_stmt_fetch)
 /* {{{  php_add_field_properties */
 static void php_add_field_properties(zval *value, const MYSQL_FIELD *field TSRMLS_DC)
 {
-	add_property_string(value, "name",(field->name ? field->name : ""), 1);
-	add_property_string(value, "orgname",(field->org_name ? field->org_name : ""), 1);
-	add_property_string(value, "table",(field->table ? field->table : ""), 1);
-	add_property_string(value, "orgtable",(field->org_table ? field->org_table : ""), 1);
-	add_property_string(value, "def",(field->def ? field->def : ""), 1);
-	add_property_string(value, "db",(field->db ? field->db : ""), 1);
+	add_property_string(value, "name",(field->name ? field->name : ""));
+	add_property_string(value, "orgname",(field->org_name ? field->org_name : ""));
+	add_property_string(value, "table",(field->table ? field->table : ""));
+	add_property_string(value, "orgtable",(field->org_table ? field->org_table : ""));
+	add_property_string(value, "def",(field->def ? field->def : ""));
+	add_property_string(value, "db",(field->db ? field->db : ""));
 
 	/* FIXME: manually set the catalog to "def" due to bug in
 	 * libmysqlclient which does not initialize field->catalog
 	 * and in addition, the catalog is always be "def"
 	 */
-	add_property_string(value, "catalog", "def", 1);
+	add_property_string(value, "catalog", "def");
 
 	add_property_long(value, "max_length", field->max_length);
 	add_property_long(value, "length", field->length);
diff --git a/ext/mysqli/mysqli_nonapi.c b/ext/mysqli/mysqli_nonapi.c
index 00cbcf204c..034c835b96 100644
--- a/ext/mysqli/mysqli_nonapi.c
+++ b/ext/mysqli/mysqli_nonapi.c
@@ -440,8 +440,8 @@ PHP_FUNCTION(mysqli_error_list)
 			MAKE_STD_ZVAL(single_error);
 			array_init(single_error);
 			add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
-			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
-			add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+			add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
 			add_next_index_zval(return_value, single_error);
 		}
 	}
@@ -451,8 +451,8 @@ PHP_FUNCTION(mysqli_error_list)
 		MAKE_STD_ZVAL(single_error);
 		array_init(single_error);
 		add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_errno(mysql->mysql));
-		add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql), 1);
-		add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql), 1);
+		add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql));
+		add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql));
 		add_next_index_zval(return_value, single_error);
 	}
 #endif
@@ -484,8 +484,8 @@ PHP_FUNCTION(mysqli_stmt_error_list)
 			MAKE_STD_ZVAL(single_error);
 			array_init(single_error);
 			add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
-			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
-			add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+			add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
 			add_next_index_zval(return_value, single_error);
 		}
 	}
@@ -495,8 +495,8 @@ PHP_FUNCTION(mysqli_stmt_error_list)
 		MAKE_STD_ZVAL(single_error);
 		array_init(single_error);
 		add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_stmt_errno(stmt->stmt));
-		add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt), 1);
-		add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt), 1);
+		add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt));
+		add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt));
 		add_next_index_zval(return_value, single_error);
 	}
 #endif
@@ -1039,14 +1039,14 @@ PHP_FUNCTION(mysqli_get_charset)
 #endif
 	object_init(return_value);
 
-	add_property_string(return_value, "charset", (name) ? (char *)name : "", 1);
-	add_property_string(return_value, "collation",(collation) ? (char *)collation : "", 1);
-	add_property_string(return_value, "dir", (dir) ? (char *)dir : "", 1);
+	add_property_string(return_value, "charset", (name) ? (char *)name : "");
+	add_property_string(return_value, "collation",(collation) ? (char *)collation : "");
+	add_property_string(return_value, "dir", (dir) ? (char *)dir : "");
 	add_property_long(return_value, "min_length", minlength);
 	add_property_long(return_value, "max_length", maxlength);
 	add_property_long(return_value, "number", number);
 	add_property_long(return_value, "state", state);
-	add_property_string(return_value, "comment", (comment) ? (char *)comment : "", 1);
+	add_property_string(return_value, "comment", (comment) ? (char *)comment : "");
 }
 /* }}} */
 #endif
diff --git a/ext/mysqli/mysqli_prop.c b/ext/mysqli/mysqli_prop.c
index 2d36336372..8d28e0181f 100644
--- a/ext/mysqli/mysqli_prop.c
+++ b/ext/mysqli/mysqli_prop.c
@@ -216,8 +216,8 @@ static int link_error_list_read(mysqli_object *obj, zval **retval TSRMLS_DC)
 				MAKE_STD_ZVAL(single_error);
 				array_init(single_error);
 				add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
-				add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
-				add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+				add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+				add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
 				add_next_index_zval(*retval, single_error);
 			}
 		}
@@ -227,8 +227,8 @@ static int link_error_list_read(mysqli_object *obj, zval **retval TSRMLS_DC)
 			MAKE_STD_ZVAL(single_error);
 			array_init(single_error);
 			add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_errno(mysql->mysql));
-			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql), 1);
-			add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql), 1);
+			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_sqlstate(mysql->mysql));
+			add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_error(mysql->mysql));
 			add_next_index_zval(*retval, single_error);
 		}
 #endif
@@ -415,8 +415,8 @@ static int stmt_error_list_read(mysqli_object *obj, zval **retval TSRMLS_DC)
 				MAKE_STD_ZVAL(single_error);
 				array_init(single_error);
 				add_assoc_long_ex(single_error, "errno", sizeof("errno"), message->error_no);
-				add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate, 1);
-				add_assoc_string_ex(single_error, "error", sizeof("error"), message->error, 1);
+				add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), message->sqlstate);
+				add_assoc_string_ex(single_error, "error", sizeof("error"), message->error);
 				add_next_index_zval(*retval, single_error);
 			}
 		}
@@ -426,8 +426,8 @@ static int stmt_error_list_read(mysqli_object *obj, zval **retval TSRMLS_DC)
 			MAKE_STD_ZVAL(single_error);
 			array_init(single_error);
 			add_assoc_long_ex(single_error, "errno", sizeof("errno"), mysql_stmt_errno(stmt->stmt));
-			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt), 1);
-			add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt), 1);
+			add_assoc_string_ex(single_error, "sqlstate", sizeof("sqlstate"), mysql_stmt_sqlstate(stmt->stmt));
+			add_assoc_string_ex(single_error, "error", sizeof("error"), mysql_stmt_error(stmt->stmt));
 			add_next_index_zval(*retval, single_error);
 		}
 #endif
diff --git a/ext/mysqlnd/mysqlnd_plugin.c b/ext/mysqlnd/mysqlnd_plugin.c
index 86543a05c2..702d591c3e 100644
--- a/ext/mysqlnd/mysqlnd_plugin.c
+++ b/ext/mysqlnd/mysqlnd_plugin.c
@@ -173,16 +173,18 @@ PHPAPI void _mysqlnd_plugin_apply_with_argument(apply_func_arg_t apply_func, voi
 	 * zend_hash_apply_with_argument nor zend_hash_internal_pointer_reset and
 	 * friends
 	 */
+	uint idx;
 	Bucket *p;
+	int result;
 
-	p = mysqlnd_registered_plugins.pListHead;
-	while (p != NULL) {
-		int result = apply_func(p->pData, argument TSRMLS_CC);
+	for (idx = 0; idx < mysqlnd_registered_plugins.nNumUsed; idx++) {
+		p = mysqlnd_registered_plugins.arData + idx;
+		if (!p->xData) continue;
+		result = apply_func(HASH_DATA(&mysqlnd_registered_plugins, p), argument TSRMLS_CC);
 
 		if (result & ZEND_HASH_APPLY_REMOVE) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "mysqlnd_plugin_apply_with_argument must not remove table entries");
 		}
-		p = p->pListNext;
 		if (result & ZEND_HASH_APPLY_STOP) {
 			break;
 		}
diff --git a/ext/mysqlnd/mysqlnd_statistics.c b/ext/mysqlnd/mysqlnd_statistics.c
index ce193275ec..c6387e4e8a 100644
--- a/ext/mysqlnd/mysqlnd_statistics.c
+++ b/ext/mysqlnd/mysqlnd_statistics.c
@@ -206,7 +206,7 @@ mysqlnd_fill_stats_hash(const MYSQLND_STATS * const stats, const MYSQLND_STRING
 		char tmp[25];
 
 		sprintf((char *)&tmp, MYSQLND_LLU_SPEC, stats->values[i]);
-		add_assoc_string_ex(return_value, names[i].s, names[i].l + 1, tmp, 1);
+		add_assoc_string_ex(return_value, names[i].s, names[i].l + 1, tmp);
 	}
 }
 /* }}} */
diff --git a/ext/oci8/oci8_interface.c b/ext/oci8/oci8_interface.c
index ca69febb2a..198493b946 100644
--- a/ext/oci8/oci8_interface.c
+++ b/ext/oci8/oci8_interface.c
@@ -1660,9 +1660,11 @@ go_out:
 	if (errcode) {
 		array_init(return_value);
 		add_assoc_long(return_value, "code", errcode);
-		add_assoc_string(return_value, "message", (char*) errbuf, 0);
+		// TODO: avoid reallocation ???
+		add_assoc_string(return_value, "message", (char*) errbuf);
+		efree(errbuf);
 		add_assoc_long(return_value, "offset", error_offset);
-		add_assoc_string(return_value, "sqltext", sqltext ? (char *) sqltext : "", 1);
+		add_assoc_string(return_value, "sqltext", sqltext ? (char *) sqltext : "");
 	} else {
 		RETURN_FALSE;
 	}
diff --git a/ext/oci8/oci8_statement.c b/ext/oci8/oci8_statement.c
index 3ea7935308..f9d2a3a0ff 100644
--- a/ext/oci8/oci8_statement.c
+++ b/ext/oci8/oci8_statement.c
@@ -1046,7 +1046,7 @@ int php_oci_bind_post_exec(void *data TSRMLS_DC)
 							add_next_index_null(bind->zval);
 						} else {
 							connection->errcode = 0; /* retain backwards compat with OCI8 1.4 */
-							add_next_index_stringl(bind->zval, (char *)buff, buff_len, 1);
+							add_next_index_stringl(bind->zval, (char *)buff, buff_len);
 						}
 					}
 				}
@@ -1066,7 +1066,7 @@ int php_oci_bind_post_exec(void *data TSRMLS_DC)
 						ZVAL_STRINGL(*entry, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length, 1);
 						zend_hash_move_forward(hash);
 					} else {
-						add_next_index_stringl(bind->zval, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length, 1);
+						add_next_index_stringl(bind->zval, (char *)(((text *)bind->array.elements)+i*bind->array.max_length), curr_element_length);
 					}
 				}
 				break;
diff --git a/ext/odbc/php_odbc.c b/ext/odbc/php_odbc.c
index 4d21b3a136..bc3f4c9520 100644
--- a/ext/odbc/php_odbc.c
+++ b/ext/odbc/php_odbc.c
@@ -1553,8 +1553,8 @@ PHP_FUNCTION(odbc_data_source)
 
 	array_init(return_value);
 
-	add_assoc_string_ex(return_value, "server", sizeof("server"), server_name, 1);
-	add_assoc_string_ex(return_value, "description", sizeof("description"), desc, 1);
+	add_assoc_string_ex(return_value, "server", sizeof("server"), server_name);
+	add_assoc_string_ex(return_value, "description", sizeof("description"), desc);
 
 }
 /* }}} */
diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index a6114733e3..51ab3cd97b 100644
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -1,19 +1,19 @@
 #define DEBUG_BLOCKPASS 0
 
 /* Checks if a constant (like "true") may be replaced by its value */
-static int zend_get_persistent_constant(char *name, uint name_len, zval *result, int copy TSRMLS_DC ELS_DC)
+static int zend_get_persistent_constant(zend_string *name, zval *result, int copy TSRMLS_DC ELS_DC)
 {
 	zend_constant *c;
 	char *lookup_name;
 	int retval = 1;
 	ALLOCA_FLAG(use_heap);
 
-	if (zend_hash_find(EG(zend_constants), name, name_len + 1, (void **) &c) == FAILURE) {
-		lookup_name = DO_ALLOCA(name_len + 1);
-		memcpy(lookup_name, name, name_len + 1);
-		zend_str_tolower(lookup_name, name_len);
+	if ((c = zend_hash_find_ptr(EG(zend_constants), name)) == NULL) {
+		lookup_name = DO_ALLOCA(name->len + 1);
+		memcpy(lookup_name, name->val, name->len + 1);
+		zend_str_tolower(lookup_name, name->len);
 
-		if (zend_hash_find(EG(zend_constants), lookup_name, name_len + 1, (void **) &c) == SUCCESS) {
+		if ((c = zend_hash_str_find_ptr(EG(zend_constants), lookup_name, name->len)) != NULL) {
 			if (!(c->flags & CONST_CT_SUBST) || (c->flags & CONST_CS)) {
 				retval = 0;
 			}
@@ -25,7 +25,7 @@ static int zend_get_persistent_constant(char *name, uint name_len, zval *result,
 
 	if (retval) {
 		if (c->flags & CONST_PERSISTENT) {
-			*result = c->value;
+			ZVAL_COPY_VALUE(result, &c->value);
 			if (copy) {
 				zval_copy_ctor(result);
 			}
@@ -533,7 +533,7 @@ static void zend_rebuild_access_path(zend_cfg *cfg, zend_op_array *op_array, int
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 
-# define VAR_NUM_EX(op) ((op ## _type & (IS_TMP_VAR|IS_VAR))?VAR_NUM((op).var):(op).var)
+# define VAR_NUM_EX(op) VAR_NUM((op).var)
 
 # define VAR_SOURCE(op) Tsource[VAR_NUM(op.var)]
 # define SET_VAR_SOURCE(opline) Tsource[VAR_NUM(opline->result.var)] = opline
@@ -553,7 +553,7 @@ static void zend_rebuild_access_path(zend_cfg *cfg, zend_op_array *op_array, int
 
 #define convert_to_string_safe(v) \
 	if (Z_TYPE_P((v)) == IS_NULL) { \
-		ZVAL_STRINGL((v), "", 0, 1); \
+		ZVAL_STRINGL((v), "", 0); \
 	} else { \
 		convert_to_string((v)); \
 	}
@@ -627,7 +627,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 
 	/* we track data dependencies only insight a single basic block */
 	if (op_array->T) {
-		Tsource = ecalloc(op_array->T, sizeof(zend_op *));
+		Tsource = ecalloc(op_array->last_var + op_array->T, sizeof(zend_op *));
 	}
 	opline = block->start_opline;
 	end = opline + block->len;
@@ -683,7 +683,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 
 		/* T = CAST(X, String), ECHO(T) => NOP, ECHO(X) */
 		if ((opline->opcode == ZEND_ECHO || opline->opcode == ZEND_PRINT) &&
-			ZEND_OP1_TYPE(opline) == IS_TMP_VAR &&
+			ZEND_OP1_TYPE(opline) & (IS_TMP_VAR|IS_VAR) &&
 			VAR_SOURCE(opline->op1) &&
 			VAR_SOURCE(opline->op1)->opcode == ZEND_CAST &&
 			VAR_SOURCE(opline->op1)->extended_value == IS_STRING) {
@@ -740,7 +740,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 				int flen = FUNCTION_CACHE->funcs[Z_LVAL(ZEND_OP1_LITERAL(fcall))].name_len;
 				if(flen == sizeof("defined")-1 && zend_binary_strcasecmp(fname, flen, "defined", sizeof("defined")-1) == 0) {
 					zval c;
-					if(zend_get_persistent_constant(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &c, 0 TSRMLS_CC ELS_CC) != 0) {
+					if(zend_get_persistent_constant(Z_STR_P(arg), &c, 0 TSRMLS_CC ELS_CC) != 0) {
 						literal_dtor(arg);
 						MAKE_NOP(sv);
 						MAKE_NOP(fcall);
@@ -760,7 +760,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 					}
 				} else if(flen == sizeof("constant")-1 && zend_binary_strcasecmp(fname, flen, "constant", sizeof("constant")-1) == 0) {
 					zval c;
-					if(zend_get_persistent_constant(Z_STRVAL_P(arg), Z_STRLEN_P(arg), &c, 1 TSRMLS_CC ELS_CC) != 0) {
+					if(zend_get_persistent_constant(Z_STR_P(arg), &c, 1 TSRMLS_CC ELS_CC) != 0) {
 						literal_dtor(arg);
 						MAKE_NOP(sv);
 						MAKE_NOP(fcall);
@@ -785,20 +785,23 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
          * IS_EQ(FALSE, X)     => BOOL_NOT(X)
          * IS_NOT_EQ(TRUE, X)  => BOOL_NOT(X)
          * IS_NOT_EQ(FALSE, X) => BOOL(X)
+         * CASE(TRUE, X)       => BOOL(X)
+         * CASE(FALSE, X)      => BOOL_NOT(X)
          */
 		if (opline->opcode == ZEND_IS_EQUAL ||
-			opline->opcode == ZEND_IS_NOT_EQUAL) {
+			opline->opcode == ZEND_IS_NOT_EQUAL ||
+			opline->opcode == ZEND_CASE) {
 			if (ZEND_OP1_TYPE(opline) == IS_CONST &&
 				Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_BOOL) {
 				opline->opcode =
-					((opline->opcode == ZEND_IS_EQUAL) == Z_LVAL(ZEND_OP1_LITERAL(opline)))?
+					((opline->opcode != ZEND_IS_NOT_EQUAL) == Z_LVAL(ZEND_OP1_LITERAL(opline)))?
 					ZEND_BOOL : ZEND_BOOL_NOT;
 				COPY_NODE(opline->op1, opline->op2);
 				SET_UNUSED(opline->op2);
 			} else if (ZEND_OP2_TYPE(opline) == IS_CONST &&
 					   Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_BOOL) {
 				opline->opcode =
-					((opline->opcode == ZEND_IS_EQUAL) == Z_LVAL(ZEND_OP2_LITERAL(opline)))?
+					((opline->opcode != ZEND_IS_NOT_EQUAL) == Z_LVAL(ZEND_OP2_LITERAL(opline)))?
 					ZEND_BOOL : ZEND_BOOL_NOT;
 				SET_UNUSED(opline->op2);
 			}
@@ -907,7 +910,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			 * Float to string conversion may be affected by current
 			 * locale setting.
 			 */
-			int l;
+			int l, old_len;
 
 			if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
 				convert_to_string_safe(&ZEND_OP1_LITERAL(opline));
@@ -915,24 +918,28 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			if (Z_TYPE(ZEND_OP1_LITERAL(last_op)) != IS_STRING) {
 				convert_to_string_safe(&ZEND_OP1_LITERAL(last_op));
 			}
-			l = Z_STRLEN(ZEND_OP1_LITERAL(opline)) + Z_STRLEN(ZEND_OP1_LITERAL(last_op));
-			if (IS_INTERNED(Z_STRVAL(ZEND_OP1_LITERAL(last_op)))) {
-				char *tmp = emalloc(l + 1);
-				memcpy(tmp, Z_STRVAL(ZEND_OP1_LITERAL(last_op)), l + 1);
-				Z_STRVAL(ZEND_OP1_LITERAL(last_op)) = tmp;
+			old_len = Z_STRLEN(ZEND_OP1_LITERAL(last_op));
+			l = old_len + Z_STRLEN(ZEND_OP1_LITERAL(opline));
+			if (IS_INTERNED(Z_STR(ZEND_OP1_LITERAL(last_op)))) {
+				zend_string *tmp = STR_ALLOC(l, 0);
+				memcpy(tmp->val, Z_STRVAL(ZEND_OP1_LITERAL(last_op)), old_len);
+				Z_STR(ZEND_OP1_LITERAL(last_op)) = tmp;
 			} else {
-				Z_STRVAL(ZEND_OP1_LITERAL(last_op)) = erealloc(Z_STRVAL(ZEND_OP1_LITERAL(last_op)), l + 1);
+				Z_STR(ZEND_OP1_LITERAL(last_op)) = STR_REALLOC(Z_STR(ZEND_OP1_LITERAL(last_op)), l, 0);
 			}
-			memcpy(Z_STRVAL(ZEND_OP1_LITERAL(last_op))+Z_STRLEN(ZEND_OP1_LITERAL(last_op)), Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)));
+			Z_TYPE_INFO(ZEND_OP1_LITERAL(last_op)) = IS_STRING_EX;
+			memcpy(Z_STRVAL(ZEND_OP1_LITERAL(last_op)) + old_len, Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)));
 			Z_STRVAL(ZEND_OP1_LITERAL(last_op))[l] = '\0';
 			zval_dtor(&ZEND_OP1_LITERAL(opline));
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-			Z_STRVAL(ZEND_OP1_LITERAL(opline)) = (char*)zend_new_interned_string(Z_STRVAL(ZEND_OP1_LITERAL(last_op)), l + 1, 1 TSRMLS_CC);
-			Z_TYPE(ZEND_OP1_LITERAL(last_op)) = IS_NULL;
+			Z_STR(ZEND_OP1_LITERAL(opline)) = zend_new_interned_string(Z_STR(ZEND_OP1_LITERAL(last_op)) TSRMLS_CC);
+			if (IS_INTERNED(Z_STR(ZEND_OP1_LITERAL(opline)))) {
+				Z_TYPE_FLAGS(ZEND_OP1_LITERAL(opline)) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+			}
+			ZVAL_NULL(&ZEND_OP1_LITERAL(last_op));
 #else
-			Z_STRVAL(ZEND_OP1_LITERAL(opline)) = Z_STRVAL(ZEND_OP1_LITERAL(last_op));
+			Z_STR(ZEND_OP1_LITERAL(opline)) = Z_STR(ZEND_OP1_LITERAL(last_op));
 #endif
-			Z_STRLEN(ZEND_OP1_LITERAL(opline)) = l;
 			MAKE_NOP(last_op);
 		} else if (opline->opcode == ZEND_CONCAT &&
 				  ZEND_OP2_TYPE(opline) == IS_CONST &&
@@ -944,7 +951,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 				  ZEND_RESULT(VAR_SOURCE(opline->op1)).var == ZEND_OP1(opline).var) {
 			/* compress consecutive CONCATs */
 			zend_op *src = VAR_SOURCE(opline->op1);
-			int l;
+			int l, old_len;
 
 			if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
 				convert_to_string_safe(&ZEND_OP2_LITERAL(opline));
@@ -959,26 +966,28 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 				opline->opcode = ZEND_ADD_STRING;
 			}
 			COPY_NODE(opline->op1, src->op1);
-			l = Z_STRLEN(ZEND_OP2_LITERAL(opline)) + Z_STRLEN(ZEND_OP2_LITERAL(src));
-			if (IS_INTERNED(Z_STRVAL(ZEND_OP2_LITERAL(src)))) {
-				char *tmp = emalloc(l + 1);
-				memcpy(tmp, Z_STRVAL(ZEND_OP2_LITERAL(src)), l + 1);
-				Z_STRVAL(ZEND_OP2_LITERAL(src)) = tmp;
+			old_len = Z_STRLEN(ZEND_OP2_LITERAL(src));
+			l = old_len + Z_STRLEN(ZEND_OP2_LITERAL(opline));
+			if (IS_INTERNED(Z_STR(ZEND_OP2_LITERAL(src)))) {
+				zend_string *tmp = STR_ALLOC(l, 0);
+				memcpy(tmp->val, Z_STRVAL(ZEND_OP2_LITERAL(src)), old_len);
+				Z_STR(ZEND_OP2_LITERAL(last_op)) = tmp;
 			} else {
-				Z_STRVAL(ZEND_OP2_LITERAL(src)) = erealloc(Z_STRVAL(ZEND_OP2_LITERAL(src)), l + 1);
+				Z_STR(ZEND_OP2_LITERAL(src)) = STR_REALLOC(Z_STR(ZEND_OP2_LITERAL(src)), l, 0);
 			}
-			memcpy(Z_STRVAL(ZEND_OP2_LITERAL(src))+Z_STRLEN(ZEND_OP2_LITERAL(src)), Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
+			Z_TYPE_INFO(ZEND_OP2_LITERAL(last_op)) = IS_STRING_EX;
+			memcpy(Z_STRVAL(ZEND_OP2_LITERAL(src)) + old_len, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
 			Z_STRVAL(ZEND_OP2_LITERAL(src))[l] = '\0';
-			if (!IS_INTERNED(Z_STRVAL(ZEND_OP2_LITERAL(opline)))) {
-				efree(Z_STRVAL(ZEND_OP2_LITERAL(opline)));
-			}
+			STR_RELEASE(Z_STR(ZEND_OP2_LITERAL(opline)));
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-			Z_STRVAL(ZEND_OP2_LITERAL(opline)) = (char*)zend_new_interned_string(Z_STRVAL(ZEND_OP2_LITERAL(src)), l + 1, 1 TSRMLS_CC);
-			Z_TYPE(ZEND_OP2_LITERAL(src)) = IS_NULL;
+			Z_STR(ZEND_OP2_LITERAL(opline)) = zend_new_interned_string(Z_STR(ZEND_OP2_LITERAL(src)) TSRMLS_CC);
+			if (IS_INTERNED(Z_STR(ZEND_OP2_LITERAL(opline)))) {
+				Z_TYPE_FLAGS(ZEND_OP2_LITERAL(opline)) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+			}
+			ZVAL_NULL(&ZEND_OP2_LITERAL(src));
 #else
-			Z_STRVAL(ZEND_OP2_LITERAL(opline)) = Z_STRVAL(ZEND_OP2_LITERAL(src));
+			Z_STR(ZEND_OP2_LITERAL(opline)) = Z_STR(ZEND_OP2_LITERAL(src));
 #endif
-			Z_STRLEN(ZEND_OP2_LITERAL(opline)) = l;
 			MAKE_NOP(src);
 		} else if ((opline->opcode == ZEND_ADD_STRING || opline->opcode == ZEND_ADD_VAR) && ZEND_OP1_TYPE(opline) == IS_CONST) {
 			/* convert ADD_STRING(C1, C2) to CONCAT(C1, C2) */
@@ -987,7 +996,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 		} else if (opline->opcode == ZEND_ADD_CHAR && ZEND_OP1_TYPE(opline) == IS_CONST && ZEND_OP2_TYPE(opline) == IS_CONST) {
             /* convert ADD_CHAR(C1, C2) to CONCAT(C1, C2) */
 			char c = (char)Z_LVAL(ZEND_OP2_LITERAL(opline));
-			ZVAL_STRINGL(&ZEND_OP2_LITERAL(opline), &c, 1, 1);
+			ZVAL_STRINGL(&ZEND_OP2_LITERAL(opline), &c, 1);
 			opline->opcode = ZEND_CONCAT;
 			continue;
 		} else if ((opline->opcode == ZEND_ADD ||
@@ -1029,9 +1038,6 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			er = EG(error_reporting);
 			EG(error_reporting) = 0;
 			if (binary_op(&result, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline) TSRMLS_CC) == SUCCESS) {
-				PZ_SET_REFCOUNT_P(&result, 1);
-				PZ_UNSET_ISREF_P(&result);
-
 				literal_dtor(&ZEND_OP1_LITERAL(opline));
 				literal_dtor(&ZEND_OP2_LITERAL(opline));
 				opline->opcode = ZEND_QM_ASSIGN;
@@ -1057,10 +1063,8 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 				/* BOOL */
 				result = ZEND_OP1_LITERAL(opline);
 				convert_to_boolean(&result);
-				Z_TYPE(ZEND_OP1_LITERAL(opline)) = IS_NULL;
+				ZVAL_NULL(&ZEND_OP1_LITERAL(opline));
 			}
-			PZ_SET_REFCOUNT_P(&result, 1);
-			PZ_UNSET_ISREF_P(&result);
 			opline->opcode = ZEND_QM_ASSIGN;
 			update_op1_const(op_array, opline, &result TSRMLS_CC);
 		} else if ((opline->opcode == ZEND_RETURN || opline->opcode == ZEND_EXIT) &&
@@ -1086,7 +1090,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			COPY_NODE(opline->op1, opline->op2);
 			if (opline->opcode == ZEND_ADD_CHAR) {
 				char c = (char)Z_LVAL(ZEND_OP2_LITERAL(opline));
-				ZVAL_STRINGL(&ZEND_OP1_LITERAL(opline), &c, 1, 1);
+				ZVAL_STRINGL(&ZEND_OP1_LITERAL(opline), &c, 1);
 			}
 			SET_UNUSED(opline->op2);
 			MAKE_NOP(src);
@@ -1107,11 +1111,15 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			COPY_NODE(opline->op1, src->op1);
 			if (opline->opcode == ZEND_ADD_CHAR) {
 				char c = (char)Z_LVAL(ZEND_OP2_LITERAL(opline));
-				ZVAL_STRINGL(&ZEND_OP2_LITERAL(opline), &c, 1, 1);
+				ZVAL_STRINGL(&ZEND_OP2_LITERAL(opline), &c, 1);
 			}
 			opline->opcode = ZEND_CONCAT;
 			literal_dtor(&ZEND_OP2_LITERAL(src)); /* will take care of empty_string too */
 			MAKE_NOP(src);
+//??? This optimization can't work anymore because ADD_VAR returns IS_TMP_VAR
+//??? and ZEND_CAST returns IS_VAR.
+//??? BTW: it wan't used for long time, because we don't use INIT_STRING
+#if 0
 		} else if (opline->opcode == ZEND_ADD_VAR &&
 					ZEND_OP1_TYPE(opline) == IS_TMP_VAR &&
 					VAR_SOURCE(opline->op1) &&
@@ -1124,11 +1132,12 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			MAKE_NOP(src);
 			opline->opcode = ZEND_CAST;
 			opline->extended_value = IS_STRING;
+#endif
 		} else if ((opline->opcode == ZEND_ADD_STRING ||
 					opline->opcode == ZEND_ADD_CHAR ||
 					opline->opcode == ZEND_ADD_VAR ||
 					opline->opcode == ZEND_CONCAT) &&
-					ZEND_OP1_TYPE(opline) == IS_TMP_VAR &&
+					ZEND_OP1_TYPE(opline) == (IS_TMP_VAR|IS_VAR) &&
 					VAR_SOURCE(opline->op1) &&
 					VAR_SOURCE(opline->op1)->opcode == ZEND_CAST &&
 					VAR_SOURCE(opline->op1)->extended_value == IS_STRING) {
@@ -1138,7 +1147,7 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
 			COPY_NODE(opline->op1, src->op1);
 			if (opline->opcode == ZEND_ADD_CHAR) {
 				char c = (char)Z_LVAL(ZEND_OP2_LITERAL(opline));
-				ZVAL_STRINGL(&ZEND_OP2_LITERAL(opline), &c, 1, 1);
+				ZVAL_STRINGL(&ZEND_OP2_LITERAL(opline), &c, 1);
 			}
 			opline->opcode = ZEND_CONCAT;
 			MAKE_NOP(src);
@@ -1639,12 +1648,8 @@ next_target:
 				zend_op *target, *target_end;
 				char *same_t=NULL;
 				zend_code_block *target_block;
-				int var_num = 0;
-				if (op_array->T >= (zend_uint)op_array->last_var) {
-					var_num = op_array->T;
-				} else {
-					var_num = op_array->last_var;
-				}
+				int var_num = op_array->last_var + op_array->T;
+		
 				if (var_num <= 0) {
    					return;
 				}
@@ -1889,8 +1894,8 @@ static void zend_t_usage(zend_code_block *block, zend_op_array *op_array, char *
 		return;
 	}
 
-	usage = ecalloc(op_array->T, 1);
-	defined_here = emalloc(op_array->T);
+	usage = ecalloc(op_array->last_var + op_array->T, 1);
+	defined_here = emalloc(op_array->last_var + op_array->T);
 
 	while (next_block) {
 		zend_op *opline = next_block->start_opline;
@@ -1900,7 +1905,7 @@ static void zend_t_usage(zend_code_block *block, zend_op_array *op_array, char *
 			next_block = next_block->next;
 			continue;
 		}
-		memset(defined_here, 0, op_array->T);
+		memset(defined_here, 0, op_array->last_var + op_array->T);
 
 		while (opline<end) {
 			T_USAGE(opline->op1);
@@ -1927,7 +1932,7 @@ static void zend_t_usage(zend_code_block *block, zend_op_array *op_array, char *
 #if DEBUG_BLOCKPASS
 	{
 		int i;
-		for (i = 0; i< op_array->T; i++) {
+		for (i = op_array->last_var; i< op_array->T; i++) {
 			fprintf(stderr, "T%d: %c\n", i, used_ext[i] + '0');
 		}
 	}
@@ -1941,7 +1946,7 @@ static void zend_t_usage(zend_code_block *block, zend_op_array *op_array, char *
 			continue;
 		}
 
-		memcpy(usage, used_ext, op_array->T);
+		memcpy(usage, used_ext, op_array->last_var + op_array->T);
 
 		while (opline >= block->start_opline) {
 			/* usage checks */
@@ -2067,10 +2072,10 @@ static void zend_block_optimization(zend_op_array *op_array TSRMLS_DC)
 
 	zend_rebuild_access_path(&cfg, op_array, 0);
 	/* full rebuild here to produce correct sources! */
-	usage = emalloc(op_array->T);
+	usage = emalloc(op_array->last_var + op_array->T);
 	for (pass = 0; pass < PASSES; pass++) {
 		/* Compute data dependencies */
-		memset(usage, 0, op_array->T);
+		memset(usage, 0, op_array->last_var + op_array->T);
 		zend_t_usage(cfg.blocks, op_array, usage);
 
 		/* optimize each basic block separately */
@@ -2093,7 +2098,7 @@ static void zend_block_optimization(zend_op_array *op_array TSRMLS_DC)
 		zend_rebuild_access_path(&cfg, op_array, 1);
 	}
 
-	memset(usage, 0, op_array->T);
+	memset(usage, 0, op_array->last_var + op_array->T);
 	zend_t_usage(cfg.blocks, op_array, usage);
 	assemble_code_blocks(&cfg, op_array);
 	efree(usage);
diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c
index b29241344c..04183292d6 100644
--- a/ext/opcache/Optimizer/compact_literals.c
+++ b/ext/opcache/Optimizer/compact_literals.c
@@ -63,7 +63,7 @@ static void optimizer_literal_obj_info(literal_info   *info,
 	 * In general it's also possible to do it for any CV variable as well,
 	 * but it would require complex dataflow and/or type analysis.
 	 */
-	if (Z_TYPE(op_array->literals[constant].constant) == IS_STRING &&
+	if (Z_TYPE(op_array->literals[constant]) == IS_STRING &&
 	    op_type == IS_UNUSED) {
 		LITERAL_INFO_OBJ(constant, kind, 1, slots, related, op_array->this_var);
 	} else {
@@ -90,15 +90,13 @@ static void optimizer_literal_class_info(literal_info   *info,
 static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 {
 	zend_op *opline, *end;
-	int i, j, n, *pos, *map, cache_slots;
-	ulong h;
+	int i, j, n, pos, *map, cache_slots;
 	literal_info *info;
 	int l_null = -1;
 	int l_false = -1;
 	int l_true = -1;
 	HashTable hash;
-	char *key;
-	int key_len;
+	zend_string *key = NULL;
 
 	if (op_array->last_literal) {
 		info = (literal_info*)ecalloc(op_array->last_literal, sizeof(literal_info));
@@ -287,10 +285,10 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 		for (i = 0; i < op_array->last_literal; i++) {
 			if (!info[i].flags) {
 				/* unsed literal */
-				zval_dtor(&op_array->literals[i].constant);
+				zval_dtor(&op_array->literals[i]);
 				continue;
 			}
-			switch (Z_TYPE(op_array->literals[i].constant)) {
+			switch (Z_TYPE(op_array->literals[i])) {
 				case IS_NULL:
 					if (l_null < 0) {
 						l_null = j;
@@ -303,7 +301,7 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 					map[i] = l_null;
 					break;
 				case IS_BOOL:
-					if (Z_LVAL(op_array->literals[i].constant)) {
+					if (Z_LVAL(op_array->literals[i])) {
 						if (l_true < 0) {
 							l_true = j;
 							if (i != j) {
@@ -326,11 +324,11 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 					}
 					break;
 				case IS_LONG:
-					if (zend_hash_index_find(&hash, Z_LVAL(op_array->literals[i].constant), (void**)&pos) == SUCCESS) {
-						map[i] = *pos;
+					if ((pos = (int)zend_hash_index_find_ptr(&hash, Z_LVAL(op_array->literals[i]))) != 0) {
+						map[i] = pos - 1;
 					} else {
 						map[i] = j;
-						zend_hash_index_update(&hash, Z_LVAL(op_array->literals[i].constant), (void**)&j, sizeof(int), NULL);
+						zend_hash_index_update_ptr(&hash, Z_LVAL(op_array->literals[i]), (void*)j + 1);
 						if (i != j) {
 							op_array->literals[j] = op_array->literals[i];
 							info[j] = info[i];
@@ -339,11 +337,11 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 					}
 					break;
 				case IS_DOUBLE:
-					if (zend_hash_find(&hash, (char*)&Z_DVAL(op_array->literals[i].constant), sizeof(double), (void**)&pos) == SUCCESS) {
-						map[i] = *pos;
+					if ((pos = (int)zend_hash_str_find_ptr(&hash, (char*)&Z_DVAL(op_array->literals[i]), sizeof(double))) != 0) {
+						map[i] = pos - 1;
 					} else {
 						map[i] = j;
-						zend_hash_add(&hash, (char*)&Z_DVAL(op_array->literals[i].constant), sizeof(double), (void**)&j, sizeof(int), NULL);
+						zend_hash_str_add_ptr(&hash, (char*)&Z_DVAL(op_array->literals[i]), sizeof(double), (void*)j + 1);
 						if (i != j) {
 							op_array->literals[j] = op_array->literals[i];
 							info[j] = info[i];
@@ -355,62 +353,51 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 				case IS_CONSTANT:
 					if (info[i].flags & LITERAL_MAY_MERGE) {
 						if (info[i].flags & LITERAL_EX_OBJ) {
-							key_len = MAX_LENGTH_OF_LONG + sizeof("->") + Z_STRLEN(op_array->literals[i].constant);
-							key = emalloc(key_len);
-							key_len = snprintf(key, key_len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i].constant));
+							int key_len = MAX_LENGTH_OF_LONG + sizeof("->") + Z_STRLEN(op_array->literals[i]);
+							key = STR_ALLOC(key_len, 0);
+							key->len = snprintf(key->val, key->len-1, "%d->%s", info[i].u.num, Z_STRVAL(op_array->literals[i]));
 						} else if (info[i].flags & LITERAL_EX_CLASS) {
-							zval *class_name = &op_array->literals[(info[i].u.num < i) ? map[info[i].u.num] : info[i].u.num].constant;
-							key_len = Z_STRLEN_P(class_name) + sizeof("::") + Z_STRLEN(op_array->literals[i].constant);
-							key = emalloc(key_len);
-							memcpy(key, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
-							memcpy(key + Z_STRLEN_P(class_name), "::", sizeof("::") - 1);
-							memcpy(key + Z_STRLEN_P(class_name) + sizeof("::") - 1,
-								Z_STRVAL(op_array->literals[i].constant),
-								Z_STRLEN(op_array->literals[i].constant) + 1);
+							int key_len;
+							zval *class_name = &op_array->literals[(info[i].u.num < i) ? map[info[i].u.num] : info[i].u.num];
+							key_len = Z_STRLEN_P(class_name) + sizeof("::") + Z_STRLEN(op_array->literals[i]);
+							key = STR_ALLOC(key_len, 0);
+							memcpy(key->val, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
+							memcpy(key->val + Z_STRLEN_P(class_name), "::", sizeof("::") - 1);
+							memcpy(key->val + Z_STRLEN_P(class_name) + sizeof("::") - 1,
+								Z_STRVAL(op_array->literals[i]),
+								Z_STRLEN(op_array->literals[i]) + 1);
 						} else {
-							key = Z_STRVAL(op_array->literals[i].constant);
-							key_len = Z_STRLEN(op_array->literals[i].constant)+1;
+							key = STR_INIT(Z_STRVAL(op_array->literals[i]), Z_STRLEN(op_array->literals[i]), 0);
 						}
-						h = zend_hash_func(key, key_len);
-						h += info[i].flags;
+						key->h = zend_hash_func(key->val, key->len);
+						key->h += info[i].flags;
 					}
 					if ((info[i].flags & LITERAL_MAY_MERGE) &&
-						zend_hash_quick_find(&hash, key, key_len, h, (void**)&pos) == SUCCESS &&
-					   	Z_TYPE(op_array->literals[i].constant) == Z_TYPE(op_array->literals[*pos].constant) &&
-						info[i].flags == info[*pos].flags) {
+						(pos = (int)zend_hash_find_ptr(&hash, key)) != 0 &&
+					   	Z_TYPE(op_array->literals[i]) == Z_TYPE(op_array->literals[pos-1]) &&
+						info[i].flags == info[pos-1].flags) {
 
-						if (info[i].flags & (LITERAL_EX_OBJ|LITERAL_EX_CLASS)) {
-							efree(key);
-						}
-						map[i] = *pos;
-						zval_dtor(&op_array->literals[i].constant);
+						STR_RELEASE(key);
+						map[i] = pos - 1;
+						zval_dtor(&op_array->literals[i]);
 						n = LITERAL_NUM_RELATED(info[i].flags);
 						while (n > 1) {
 							i++;
-							zval_dtor(&op_array->literals[i].constant);
+							zval_dtor(&op_array->literals[i]);
 							n--;
 						}
 					} else {
 						map[i] = j;
 						if (info[i].flags & LITERAL_MAY_MERGE) {
-							zend_hash_quick_add(&hash, key, key_len, h, (void**)&j, sizeof(int), NULL);
-							if (info[i].flags & (LITERAL_EX_OBJ|LITERAL_EX_CLASS)) {
-								efree(key);
-							}
+							zend_hash_add_ptr(&hash, key, (void*)j + 1);
+							STR_RELEASE(key);
 						}
 						if (i != j) {
 							op_array->literals[j] = op_array->literals[i];
 							info[j] = info[i];
 						}
-						if (!op_array->literals[j].hash_value) {
-							if (IS_INTERNED(Z_STRVAL(op_array->literals[j].constant))) {
-								op_array->literals[j].hash_value = INTERNED_HASH(Z_STRVAL(op_array->literals[j].constant));
-							} else {
-								op_array->literals[j].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[j].constant), Z_STRLEN(op_array->literals[j].constant)+1);
-							}
-						}
 						if (LITERAL_NUM_SLOTS(info[i].flags)) {
-							op_array->literals[j].cache_slot = cache_slots;
+							Z_CACHE_SLOT(op_array->literals[j]) = cache_slots;
 							cache_slots += LITERAL_NUM_SLOTS(info[i].flags);
 						}
 						j++;
@@ -418,13 +405,6 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
 						while (n > 1) {
 							i++;
 							if (i != j) op_array->literals[j] = op_array->literals[i];
-							if (!op_array->literals[j].hash_value) {
-								if (IS_INTERNED(Z_STRVAL(op_array->literals[j].constant))) {
-									op_array->literals[j].hash_value = INTERNED_HASH(Z_STRVAL(op_array->literals[j].constant));
-								} else {
-									op_array->literals[j].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[j].constant), Z_STRLEN(op_array->literals[j].constant)+1);
-								}
-							}
 							j++;
 							n--;
 						}
diff --git a/ext/opcache/Optimizer/optimize_func_calls.c b/ext/opcache/Optimizer/optimize_func_calls.c
index 14f8255653..f9ae14290f 100644
--- a/ext/opcache/Optimizer/optimize_func_calls.c
+++ b/ext/opcache/Optimizer/optimize_func_calls.c
@@ -25,10 +25,9 @@ static void optimize_func_calls(zend_op_array *op_array, zend_persistent_script
 			case ZEND_INIT_NS_FCALL_BY_NAME:
 				if (ZEND_OP2_TYPE(opline) == IS_CONST) {
 					zend_function *func;
-					zval *function_name = &op_array->literals[opline->op2.constant + 1].constant;
-					if ((zend_hash_quick_find(&script->function_table,
-							Z_STRVAL_P(function_name), Z_STRLEN_P(function_name) + 1,
-							Z_HASH_P(function_name), (void **)&func) == SUCCESS)) {
+					zval *function_name = &op_array->literals[opline->op2.constant + 1];
+					if ((func = zend_hash_find_ptr(&script->function_table,
+							Z_STR_P(function_name))) != NULL) {
 						call_stack[call].func = func;
 					}
 				}
@@ -54,10 +53,10 @@ static void optimize_func_calls(zend_op_array *op_array, zend_persistent_script
 					opline->opcode = ZEND_DO_FCALL;
 					ZEND_OP1_TYPE(opline) = IS_CONST;
 					opline->op1.constant = fcall->op2.constant + 1;
-					op_array->literals[fcall->op2.constant + 1].cache_slot = op_array->literals[fcall->op2.constant].cache_slot;
+					Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]);
 					literal_dtor(&ZEND_OP2_LITERAL(fcall));
 					if (fcall->opcode == ZEND_INIT_NS_FCALL_BY_NAME) {
-						literal_dtor(&op_array->literals[fcall->op2.constant + 2].constant);
+						literal_dtor(&op_array->literals[fcall->op2.constant + 2]);
 					}
 					MAKE_NOP(fcall);
 				} else if (opline->extended_value == 0 &&
@@ -70,7 +69,7 @@ static void optimize_func_calls(zend_op_array *op_array, zend_persistent_script
 					opline->opcode = ZEND_DO_FCALL;
 					ZEND_OP1_TYPE(opline) = IS_CONST;
 					opline->op1.constant = fcall->op2.constant + 1;
-					op_array->literals[fcall->op2.constant + 1].cache_slot = op_array->literals[fcall->op2.constant].cache_slot;
+					Z_CACHE_SLOT(op_array->literals[fcall->op2.constant + 1]) = Z_CACHE_SLOT(op_array->literals[fcall->op2.constant]);
 					literal_dtor(&ZEND_OP2_LITERAL(fcall));
 					MAKE_NOP(fcall);
 				}
diff --git a/ext/opcache/Optimizer/optimize_temp_vars_5.c b/ext/opcache/Optimizer/optimize_temp_vars_5.c
index dc630733fa..77e07a586e 100644
--- a/ext/opcache/Optimizer/optimize_temp_vars_5.c
+++ b/ext/opcache/Optimizer/optimize_temp_vars_5.c
@@ -73,6 +73,7 @@ static const char op_const_means_class[256]  = {
 static void optimize_temporary_variables(zend_op_array *op_array)
 {
 	int T = op_array->T;
+	int offset = op_array->last_var;
 	char *taken_T;			/* T index in use */
 	zend_op **start_of_T;	/* opline where T is first used */
 	char *valid_T;			/* Is the map_T valid */
@@ -96,12 +97,22 @@ static void optimize_temporary_variables(zend_op_array *op_array)
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
         if (ZEND_RESULT_TYPE(opline) & (IS_VAR | IS_TMP_VAR | IS_CONST)) {
 			if (!(op_const_means_class[opline->opcode] & RESULT_IS_UNUSED)) {
-				start_of_T[VAR_NUM(ZEND_RESULT(opline).var)] = opline;
+				start_of_T[VAR_NUM(ZEND_RESULT(opline).var) - offset] = opline;
 			}
 		}
 #else
         if (ZEND_RESULT_TYPE(opline) & (IS_VAR | IS_TMP_VAR)) {
-			start_of_T[VAR_NUM(ZEND_RESULT(opline).var)] = opline;
+			start_of_T[VAR_NUM(ZEND_RESULT(opline).var) - offset] = opline;
+		}
+		/* special puprose variable to keep HashPointer on VM stack */
+		if (opline->opcode == ZEND_OP_DATA &&
+		    (opline-1)->opcode == ZEND_FE_FETCH &&
+		    opline->op1_type == IS_TMP_VAR) {
+			start_of_T[VAR_NUM(ZEND_OP1(opline).var) - offset] = opline;
+			if (sizeof(HashPointer) > sizeof(zval)) {
+				/* Make shure 1 zval is enough for HashPointer (2 must be enough) */
+				start_of_T[VAR_NUM(ZEND_OP1(opline).var) + 1 - offset] = opline;
+			}
 		}
 #endif
 		opline--;
@@ -119,13 +130,26 @@ static void optimize_temporary_variables(zend_op_array *op_array)
 			|| ((op_const_means_class[opline->opcode] & OP1_CONST_IS_CLASS) && ZEND_OP1_TYPE(opline) == IS_CONST)
 #endif
 			) {
-			currT = VAR_NUM(ZEND_OP1(opline).var);
-			if (!valid_T[currT]) {
-				GET_AVAILABLE_T();
-				map_T[currT] = i;
-				valid_T[currT] = 1;
+
+			/* special puprose variable to keep HashPointer on VM stack */
+			if (opline->opcode == ZEND_OP_DATA &&
+			    (opline-1)->opcode == ZEND_FE_FETCH &&
+		    	opline->op1_type == IS_TMP_VAR) {
+				max++;
+				ZEND_OP1(opline).var = NUM_VAR(max + offset);
+				if (sizeof(HashPointer) > sizeof(zval)) {
+					/* Make shure 1 zval is enough for HashPointer (2 must be enough) */
+					max++;
+				}
+			} else {
+				currT = VAR_NUM(ZEND_OP1(opline).var) - offset;
+				if (!valid_T[currT]) {
+					GET_AVAILABLE_T();
+					map_T[currT] = i;
+					valid_T[currT] = 1;
+				}
+				ZEND_OP1(opline).var = NUM_VAR(map_T[currT] + offset);
 			}
-			ZEND_OP1(opline).var = NUM_VAR(map_T[currT]);
 		}
 
 		/* Skip OP_DATA */
@@ -140,13 +164,13 @@ static void optimize_temporary_variables(zend_op_array *op_array)
 			|| ((op_const_means_class[opline->opcode] & OP2_CONST_IS_CLASS) && ZEND_OP2_TYPE(opline) == IS_CONST)
 #endif
 		   ) {
-			currT = VAR_NUM(ZEND_OP2(opline).var);
+			currT = VAR_NUM(ZEND_OP2(opline).var) - offset;
 			if (!valid_T[currT]) {
 				GET_AVAILABLE_T();
 				map_T[currT] = i;
 				valid_T[currT] = 1;
 			}
-			ZEND_OP2(opline).var = NUM_VAR(map_T[currT]);
+			ZEND_OP2(opline).var = NUM_VAR(map_T[currT] + offset);
 		}
 
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
@@ -155,25 +179,25 @@ static void optimize_temporary_variables(zend_op_array *op_array)
 		if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS ||
             opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) {
 #endif
-			currT = VAR_NUM(opline->extended_value);
+			currT = VAR_NUM(opline->extended_value) - offset;
 			if (!valid_T[currT]) {
 				GET_AVAILABLE_T();
 				map_T[currT] = i;
 				valid_T[currT] = 1;
 			}
-			opline->extended_value = NUM_VAR(map_T[currT]);
+			opline->extended_value = NUM_VAR(map_T[currT] + offset);
 		}
 
 		/* Allocate OP_DATA->op2 after "operands", but before "result" */
 		if (opline->opcode == ZEND_ASSIGN_DIM &&
 		    (opline + 1)->opcode == ZEND_OP_DATA &&
 		    ZEND_OP2_TYPE(opline + 1) & (IS_VAR | IS_TMP_VAR)) {
-			currT = VAR_NUM(ZEND_OP2(opline + 1).var);
+			currT = VAR_NUM(ZEND_OP2(opline + 1).var) - offset;
 			GET_AVAILABLE_T();
 			map_T[currT] = i;
 			valid_T[currT] = 1;
 			taken_T[i] = 0;
-			ZEND_OP2(opline + 1).var = NUM_VAR(i);
+			ZEND_OP2(opline + 1).var = NUM_VAR(i + offset);
 			var_to_free = i;
 		}
 
@@ -183,12 +207,12 @@ static void optimize_temporary_variables(zend_op_array *op_array)
 #else
 		if (ZEND_RESULT_TYPE(opline) & (IS_VAR | IS_TMP_VAR)) {
 #endif
-				currT = VAR_NUM(ZEND_RESULT(opline).var);
+				currT = VAR_NUM(ZEND_RESULT(opline).var) - offset;
 				if (valid_T[currT]) {
 					if (start_of_T[currT] == opline) {
 						taken_T[map_T[currT]] = 0;
 					}
-					ZEND_RESULT(opline).var = NUM_VAR(map_T[currT]);
+					ZEND_RESULT(opline).var = NUM_VAR(map_T[currT] + offset);
 				} else { /* Au still needs to be assigned a T which is a bit dumb. Should consider changing Zend */
 					GET_AVAILABLE_T();
 
@@ -199,7 +223,7 @@ static void optimize_temporary_variables(zend_op_array *op_array)
 						map_T[currT] = i;
 						valid_T[currT] = 1;
 					}
-					ZEND_RESULT(opline).var = NUM_VAR(i);
+					ZEND_RESULT(opline).var = NUM_VAR(i + offset);
 				}
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
 			}
diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c
index 577d1b6609..cae7e80375 100644
--- a/ext/opcache/Optimizer/pass1_5.c
+++ b/ext/opcache/Optimizer/pass1_5.c
@@ -7,7 +7,7 @@
  */
 
 #if ZEND_EXTENSION_API_NO > PHP_5_2_X_API_NO
-# define ZEND_IS_CONSTANT_TYPE(t)	(((t) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT)
+# define ZEND_IS_CONSTANT_TYPE(t)	((t) == IS_CONSTANT)
 #else
 # define ZEND_IS_CONSTANT_TYPE(t)	((t) == IS_CONSTANT)
 #endif
@@ -60,9 +60,6 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				EG(error_reporting) = er;
-				PZ_SET_REFCOUNT_P(&result, 1);
-				PZ_UNSET_ISREF_P(&result);
-
 				literal_dtor(&ZEND_OP1_LITERAL(opline));
 				literal_dtor(&ZEND_OP2_LITERAL(opline));
 				MAKE_NOP(opline);
@@ -102,7 +99,11 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 				literal_dtor(&ZEND_OP1_LITERAL(opline));
 				MAKE_NOP(opline);
 
-				replace_tmp_by_const(op_array, opline + 1, tv, &res TSRMLS_CC);
+				if (opline->result_type == IS_TMP_VAR) {
+					replace_tmp_by_const(op_array, opline + 1, tv, &res TSRMLS_CC);
+				} else /* if (opline->result_type == IS_VAR) */ {
+					replace_var_by_const(op_array, opline + 1, tv, &res TSRMLS_CC);
+				}
 			} else if (opline->extended_value == IS_BOOL) {
 				/* T = CAST(X, IS_BOOL) => T = BOOL(X) */
 				opline->opcode = ZEND_BOOL;
@@ -130,9 +131,6 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				EG(error_reporting) = er;
-				PZ_SET_REFCOUNT_P(&result, 1);
-				PZ_UNSET_ISREF_P(&result);
-
 				literal_dtor(&ZEND_OP1_LITERAL(opline));
 				MAKE_NOP(opline);
 
@@ -146,6 +144,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 				zend_op *next_op = opline + 1;
 				int requires_conversion = (opline->opcode == ZEND_ADD_CHAR? 1 : 0);
 				size_t final_length = 0;
+				zend_string *str;
 				char *ptr;
 				zend_op *last_op;
 
@@ -161,7 +160,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					if (next_op->opcode == ZEND_ADD_CHAR) {
 						final_length += 1;
 					} else { /* ZEND_ADD_STRING */
-						final_length += ZEND_OP2_LITERAL(next_op).value.str.len;
+						final_length += Z_STRLEN(ZEND_OP2_LITERAL(next_op));
 					}
 					next_op++;
 				}
@@ -169,34 +168,32 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				last_op = next_op;
-				final_length += (requires_conversion? 1 : ZEND_OP2_LITERAL(opline).value.str.len);
-				ptr = (char *)emalloc(final_length + 1);
+				final_length += (requires_conversion? 1 : Z_STRLEN(ZEND_OP2_LITERAL(opline)));
+				str = STR_ALLOC(final_length, 0);
+				ptr = str->val;
 				ptr[final_length] = '\0';
 				if (requires_conversion) { /* ZEND_ADD_CHAR */
-					char chval = (char)ZEND_OP2_LITERAL(opline).value.lval;
+					char chval = (char)Z_LVAL(ZEND_OP2_LITERAL(opline));
 
-					ZEND_OP2_LITERAL(opline).value.str.val = ptr;
+					ZVAL_NEW_STR(&ZEND_OP2_LITERAL(opline), str);
 					ptr[0] = chval;
-					ZEND_OP2_LITERAL(opline).type = IS_STRING;
 					opline->opcode = ZEND_ADD_STRING;
 					ptr++;
 				} else { /* ZEND_ADD_STRING */
 					memcpy(ptr, Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)));
-					if (!IS_INTERNED(Z_STRVAL(ZEND_OP2_LITERAL(opline)))) {
-						efree(Z_STRVAL(ZEND_OP2_LITERAL(opline)));
-					}
-					Z_STRVAL(ZEND_OP2_LITERAL(opline)) = ptr;
+					STR_RELEASE(Z_STR(ZEND_OP2_LITERAL(opline)));
+					Z_STR(ZEND_OP2_LITERAL(opline)) = str;
 					ptr += Z_STRLEN(ZEND_OP2_LITERAL(opline));
 				}
-				ZEND_OP2_LITERAL(opline).value.str.len = final_length;
+				Z_STRLEN(ZEND_OP2_LITERAL(opline)) = final_length;
 				next_op = opline + 1;
 				while (next_op < last_op) {
 					if (next_op->opcode == ZEND_ADD_STRING) {
-						memcpy(ptr, ZEND_OP2_LITERAL(next_op).value.str.val, ZEND_OP2_LITERAL(next_op).value.str.len);
-						ptr += ZEND_OP2_LITERAL(next_op).value.str.len;
+						memcpy(ptr, Z_STRVAL(ZEND_OP2_LITERAL(next_op)), Z_STRLEN(ZEND_OP2_LITERAL(next_op)));
+						ptr += Z_STRLEN(ZEND_OP2_LITERAL(next_op));
 						literal_dtor(&ZEND_OP2_LITERAL(next_op));
 					} else { /* ZEND_ADD_CHAR */
-						*ptr = (char)ZEND_OP2_LITERAL(next_op).value.lval;
+						*ptr = (char)Z_LVAL(ZEND_OP2_LITERAL(next_op));
 						ptr++;
 					}
 					MAKE_NOP(next_op);
@@ -221,16 +218,16 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 				/* substitute __COMPILER_HALT_OFFSET__ constant */
 				zend_bool orig_in_execution = EG(in_execution);
 				zend_op_array *orig_op_array = EG(active_op_array);
-				zval offset;
+				zval *offset;
 
 				EG(in_execution) = 1;
 				EG(active_op_array) = op_array;
-				if (zend_get_constant("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1, &offset TSRMLS_CC)) {
+				if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1 TSRMLS_CC)) != NULL) {
 					zend_uint tv = ZEND_RESULT(opline).var;
 
 					literal_dtor(&ZEND_OP2_LITERAL(opline));
 					MAKE_NOP(opline);
-					replace_tmp_by_const(op_array, opline, tv, &offset TSRMLS_CC);
+					replace_tmp_by_const(op_array, opline, tv, offset TSRMLS_CC);
 				}
 				EG(active_op_array) = orig_op_array;
 				EG(in_execution) = orig_in_execution;
@@ -239,12 +236,12 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 
 			if (ZEND_OP1_TYPE(opline) == IS_UNUSED &&
 				ZEND_OP2_TYPE(opline) == IS_CONST &&
-				ZEND_OP2_LITERAL(opline).type == IS_STRING) {
+				Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
 				/* substitute persistent constants */
 				zend_uint tv = ZEND_RESULT(opline).var;
 				zval c;
 
-				if (!zend_get_persistent_constant(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)), &c, 1 TSRMLS_CC)) {
+				if (!zend_get_persistent_constant(Z_STR(ZEND_OP2_LITERAL(opline)), &c, 1 TSRMLS_CC)) {
 					if (!*constants || !zend_optimizer_get_collected_constant(*constants, &ZEND_OP2_LITERAL(opline), &c)) {
 						break;
 					}
@@ -258,27 +255,24 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 			/* class constant */
 			if (ZEND_OP1_TYPE(opline) != IS_UNUSED &&
 			    ZEND_OP2_TYPE(opline) == IS_CONST &&
-				ZEND_OP2_LITERAL(opline).type == IS_STRING) {
+				Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
 
-				zend_class_entry **pce = NULL;
+				zend_class_entry *ce = NULL;
 
 				if (ZEND_OP1_TYPE(opline) == IS_CONST &&
-			        ZEND_OP1_LITERAL(opline).type == IS_STRING) {
+			        Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
 					/* for A::B */
 					if (op_array->scope && 
 						!strncasecmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)),
-						op_array->scope->name, Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1)) {
-						pce = &op_array->scope;
+						op_array->scope->name->val, Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1)) {
+						ce = op_array->scope;
 					} else { 
-						if (zend_hash_quick_find(EG(class_table), 
-								Z_STRVAL(op_array->literals[opline->op1.constant + 1].constant), 
-								Z_STRLEN(op_array->literals[opline->op1.constant].constant) + 1, 
-								Z_HASH_P(&op_array->literals[opline->op1.constant + 1].constant),
-								(void **)&pce) == FAILURE ||
-								((*pce)->type == ZEND_INTERNAL_CLASS &&
-								 (*pce)->info.internal.module->type != MODULE_PERSISTENT) ||
-								((*pce)->type == ZEND_USER_CLASS &&
-								 ZEND_CE_FILENAME(*pce) != op_array->filename)) {
+						if ((ce = zend_hash_find_ptr(EG(class_table), 
+								Z_STR(op_array->literals[opline->op1.constant + 1]))) == NULL ||
+								(ce->type == ZEND_INTERNAL_CLASS &&
+								 ce->info.internal.module->type != MODULE_PERSISTENT) ||
+								(ce->type == ZEND_USER_CLASS &&
+								 ZEND_CE_FILENAME(ce) != op_array->filename)) {
 							break;
 						}
 					}
@@ -289,24 +283,23 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					((opline - 1)->extended_value & ~ZEND_FETCH_CLASS_NO_AUTOLOAD) == ZEND_FETCH_CLASS_SELF) &&
 					ZEND_RESULT((opline - 1)).var == ZEND_OP1(opline).var) {
 					/* for self::B */
-					pce = &op_array->scope;
+					ce = op_array->scope;
 				}
 
-				if (pce) {
+				if (ce) {
 					zend_uint tv = ZEND_RESULT(opline).var;
-					zval **c, t;
-
-					if (zend_hash_find(&(*pce)->constants_table,
-							Z_STRVAL(ZEND_OP2_LITERAL(opline)),
-							Z_STRLEN(ZEND_OP2_LITERAL(opline)) + 1,
-							(void **) &c) == SUCCESS) {
-						if (ZEND_IS_CONSTANT_TYPE(Z_TYPE_PP(c))) { 
-							if (!zend_get_persistent_constant(Z_STRVAL_PP(c), Z_STRLEN_PP(c), &t, 1 TSRMLS_CC) ||
+					zval *c, t;
+
+					if ((c = zend_hash_find(&ce->constants_table,
+							Z_STR(ZEND_OP2_LITERAL(opline)))) != NULL) {
+						ZVAL_DEREF(c);
+						if (ZEND_IS_CONSTANT_TYPE(Z_TYPE_P(c))) { 
+							if (!zend_get_persistent_constant(Z_STR_P(c), &t, 1 TSRMLS_CC) ||
 							    ZEND_IS_CONSTANT_TYPE(Z_TYPE(t))) {
 								break;
 							}
 						} else {
-							t = **c;
+							ZVAL_COPY_VALUE(&t, c);
 							zval_copy_ctor(&t);
 						}
 
@@ -354,8 +347,8 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 			   extension_loaded(x)
 			*/
 			if (opline->extended_value == 1 && (opline - 1)->opcode == ZEND_SEND_VAL &&
-				ZEND_OP1_TYPE(opline - 1) == IS_CONST && ZEND_OP1_LITERAL(opline - 1).type == IS_STRING &&
-				ZEND_OP1_TYPE(opline) == IS_CONST && ZEND_OP1_LITERAL(opline).type == IS_STRING) {
+				ZEND_OP1_TYPE(opline - 1) == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline - 1)) == IS_STRING &&
+				ZEND_OP1_TYPE(opline) == IS_CONST && Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
 				if ((Z_STRLEN(ZEND_OP1_LITERAL(opline)) == sizeof("function_exists")-1 &&
 					!memcmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)),
 						"function_exists", sizeof("function_exists")-1)) ||
@@ -366,8 +359,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					char *lc_name = zend_str_tolower_dup(
 							Z_STRVAL(ZEND_OP1_LITERAL(opline - 1)), Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)));
 					
-					if (zend_hash_find(EG(function_table), lc_name, Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)) + 1,
-								(void *)&func) == SUCCESS &&
+					if ((func = zend_hash_str_find_ptr(EG(function_table), lc_name, Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)))) != NULL &&
 							func->type == ZEND_INTERNAL_FUNCTION &&
 							func->module->type == MODULE_PERSISTENT) {
 						zval t;
@@ -384,14 +376,13 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					!memcmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)),
 						"extension_loaded", sizeof("extension_loaded")-1)) {
 					zval t;
-					zend_module_entry *m;
 					char *lc_name = zend_str_tolower_dup(
 							Z_STRVAL(ZEND_OP1_LITERAL(opline - 1)), Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)));
-					int found = zend_hash_find(&module_registry,
-							lc_name, Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)) + 1, (void *)&m) == SUCCESS;
+					zend_module_entry *m = zend_hash_str_find_ptr(&module_registry,
+							lc_name, Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)));
 
 					efree(lc_name);
-					if (!found) {
+					if (!m) {
 						if (!PG(enable_dl)) {
 							break;
 						} else {
@@ -416,8 +407,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 						"defined", sizeof("defined")-1)) {
 					zval t;
 
-					if (zend_get_persistent_constant(Z_STRVAL(ZEND_OP1_LITERAL(opline - 1)),
-						Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)), &t, 0 TSRMLS_CC)) {
+					if (zend_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline - 1)), &t, 0 TSRMLS_CC)) {
 
 						ZVAL_BOOL(&t, 1);
 						if (replace_var_by_const(op_array, opline + 1, ZEND_RESULT(opline).var, &t TSRMLS_CC)) {
@@ -432,8 +422,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 						"constant", sizeof("constant")-1)) {
 					zval t;
 					
-					if (zend_get_persistent_constant(Z_STRVAL(ZEND_OP1_LITERAL(opline - 1)),
-						Z_STRLEN(ZEND_OP1_LITERAL(opline - 1)), &t, 1 TSRMLS_CC)) {
+					if (zend_get_persistent_constant(Z_STR(ZEND_OP1_LITERAL(opline - 1)), &t, 1 TSRMLS_CC)) {
 						if (replace_var_by_const(op_array, opline + 1, ZEND_RESULT(opline).var, &t TSRMLS_CC)) {
 							literal_dtor(&ZEND_OP1_LITERAL(opline - 1));
 							MAKE_NOP((opline - 1));
@@ -504,7 +493,6 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 #endif
 			collect_constants = 0;
 			break;
-
 #if ZEND_EXTENSION_API_NO >= PHP_5_5_X_API_NO
 		case ZEND_FETCH_R:
 		case ZEND_FETCH_W:
@@ -557,21 +545,18 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
 					if (use->op1_type == IS_VAR && use->op1.var == var) {
 						use->op1_type = IS_CV;
 						use->op1.var = zend_optimizer_lookup_cv(op_array,
-							Z_STRVAL(ZEND_OP1_LITERAL(opline)),
-							Z_STRLEN(ZEND_OP1_LITERAL(opline)));
+							Z_STR(ZEND_OP1_LITERAL(opline)));
 						MAKE_NOP(opline);
 					} else if (use->op2_type == IS_VAR && use->op2.var == var) {
 						use->op2_type = IS_CV;
 						use->op2.var = zend_optimizer_lookup_cv(op_array,
-							Z_STRVAL(ZEND_OP1_LITERAL(opline)),
-							Z_STRLEN(ZEND_OP1_LITERAL(opline)));
+							Z_STR(ZEND_OP1_LITERAL(opline)));
 						MAKE_NOP(opline);
 					}
 				}
 			}
 			break;
 #endif
-		
 		}
 		opline++;
 		i++;
diff --git a/ext/opcache/Optimizer/pass2.c b/ext/opcache/Optimizer/pass2.c
index d5f4f0492b..e7e6f3d591 100644
--- a/ext/opcache/Optimizer/pass2.c
+++ b/ext/opcache/Optimizer/pass2.c
@@ -16,7 +16,7 @@ if (ZEND_OPTIMIZER_PASS_2 & OPTIMIZATION_LEVEL) {
 			case ZEND_MUL:
 			case ZEND_DIV:
 				if (ZEND_OP1_TYPE(opline) == IS_CONST) {
-					if (ZEND_OP1_LITERAL(opline).type == IS_STRING) {
+					if (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING) {
 						convert_scalar_to_number(&ZEND_OP1_LITERAL(opline) TSRMLS_CC);
 					}
 				}
@@ -30,7 +30,7 @@ if (ZEND_OPTIMIZER_PASS_2 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				if (ZEND_OP2_TYPE(opline) == IS_CONST) {
-					if (ZEND_OP2_LITERAL(opline).type == IS_STRING) {
+					if (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING) {
 						convert_scalar_to_number(&ZEND_OP2_LITERAL(opline) TSRMLS_CC);
 					}
 				}
@@ -40,7 +40,7 @@ if (ZEND_OPTIMIZER_PASS_2 & OPTIMIZATION_LEVEL) {
 			case ZEND_SL:
 			case ZEND_SR:
 				if (ZEND_OP1_TYPE(opline) == IS_CONST) {
-					if (ZEND_OP1_LITERAL(opline).type != IS_LONG) {
+					if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_LONG) {
 						convert_to_long(&ZEND_OP1_LITERAL(opline));
 					}
 				}
@@ -53,7 +53,7 @@ if (ZEND_OPTIMIZER_PASS_2 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				if (ZEND_OP2_TYPE(opline) == IS_CONST) {
-					if (ZEND_OP2_LITERAL(opline).type != IS_LONG) {
+					if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_LONG) {
 						convert_to_long(&ZEND_OP2_LITERAL(opline));
 					}
 				}
@@ -61,7 +61,7 @@ if (ZEND_OPTIMIZER_PASS_2 & OPTIMIZATION_LEVEL) {
 
 			case ZEND_CONCAT:
 				if (ZEND_OP1_TYPE(opline) == IS_CONST) {
-					if (ZEND_OP1_LITERAL(opline).type != IS_STRING) {
+					if (Z_TYPE(ZEND_OP1_LITERAL(opline)) != IS_STRING) {
 						convert_to_string(&ZEND_OP1_LITERAL(opline));
 					}
 				}
@@ -72,7 +72,7 @@ if (ZEND_OPTIMIZER_PASS_2 & OPTIMIZATION_LEVEL) {
 					break;
 				}
 				if (ZEND_OP2_TYPE(opline) == IS_CONST) {
-					if (ZEND_OP2_LITERAL(opline).type != IS_STRING) {
+					if (Z_TYPE(ZEND_OP2_LITERAL(opline)) != IS_STRING) {
 						convert_to_string(&ZEND_OP2_LITERAL(opline));
 					}
 				}
diff --git a/ext/opcache/Optimizer/zend_optimizer.c b/ext/opcache/Optimizer/zend_optimizer.c
index 973ba3aaac..39f7b01eea 100644
--- a/ext/opcache/Optimizer/zend_optimizer.c
+++ b/ext/opcache/Optimizer/zend_optimizer.c
@@ -41,65 +41,79 @@ static void zend_optimizer_collect_constant(HashTable **constants, zval *name, z
 
 	if (!*constants) {
 		*constants = emalloc(sizeof(HashTable));
-		zend_hash_init(*constants, 16, NULL, (void (*)(void *))zend_optimizer_zval_dtor_wrapper, 0);
+		zend_hash_init(*constants, 16, NULL, zend_optimizer_zval_dtor_wrapper, 0);
 	}
-	val = *value;
-	zval_copy_ctor(&val);
-	zend_hash_add(*constants, Z_STRVAL_P(name), Z_STRLEN_P(name)+1, (void**)&val, sizeof(zval), NULL);
+	ZVAL_DUP(&val, value);
+	zend_hash_add(*constants, Z_STR_P(name), &val);
 }
 
 static int zend_optimizer_get_collected_constant(HashTable *constants, zval *name, zval* value)
 {
 	zval *val;
 
-	if (zend_hash_find(constants, Z_STRVAL_P(name), Z_STRLEN_P(name)+1, (void**)&val) == SUCCESS) {
-		*value = *val;
-		zval_copy_ctor(value);
+	if ((val = zend_hash_find(constants, Z_STR_P(name))) != NULL) {
+		ZVAL_DUP(value, val);
 		return 1;
 	}
 	return 0;
 }
 
 #if ZEND_EXTENSION_API_NO >= PHP_5_5_X_API_NO
-static int zend_optimizer_lookup_cv(zend_op_array *op_array, char* name, int name_len)
+static int zend_optimizer_lookup_cv(zend_op_array *op_array, zend_string* name)
 {
 	int i = 0;
-	ulong hash_value = zend_inline_hash_func(name, name_len+1);
+	ulong hash_value = STR_HASH_VAL(name);
 
 	while (i < op_array->last_var) {
-		if (op_array->vars[i].name == name ||
-		    (op_array->vars[i].hash_value == hash_value &&
-		     op_array->vars[i].name_len == name_len &&
-		     memcmp(op_array->vars[i].name, name, name_len) == 0)) {
-			return i;
+		if (op_array->vars[i] == name ||
+		    (op_array->vars[i]->h == hash_value &&
+		     op_array->vars[i]->len == name->len &&
+		     memcmp(op_array->vars[i]->val, name->val, name->len) == 0)) {
+			return (int)EX_VAR_NUM_2(NULL, i);
 		}
 		i++;
 	}
 	i = op_array->last_var;
 	op_array->last_var++;
-	op_array->vars = erealloc(op_array->vars, op_array->last_var * sizeof(zend_compiled_variable));
-	if (IS_INTERNED(name)) {
-		op_array->vars[i].name = name;
-	} else {
-		op_array->vars[i].name = estrndup(name, name_len);
+	op_array->vars = erealloc(op_array->vars, op_array->last_var * sizeof(zend_string*));
+	op_array->vars[i] = STR_DUP(name, 0);
+
+	/* all IS_TMP_VAR and IS_VAR variable numbers have to be adjusted */
+	{
+		zend_op *opline = op_array->opcodes;
+		zend_op *end = opline + op_array->last;
+		while (opline < end) {
+			if (opline->op1_type & (IS_TMP_VAR|IS_VAR)) {
+				opline->op1.var += sizeof(zval);
+			}
+			if (opline->op2_type & (IS_TMP_VAR|IS_VAR)) {
+				opline->op2.var += sizeof(zval);
+			}
+			if (opline->result_type & (IS_TMP_VAR|IS_VAR)) {
+				opline->result.var += sizeof(zval);
+			}
+			if (opline->opcode == ZEND_DECLARE_INHERITED_CLASS ||
+			    opline->opcode == ZEND_DECLARE_INHERITED_CLASS_DELAYED) {
+				opline->extended_value += sizeof(zval);
+			}
+			opline++;
+		}
 	}
-	op_array->vars[i].name_len = name_len;
-	op_array->vars[i].hash_value = hash_value;
-	return i;
+	
+	return (int)EX_VAR_NUM_2(NULL, i);
 }
 #endif
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-int zend_optimizer_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC)
+int zend_optimizer_add_literal(zend_op_array *op_array, zval *zv TSRMLS_DC)
 {
 	int i = op_array->last_literal;
 	op_array->last_literal++;
-	op_array->literals = (zend_literal*)erealloc(op_array->literals, op_array->last_literal * sizeof(zend_literal));
-	op_array->literals[i].constant = *zv;
-	op_array->literals[i].hash_value = 0;
-	op_array->literals[i].cache_slot = -1;
-	Z_SET_REFCOUNT(op_array->literals[i].constant, 2);
-	Z_SET_ISREF(op_array->literals[i].constant);
+	op_array->literals = (zval*)erealloc(op_array->literals, op_array->last_literal * sizeof(zval));
+	ZVAL_COPY_VALUE(&op_array->literals[i], zv);
+	Z_CACHE_SLOT(op_array->literals[i]) = -1;
+//???	Z_SET_REFCOUNT(op_array->literals[i].constant, 2);
+//???	Z_SET_ISREF(op_array->literals[i].constant);
 	return i;
 }
 
@@ -117,7 +131,7 @@ int zend_optimizer_add_literal(zend_op_array *op_array, const zval *zv TSRMLS_DC
 
 # define literal_dtor(zv) do { \
 		zval_dtor(zv); \
-		Z_TYPE_P(zv) = IS_NULL; \
+		ZVAL_NULL(zv); \
 	} while (0)
 
 #define COPY_NODE(target, src) do { \
@@ -155,21 +169,21 @@ static void update_op1_const(zend_op_array *op_array,
 				case ZEND_CATCH:
 				case ZEND_FETCH_CONSTANT:
 					opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-					Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1);
-					op_array->literals[opline->op1.constant].cache_slot = op_array->last_cache_slot++;
+					STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline)));
+					Z_CACHE_SLOT(op_array->literals[opline->op1.constant]) = op_array->last_cache_slot++;
 					zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
 					zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-					op_array->literals[opline->op1.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op1.constant+1].constant), Z_STRLEN(op_array->literals[opline->op1.constant+1].constant) + 1);
+					STR_HASH_VAL(Z_STR(op_array->literals[opline->op1.constant+1]));
 					break;
 				case ZEND_DO_FCALL:
 					zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
 					opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-					Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1);
-					op_array->literals[opline->op1.constant].cache_slot = op_array->last_cache_slot++;
+					STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline)));
+					Z_CACHE_SLOT(op_array->literals[opline->op1.constant]) = op_array->last_cache_slot++;
 					break;
 				default:
 					opline->op1.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-					Z_HASH_P(&ZEND_OP1_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)) + 1);
+					STR_HASH_VAL(Z_STR(ZEND_OP1_LITERAL(opline)));
 					break;
 			}
 		} else {
@@ -189,7 +203,7 @@ static void update_op2_const(zend_op_array *op_array,
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	opline->op2.constant = zend_optimizer_add_literal(op_array, val TSRMLS_CC);
 	if (Z_TYPE_P(val) == IS_STRING) {
-		Z_HASH_P(&ZEND_OP2_LITERAL(opline)) = zend_hash_func(Z_STRVAL(ZEND_OP2_LITERAL(opline)), Z_STRLEN(ZEND_OP2_LITERAL(opline)) + 1);
+		STR_HASH_VAL(Z_STR(ZEND_OP2_LITERAL(opline)));
 		switch (opline->opcode) {
 			case ZEND_FETCH_R:
 			case ZEND_FETCH_W:
@@ -204,16 +218,16 @@ static void update_op2_const(zend_op_array *op_array,
 			case ZEND_ISSET_ISEMPTY_VAR:
 			case ZEND_ADD_INTERFACE:
 			case ZEND_ADD_TRAIT:
-				op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot++;
+				Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot++;
 				zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
 				zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-				op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1);
+				STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1]));
 				break;
 			case ZEND_INIT_METHOD_CALL:
 			case ZEND_INIT_STATIC_METHOD_CALL:
 				zend_str_tolower(Z_STRVAL_P(val), Z_STRLEN_P(val));
 				zend_optimizer_add_literal(op_array, val TSRMLS_CC);
-				op_array->literals[opline->op2.constant+1].hash_value = zend_hash_func(Z_STRVAL(op_array->literals[opline->op2.constant+1].constant), Z_STRLEN(op_array->literals[opline->op2.constant+1].constant) + 1);
+				STR_HASH_VAL(Z_STR(op_array->literals[opline->op2.constant+1]));
 				/* break missing intentionally */						
 			/*case ZEND_FETCH_CONSTANT:*/
 			case ZEND_ASSIGN_OBJ:
@@ -229,7 +243,7 @@ static void update_op2_const(zend_op_array *op_array,
 			case ZEND_POST_INC_OBJ:
 			case ZEND_POST_DEC_OBJ:
 			case ZEND_ISSET_ISEMPTY_PROP_OBJ:
-				op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot;
+				Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot;
 				op_array->last_cache_slot += 2;
 				break;
 			case ZEND_ASSIGN_ADD:
@@ -244,7 +258,7 @@ static void update_op2_const(zend_op_array *op_array,
 			case ZEND_ASSIGN_BW_AND:
 			case ZEND_ASSIGN_BW_XOR:
 				if (opline->extended_value == ZEND_ASSIGN_OBJ) {
-					op_array->literals[opline->op2.constant].cache_slot = op_array->last_cache_slot;
+					Z_CACHE_SLOT(op_array->literals[opline->op2.constant]) = op_array->last_cache_slot;
 					op_array->last_cache_slot += 2;
 				}
 				break;
@@ -286,7 +300,7 @@ check_numeric:
 					if (numeric) {
 						zval_dtor(val);
 						ZVAL_LONG(val, index);
-						op_array->literals[opline->op2.constant].constant = *val;
+						op_array->literals[opline->op2.constant] = *val;
 		        	}
 				}
 				break;
@@ -467,10 +481,10 @@ static void zend_accel_optimize(zend_op_array           *op_array,
 	while (opline < end) {
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 		if (opline->op1_type == IS_CONST) {
-			opline->op1.constant = opline->op1.literal - op_array->literals;
+			opline->op1.constant = opline->op1.zv - op_array->literals;
 		}
 		if (opline->op2_type == IS_CONST) {
-			opline->op2.constant = opline->op2.literal - op_array->literals;
+			opline->op2.constant = opline->op2.zv - op_array->literals;
 		}
 #endif
 		switch (opline->opcode) {
@@ -508,10 +522,10 @@ static void zend_accel_optimize(zend_op_array           *op_array,
 	while (opline < end) {
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 		if (opline->op1_type == IS_CONST) {
-			opline->op1.zv = &op_array->literals[opline->op1.constant].constant;
+			opline->op1.zv = &op_array->literals[opline->op1.constant];
 		}
 		if (opline->op2_type == IS_CONST) {
-			opline->op2.zv = &op_array->literals[opline->op2.constant].constant;
+			opline->op2.zv = &op_array->literals[opline->op2.constant];
 		}
 #endif
 		switch (opline->opcode) {
@@ -544,37 +558,40 @@ static void zend_accel_optimize(zend_op_array           *op_array,
 
 int zend_accel_script_optimize(zend_persistent_script *script TSRMLS_DC)
 {
+	uint idx, j;
 	Bucket *p, *q;
 	HashTable *constants = NULL;
+	zend_class_entry *ce;
+	zend_op_array *op_array;
 
 	zend_accel_optimize(&script->main_op_array, script, &constants TSRMLS_CC);
 
-	p = script->function_table.pListHead;
-	while (p) {
-		zend_op_array *op_array = (zend_op_array*)p->pData;
+	for (idx = 0; idx < script->function_table.nNumUsed; idx++) {
+		p = script->function_table.arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		op_array = (zend_op_array*)Z_PTR(p->val);
 		zend_accel_optimize(op_array, script, &constants TSRMLS_CC);
-		p = p->pListNext;
 	}
 
-	p = script->class_table.pListHead;
-	while (p) {
-		zend_class_entry *ce = (zend_class_entry*)p->pDataPtr;
-		q = ce->function_table.pListHead;
-		while (q) {
-			zend_op_array *op_array = (zend_op_array*)q->pData;
+	for (idx = 0; idx < script->class_table.nNumUsed; idx++) {
+		p = script->class_table.arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		ce = (zend_class_entry*)Z_PTR(p->val);
+		for (j = 0; j < ce->function_table.nNumUsed; j++) {
+			q = ce->function_table.arData + j;
+			if (Z_TYPE(q->val) == IS_UNDEF) continue;
+			op_array = (zend_op_array*)Z_PTR(q->val);
 			if (op_array->scope == ce) {
 				zend_accel_optimize(op_array, script, &constants TSRMLS_CC);
 			} else if (op_array->type == ZEND_USER_FUNCTION) {
 				zend_op_array *orig_op_array;
-				if (zend_hash_find(&op_array->scope->function_table, q->arKey, q->nKeyLength, (void**)&orig_op_array) == SUCCESS) {
+				if ((orig_op_array = zend_hash_find_ptr(&op_array->scope->function_table, q->key)) != NULL) {
 					HashTable *ht = op_array->static_variables;
 					*op_array = *orig_op_array;
 					op_array->static_variables = ht;
 				}
 			}
-			q = q->pListNext;
 		}
-		p = p->pListNext;
 	}
 
 	if (constants) {
diff --git a/ext/opcache/Optimizer/zend_optimizer_internal.h b/ext/opcache/Optimizer/zend_optimizer_internal.h
index d4baf531e1..049036c1f4 100644
--- a/ext/opcache/Optimizer/zend_optimizer_internal.h
+++ b/ext/opcache/Optimizer/zend_optimizer_internal.h
@@ -24,7 +24,10 @@
 
 #include "ZendAccelerator.h"
 
-#if ZEND_EXTENSION_API_NO > PHP_5_4_X_API_NO
+#if 1 // TODO: remove support for old PHP versions ???
+# define VAR_NUM(v) EX_VAR_TO_NUM(v)
+# define NUM_VAR(v) ((zend_uint)(zend_uintptr_t)EX_VAR_NUM_2(0, v))
+#elif ZEND_EXTENSION_API_NO > PHP_5_4_X_API_NO
 # define VAR_NUM(v) ((zend_uint)(EX_TMP_VAR_NUM(0, 0) - EX_TMP_VAR(0, v)))
 # define NUM_VAR(v) ((zend_uint)(zend_uintptr_t)EX_TMP_VAR_NUM(0, v))
 #elif ZEND_EXTENSION_API_NO > PHP_5_2_X_API_NO
diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index 7c55de3752..bf951ff72a 100644
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -251,9 +251,7 @@ static ZEND_INI_MH(accel_include_path_on_modify)
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 /* Interned strings support */
-static char *orig_interned_strings_start;
-static char *orig_interned_strings_end;
-static const char *(*orig_new_interned_string)(const char *str, int len, int free_src TSRMLS_DC);
+static zend_string *(*orig_new_interned_string)(zend_string *str TSRMLS_DC);
 static void (*orig_interned_strings_snapshot)(TSRMLS_D);
 static void (*orig_interned_strings_restore)(TSRMLS_D);
 
@@ -261,7 +259,7 @@ static void (*orig_interned_strings_restore)(TSRMLS_D);
  * it creates interned strings in shared memory when saves a script.
  * Such interned strings are shared across all PHP processes
  */
-static const char *accel_new_interned_string_for_php(const char *str, int len, int free_src TSRMLS_DC)
+static zend_string *accel_new_interned_string_for_php(zend_string *str TSRMLS_DC)
 {
 	return str;
 }
@@ -277,112 +275,100 @@ static void accel_interned_strings_restore_for_php(TSRMLS_D)
 #ifndef ZTS
 static void accel_interned_strings_restore_state(TSRMLS_D)
 {
-	unsigned int i;
-
-	for (i = 0; i < ZCSG(interned_strings).nTableSize; i++) {
-		ZCSG(interned_strings).arBuckets[i] = ZCSG(interned_strings_saved_state).arBuckets[i];
-		if (ZCSG(interned_strings).arBuckets[i]) {
-			ZCSG(interned_strings).arBuckets[i]->pLast = NULL;
-		}
-	}
-	ZCSG(interned_strings).pListHead = ZCSG(interned_strings_saved_state).pListHead;
-	ZCSG(interned_strings).pListTail = ZCSG(interned_strings_saved_state).pListTail;
-	if (ZCSG(interned_strings).pListHead) {
-		ZCSG(interned_strings).pListHead->pListLast = NULL;
-	}
-	if (ZCSG(interned_strings).pListTail) {
-		ZCSG(interned_strings).pListTail->pListNext = NULL;
+    uint idx = ZCSG(interned_strings).nNumUsed;
+    uint nIndex;
+    Bucket *p;
+
+	ZCSG(interned_strings_top) = ZCSG(interned_strings_saved_top);
+    while (idx > 0) {
+    	idx--;
+		p = ZCSG(interned_strings).arData + idx;
+		if ((char*)p->key < ZCSG(interned_strings_top)) break;
+		ZCSG(interned_strings).nNumUsed--;
+		ZCSG(interned_strings).nNumOfElements--;
+
+		nIndex = p->h & ZCSG(interned_strings).nTableMask;
+		if (ZCSG(interned_strings).arHash[nIndex] == idx) {
+			ZCSG(interned_strings).arHash[nIndex] = Z_NEXT(p->val);
+		} else {
+			uint prev = ZCSG(interned_strings).arHash[nIndex];
+			while (Z_NEXT(ZCSG(interned_strings).arData[prev].val) != idx) {
+				prev = Z_NEXT(ZCSG(interned_strings).arData[prev].val);
+ 			}
+			Z_NEXT(ZCSG(interned_strings).arData[prev].val) = Z_NEXT(p->val);
+ 		}
 	}
-	ZCSG(interned_strings_top) = ZCSG(interned_strings_saved_state).top;
 }
 
 static void accel_interned_strings_save_state(TSRMLS_D)
 {
-	ZCSG(interned_strings_saved_state).arBuckets = (Bucket**)zend_shared_alloc(ZCSG(interned_strings).nTableSize * sizeof(Bucket *));
-	if (!ZCSG(interned_strings_saved_state).arBuckets) {
-		zend_accel_error(ACCEL_LOG_FATAL, "Insufficient shared memory!");
-	}
-	memcpy(ZCSG(interned_strings_saved_state).arBuckets, ZCSG(interned_strings).arBuckets, ZCSG(interned_strings).nTableSize * sizeof(Bucket *));
-	ZCSG(interned_strings_saved_state).pListHead = ZCSG(interned_strings).pListHead;
-	ZCSG(interned_strings_saved_state).pListTail = ZCSG(interned_strings).pListTail;
-	ZCSG(interned_strings_saved_state).top = ZCSG(interned_strings_top);
+	ZCSG(interned_strings_saved_top) = ZCSG(interned_strings_top);
 }
 #endif
 
-const char *accel_new_interned_string(const char *arKey, int nKeyLength, int free_src TSRMLS_DC)
+zend_string *accel_new_interned_string(zend_string *str TSRMLS_DC)
 {
 /* for now interned strings are supported only for non-ZTS build */
 #ifndef ZTS
 	ulong h;
 	uint nIndex;
+	uint idx;
 	Bucket *p;
 
-	if (arKey >= ZCSG(interned_strings_start) && arKey < ZCSG(interned_strings_end)) {
+	if (IS_ACCEL_INTERNED(str)) {
 		/* this is already an interned string */
-		return arKey;
+		return str;
 	}
 
-	h = zend_inline_hash_func(arKey, nKeyLength);
+	h = STR_HASH_VAL(str);
 	nIndex = h & ZCSG(interned_strings).nTableMask;
 
 	/* check for existing interned string */
-	p = ZCSG(interned_strings).arBuckets[nIndex];
-	while (p != NULL) {
-		if ((p->h == h) && (p->nKeyLength == (uint)nKeyLength)) {
-			if (!memcmp(p->arKey, arKey, nKeyLength)) {
-				if (free_src) {
-					efree((char*)arKey);
-				}
-				return p->arKey;
+	idx = ZCSG(interned_strings).arHash[nIndex];
+	while (idx != INVALID_IDX) {
+		p = ZCSG(interned_strings).arData + idx;
+		if ((p->h == h) && (p->key->len == str->len)) {
+			if (!memcmp(p->key->val, str->val, str->len)) {
+				STR_RELEASE(str);
+				return p->key;
 			}
 		}
-		p = p->pNext;
+		idx = Z_NEXT(p->val);
 	}
 
-	if (ZCSG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength) >=
+	if (ZCSG(interned_strings_top) + ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + str->len + 1) >=
 	    ZCSG(interned_strings_end)) {
 	    /* no memory, return the same non-interned string */
 		zend_accel_error(ACCEL_LOG_WARNING, "Interned string buffer overflow");
-		return arKey;
+		return str;
 	}
 
 	/* create new interning string in shared interned strings buffer */
-	p = (Bucket *) ZCSG(interned_strings_top);
-	ZCSG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(sizeof(Bucket) + nKeyLength);
-
-	p->arKey = (char*)(p + 1);
-	memcpy((char*)p->arKey, arKey, nKeyLength);
-	p->nKeyLength = nKeyLength;
-	p->h = h;
-	p->pData = &p->pDataPtr;
-	p->pDataPtr = p;
-
-	p->pNext = ZCSG(interned_strings).arBuckets[nIndex];
-	p->pLast = NULL;
-	if (p->pNext) {
-		p->pNext->pLast = p;
-	}
-	ZCSG(interned_strings).arBuckets[nIndex] = p;
-
-	p->pListLast = ZCSG(interned_strings).pListTail;
-	ZCSG(interned_strings).pListTail = p;
-	p->pListNext = NULL;
-	if (p->pListLast != NULL) {
-		p->pListLast->pListNext = p;
-	}
-	if (!ZCSG(interned_strings).pListHead) {
-		ZCSG(interned_strings).pListHead = p;
-	}
 
+	idx = ZCSG(interned_strings).nNumUsed++;
 	ZCSG(interned_strings).nNumOfElements++;
-
-	if (free_src) {
-		efree((char*)arKey);
-	}
-
-	return p->arKey;
+	p = ZCSG(interned_strings).arData + idx;
+	p->key = (zend_string*) ZCSG(interned_strings_top);
+	ZCSG(interned_strings_top) += ZEND_MM_ALIGNED_SIZE(_STR_HEADER_SIZE + str->len + 1);
+	p->h = h;
+	GC_REFCOUNT(p->key) = 1;
+#if 1
+	/* optimized single assignment */
+	GC_TYPE_INFO(p->key) = IS_STRING | ((IS_STR_INTERNED | IS_STR_PERMANENT) << 8);
 #else
-	return arKey;
+	GC_TYPE(p->key) = IS_STRING;
+	GC_FLAGS(p->key) = IS_STR_INTERNED | IS_STR_PERMANENT;
+#endif
+	p->key->h = str->h;
+	p->key->len = str->len;
+	memcpy(p->key->val, str->val, str->len);
+	ZVAL_STR(&p->val, p->key);
+	Z_NEXT(p->val) = ZCSG(interned_strings).arHash[nIndex];
+	ZCSG(interned_strings).arHash[nIndex] = idx;
+	STR_RELEASE(str);
+	return p->key;
+#else
+	return str;
 #endif
 }
 
@@ -390,88 +376,99 @@ const char *accel_new_interned_string(const char *arKey, int nKeyLength, int fre
 /* Copy PHP interned strings from PHP process memory into the shared memory */
 static void accel_use_shm_interned_strings(TSRMLS_D)
 {
+	uint idx, j;
 	Bucket *p, *q;
 
 #if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
 	/* empty string */
-	CG(interned_empty_string) = accel_new_interned_string("", sizeof(""), 0 TSRMLS_CC);
+	CG(empty_string) = accel_new_interned_string(CG(empty_string) TSRMLS_CC);
+	for (j = 0; j < 256; j++) {
+		char s[2];
+		s[0] = j;
+		s[1] = 0;
+		CG(one_char_string)[j] = accel_new_interned_string(STR_INIT(s, 1, 0) TSRMLS_CC);
+	}
 #endif
 
 	/* function table hash keys */
-	p = CG(function_table)->pListHead;
-	while (p) {
-		if (p->nKeyLength) {
-			p->arKey = accel_new_interned_string(p->arKey, p->nKeyLength, 0 TSRMLS_CC);
+	for (idx = 0; idx < CG(function_table)->nNumUsed; idx++) {		
+		p = CG(function_table)->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key) {
+			p->key = accel_new_interned_string(p->key TSRMLS_CC);
 		}
-		p = p->pListNext;
 	}
 
 	/* class table hash keys, class names, properties, methods, constants, etc */
-	p = CG(class_table)->pListHead;
-	while (p) {
-		zend_class_entry *ce = (zend_class_entry*)(p->pDataPtr);
+	for (idx = 0; idx < CG(class_table)->nNumUsed; idx++) {		
+		p = CG(class_table)->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		zend_class_entry *ce = (zend_class_entry*)Z_PTR(p->val);
 
-		if (p->nKeyLength) {
-			p->arKey = accel_new_interned_string(p->arKey, p->nKeyLength, 0 TSRMLS_CC);
+		if (p->key) {
+			p->key = accel_new_interned_string(p->key TSRMLS_CC);
 		}
 
 		if (ce->name) {
-			ce->name = accel_new_interned_string(ce->name, ce->name_length + 1, 0 TSRMLS_CC);
+			ce->name = accel_new_interned_string(ce->name TSRMLS_CC);
 		}
 
-		q = ce->properties_info.pListHead;
-		while (q) {
-			zend_property_info *info = (zend_property_info*)(q->pData);
+		for (j = 0; j < ce->properties_info.nNumUsed; j++) {
+			zend_property_info *info;
 
-			if (q->nKeyLength) {
-				q->arKey = accel_new_interned_string(q->arKey, q->nKeyLength, 0 TSRMLS_CC);
+			q = ce->properties_info.arData + j;
+			if (Z_TYPE(q->val) == IS_UNDEF) continue;
+			
+			info = (zend_property_info*)Z_PTR(q->val);
+
+			if (q->key) {
+				q->key = accel_new_interned_string(q->key TSRMLS_CC);
 			}
 
 			if (info->name) {
-				info->name = accel_new_interned_string(info->name, info->name_length + 1, 0 TSRMLS_CC);
+				info->name = accel_new_interned_string(info->name TSRMLS_CC);
 			}
-
-			q = q->pListNext;
 		}
 
-		q =	ce->function_table.pListHead;
-		while (q) {
-			if (q->nKeyLength) {
-				q->arKey = accel_new_interned_string(q->arKey, q->nKeyLength, 0 TSRMLS_CC);
+		for (j = 0; j < ce->function_table.nNumUsed; j++) {
+			q = ce->function_table.arData + j;
+			if (Z_TYPE(q->val) == IS_UNDEF) continue;
+			if (q->key) {
+				q->key = accel_new_interned_string(q->key TSRMLS_CC);
 			}
-			q = q->pListNext;
 		}
 
-		q =	ce->constants_table.pListHead;
-		while (q) {
-			if (q->nKeyLength) {
-				q->arKey = accel_new_interned_string(q->arKey, q->nKeyLength, 0 TSRMLS_CC);
+		for (j = 0; j < ce->constants_table.nNumUsed; j++) {
+			q = ce->constants_table.arData + j;
+			if (!Z_TYPE(q->val) == IS_UNDEF) continue;
+			if (q->key) {
+				q->key = accel_new_interned_string(q->key TSRMLS_CC);
 			}
-			q = q->pListNext;
 		}
-
-		p = p->pListNext;
 	}
 
 	/* constant hash keys */
-	p = EG(zend_constants)->pListHead;
-	while (p) {
-		if (p->nKeyLength) {
-			p->arKey = accel_new_interned_string(p->arKey, p->nKeyLength, 0 TSRMLS_CC);
+	for (idx = 0; idx < EG(zend_constants)->nNumUsed; idx++) {		
+		p = EG(zend_constants)->arData + idx;
+		if (!Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key) {
+			p->key = accel_new_interned_string(p->key TSRMLS_CC);
 		}
-		p = p->pListNext;
 	}
 
 	/* auto globals hash keys and names */
-	p = CG(auto_globals)->pListHead;
-	while (p) {
-		zend_auto_global *auto_global = (zend_auto_global*)p->pData;
+	for (idx = 0; idx < CG(auto_globals)->nNumUsed; idx++) {		
+		zend_auto_global *auto_global;
 
-		auto_global->name = accel_new_interned_string(auto_global->name, auto_global->name_len + 1, 0 TSRMLS_CC);
-		if (p->nKeyLength) {
-			p->arKey = accel_new_interned_string(p->arKey, p->nKeyLength, 0 TSRMLS_CC);
+		p = CG(auto_globals)->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		
+		auto_global = (zend_auto_global*)Z_PTR(p->val);;
+
+		auto_global->name = accel_new_interned_string(auto_global->name TSRMLS_CC);
+		if (p->key) {
+			p->key = accel_new_interned_string(p->key TSRMLS_CC);
 		}
-		p = p->pListNext;
 	}
 }
 #endif
@@ -840,7 +837,7 @@ static inline int do_validate_timestamps(zend_persistent_script *persistent_scri
 	 * See bug #15140
 	 */
 	if (file_handle->opened_path) {
-		if (strcmp(persistent_script->full_path, file_handle->opened_path) != 0) {
+		if (strcmp(persistent_script->full_path->val, file_handle->opened_path) != 0) {
 			return FAILURE;
 		}
 	} else {		
@@ -849,7 +846,7 @@ static inline int do_validate_timestamps(zend_persistent_script *persistent_scri
 #else
 		full_path_ptr = accelerator_orig_zend_resolve_path(file_handle->filename, strlen(file_handle->filename) TSRMLS_CC);
 #endif
-		if (full_path_ptr && strcmp(persistent_script->full_path, full_path_ptr) != 0) {
+		if (full_path_ptr && strcmp(persistent_script->full_path->val, full_path_ptr) != 0) {
 			efree(full_path_ptr);
 			return FAILURE;
 		}
@@ -877,8 +874,8 @@ static inline int do_validate_timestamps(zend_persistent_script *persistent_scri
 	}
 
 	ps_handle.type = ZEND_HANDLE_FILENAME;
-	ps_handle.filename = persistent_script->full_path;
-	ps_handle.opened_path = persistent_script->full_path;
+	ps_handle.filename = persistent_script->full_path->val;
+	ps_handle.opened_path = persistent_script->full_path->val;
 
 	if (zend_get_file_handle_timestamp(&ps_handle, NULL TSRMLS_CC) == persistent_script->timestamp) {
 		return SUCCESS;
@@ -1164,7 +1161,7 @@ static zend_persistent_script *cache_script_in_shared_memory(zend_persistent_scr
 	/* Check if we still need to put the file into the cache (may be it was
 	 * already stored by another process. This final check is done under
 	 * exclusive lock) */
-	bucket = zend_accel_hash_find_entry(&ZCSG(hash), new_persistent_script->full_path, new_persistent_script->full_path_len + 1);
+	bucket = zend_accel_hash_find_entry(&ZCSG(hash), new_persistent_script->full_path->val, new_persistent_script->full_path->len + 1);
 	if (bucket) {
 		zend_persistent_script *existing_persistent_script = (zend_persistent_script *)bucket->data;
 
@@ -1202,7 +1199,7 @@ static zend_persistent_script *cache_script_in_shared_memory(zend_persistent_scr
 		zend_accel_error(
 			((char*)new_persistent_script->mem + new_persistent_script->size < (char*)ZCG(mem)) ? ACCEL_LOG_ERROR : ACCEL_LOG_WARNING,
 			"Internal error: wrong size calculation: %s start=0x%08x, end=0x%08x, real=0x%08x\n",
-			new_persistent_script->full_path,
+			new_persistent_script->full_path->val,
 			new_persistent_script->mem,
 			(char *)new_persistent_script->mem + new_persistent_script->size,
 			ZCG(mem));
@@ -1211,14 +1208,14 @@ static zend_persistent_script *cache_script_in_shared_memory(zend_persistent_scr
 	new_persistent_script->dynamic_members.checksum = zend_accel_script_checksum(new_persistent_script);
 
 	/* store script structure in the hash table */
-	bucket = zend_accel_hash_update(&ZCSG(hash), new_persistent_script->full_path, new_persistent_script->full_path_len + 1, 0, new_persistent_script);
+	bucket = zend_accel_hash_update(&ZCSG(hash), new_persistent_script->full_path->val, new_persistent_script->full_path->len + 1, 0, new_persistent_script);
 	if (bucket) {
 		zend_accel_error(ACCEL_LOG_INFO, "Cached script '%s'", new_persistent_script->full_path);
 		if (!ZCG(accel_directives).revalidate_path &&
 		    /* key may contain non-persistent PHAR aliases (see issues #115 and #149) */
 		    memcmp(key, "phar://", sizeof("phar://") - 1) != 0 &&
-		    (new_persistent_script->full_path_len != key_length ||
-		     memcmp(new_persistent_script->full_path, key, key_length) != 0)) {
+		    (new_persistent_script->full_path->len != key_length ||
+		     memcmp(new_persistent_script->full_path->val, key, key_length) != 0)) {
 			/* link key to the same persistent script in hash table */
 			if (zend_accel_hash_update(&ZCSG(hash), key, key_length + 1, 1, bucket)) {
 				zend_accel_error(ACCEL_LOG_INFO, "Added key '%s'", key);
@@ -1243,14 +1240,16 @@ static const struct jit_auto_global_info
     const char *name;
     size_t len;
 } jit_auto_globals_info[] = {
-    { "_SERVER",  sizeof("_SERVER")},
-    { "_ENV",     sizeof("_ENV")},
-    { "_REQUEST", sizeof("_REQUEST")},
+    { "_SERVER",  sizeof("_SERVER")-1},
+    { "_ENV",     sizeof("_ENV")-1},
+    { "_REQUEST", sizeof("_REQUEST")-1},
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-    { "GLOBALS",  sizeof("GLOBALS")},
+    { "GLOBALS",  sizeof("GLOBALS")-1},
 #endif
 };
 
+static zend_string *jit_auto_globals_str[4];
+
 static int zend_accel_get_auto_globals(TSRMLS_D)
 {
 	int i, ag_size = (sizeof(jit_auto_globals_info) / sizeof(jit_auto_globals_info[0]));
@@ -1258,7 +1257,7 @@ static int zend_accel_get_auto_globals(TSRMLS_D)
 	int mask = 0;
 
 	for (i = 0; i < ag_size ; i++) {
-		if (zend_hash_exists(&EG(symbol_table), jit_auto_globals_info[i].name, jit_auto_globals_info[i].len)) {
+		if (zend_hash_exists(&EG(symbol_table).ht, jit_auto_globals_str[i])) {
 			mask |= n;
 		}
 		n += n;
@@ -1269,7 +1268,7 @@ static int zend_accel_get_auto_globals(TSRMLS_D)
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 static int zend_accel_get_auto_globals_no_jit(TSRMLS_D)
 {
-	if (zend_hash_exists(&EG(symbol_table), jit_auto_globals_info[3].name, jit_auto_globals_info[3].len)) {
+	if (zend_hash_exists(&EG(symbol_table).ht, jit_auto_globals_str[3])) {
 		return 8;
 	}
 	return 0;
@@ -1283,18 +1282,29 @@ static void zend_accel_set_auto_globals(int mask TSRMLS_DC)
 
 	for (i = 0; i < ag_size ; i++) {
 		if (mask & n) {
-			zend_is_auto_global(jit_auto_globals_info[i].name, jit_auto_globals_info[i].len - 1 TSRMLS_CC);
+			zend_is_auto_global(jit_auto_globals_str[i] TSRMLS_CC);
 		}
 		n += n;
 	}
 }
 
+static void zend_accel_init_auto_globals(TSRMLS_D)
+{
+	int i, ag_size = (sizeof(jit_auto_globals_info) / sizeof(jit_auto_globals_info[0]));
+
+	for (i = 0; i < ag_size ; i++) {
+		jit_auto_globals_str[i] = STR_INIT(jit_auto_globals_info[i].name, jit_auto_globals_info[i].len, 1);
+		STR_HASH_VAL(jit_auto_globals_str[i]);
+		jit_auto_globals_str[i] = accel_new_interned_string(jit_auto_globals_str[i] TSRMLS_CC);
+	}
+}
+
 static zend_persistent_script *compile_and_cache_file(zend_file_handle *file_handle, int type, char *key, unsigned int key_length, zend_op_array **op_array_p, int *from_shared_memory TSRMLS_DC)
 {
 	zend_persistent_script *new_persistent_script;
 	zend_op_array *orig_active_op_array;
 	HashTable *orig_function_table, *orig_class_table;
-	zval *orig_user_error_handler;
+	zval orig_user_error_handler;
 	zend_op_array *op_array;
 	int do_bailout = 0;
 	accel_time_t timestamp = 0;
@@ -1391,12 +1401,12 @@ static zend_persistent_script *compile_and_cache_file(zend_file_handle *file_han
 	orig_active_op_array = CG(active_op_array);
 	orig_function_table = CG(function_table);
 	orig_class_table = CG(class_table);
-	orig_user_error_handler = EG(user_error_handler);
+	ZVAL_COPY_VALUE(&orig_user_error_handler, &EG(user_error_handler));
 
 	/* Override them with ours */
 	CG(function_table) = &ZCG(function_table);
 	EG(class_table) = CG(class_table) = &new_persistent_script->class_table;
-	EG(user_error_handler) = NULL;
+	ZVAL_UNDEF(&EG(user_error_handler));
 
 	zend_try {
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
@@ -1466,13 +1476,11 @@ static zend_persistent_script *compile_and_cache_file(zend_file_handle *file_han
 	}
 
 	if (file_handle->opened_path) {
-		new_persistent_script->full_path_len = strlen(file_handle->opened_path);
-		new_persistent_script->full_path = estrndup(file_handle->opened_path, new_persistent_script->full_path_len);
+		new_persistent_script->full_path = STR_INIT(file_handle->opened_path, strlen(file_handle->opened_path), 0);
 	} else {
-		new_persistent_script->full_path_len = strlen(file_handle->filename);
-		new_persistent_script->full_path = estrndup(file_handle->filename, new_persistent_script->full_path_len);
+		new_persistent_script->full_path = STR_INIT(file_handle->filename, strlen(file_handle->filename), 0);
 	}
-	new_persistent_script->hash_value = zend_hash_func(new_persistent_script->full_path, new_persistent_script->full_path_len + 1);
+	STR_HASH_VAL(new_persistent_script->full_path);
 
 	/* Now persistent_script structure is ready in process memory */
 	return cache_script_in_shared_memory(new_persistent_script, key, key_length, from_shared_memory TSRMLS_CC);
@@ -1682,16 +1690,15 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type T
  			    ((*EG(opline_ptr))->op2.u.constant.value.lval != ZEND_INCLUDE_ONCE &&
  			     (*EG(opline_ptr))->op2.u.constant.value.lval != ZEND_REQUIRE_ONCE)) {
 #endif
-				void *dummy = (void *) 1;
 
-				if (zend_hash_quick_add(&EG(included_files), persistent_script->full_path, persistent_script->full_path_len + 1, persistent_script->hash_value, &dummy, sizeof(void *), NULL) == SUCCESS) {
+				if (zend_hash_add_empty_element(&EG(included_files), persistent_script->full_path) == SUCCESS) {
 					/* ext/phar has to load phar's metadata into memory */
-					if (strstr(persistent_script->full_path, ".phar") && !strstr(persistent_script->full_path, "://")) {
+					if (strstr(persistent_script->full_path->val, ".phar") && !strstr(persistent_script->full_path->val, "://")) {
 						php_stream_statbuf ssb;
-						char *fname = emalloc(sizeof("phar://") + persistent_script->full_path_len);
+						char *fname = emalloc(sizeof("phar://") + persistent_script->full_path->len);
 
 						memcpy(fname, "phar://", sizeof("phar://") - 1);
-						memcpy(fname + sizeof("phar://") - 1, persistent_script->full_path, persistent_script->full_path_len + 1);
+						memcpy(fname + sizeof("phar://") - 1, persistent_script->full_path->val, persistent_script->full_path->len + 1);
 						php_stream_stat_path(fname, &ssb);
 						efree(fname);
 					}
@@ -1958,7 +1965,7 @@ static int persistent_stream_open_function(const char *filename, zend_file_handl
 			    (EG(opline_ptr) &&
 			     (ZCG(cache_opline) == *EG(opline_ptr)))) {
 				persistent_script = ZCG(cache_persistent_script);
-				handle->opened_path = estrndup(persistent_script->full_path, persistent_script->full_path_len);
+				handle->opened_path = estrndup(persistent_script->full_path->val, persistent_script->full_path->len);
 				handle->type = ZEND_HANDLE_FILENAME;
 				return SUCCESS;
 #if 0
@@ -2024,11 +2031,11 @@ static char* persistent_zend_resolve_path(const char *filename, int filename_len
 			    (bucket = zend_accel_hash_find_entry(&ZCSG(hash), (char*)filename, filename_len + 1)) != NULL) {
 				persistent_script = (zend_persistent_script *)bucket->data;
 				if (persistent_script && !persistent_script->corrupted) {
-					memcpy(ZCG(key), persistent_script->full_path, persistent_script->full_path_len + 1);
-					ZCG(key_len) = persistent_script->full_path_len;
+					memcpy(ZCG(key), persistent_script->full_path->val, persistent_script->full_path->len + 1);
+					ZCG(key_len) = persistent_script->full_path->len;
 					ZCG(cache_opline) = EG(opline_ptr) ? *EG(opline_ptr) : NULL;
 					ZCG(cache_persistent_script) = persistent_script;
-					return estrndup(persistent_script->full_path, persistent_script->full_path_len);
+					return estrndup(persistent_script->full_path->val, persistent_script->full_path->len);
 				}
 		    }
 
@@ -2045,7 +2052,7 @@ static char* persistent_zend_resolve_path(const char *filename, int filename_len
 				/* we have persistent script */
 				ZCG(cache_opline) = EG(opline_ptr) ? *EG(opline_ptr) : NULL;
 				ZCG(cache_persistent_script) = persistent_script;
-				return estrndup(persistent_script->full_path, persistent_script->full_path_len);
+				return estrndup(persistent_script->full_path->val, persistent_script->full_path->len);
 			}
 
 			/* find the full real path */
@@ -2191,23 +2198,23 @@ static void accel_activate(void)
 
 static void accel_fast_hash_destroy(HashTable *ht)
 {
-	Bucket *p = ht->pListHead;
-
-	while (p != NULL) {
-		ht->pDestructor(p->pData);
-		p = p->pListNext;
+	uint idx;
+	Bucket *p;
+	
+	for (idx = 0; idx < ht->nNumUsed; idx++) {	
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		ht->pDestructor(&p->val);
 	}
 }
 
-static void accel_fast_zval_ptr_dtor(zval **zval_ptr)
+static void accel_fast_zval_dtor(zval *zvalue)
 {
-	zval *zvalue = *zval_ptr;
-
-	if (Z_DELREF_P(zvalue) == 0) {
+	if (Z_REFCOUNTED_P(zvalue) && Z_DELREF_P(zvalue) == 0) {
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-		switch (Z_TYPE_P(zvalue) & IS_CONSTANT_TYPE_MASK) {
+		switch (Z_TYPE_P(zvalue)) {
 #else
-		switch (Z_TYPE_P(zvalue) & ~IS_CONSTANT_INDEX) {
+		switch (Z_TYPE_P(zvalue)) {
 #endif
 #if ZEND_EXTENSION_API_NO <= PHP_5_5_API_NO
 			case IS_CONSTANT_ARRAY:
@@ -2216,13 +2223,13 @@ static void accel_fast_zval_ptr_dtor(zval **zval_ptr)
 					TSRMLS_FETCH();
 
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-					GC_REMOVE_ZVAL_FROM_BUFFER(zvalue);
+					GC_REMOVE_FROM_BUFFER(Z_ARR_P(zvalue));
 #endif
-					if (zvalue->value.ht && (zvalue->value.ht != &EG(symbol_table))) {
+					if (Z_ARR_P(zvalue) != &EG(symbol_table)) {
 						/* break possible cycles */
-						Z_TYPE_P(zvalue) = IS_NULL;
-						zvalue->value.ht->pDestructor = (dtor_func_t)accel_fast_zval_ptr_dtor;
-						accel_fast_hash_destroy(zvalue->value.ht);
+						ZVAL_NULL(zvalue);
+						Z_ARRVAL_P(zvalue)->pDestructor = accel_fast_zval_dtor;
+						accel_fast_hash_destroy(Z_ARRVAL_P(zvalue));
 					}
 				}
 				break;
@@ -2230,10 +2237,7 @@ static void accel_fast_zval_ptr_dtor(zval **zval_ptr)
 				{
 					TSRMLS_FETCH();
 
-#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-					GC_REMOVE_ZVAL_FROM_BUFFER(zvalue);
-#endif
-					Z_OBJ_HT_P(zvalue)->del_ref(zvalue TSRMLS_CC);
+					OBJ_RELEASE(Z_OBJ_P(zvalue));
 				}
 				break;
 			case IS_RESOURCE:
@@ -2241,7 +2245,7 @@ static void accel_fast_zval_ptr_dtor(zval **zval_ptr)
 					TSRMLS_FETCH();
 
 					/* destroy resource */
-					zend_list_delete(zvalue->value.lval);
+					zend_list_delete(Z_RES_P(zvalue));
 				}
 				break;
 			case IS_LONG:
@@ -2257,13 +2261,15 @@ static void accel_fast_zval_ptr_dtor(zval **zval_ptr)
 	}
 }
 
-static int accel_clean_non_persistent_function(zend_function *function TSRMLS_DC)
+static int accel_clean_non_persistent_function(zval *zv TSRMLS_DC)
 {
+	zend_function *function = Z_PTR_P(zv);
+
 	if (function->type == ZEND_INTERNAL_FUNCTION) {
 		return ZEND_HASH_APPLY_STOP;
 	} else {
 		if (function->op_array.static_variables) {
-			function->op_array.static_variables->pDestructor = (dtor_func_t)accel_fast_zval_ptr_dtor;
+			function->op_array.static_variables->pDestructor = accel_fast_zval_dtor;
 			accel_fast_hash_destroy(function->op_array.static_variables);
 			function->op_array.static_variables = NULL;
 		}
@@ -2273,11 +2279,13 @@ static int accel_clean_non_persistent_function(zend_function *function TSRMLS_DC
 	}
 }
 
-static int accel_cleanup_function_data(zend_function *function TSRMLS_DC)
+static int accel_cleanup_function_data(zval *zv TSRMLS_DC)
 {
+	zend_function *function = Z_PTR_P(zv);
+
 	if (function->type == ZEND_USER_FUNCTION) {
 		if (function->op_array.static_variables) {
-			function->op_array.static_variables->pDestructor = (dtor_func_t)accel_fast_zval_ptr_dtor;
+			function->op_array.static_variables->pDestructor = accel_fast_zval_dtor;
 			accel_fast_hash_destroy(function->op_array.static_variables);
 			function->op_array.static_variables = NULL;
 		}
@@ -2285,9 +2293,9 @@ static int accel_cleanup_function_data(zend_function *function TSRMLS_DC)
 	return 0;
 }
 
-static int accel_clean_non_persistent_class(zend_class_entry **pce TSRMLS_DC)
+static int accel_clean_non_persistent_class(zval *zv TSRMLS_DC)
 {
-	zend_class_entry *ce = *pce;
+	zend_class_entry *ce = Z_PTR_P(zv);
 
 	if (ce->type == ZEND_INTERNAL_CLASS) {
 		return ZEND_HASH_APPLY_STOP;
@@ -2300,17 +2308,15 @@ static int accel_clean_non_persistent_class(zend_class_entry **pce TSRMLS_DC)
 			int i;
 
 			for (i = 0; i < ce->default_static_members_count; i++) {
-				if (ce->static_members_table[i]) {
-					accel_fast_zval_ptr_dtor(&ce->static_members_table[i]);
-					ce->static_members_table[i] = NULL;
-				}
+				accel_fast_zval_dtor(&ce->static_members_table[i]);
+				ZVAL_UNDEF(&ce->static_members_table[i]);
 			}
 			ce->static_members_table = NULL;
 		}
 #else
 		zend_hash_apply(&ce->function_table, (apply_func_t) accel_cleanup_function_data TSRMLS_CC);
 		if (ce->static_members) {
-			ce->static_members->pDestructor = (dtor_func_t)accel_fast_zval_ptr_dtor;
+			ce->static_members->pDestructor = accel_fast_zval_dtor;
 			accel_fast_hash_destroy(ce->static_members);
 			ce->static_members = NULL;
 		}
@@ -2319,12 +2325,14 @@ static int accel_clean_non_persistent_class(zend_class_entry **pce TSRMLS_DC)
 	}
 }
 
-static int accel_clean_non_persistent_constant(zend_constant *c TSRMLS_DC)
+static int accel_clean_non_persistent_constant(zval *zv TSRMLS_DC)
 {
+	zend_constant *c = Z_PTR_P(zv);
+
 	if (c->flags & CONST_PERSISTENT) {
 		return ZEND_HASH_APPLY_STOP;
 	} else {
-		interned_free(c->name);
+		STR_RELEASE(c->name);
 		return ZEND_HASH_APPLY_REMOVE;
 	}
 }
@@ -2332,21 +2340,21 @@ static int accel_clean_non_persistent_constant(zend_constant *c TSRMLS_DC)
 static void zend_accel_fast_shutdown(TSRMLS_D)
 {
 	if (EG(full_tables_cleanup)) {
-		EG(symbol_table).pDestructor = (dtor_func_t)accel_fast_zval_ptr_dtor;
+		EG(symbol_table).ht.pDestructor = accel_fast_zval_dtor;
 	} else {
 		dtor_func_t old_destructor;
 
 		if (EG(objects_store).top > 1 || zend_hash_num_elements(&EG(regular_list)) > 0) {
 			/* We don't have to destroy all zvals if they cannot call any destructors */
 
-		    old_destructor = EG(symbol_table).pDestructor;
-			EG(symbol_table).pDestructor = (dtor_func_t)accel_fast_zval_ptr_dtor;
+		    old_destructor = EG(symbol_table).ht.pDestructor;
+			EG(symbol_table).ht.pDestructor = accel_fast_zval_dtor;
 			zend_try {
-				zend_hash_graceful_reverse_destroy(&EG(symbol_table));
+				zend_hash_graceful_reverse_destroy(&EG(symbol_table).ht);
 			} zend_end_try();
-			EG(symbol_table).pDestructor = old_destructor;
+			EG(symbol_table).ht.pDestructor = old_destructor;
 		}
-		zend_hash_init(&EG(symbol_table), 0, NULL, NULL, 0);
+		zend_hash_init(&EG(symbol_table).ht, 8, NULL, NULL, 0);
 		old_destructor = EG(function_table)->pDestructor;
 		EG(function_table)->pDestructor = NULL;
 		zend_hash_reverse_apply(EG(function_table), (apply_func_t) accel_clean_non_persistent_function TSRMLS_CC);
@@ -2476,19 +2484,21 @@ static int zend_accel_init_shm(TSRMLS_D)
 	zend_hash_init(&ZCSG(interned_strings), (ZCG(accel_directives).interned_strings_buffer * 1024 * 1024) / (sizeof(Bucket) + sizeof(Bucket*) + 8 /* average string length */), NULL, NULL, 1);
 	if (ZCG(accel_directives).interned_strings_buffer) {
 		ZCSG(interned_strings).nTableMask = ZCSG(interned_strings).nTableSize - 1;
-		ZCSG(interned_strings).arBuckets = zend_shared_alloc(ZCSG(interned_strings).nTableSize * sizeof(Bucket *));
+		ZCSG(interned_strings).arData = zend_shared_alloc(ZCSG(interned_strings).nTableSize * sizeof(Bucket));
+		ZCSG(interned_strings).arHash = (zend_uint*)zend_shared_alloc(ZCSG(interned_strings).nTableSize * sizeof(zend_uint));
 		ZCSG(interned_strings_start) = zend_shared_alloc((ZCG(accel_directives).interned_strings_buffer * 1024 * 1024));
-		if (!ZCSG(interned_strings).arBuckets || !ZCSG(interned_strings_start)) {
+		if (!ZCSG(interned_strings).arData || !ZCSG(interned_strings_start)) {
 			zend_accel_error(ACCEL_LOG_FATAL, ACCELERATOR_PRODUCT_NAME " cannot allocate buffer for interned strings");
 			return FAILURE;
 		}
+		memset(ZCSG(interned_strings).arHash, INVALID_IDX, ZCSG(interned_strings).nTableSize * sizeof(zend_uint));
 		ZCSG(interned_strings_end)   = ZCSG(interned_strings_start) + (ZCG(accel_directives).interned_strings_buffer * 1024 * 1024);
 		ZCSG(interned_strings_top)   = ZCSG(interned_strings_start);
 
-		orig_interned_strings_start = CG(interned_strings_start);
-		orig_interned_strings_end = CG(interned_strings_end);
-		CG(interned_strings_start) = ZCSG(interned_strings_start);
-		CG(interned_strings_end) = ZCSG(interned_strings_end);
+//		orig_interned_strings_start = CG(interned_strings_start);
+//		orig_interned_strings_end = CG(interned_strings_end);
+//		CG(interned_strings_start) = ZCSG(interned_strings_start);
+//		CG(interned_strings_end) = ZCSG(interned_strings_end);
 	}
 # endif
 
@@ -2531,9 +2541,14 @@ static void accel_globals_ctor(zend_accel_globals *accel_globals TSRMLS_DC)
 	zend_accel_copy_internal_functions(TSRMLS_C);
 }
 
+static void accel_globals_internal_func_dtor(zval *zv)
+{
+	free(Z_PTR_P(zv));
+}
+
 static void accel_globals_dtor(zend_accel_globals *accel_globals TSRMLS_DC)
 {
-	accel_globals->function_table.pDestructor = NULL;
+	accel_globals->function_table.pDestructor = accel_globals_internal_func_dtor;
 	zend_hash_destroy(&accel_globals->function_table);
 }
 
@@ -2596,14 +2611,10 @@ static int accel_startup(zend_extension *extension)
 			accel_shared_globals = (zend_accel_shared_globals *) ZSMMG(app_shared_globals);
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 			zend_shared_alloc_lock(TSRMLS_C);
-			orig_interned_strings_start = CG(interned_strings_start);
-			orig_interned_strings_end = CG(interned_strings_end);
 			orig_new_interned_string = zend_new_interned_string;
 			orig_interned_strings_snapshot = zend_interned_strings_snapshot;
 			orig_interned_strings_restore = zend_interned_strings_restore;
 
-			CG(interned_strings_start) = ZCSG(interned_strings_start);
-			CG(interned_strings_end) = ZCSG(interned_strings_end);
 			zend_new_interned_string = accel_new_interned_string_for_php;
 			zend_interned_strings_snapshot = accel_interned_strings_snapshot_for_php;
 			zend_interned_strings_restore = accel_interned_strings_restore_for_php;
@@ -2625,6 +2636,9 @@ static int accel_startup(zend_extension *extension)
 
 	/* from this point further, shared memory is supposed to be OK */
 
+	/* Init auto-global strings */
+	zend_accel_init_auto_globals(TSRMLS_C);
+
 	/* Override compiler */
 	accelerator_orig_compile_file = zend_compile_file;
 	zend_compile_file = persistent_compile_file;
@@ -2646,7 +2660,7 @@ static int accel_startup(zend_extension *extension)
 	}
 
 	/* Override chdir() function */
-	if (zend_hash_find(CG(function_table), "chdir", sizeof("chdir"), (void**)&func) == SUCCESS &&
+	if ((func = zend_hash_str_find_ptr(CG(function_table), "chdir", sizeof("chdir")-1)) != NULL &&
 	    func->type == ZEND_INTERNAL_FUNCTION) {
 		orig_chdir = func->internal_function.handler;
 		func->internal_function.handler = ZEND_FN(accel_chdir);
@@ -2654,7 +2668,7 @@ static int accel_startup(zend_extension *extension)
 	ZCG(cwd) = NULL;
 
 	/* Override "include_path" modifier callback */
-	if (zend_hash_find(EG(ini_directives), "include_path", sizeof("include_path"), (void **) &ini_entry) == SUCCESS) {
+	if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives), "include_path", sizeof("include_path")-1)) != NULL) {
 		ZCG(include_path) = INI_STR("include_path");
 		ZCG(include_path_key) = NULL;
 		if (ZCG(include_path) && *ZCG(include_path)) {
@@ -2735,12 +2749,11 @@ void accel_shutdown(TSRMLS_D)
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	if (ZCG(accel_directives).interned_strings_buffer) {
 # ifndef ZTS
+		zend_hash_clean(CG(auto_globals));
 		zend_hash_clean(CG(function_table));
 		zend_hash_clean(CG(class_table));
 		zend_hash_clean(EG(zend_constants));
 # endif
-		CG(interned_strings_start) = orig_interned_strings_start;
-		CG(interned_strings_end) = orig_interned_strings_end;
 	}
 	zend_new_interned_string = orig_new_interned_string;
 	zend_interned_strings_snapshot = orig_interned_strings_snapshot;
@@ -2751,7 +2764,7 @@ void accel_shutdown(TSRMLS_D)
 	zend_shared_alloc_shutdown();
 	zend_compile_file = accelerator_orig_compile_file;
 
-	if (zend_hash_find(EG(ini_directives), "include_path", sizeof("include_path"), (void **) &ini_entry) == SUCCESS) {
+	if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives), "include_path", sizeof("include_path")-1)) != NULL) {
 		ini_entry->on_modify = orig_include_path_on_modify;
 	}
 }
diff --git a/ext/opcache/ZendAccelerator.h b/ext/opcache/ZendAccelerator.h
index 6479a6ff40..a26d32e58e 100644
--- a/ext/opcache/ZendAccelerator.h
+++ b/ext/opcache/ZendAccelerator.h
@@ -183,9 +183,7 @@ typedef enum _zend_accel_restart_reason {
 } zend_accel_restart_reason;
 
 typedef struct _zend_persistent_script {
-	ulong          hash_value;
-	char          *full_path;              /* full real path with resolved symlinks */
-	unsigned int   full_path_len;
+	zend_string   *full_path;              /* full real path with resolved symlinks */
 	zend_op_array  main_op_array;
 	HashTable      function_table;
 	HashTable      class_table;
@@ -304,13 +302,8 @@ typedef struct _zend_accel_shared_globals {
 	char           *interned_strings_start;
 	char           *interned_strings_top;
 	char           *interned_strings_end;
+	char           *interned_strings_saved_top;
 	HashTable       interned_strings;
-	struct {
-		Bucket **arBuckets;
-		Bucket  *pListHead;
-		Bucket  *pListTail;
-		char    *top;
-	} interned_strings_saved_state;
 #endif
 } zend_accel_shared_globals;
 
@@ -347,32 +340,23 @@ zend_op_array *persistent_compile_file(zend_file_handle *file_handle, int type T
 
 #define ZEND_DECLARE_INHERITED_CLASS_DELAYED_FLAG 0x80
 
+#define IS_ACCEL_INTERNED(str) \
+	((char*)(str) >= ZCSG(interned_strings_start) && (char*)(str) < ZCSG(interned_strings_end))
+
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 
-const char *accel_new_interned_string(const char *arKey, int nKeyLength, int free_src TSRMLS_DC);
-
-# define interned_free(s) do { \
-		if (!IS_INTERNED(s)) { \
-			free(s); \
-		} \
-	} while (0)
-# define interned_efree(s) do { \
-		if (!IS_INTERNED(s)) { \
-			efree(s); \
-		} \
-	} while (0)
-# define interned_estrndup(s, n) \
-	(IS_INTERNED(s) ? (s) : estrndup(s, n))
+zend_string *accel_new_interned_string(zend_string *str TSRMLS_DC);
+
 # define ZEND_RESULT_TYPE(opline)	(opline)->result_type
 # define ZEND_RESULT(opline)		(opline)->result
 # define ZEND_OP1_TYPE(opline)		(opline)->op1_type
 # define ZEND_OP1(opline)			(opline)->op1
 # define ZEND_OP1_CONST(opline)		(*(opline)->op1.zv)
-# define ZEND_OP1_LITERAL(opline)	(op_array)->literals[(opline)->op1.constant].constant
+# define ZEND_OP1_LITERAL(opline)	(op_array)->literals[(opline)->op1.constant]
 # define ZEND_OP2_TYPE(opline)		(opline)->op2_type
 # define ZEND_OP2(opline)			(opline)->op2
 # define ZEND_OP2_CONST(opline)		(*(opline)->op2.zv)
-# define ZEND_OP2_LITERAL(opline)	(op_array)->literals[(opline)->op2.constant].constant
+# define ZEND_OP2_LITERAL(opline)	(op_array)->literals[(opline)->op2.constant]
 # define ZEND_DONE_PASS_TWO(op_array)	(((op_array)->fn_flags & ZEND_ACC_DONE_PASS_TWO) != 0)
 # define ZEND_CE_FILENAME(ce)			(ce)->info.user.filename
 # define ZEND_CE_DOC_COMMENT(ce)        (ce)->info.user.doc_comment
diff --git a/ext/opcache/zend_accelerator_blacklist.c b/ext/opcache/zend_accelerator_blacklist.c
index 0ca37dfa42..af56fbf9e9 100644
--- a/ext/opcache/zend_accelerator_blacklist.c
+++ b/ext/opcache/zend_accelerator_blacklist.c
@@ -371,7 +371,7 @@ zend_bool zend_accel_blacklist_is_blacklisted(zend_blacklist *blacklist, char *v
 	return ret;
 }
 
-void zend_accel_blacklist_apply(zend_blacklist *blacklist, apply_func_arg_t func, void *argument TSRMLS_DC)
+void zend_accel_blacklist_apply(zend_blacklist *blacklist, blacklist_apply_func_arg_t func, void *argument TSRMLS_DC)
 {
 	int i;
 
diff --git a/ext/opcache/zend_accelerator_blacklist.h b/ext/opcache/zend_accelerator_blacklist.h
index 869068410f..1990e414b9 100644
--- a/ext/opcache/zend_accelerator_blacklist.h
+++ b/ext/opcache/zend_accelerator_blacklist.h
@@ -37,6 +37,8 @@ typedef struct _zend_blacklist {
 	zend_regexp_list     *regexp_list;
 } zend_blacklist;
 
+typedef int (*blacklist_apply_func_arg_t)(zend_blacklist_entry *, zval * TSRMLS_DC);
+
 extern zend_blacklist accel_blacklist;
 
 void zend_accel_blacklist_init(zend_blacklist *blacklist);
@@ -44,6 +46,6 @@ void zend_accel_blacklist_shutdown(zend_blacklist *blacklist);
 
 void zend_accel_blacklist_load(zend_blacklist *blacklist, char *filename);
 zend_bool zend_accel_blacklist_is_blacklisted(zend_blacklist *blacklist, char *verify_path);
-void zend_accel_blacklist_apply(zend_blacklist *blacklist, apply_func_arg_t func, void *argument TSRMLS_DC);
+void zend_accel_blacklist_apply(zend_blacklist *blacklist, blacklist_apply_func_arg_t func, void *argument TSRMLS_DC);
 
 #endif /* ZEND_ACCELERATOR_BLACKLIST_H */
diff --git a/ext/opcache/zend_accelerator_module.c b/ext/opcache/zend_accelerator_module.c
index f4dd9fbb85..7ed055e9c6 100644
--- a/ext/opcache/zend_accelerator_module.c
+++ b/ext/opcache/zend_accelerator_module.c
@@ -126,10 +126,9 @@ static ZEND_INI_MH(OnUpdateMemoryConsumption)
 		zend_accel_error(ACCEL_LOG_WARNING, "opcache.memory_consumption is set below the required 8MB.\n");
 		zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the minimal 8MB configuration.\n");
 
-		if (zend_hash_find(EG(ini_directives),
+		if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
 					"opcache.memory_consumption",
-					sizeof("opcache.memory_consumption"),
-					(void *) &ini_entry) == FAILURE) {
+					sizeof("opcache.memory_consumption")-1)) == NULL) {
 			return FAILURE;
 		}
 
@@ -173,10 +172,9 @@ static ZEND_INI_MH(OnUpdateMaxAcceleratedFiles)
 			zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_accelerated_files is set above the limit (%d).\n", MAX_ACCEL_FILES);
 			zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use the maximal configuration.\n");
 		}
-		if (zend_hash_find(EG(ini_directives),
+		if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
 					"opcache.max_accelerated_files",
-					sizeof("opcache.max_accelerated_files"),
-					(void *) &ini_entry) == FAILURE) {
+					sizeof("opcache.max_accelerated_files")-1)) == NULL) {
 			return FAILURE;
 		}
 		ini_entry->value = strdup(new_new_value);
@@ -209,10 +207,9 @@ static ZEND_INI_MH(OnUpdateMaxWastedPercentage)
 		percentage = 5;
 		zend_accel_error(ACCEL_LOG_WARNING, "opcache.max_wasted_percentage must be set between 1 and 50.\n");
 		zend_accel_error(ACCEL_LOG_WARNING, ACCELERATOR_PRODUCT_NAME " will use 5%.\n");
-		if (zend_hash_find(EG(ini_directives),
+		if ((ini_entry = zend_hash_str_find_ptr(EG(ini_directives),
 					"opcache.max_wasted_percentage",
-					sizeof("opcache.max_wasted_percentage"),
-					(void *) &ini_entry) == FAILURE) {
+					sizeof("opcache.max_wasted_percentage")-1)) == NULL) {
 			return FAILURE;
 		}
 		ini_entry->value = strdup(new_new_value);
@@ -339,15 +336,15 @@ static int filename_is_in_cache(char *filename, int filename_len TSRMLS_DC)
 
 static int accel_file_in_cache(INTERNAL_FUNCTION_PARAMETERS)
 {
-	zval **zfilename;
+	zval zfilename;
 
 	if (ZEND_NUM_ARGS() != 1 ||
 	    zend_get_parameters_array_ex(1, &zfilename) == FAILURE ||
-	    Z_TYPE_PP(zfilename) != IS_STRING ||
-	    Z_STRLEN_PP(zfilename) == 0) {
+	    Z_TYPE(zfilename) != IS_STRING ||
+	    Z_STRLEN(zfilename) == 0) {
 		return 0;
 	}
-	return filename_is_in_cache(Z_STRVAL_PP(zfilename), Z_STRLEN_PP(zfilename) TSRMLS_CC);
+	return filename_is_in_cache(Z_STRVAL(zfilename), Z_STRLEN(zfilename) TSRMLS_CC);
 }
 
 static void accel_file_exists(INTERNAL_FUNCTION_PARAMETERS)
@@ -393,15 +390,15 @@ void zend_accel_override_file_functions(TSRMLS_D)
 	zend_function *old_function;
 	if (ZCG(enabled) && accel_startup_ok && ZCG(accel_directives).file_override_enabled) {
 		/* override file_exists */
-		if (zend_hash_find(CG(function_table), "file_exists", sizeof("file_exists"), (void **)&old_function) == SUCCESS) {
+		if ((old_function = zend_hash_str_find_ptr(CG(function_table), "file_exists", sizeof("file_exists")-1)) != NULL) {
 			orig_file_exists = old_function->internal_function.handler;
 			old_function->internal_function.handler = accel_file_exists;
 		}
-		if (zend_hash_find(CG(function_table), "is_file", sizeof("is_file"), (void **)&old_function) == SUCCESS) {
+		if ((old_function = zend_hash_str_find_ptr(CG(function_table), "is_file", sizeof("is_file")-1)) != NULL) {
 			orig_is_file = old_function->internal_function.handler;
 			old_function->internal_function.handler = accel_is_file;
 		}
-		if (zend_hash_find(CG(function_table), "is_readable", sizeof("is_readable"), (void **)&old_function) == SUCCESS) {
+		if ((old_function = zend_hash_str_find_ptr(CG(function_table), "is_readable", sizeof("is_readable")-1)) != NULL) {
 			orig_is_readable = old_function->internal_function.handler;
 			old_function->internal_function.handler = accel_is_readable;
 		}
@@ -502,10 +499,10 @@ int start_accel_module(void)
 
 /* {{{ proto array accelerator_get_scripts()
    Get the scripts which are accelerated by ZendAccelerator */
-static zval* accelerator_get_scripts(TSRMLS_D)
+static int accelerator_get_scripts(zval *return_value TSRMLS_DC)
 {
 	uint i;
-	zval *return_value,*persistent_script_report;
+	zval persistent_script_report;
 	zend_accel_hash_entry *cache_entry;
 	struct tm *ta;
 	struct timeval exec_time;
@@ -515,7 +512,6 @@ static zval* accelerator_get_scripts(TSRMLS_D)
 		return 0;
 	}
 
-	MAKE_STD_ZVAL(return_value);
 	array_init(return_value);
 	for (i = 0; i<ZCSG(hash).max_num_entries; i++) {
 		for (cache_entry = ZCSG(hash).hash_table[i]; cache_entry; cache_entry = cache_entry->next) {
@@ -527,29 +523,28 @@ static zval* accelerator_get_scripts(TSRMLS_D)
 
 			script = (zend_persistent_script *)cache_entry->data;
 
-			MAKE_STD_ZVAL(persistent_script_report);
-			array_init(persistent_script_report);
-			add_assoc_stringl(persistent_script_report, "full_path", script->full_path, script->full_path_len, 1);
-			add_assoc_long(persistent_script_report, "hits", script->dynamic_members.hits);
-			add_assoc_long(persistent_script_report, "memory_consumption", script->dynamic_members.memory_consumption);
+			array_init(&persistent_script_report);
+			add_assoc_str(&persistent_script_report, "full_path", STR_DUP(script->full_path, 0));
+			add_assoc_long(&persistent_script_report, "hits", script->dynamic_members.hits);
+			add_assoc_long(&persistent_script_report, "memory_consumption", script->dynamic_members.memory_consumption);
 			ta = localtime(&script->dynamic_members.last_used);
 			str = asctime(ta);
 			len = strlen(str);
 			if (len > 0 && str[len - 1] == '\n') len--;
-			add_assoc_stringl(persistent_script_report, "last_used", str, len, 1);
-			add_assoc_long(persistent_script_report, "last_used_timestamp", script->dynamic_members.last_used);
+			add_assoc_stringl(&persistent_script_report, "last_used", str, len);
+			add_assoc_long(&persistent_script_report, "last_used_timestamp", script->dynamic_members.last_used);
 			if (ZCG(accel_directives).validate_timestamps) {
-				add_assoc_long(persistent_script_report, "timestamp", (long)script->timestamp);
+				add_assoc_long(&persistent_script_report, "timestamp", (long)script->timestamp);
 			}
 			timerclear(&exec_time);
 			timerclear(&fetch_time);
 
-			zend_hash_update(return_value->value.ht, cache_entry->key, cache_entry->key_length, &persistent_script_report, sizeof(zval *), NULL);
+			zend_hash_str_update(Z_ARRVAL_P(return_value), cache_entry->key, cache_entry->key_length-1, &persistent_script_report);
 		}
 	}
 	accelerator_shm_read_unlock(TSRMLS_C);
 
-	return return_value;
+	return 1;
 }
 
 /* {{{ proto array accelerator_get_status([bool fetch_scripts])
@@ -557,12 +552,9 @@ static zval* accelerator_get_scripts(TSRMLS_D)
 static ZEND_FUNCTION(opcache_get_status)
 {
 	long reqs;
-	zval *memory_usage,*statistics,*scripts;
+	zval memory_usage, statistics, scripts;
 	zend_bool fetch_scripts = 1;
 
-	/* keep the compiler happy */
-	(void)ht; (void)return_value_ptr; (void)this_ptr; (void)return_value_used;
-
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &fetch_scripts) == FAILURE) {
 		return;
 	}
@@ -584,59 +576,55 @@ static ZEND_FUNCTION(opcache_get_status)
 	add_assoc_bool(return_value, "restart_in_progress", ZCSG(restart_in_progress));
 
 	/* Memory usage statistics */
-	MAKE_STD_ZVAL(memory_usage);
-	array_init(memory_usage);
-	add_assoc_long(memory_usage, "used_memory", ZCG(accel_directives).memory_consumption-zend_shared_alloc_get_free_memory()-ZSMMG(wasted_shared_memory));
-	add_assoc_long(memory_usage, "free_memory", zend_shared_alloc_get_free_memory());
-	add_assoc_long(memory_usage, "wasted_memory", ZSMMG(wasted_shared_memory));
-	add_assoc_double(memory_usage, "current_wasted_percentage", (((double) ZSMMG(wasted_shared_memory))/ZCG(accel_directives).memory_consumption)*100.0);
-	add_assoc_zval(return_value, "memory_usage", memory_usage);
+	array_init(&memory_usage);
+	add_assoc_long(&memory_usage, "used_memory", ZCG(accel_directives).memory_consumption-zend_shared_alloc_get_free_memory()-ZSMMG(wasted_shared_memory));
+	add_assoc_long(&memory_usage, "free_memory", zend_shared_alloc_get_free_memory());
+	add_assoc_long(&memory_usage, "wasted_memory", ZSMMG(wasted_shared_memory));
+	add_assoc_double(&memory_usage, "current_wasted_percentage", (((double) ZSMMG(wasted_shared_memory))/ZCG(accel_directives).memory_consumption)*100.0);
+	add_assoc_zval(return_value, "memory_usage", &memory_usage);
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	if (ZCSG(interned_strings_start) && ZCSG(interned_strings_end) && ZCSG(interned_strings_top)) {
-		zval *interned_strings_usage;
+		zval interned_strings_usage;
 
-		MAKE_STD_ZVAL(interned_strings_usage);
-		array_init(interned_strings_usage);
-		add_assoc_long(interned_strings_usage, "buffer_size", ZCSG(interned_strings_end) - ZCSG(interned_strings_start));
-		add_assoc_long(interned_strings_usage, "used_memory", ZCSG(interned_strings_top) - ZCSG(interned_strings_start));
-		add_assoc_long(interned_strings_usage, "free_memory", ZCSG(interned_strings_end) - ZCSG(interned_strings_top));
-		add_assoc_long(interned_strings_usage, "number_of_strings", ZCSG(interned_strings).nNumOfElements);
-		add_assoc_zval(return_value, "interned_strings_usage", interned_strings_usage);
+		array_init(&interned_strings_usage);
+		add_assoc_long(&interned_strings_usage, "buffer_size", ZCSG(interned_strings_end) - ZCSG(interned_strings_start));
+		add_assoc_long(&interned_strings_usage, "used_memory", ZCSG(interned_strings_top) - ZCSG(interned_strings_start));
+		add_assoc_long(&interned_strings_usage, "free_memory", ZCSG(interned_strings_end) - ZCSG(interned_strings_top));
+		add_assoc_long(&interned_strings_usage, "number_of_strings", ZCSG(interned_strings).nNumOfElements);
+		add_assoc_zval(return_value, "interned_strings_usage", &interned_strings_usage);
 	}
 #endif
 	
 	/* Accelerator statistics */
-	MAKE_STD_ZVAL(statistics);
-	array_init(statistics);
-	add_assoc_long(statistics, "num_cached_scripts", ZCSG(hash).num_direct_entries);
-	add_assoc_long(statistics, "num_cached_keys",    ZCSG(hash).num_entries);
-	add_assoc_long(statistics, "max_cached_keys",    ZCSG(hash).max_num_entries);
-	add_assoc_long(statistics, "hits", ZCSG(hits));
-	add_assoc_long(statistics, "start_time", ZCSG(start_time));
-	add_assoc_long(statistics, "last_restart_time", ZCSG(last_restart_time));
-	add_assoc_long(statistics, "oom_restarts", ZCSG(oom_restarts));
-	add_assoc_long(statistics, "hash_restarts", ZCSG(hash_restarts));
-	add_assoc_long(statistics, "manual_restarts", ZCSG(manual_restarts));
-	add_assoc_long(statistics, "misses", ZSMMG(memory_exhausted)?ZCSG(misses):ZCSG(misses)-ZCSG(blacklist_misses));
-	add_assoc_long(statistics, "blacklist_misses", ZCSG(blacklist_misses));
+	array_init(&statistics);
+	add_assoc_long(&statistics, "num_cached_scripts", ZCSG(hash).num_direct_entries);
+	add_assoc_long(&statistics, "num_cached_keys",    ZCSG(hash).num_entries);
+	add_assoc_long(&statistics, "max_cached_keys",    ZCSG(hash).max_num_entries);
+	add_assoc_long(&statistics, "hits", ZCSG(hits));
+	add_assoc_long(&statistics, "start_time", ZCSG(start_time));
+	add_assoc_long(&statistics, "last_restart_time", ZCSG(last_restart_time));
+	add_assoc_long(&statistics, "oom_restarts", ZCSG(oom_restarts));
+	add_assoc_long(&statistics, "hash_restarts", ZCSG(hash_restarts));
+	add_assoc_long(&statistics, "manual_restarts", ZCSG(manual_restarts));
+	add_assoc_long(&statistics, "misses", ZSMMG(memory_exhausted)?ZCSG(misses):ZCSG(misses)-ZCSG(blacklist_misses));
+	add_assoc_long(&statistics, "blacklist_misses", ZCSG(blacklist_misses));
 	reqs = ZCSG(hits)+ZCSG(misses);
-	add_assoc_double(statistics, "blacklist_miss_ratio", reqs?(((double) ZCSG(blacklist_misses))/reqs)*100.0:0);
-	add_assoc_double(statistics, "opcache_hit_rate", reqs?(((double) ZCSG(hits))/reqs)*100.0:0);
-	add_assoc_zval(return_value, "opcache_statistics", statistics);
+	add_assoc_double(&statistics, "blacklist_miss_ratio", reqs?(((double) ZCSG(blacklist_misses))/reqs)*100.0:0);
+	add_assoc_double(&statistics, "opcache_hit_rate", reqs?(((double) ZCSG(hits))/reqs)*100.0:0);
+	add_assoc_zval(return_value, "opcache_statistics", &statistics);
 
 	if (fetch_scripts) {
 		/* accelerated scripts */
-		scripts = accelerator_get_scripts(TSRMLS_C);
-		if (scripts) {
-			add_assoc_zval(return_value, "scripts", scripts);
+		if (accelerator_get_scripts(&scripts TSRMLS_CC)) {
+			add_assoc_zval(return_value, "scripts", &scripts);
 		}
 	}
 }
 
 static int add_blacklist_path(zend_blacklist_entry *p, zval *return_value TSRMLS_DC)
 {
-	add_next_index_stringl(return_value, p->path, p->path_length, 1);
+	add_next_index_stringl(return_value, p->path, p->path_length);
 	return 0;
 }
 
@@ -644,10 +632,7 @@ static int add_blacklist_path(zend_blacklist_entry *p, zval *return_value TSRMLS
    Obtain configuration information */
 static ZEND_FUNCTION(opcache_get_configuration)
 {
-	zval *directives,*version,*blacklist;
-
-	/* keep the compiler happy */
-	(void)ht; (void)return_value_ptr; (void)this_ptr; (void)return_value_used;
+	zval directives, version, blacklist;
 
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -662,61 +647,55 @@ static ZEND_FUNCTION(opcache_get_configuration)
 	array_init(return_value);
 
 	/* directives */
-	MAKE_STD_ZVAL(directives);
-	array_init(directives);
-	add_assoc_bool(directives, "opcache.enable",              ZCG(enabled));
-	add_assoc_bool(directives, "opcache.enable_cli",          ZCG(accel_directives).enable_cli);
-	add_assoc_bool(directives, "opcache.use_cwd",             ZCG(accel_directives).use_cwd);
-	add_assoc_bool(directives, "opcache.validate_timestamps", ZCG(accel_directives).validate_timestamps);
-	add_assoc_bool(directives, "opcache.inherited_hack",      ZCG(accel_directives).inherited_hack);
-	add_assoc_bool(directives, "opcache.dups_fix",            ZCG(accel_directives).ignore_dups);
-	add_assoc_bool(directives, "opcache.revalidate_path",     ZCG(accel_directives).revalidate_path);
-
-	add_assoc_long(directives,   "opcache.log_verbosity_level",    ZCG(accel_directives).log_verbosity_level);
-	add_assoc_long(directives,	 "opcache.memory_consumption",     ZCG(accel_directives).memory_consumption);
+	array_init(&directives);
+	add_assoc_bool(&directives, "opcache.enable",              ZCG(enabled));
+	add_assoc_bool(&directives, "opcache.enable_cli",          ZCG(accel_directives).enable_cli);
+	add_assoc_bool(&directives, "opcache.use_cwd",             ZCG(accel_directives).use_cwd);
+	add_assoc_bool(&directives, "opcache.validate_timestamps", ZCG(accel_directives).validate_timestamps);
+	add_assoc_bool(&directives, "opcache.inherited_hack",      ZCG(accel_directives).inherited_hack);
+	add_assoc_bool(&directives, "opcache.dups_fix",            ZCG(accel_directives).ignore_dups);
+	add_assoc_bool(&directives, "opcache.revalidate_path",     ZCG(accel_directives).revalidate_path);
+
+	add_assoc_long(&directives,   "opcache.log_verbosity_level",    ZCG(accel_directives).log_verbosity_level);
+	add_assoc_long(&directives,	 "opcache.memory_consumption",     ZCG(accel_directives).memory_consumption);
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-	add_assoc_long(directives,	 "opcache.interned_strings_buffer",ZCG(accel_directives).interned_strings_buffer);
+	add_assoc_long(&directives,	 "opcache.interned_strings_buffer",ZCG(accel_directives).interned_strings_buffer);
 #endif
-	add_assoc_long(directives, 	 "opcache.max_accelerated_files",  ZCG(accel_directives).max_accelerated_files);
-	add_assoc_double(directives, "opcache.max_wasted_percentage",  ZCG(accel_directives).max_wasted_percentage);
-	add_assoc_long(directives, 	 "opcache.consistency_checks",     ZCG(accel_directives).consistency_checks);
-	add_assoc_long(directives, 	 "opcache.force_restart_timeout",  ZCG(accel_directives).force_restart_timeout);
-	add_assoc_long(directives, 	 "opcache.revalidate_freq",        ZCG(accel_directives).revalidate_freq);
-	add_assoc_string(directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model), 1);
-	add_assoc_string(directives, "opcache.blacklist_filename",     STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename), 1);
-	add_assoc_long(directives,   "opcache.max_file_size",          ZCG(accel_directives).max_file_size);
-	add_assoc_string(directives, "opcache.error_log",              STRING_NOT_NULL(ZCG(accel_directives).error_log), 1);
-
-	add_assoc_bool(directives,   "opcache.protect_memory",         ZCG(accel_directives).protect_memory);
-	add_assoc_bool(directives,   "opcache.save_comments",          ZCG(accel_directives).save_comments);
-	add_assoc_bool(directives,   "opcache.load_comments",          ZCG(accel_directives).load_comments);
-	add_assoc_bool(directives,   "opcache.fast_shutdown",          ZCG(accel_directives).fast_shutdown);
-	add_assoc_bool(directives,   "opcache.enable_file_override",   ZCG(accel_directives).file_override_enabled);
-	add_assoc_long(directives, 	 "opcache.optimization_level",     ZCG(accel_directives).optimization_level);
-
-	add_assoc_zval(return_value, "directives", directives);
+	add_assoc_long(&directives, 	 "opcache.max_accelerated_files",  ZCG(accel_directives).max_accelerated_files);
+	add_assoc_double(&directives, "opcache.max_wasted_percentage",  ZCG(accel_directives).max_wasted_percentage);
+	add_assoc_long(&directives, 	 "opcache.consistency_checks",     ZCG(accel_directives).consistency_checks);
+	add_assoc_long(&directives, 	 "opcache.force_restart_timeout",  ZCG(accel_directives).force_restart_timeout);
+	add_assoc_long(&directives, 	 "opcache.revalidate_freq",        ZCG(accel_directives).revalidate_freq);
+	add_assoc_string(&directives, "opcache.preferred_memory_model", STRING_NOT_NULL(ZCG(accel_directives).memory_model));
+	add_assoc_string(&directives, "opcache.blacklist_filename",     STRING_NOT_NULL(ZCG(accel_directives).user_blacklist_filename));
+	add_assoc_long(&directives,   "opcache.max_file_size",          ZCG(accel_directives).max_file_size);
+	add_assoc_string(&directives, "opcache.error_log",              STRING_NOT_NULL(ZCG(accel_directives).error_log));
+
+	add_assoc_bool(&directives,   "opcache.protect_memory",         ZCG(accel_directives).protect_memory);
+	add_assoc_bool(&directives,   "opcache.save_comments",          ZCG(accel_directives).save_comments);
+	add_assoc_bool(&directives,   "opcache.load_comments",          ZCG(accel_directives).load_comments);
+	add_assoc_bool(&directives,   "opcache.fast_shutdown",          ZCG(accel_directives).fast_shutdown);
+	add_assoc_bool(&directives,   "opcache.enable_file_override",   ZCG(accel_directives).file_override_enabled);
+	add_assoc_long(&directives, 	 "opcache.optimization_level",     ZCG(accel_directives).optimization_level);
+
+	add_assoc_zval(return_value, "directives", &directives);
 
 	/*version */
-	MAKE_STD_ZVAL(version);
-	array_init(version);
-	add_assoc_string(version, "version", ACCELERATOR_VERSION, 1);
-	add_assoc_string(version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME, 1);
-	add_assoc_zval(return_value, "version", version);
+	array_init(&version);
+	add_assoc_string(&version, "version", ACCELERATOR_VERSION);
+	add_assoc_string(&version, "opcache_product_name", ACCELERATOR_PRODUCT_NAME);
+	add_assoc_zval(return_value, "version", &version);
 
 	/* blacklist */
-	MAKE_STD_ZVAL(blacklist);
-	array_init(blacklist);
-	zend_accel_blacklist_apply(&accel_blacklist, (apply_func_arg_t) add_blacklist_path, blacklist TSRMLS_CC);
-	add_assoc_zval(return_value, "blacklist", blacklist);
+	array_init(&blacklist);
+	zend_accel_blacklist_apply(&accel_blacklist, add_blacklist_path, &blacklist TSRMLS_CC);
+	add_assoc_zval(return_value, "blacklist", &blacklist);
 }
 
 /* {{{ proto void accelerator_reset()
    Request that the contents of the opcode cache to be reset */
 static ZEND_FUNCTION(opcache_reset)
 {
-	/* keep the compiler happy */
-	(void)ht; (void)return_value_ptr; (void)this_ptr; (void)return_value_used;
-
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
 	if (zend_parse_parameters_none() == FAILURE) {
 		RETURN_FALSE;
diff --git a/ext/opcache/zend_accelerator_util_funcs.c b/ext/opcache/zend_accelerator_util_funcs.c
index ae33e765ca..3c143de1c1 100644
--- a/ext/opcache/zend_accelerator_util_funcs.c
+++ b/ext/opcache/zend_accelerator_util_funcs.c
@@ -31,31 +31,33 @@ static zend_uint zend_accel_refcount = ZEND_PROTECTED_REFCOUNT;
 
 #if SIZEOF_SIZE_T <= SIZEOF_LONG
 /* If sizeof(void*) == sizeof(ulong) we can use zend_hash index functions */
-# define accel_xlat_set(old, new)	zend_hash_index_update(&ZCG(bind_hash), (ulong)(zend_uintptr_t)(old), &(new), sizeof(void*), NULL)
-# define accel_xlat_get(old, new)	zend_hash_index_find(&ZCG(bind_hash), (ulong)(zend_uintptr_t)(old), (void**)&(new))
+# define accel_xlat_set(old, new)	zend_hash_index_update_ptr(&ZCG(bind_hash), (ulong)(zend_uintptr_t)(old), (new))
+# define accel_xlat_get(old)		zend_hash_index_find_ptr(&ZCG(bind_hash), (ulong)(zend_uintptr_t)(old))
 #else
-# define accel_xlat_set(old, new)	zend_hash_quick_add(&ZCG(bind_hash), (char*)&(old), sizeof(void*), (ulong)(zend_uintptr_t)(old), (void**)&(new), sizeof(void*), NULL)
-# define accel_xlat_get(old, new)	zend_hash_quick_find(&ZCG(bind_hash), (char*)&(old), sizeof(void*), (ulong)(zend_uintptr_t)(old), (void**)&(new))
+# define accel_xlat_set(old, new)	(zend_hash_str_add_ptr(&ZCG(bind_hash), (char*)&(old), sizeof(void*), (ulong)(zend_uintptr_t)(old), (void**)&(new))
+# define accel_xlat_get(old, new)	((new) = zend_hash_str_find_ptr(&ZCG(bind_hash), (char*)&(old), sizeof(void*), (ulong)(zend_uintptr_t)(old), (void**)&(new)))
 #endif
 
 typedef int (*id_function_t)(void *, void *);
 typedef void (*unique_copy_ctor_func_t)(void *pElement);
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-static const Bucket *uninitialized_bucket = NULL;
+static const zend_uint uninitialized_bucket = {INVALID_IDX};
 #endif
 
 static int zend_prepare_function_for_execution(zend_op_array *op_array);
 static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind);
+static zend_ast *zend_ast_clone(zend_ast *ast TSRMLS_DC);
 
-static void zend_accel_destroy_zend_function(zend_function *function)
+static void zend_accel_destroy_zend_function(zval *zv)
 {
+	zend_function *function = Z_PTR_P(zv);
 	TSRMLS_FETCH();
 
 	if (function->type == ZEND_USER_FUNCTION) {
 		if (function->op_array.static_variables) {
 
-			efree(function->op_array.static_variables);
+			FREE_HASHTABLE(function->op_array.static_variables);
 			function->op_array.static_variables = NULL;
 		}
 	}
@@ -63,12 +65,11 @@ static void zend_accel_destroy_zend_function(zend_function *function)
 	destroy_zend_function(function TSRMLS_CC);
 }
 
-static void zend_accel_destroy_zend_class(zend_class_entry **pce)
+static void zend_accel_destroy_zend_class(zval *zv)
 {
-	zend_class_entry *ce = *pce;
-
-	ce->function_table.pDestructor = (dtor_func_t) zend_accel_destroy_zend_function;
-	destroy_zend_class(pce);
+	zend_class_entry *ce = Z_PTR_P(zv);
+	ce->function_table.pDestructor = zend_accel_destroy_zend_function;
+	destroy_zend_class(zv);
 }
 
 zend_persistent_script* create_persistent_script(void)
@@ -76,12 +77,12 @@ zend_persistent_script* create_persistent_script(void)
 	zend_persistent_script *persistent_script = (zend_persistent_script *) emalloc(sizeof(zend_persistent_script));
 	memset(persistent_script, 0, sizeof(zend_persistent_script));
 
-	zend_hash_init(&persistent_script->function_table, 100, NULL, (dtor_func_t) zend_accel_destroy_zend_function, 0);
+	zend_hash_init(&persistent_script->function_table, 128, NULL, (dtor_func_t) zend_accel_destroy_zend_function, 0);
 	/* class_table is usually destroyed by free_persistent_script() that
 	 * overrides destructor. ZEND_CLASS_DTOR may be used by standard
 	 * PHP compiler
 	 */
-	zend_hash_init(&persistent_script->class_table, 10, NULL, ZEND_CLASS_DTOR, 0);
+	zend_hash_init(&persistent_script->class_table, 16, NULL, ZEND_CLASS_DTOR, 0);
 
 	return persistent_script;
 }
@@ -89,10 +90,12 @@ zend_persistent_script* create_persistent_script(void)
 static int compact_hash_table(HashTable *ht)
 {
 	uint i = 3;
+	uint j;
 	uint nSize;
-	Bucket **t;
+	Bucket *d;
+	Bucket *p;
 
-	if (!ht->nNumOfElements) {
+	if (!ht->nNumOfElements || (ht->u.flags & HASH_FLAG_PACKED)) {
 		/* Empty tables don't allocate space for Buckets */
 		return 1;
 	}
@@ -112,14 +115,23 @@ static int compact_hash_table(HashTable *ht)
 		return 1;
 	}
 
-	t = (Bucket **)pemalloc(nSize * sizeof(Bucket *), ht->persistent);
-	if (!t) {
+	d = (Bucket *)pemalloc(nSize * (sizeof(Bucket) + sizeof(zend_uint)), ht->u.flags & HASH_FLAG_PERSISTENT);
+	if (!d) {
 		return 0;
 	}
 
-	pefree(ht->arBuckets, ht->persistent);
+	for (i = 0, j = 0; i < ht->nNumUsed; i++) {
+		p = ht->arData + i;
+		if (Z_TYPE(p->val) != IS_UNDEF) {
+			d[j++] = *p;
+		}
+	}
+	ht->nNumUsed = j;
 
-	ht->arBuckets = t;
+	pefree(ht->arData, ht->u.flags & HASH_FLAG_PERSISTENT);
+
+	ht->arData = d;
+	ht->arHash = (zend_uint *)(d + nSize);
 	ht->nTableSize = nSize;
 	ht->nTableMask = ht->nTableSize - 1;
 	zend_hash_rehash(ht);
@@ -136,8 +148,8 @@ int compact_persistent_script(zend_persistent_script *persistent_script)
 void free_persistent_script(zend_persistent_script *persistent_script, int destroy_elements)
 {
 	if (destroy_elements) {
-		persistent_script->function_table.pDestructor = (dtor_func_t)zend_accel_destroy_zend_function;
-		persistent_script->class_table.pDestructor = (dtor_func_t)zend_accel_destroy_zend_class;
+		persistent_script->function_table.pDestructor = zend_accel_destroy_zend_function;
+		persistent_script->class_table.pDestructor = zend_accel_destroy_zend_class;
 	} else {
 		persistent_script->function_table.pDestructor = NULL;
 		persistent_script->class_table.pDestructor = NULL;
@@ -153,8 +165,9 @@ void free_persistent_script(zend_persistent_script *persistent_script, int destr
 	efree(persistent_script);
 }
 
-static int is_not_internal_function(zend_function *function)
+static int is_not_internal_function(zval *zv)
 {
+	zend_function *function = Z_PTR_P(zv);
 	return(function->type != ZEND_INTERNAL_FUNCTION);
 }
 
@@ -167,12 +180,13 @@ void zend_accel_free_user_functions(HashTable *ht TSRMLS_DC)
 	ht->pDestructor = orig_dtor;
 }
 
-static int move_user_function(zend_function *function
+static int move_user_function(zval *zv
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
 	TSRMLS_DC 
 #endif
 	, int num_args, va_list args, zend_hash_key *hash_key) 
 {
+	zend_function *function = Z_PTR_P(zv);
 	HashTable *function_table = va_arg(args, HashTable *);
 	(void)num_args; /* keep the compiler happy */
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
@@ -180,7 +194,8 @@ static int move_user_function(zend_function *function
 #endif 
 
 	if (function->type == ZEND_USER_FUNCTION) {
-		zend_hash_quick_update(function_table, hash_key->arKey, hash_key->nKeyLength, hash_key->h, function, sizeof(zend_function), NULL);
+		zend_hash_update_ptr(function_table, hash_key->key, function);
+//???		zend_hash_update_mem(function_table, hash_key->key, function, sizeof(zend_function));
 		return 1;
 	} else {
 		return 0;
@@ -200,10 +215,11 @@ void zend_accel_move_user_functions(HashTable *src, HashTable *dst TSRMLS_DC)
 	src->pDestructor = orig_dtor;
 }
 
-static int copy_internal_function(zend_function *function, HashTable *function_table TSRMLS_DC)
+static int copy_internal_function(zval *zv, HashTable *function_table TSRMLS_DC)
 {
+	zend_internal_function *function = Z_PTR_P(zv);
 	if (function->type == ZEND_INTERNAL_FUNCTION) {
-		zend_hash_update(function_table, function->common.function_name, strlen(function->common.function_name) + 1, function, sizeof(zend_function), NULL);
+		zend_hash_update_mem(function_table, function->function_name, function, sizeof(zend_internal_function));
 	}
 	return 0;
 }
@@ -214,11 +230,92 @@ void zend_accel_copy_internal_functions(TSRMLS_D)
 	ZCG(internal_functions_count) = zend_hash_num_elements(&ZCG(function_table));
 }
 
-static void zend_destroy_property_info(zend_property_info *property_info)
+static void zend_destroy_property_info(zval *zv)
 {
-	interned_efree((char*)property_info->name);
+	zend_property_info *property_info = Z_PTR_P(zv);
+
+	STR_RELEASE(property_info->name);
 	if (property_info->doc_comment) {
-		efree((char*)property_info->doc_comment);
+		STR_RELEASE(property_info->doc_comment);
+	}
+	efree(property_info);
+}
+
+static inline zend_string *zend_clone_str(zend_string *str TSRMLS_DC)
+{
+	zend_string *ret;
+
+	if (IS_INTERNED(str)) {		
+		ret = str;
+	} else if (STR_REFCOUNT(str) <= 1 || (ret = accel_xlat_get(str)) == NULL) {
+		ret = STR_DUP(str, 0);
+		GC_FLAGS(ret) = GC_FLAGS(str);
+		if (STR_REFCOUNT(str) > 1) {
+			accel_xlat_set(str, ret);
+		}
+	} else {
+		STR_ADDREF(ret);
+	}
+	return ret;
+}
+
+static inline void zend_clone_zval(zval *src, int bind TSRMLS_DC)
+{
+	void *ptr;
+
+#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
+	switch (Z_TYPE_P(src)) {
+#else
+	switch (Z_TYPE_P(src)) {
+#endif
+		case IS_STRING:
+	    case IS_CONSTANT:
+			Z_STR_P(src) = zend_clone_str(Z_STR_P(src) TSRMLS_CC);
+			break;
+		case IS_ARRAY:
+	    case IS_CONSTANT_ARRAY:
+			if (Z_ARR_P(src) != &EG(symbol_table)) {
+		    	if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_ARR_P(src))) != NULL) {
+		    		Z_ARR_P(src) = ptr;
+				} else {
+					zend_array *old = Z_ARR_P(src);
+
+					Z_ARR_P(src) = emalloc(sizeof(zend_array));
+					Z_ARR_P(src)->gc = old->gc;
+			    	if (bind && Z_REFCOUNT_P(src) > 1) {
+						accel_xlat_set(old, Z_ARR_P(src));
+					}
+					zend_hash_clone_zval(Z_ARRVAL_P(src), &old->ht, 0);
+				}
+			}
+			break;
+	    case IS_REFERENCE:
+	    	if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_REF_P(src))) != NULL) {
+	    		Z_REF_P(src) = ptr;
+			} else {
+				zend_reference *old = Z_REF_P(src);
+				ZVAL_NEW_REF(src, &old->val);
+				Z_REF_P(src)->gc = old->gc;
+		    	if (bind && Z_REFCOUNT_P(src) > 1) {
+					accel_xlat_set(old, Z_REF_P(src));
+				}
+				zend_clone_zval(Z_REFVAL_P(src), bind TSRMLS_CC);
+			}
+	    	break;
+	    case IS_CONSTANT_AST:
+	    	if (bind && Z_REFCOUNT_P(src) > 1 && (ptr = accel_xlat_get(Z_AST_P(src))) != NULL) {
+	    		Z_AST_P(src) = ptr;
+			} else {
+				zend_ast_ref *old = Z_AST_P(src);
+
+		    	ZVAL_NEW_AST(src, old->ast);
+				Z_AST_P(src)->gc = old->gc;
+		    	if (bind && Z_REFCOUNT_P(src) > 1) {
+					accel_xlat_set(old, Z_AST_P(src));
+				}
+		    	Z_ASTVAL_P(src) = zend_ast_clone(Z_ASTVAL_P(src) TSRMLS_CC);
+			}
+	    	break;
 	}
 }
 
@@ -232,28 +329,8 @@ static zend_ast *zend_ast_clone(zend_ast *ast TSRMLS_DC)
 		node = emalloc(sizeof(zend_ast) + sizeof(zval));
 		node->kind = ZEND_CONST;
 		node->children = 0;
-		node->u.val = (zval*)(node + 1);
-		*node->u.val = *ast->u.val;
-		if ((Z_TYPE_P(ast->u.val) & IS_CONSTANT_TYPE_MASK) >= IS_ARRAY) {
-			switch ((Z_TYPE_P(ast->u.val) & IS_CONSTANT_TYPE_MASK)) {
-				case IS_STRING:
-				case IS_CONSTANT:
-					Z_STRVAL_P(node->u.val) = (char *) interned_estrndup(Z_STRVAL_P(ast->u.val), Z_STRLEN_P(ast->u.val));
-					break;
-				case IS_ARRAY:
-#if ZEND_EXTENSION_API_NO <= PHP_5_5_API_NO
-				case IS_CONSTANT_ARRAY:
-#endif
-					if (ast->u.val->value.ht && ast->u.val->value.ht != &EG(symbol_table)) {
-						ALLOC_HASHTABLE(node->u.val->value.ht);
-						zend_hash_clone_zval(node->u.val->value.ht, ast->u.val->value.ht, 0);
-					}
-					break;
-				case IS_CONSTANT_AST:
-					Z_AST_P(node->u.val) = zend_ast_clone(Z_AST_P(ast->u.val) TSRMLS_CC);
-					break;
-			}
-		}
+		ZVAL_COPY_VALUE(&node->u.val, &ast->u.val);
+		zend_clone_zval(&node->u.val, 0 TSRMLS_CC);
 	} else {
 		node = emalloc(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 		node->kind = ast->kind;
@@ -270,266 +347,148 @@ static zend_ast *zend_ast_clone(zend_ast *ast TSRMLS_DC)
 }
 #endif
 
-static inline zval* zend_clone_zval(zval *src, int bind TSRMLS_DC)
-{
-	zval *ret, **ret_ptr = NULL;
-
-	if (!bind) {
-		ALLOC_ZVAL(ret);
-		*ret = *src;
-		INIT_PZVAL(ret);
-	} else if (Z_REFCOUNT_P(src) == 1) {
-		ALLOC_ZVAL(ret);
-		*ret = *src;
-	} else if (accel_xlat_get(src, ret_ptr) != SUCCESS) {
-		ALLOC_ZVAL(ret);
-		*ret = *src;
-		accel_xlat_set(src, ret);
-	} else {
-		return *ret_ptr;
-	}
-
-#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-	if ((Z_TYPE_P(ret) & IS_CONSTANT_TYPE_MASK) >= IS_ARRAY) {
-		switch ((Z_TYPE_P(ret) & IS_CONSTANT_TYPE_MASK)) {
-#else
-	if ((Z_TYPE_P(ret) & ~IS_CONSTANT_INDEX) >= IS_ARRAY) {
-		switch ((Z_TYPE_P(ret) & ~IS_CONSTANT_INDEX)) {
-#endif
-			case IS_STRING:
-			case IS_CONSTANT:
-				Z_STRVAL_P(ret) = (char *) interned_estrndup(Z_STRVAL_P(ret), Z_STRLEN_P(ret));
-				break;
-			case IS_ARRAY:
-#if ZEND_EXTENSION_API_NO <= PHP_5_5_API_NO
-			case IS_CONSTANT_ARRAY:
-#endif
-				if (ret->value.ht && ret->value.ht != &EG(symbol_table)) {
-					ALLOC_HASHTABLE(ret->value.ht);
-					zend_hash_clone_zval(ret->value.ht, src->value.ht, 0);
-				}
-				break;
-#if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
-			case IS_CONSTANT_AST:
-				Z_AST_P(ret) = zend_ast_clone(Z_AST_P(ret) TSRMLS_CC);
-				break;
-#endif
-		}
-	}
-	return ret;
-}
-
 static void zend_hash_clone_zval(HashTable *ht, HashTable *source, int bind)
 {
-	Bucket *p, *q, **prev;
+	uint idx;
+	Bucket *p, *q;
 	ulong nIndex;
-	zval *ppz;
 	TSRMLS_FETCH();
 
 	ht->nTableSize = source->nTableSize;
 	ht->nTableMask = source->nTableMask;
+	ht->nNumUsed = 0;
 	ht->nNumOfElements = source->nNumOfElements;
 	ht->nNextFreeElement = source->nNextFreeElement;
 	ht->pDestructor = ZVAL_PTR_DTOR;
-#if ZEND_DEBUG
-	ht->inconsistent = 0;
-#endif
-	ht->persistent = 0;
-	ht->arBuckets = NULL;
-	ht->pListHead = NULL;
-	ht->pListTail = NULL;
-	ht->pInternalPointer = NULL;
-	ht->nApplyCount = 0;
-	ht->bApplyProtection = 1;
+	ht->u.flags = HASH_FLAG_APPLY_PROTECTION;
+	ht->arData = NULL;
+	ht->arHash = NULL;
+	ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX;
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	if (!ht->nTableMask) {
-		ht->arBuckets = (Bucket**)&uninitialized_bucket;
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
 		return;
 	}
 #endif
 
-	ht->arBuckets = (Bucket **) ecalloc(ht->nTableSize, sizeof(Bucket *));
+	if (source->u.flags & HASH_FLAG_PACKED) {
+		ht->u.flags |= HASH_FLAG_PACKED;
+		ht->arData = (Bucket *) emalloc(ht->nTableSize * sizeof(Bucket));
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
+	} else {
+		ht->arData = (Bucket *) emalloc(ht->nTableSize * (sizeof(Bucket) + sizeof(zend_uint)));
+		ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize);
+		memset(ht->arHash, INVALID_IDX, sizeof(zend_uint) * ht->nTableSize);
+	}
 
-	prev = &ht->pListHead;
-	p = source->pListHead;
-	while (p) {
+	for (idx = 0; idx < source->nNumUsed; idx++) {
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 		nIndex = p->h & ht->nTableMask;
 
-		/* Create bucket and initialize key */
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-		if (!p->nKeyLength) {
-			q = (Bucket *) emalloc(sizeof(Bucket));
-			q->arKey = NULL;
-		} else if (IS_INTERNED(p->arKey)) {
-			q = (Bucket *) emalloc(sizeof(Bucket));
-			q->arKey = p->arKey;
-		} else {
-			q = (Bucket *) emalloc(sizeof(Bucket) + p->nKeyLength);
-			q->arKey = ((char*)q) + sizeof(Bucket);
-			memcpy((char*)q->arKey, p->arKey, p->nKeyLength);
-		}
-#else
-		q = (Bucket *) emalloc(sizeof(Bucket) - 1 + p->nKeyLength);
-		if (p->nKeyLength) {
-			memcpy(q->arKey, p->arKey, p->nKeyLength);
-		}
-#endif
-		q->h = p->h;
-		q->nKeyLength = p->nKeyLength;
-
 		/* Insert into hash collision list */
-		q->pNext = ht->arBuckets[nIndex];
-		q->pLast = NULL;
-		if (q->pNext) {
-			q->pNext->pLast = q;
-		}
-		ht->arBuckets[nIndex] = q;
-
-		/* Insert into global list */
-		q->pListLast = ht->pListTail;
-		ht->pListTail = q;
-		q->pListNext = NULL;
-		*prev = q;
-		prev = &q->pListNext;
-
-		/* Copy data */
-		q->pData = &q->pDataPtr;
-		if (!bind) {
-			ALLOC_ZVAL(ppz);
-			*ppz = *((zval*)p->pDataPtr);
-			INIT_PZVAL(ppz);
-		} else if (Z_REFCOUNT_P((zval*)p->pDataPtr) == 1) {
-			ALLOC_ZVAL(ppz);
-			*ppz = *((zval*)p->pDataPtr);
-		} else if (accel_xlat_get(p->pDataPtr, ppz) != SUCCESS) {
-			ALLOC_ZVAL(ppz);
-			*ppz = *((zval*)p->pDataPtr);
-			accel_xlat_set(p->pDataPtr, ppz);
+		if (source->u.flags & HASH_FLAG_PACKED) {
+			Bucket *r = ht->arData + ht->nNumUsed;
+			q = ht->arData + p->h;
+			while (r != q) {
+				ZVAL_UNDEF(&r->val);
+				r++;
+			}
+			ht->nNumUsed = p->h + 1;
 		} else {
-			q->pDataPtr = *(void**)ppz;
-			p = p->pListNext;
-			continue;
+			q = ht->arData + ht->nNumUsed;
+			Z_NEXT(q->val) = ht->arHash[nIndex];
+			ht->arHash[nIndex] = ht->nNumUsed++;
 		}
-		q->pDataPtr = (void*)ppz;
 
-#if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-		if ((Z_TYPE_P((zval*)p->pDataPtr) & IS_CONSTANT_TYPE_MASK) >= IS_ARRAY) {
-			switch ((Z_TYPE_P((zval*)p->pDataPtr) & IS_CONSTANT_TYPE_MASK)) {
-#else
-		if ((Z_TYPE_P((zval*)p->pDataPtr) & ~IS_CONSTANT_INDEX) >= IS_ARRAY) {
-			switch ((Z_TYPE_P((zval*)p->pDataPtr) & ~IS_CONSTANT_INDEX)) {
-#endif
-				case IS_STRING:
-				case IS_CONSTANT:
-					Z_STRVAL_P(ppz) = (char *) interned_estrndup(Z_STRVAL_P((zval*)p->pDataPtr), Z_STRLEN_P((zval*)p->pDataPtr));
-					break;
-				case IS_ARRAY:
-#if ZEND_EXTENSION_API_NO <= PHP_5_5_API_NO
-				case IS_CONSTANT_ARRAY:
-#endif
-					if (((zval*)p->pDataPtr)->value.ht && ((zval*)p->pDataPtr)->value.ht != &EG(symbol_table)) {
-						ALLOC_HASHTABLE(ppz->value.ht);
-						zend_hash_clone_zval(ppz->value.ht, ((zval*)p->pDataPtr)->value.ht, 0);
-					}
-					break;
-#if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
-				case IS_CONSTANT_AST:
-					Z_AST_P(ppz) = zend_ast_clone(Z_AST_P(ppz) TSRMLS_CC);
-					break;
-#endif
-			}
+		/* Initialize key */
+		q->h = p->h;
+		if (!p->key) {
+			q->key = NULL;
+		} else {
+			q->key = zend_clone_str(p->key TSRMLS_CC);
 		}
 
-		p = p->pListNext;
+		/* Copy data */
+		ZVAL_COPY_VALUE(&q->val, &p->val);
+		zend_clone_zval(&q->val, bind TSRMLS_CC);
 	}
-	ht->pInternalPointer = ht->pListHead;
 }
 
 static void zend_hash_clone_methods(HashTable *ht, HashTable *source, zend_class_entry *old_ce, zend_class_entry *ce TSRMLS_DC)
 {
-	Bucket *p, *q, **prev;
+	uint idx;
+	Bucket *p, *q;
 	ulong nIndex;
-	zend_class_entry **new_ce;
-	zend_function** new_prototype;
+	zend_class_entry *new_ce;
+	zend_function *new_prototype;
 	zend_op_array *new_entry;
 
 	ht->nTableSize = source->nTableSize;
 	ht->nTableMask = source->nTableMask;
+	ht->nNumUsed = 0;
 	ht->nNumOfElements = source->nNumOfElements;
 	ht->nNextFreeElement = source->nNextFreeElement;
 	ht->pDestructor = ZEND_FUNCTION_DTOR;
-#if ZEND_DEBUG
-	ht->inconsistent = 0;
-#endif
-	ht->persistent = 0;
-	ht->pListHead = NULL;
-	ht->pListTail = NULL;
-	ht->pInternalPointer = NULL;
-	ht->nApplyCount = 0;
-	ht->bApplyProtection = 1;
+	ht->u.flags = HASH_FLAG_APPLY_PROTECTION;
+	ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX;
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	if (!ht->nTableMask) {
-		ht->arBuckets = (Bucket**)&uninitialized_bucket;
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
 		return;
 	}
 #endif
 
-	ht->arBuckets = (Bucket **) ecalloc(ht->nTableSize, sizeof(Bucket *));
+	if (source->u.flags & HASH_FLAG_PACKED) {
+		ht->u.flags |= HASH_FLAG_PACKED;
+		ht->arData = (Bucket *) emalloc(ht->nTableSize * sizeof(Bucket));
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
+	} else {
+		ht->arData = (Bucket *) emalloc(ht->nTableSize * (sizeof(Bucket) + sizeof(zend_uint)));
+		ht->arHash = (zend_uint *)(ht->arData + ht->nTableSize);
+		memset(ht->arHash, INVALID_IDX, sizeof(zend_uint) * ht->nTableSize);
+	}
+
+	for (idx = 0; idx < source->nNumUsed; idx++) {		
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 
-	prev = &ht->pListHead;
-	p = source->pListHead;
-	while (p) {
 		nIndex = p->h & ht->nTableMask;
 
-		/* Create bucket and initialize key */
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-		if (!p->nKeyLength) {
-			q = (Bucket *) emalloc(sizeof(Bucket));
-			q->arKey = NULL;
-		} else if (IS_INTERNED(p->arKey)) {
-			q = (Bucket *) emalloc(sizeof(Bucket));
-			q->arKey = p->arKey;
+		/* Insert into hash collision list */
+		if (source->u.flags & HASH_FLAG_PACKED) {
+			Bucket *r = ht->arData + ht->nNumUsed;
+			q = ht->arData + p->h;
+			while (r != q) {
+				ZVAL_UNDEF(&r->val);
+				r++;
+			}
+			ht->nNumUsed = p->h + 1;
 		} else {
-			q = (Bucket *) emalloc(sizeof(Bucket) + p->nKeyLength);
-			q->arKey = ((char*)q) + sizeof(Bucket);
-			memcpy((char*)q->arKey, p->arKey, p->nKeyLength);
+			q = ht->arData + ht->nNumUsed;
+			Z_NEXT(q->val) = ht->arHash[nIndex];
+			ht->arHash[nIndex] = ht->nNumUsed++;
 		}
-#else
-		q = (Bucket *) emalloc(sizeof(Bucket) - 1 + p->nKeyLength);
-		if (p->nKeyLength) {
-			memcpy(q->arKey, p->arKey, p->nKeyLength);
-		}
-#endif
-		q->h = p->h;
-		q->nKeyLength = p->nKeyLength;
 
-		/* Insert into hash collision list */
-		q->pNext = ht->arBuckets[nIndex];
-		q->pLast = NULL;
-		if (q->pNext) {
-			q->pNext->pLast = q;
+		/* Initialize key */
+		q->h = p->h;
+		if (!p->key) {
+			q->key = NULL;
+		} else {
+			q->key = zend_clone_str(p->key TSRMLS_CC);
 		}
-		ht->arBuckets[nIndex] = q;
-
-		/* Insert into global list */
-		q->pListLast = ht->pListTail;
-		ht->pListTail = q;
-		q->pListNext = NULL;
-		*prev = q;
-		prev = &q->pListNext;
 
 		/* Copy data */
-		q->pData = (void *) emalloc(sizeof(zend_function));
-		new_entry = (zend_op_array*)q->pData;
-		*new_entry = *(zend_op_array*)p->pData;
-		q->pDataPtr = NULL;
+		ZVAL_PTR(&q->val, (void *) emalloc(sizeof(zend_op_array)));
+		new_entry = (zend_op_array*)Z_PTR(q->val);
+		*new_entry = *(zend_op_array*)Z_PTR(p->val);
 
 		/* Copy constructor */
 		/* we use refcount to show that op_array is referenced from several places */
 		if (new_entry->refcount != NULL) {
-			accel_xlat_set(p->pData, new_entry);
+			accel_xlat_set(Z_PTR(p->val), new_entry);
 		}
 
 		zend_prepare_function_for_execution(new_entry);
@@ -537,126 +496,109 @@ static void zend_hash_clone_methods(HashTable *ht, HashTable *source, zend_class
 		if (old_ce == new_entry->scope) {
 			new_entry->scope = ce;
 		} else {
-			if (accel_xlat_get(new_entry->scope, new_ce) == SUCCESS) {
-				new_entry->scope = *new_ce;
+			if ((new_ce = accel_xlat_get(new_entry->scope)) != NULL) {
+				new_entry->scope = new_ce;
 			} else {
-				zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME " class loading error, class %s, function %s", ce->name, new_entry->function_name);
+				zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME " class loading error, class %s, function %s", ce->name->val, new_entry->function_name->val);
 			}
 		}
 
 		/* update prototype */
 		if (new_entry->prototype) {
-			if (accel_xlat_get(new_entry->prototype, new_prototype) == SUCCESS) {
-				new_entry->prototype = *new_prototype;
+			if ((new_prototype = accel_xlat_get(new_entry->prototype)) != NULL) {
+				new_entry->prototype = new_prototype;
 			} else {
-				zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME " class loading error, class %s, function %s", ce->name, new_entry->function_name);
+				zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME " class loading error, class %s, function %s", ce->name->val, new_entry->function_name->val);
 			}
 		}
-
-		p = p->pListNext;
 	}
-	ht->pInternalPointer = ht->pListHead;
 }
 
 static void zend_hash_clone_prop_info(HashTable *ht, HashTable *source, zend_class_entry *old_ce, zend_class_entry *ce TSRMLS_DC)
 {
-	Bucket *p, *q, **prev;
+	uint idx;
+	Bucket *p, *q;
 	ulong nIndex;
-	zend_class_entry **new_ce;
+	zend_class_entry *new_ce;
 	zend_property_info *prop_info;
 
 	ht->nTableSize = source->nTableSize;
 	ht->nTableMask = source->nTableMask;
+	ht->nNumUsed = 0;
 	ht->nNumOfElements = source->nNumOfElements;
 	ht->nNextFreeElement = source->nNextFreeElement;
-	ht->pDestructor = (dtor_func_t) zend_destroy_property_info;
-#if ZEND_DEBUG
-	ht->inconsistent = 0;
-#endif
-	ht->persistent = 0;
-	ht->pListHead = NULL;
-	ht->pListTail = NULL;
-	ht->pInternalPointer = NULL;
-	ht->nApplyCount = 0;
-	ht->bApplyProtection = 1;
+	ht->pDestructor = zend_destroy_property_info;
+	ht->u.flags = HASH_FLAG_APPLY_PROTECTION;
+	ht->nInternalPointer = source->nNumOfElements ? 0 : INVALID_IDX;
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	if (!ht->nTableMask) {
-		ht->arBuckets = (Bucket**)&uninitialized_bucket;
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
 		return;
 	}
 #endif
 
-	ht->arBuckets = (Bucket **) ecalloc(ht->nTableSize, sizeof(Bucket *));
+	if (source->u.flags & HASH_FLAG_PACKED) {
+		ht->arData = (Bucket *) emalloc(ht->nTableSize * sizeof(Bucket));
+		ht->u.flags |= HASH_FLAG_PACKED;
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
+	} else {
+		ht->arData = (Bucket *) emalloc(ht->nTableSize * (sizeof(Bucket) + sizeof(zend_uint)));
+		ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize);
+		memset(ht->arHash, INVALID_IDX, sizeof(zend_uint) * ht->nTableSize);
+	}
+
+	for (idx = 0; idx < source->nNumUsed; idx++) {		
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 
-	prev = &ht->pListHead;
-	p = source->pListHead;
-	while (p) {
 		nIndex = p->h & ht->nTableMask;
 
-		/* Create bucket and initialize key */
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-		if (!p->nKeyLength) {
-			q = (Bucket *) emalloc(sizeof(Bucket));
-			q->arKey = NULL;
-		} else if (IS_INTERNED(p->arKey)) {
-			q = (Bucket *) emalloc(sizeof(Bucket));
-			q->arKey = p->arKey;
+		/* Insert into hash collision list */
+		if (source->u.flags & HASH_FLAG_PACKED) {
+			Bucket *r = ht->arData + ht->nNumUsed;
+			q = ht->arData + p->h;
+			while (r != q) {
+				ZVAL_UNDEF(&r->val);
+				r++;
+			}
+			ht->nNumUsed = p->h + 1;
 		} else {
-			q = (Bucket *) emalloc(sizeof(Bucket) + p->nKeyLength);
-			q->arKey = ((char*)q) + sizeof(Bucket);
-			memcpy((char*)q->arKey, p->arKey, p->nKeyLength);
-		}
-#else
-		q = (Bucket *) emalloc(sizeof(Bucket) - 1 + p->nKeyLength);
-		if (p->nKeyLength) {
-			memcpy(q->arKey, p->arKey, p->nKeyLength);
+			q = ht->arData + ht->nNumUsed;
+			Z_NEXT(q->val) = ht->arHash[nIndex];
+			ht->arHash[nIndex] = ht->nNumUsed++;
 		}
-#endif
-		q->h = p->h;
-		q->nKeyLength = p->nKeyLength;
 
-		/* Insert into hash collision list */
-		q->pNext = ht->arBuckets[nIndex];
-		q->pLast = NULL;
-		if (q->pNext) {
-			q->pNext->pLast = q;
+		/* Initialize key */
+		q->h = p->h;
+		if (!p->key) {
+			q->key = NULL;
+		} else {
+			q->key = zend_clone_str(p->key TSRMLS_CC);
 		}
-		ht->arBuckets[nIndex] = q;
-
-		/* Insert into global list */
-		q->pListLast = ht->pListTail;
-		ht->pListTail = q;
-		q->pListNext = NULL;
-		*prev = q;
-		prev = &q->pListNext;
 
 		/* Copy data */
-		q->pData = (void *) emalloc(sizeof(zend_property_info));
-		prop_info = q->pData;
-		*prop_info = *(zend_property_info*)p->pData;
-		q->pDataPtr = NULL;
+		ZVAL_PTR(&q->val, (void *) emalloc(sizeof(zend_property_info)));
+		prop_info = Z_PTR(q->val);
+		*prop_info = *(zend_property_info*)Z_PTR(p->val);
 
 		/* Copy constructor */
-		prop_info->name = interned_estrndup(prop_info->name, prop_info->name_length);
+		prop_info->name = zend_clone_str(prop_info->name TSRMLS_CC);
 		if (prop_info->doc_comment) {
 			if (ZCG(accel_directives).load_comments) {
-				prop_info->doc_comment = estrndup(prop_info->doc_comment, prop_info->doc_comment_len);
+				prop_info->doc_comment = STR_DUP(prop_info->doc_comment, 0);
 			} else {
 				prop_info->doc_comment = NULL;
 			}
 		}
 		if (prop_info->ce == old_ce) {
 			prop_info->ce = ce;
-		} else if (accel_xlat_get(prop_info->ce, new_ce) == SUCCESS) {
-			prop_info->ce = *new_ce;
+		} else if ((new_ce = accel_xlat_get(prop_info->ce)) != NULL) {
+			prop_info->ce = new_ce;
 		} else {
-			zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME" class loading error, class %s, property %s", ce->name, prop_info->name);
+			zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME" class loading error, class %s, property %s", ce->name->val, prop_info->name->val);
 		}
-
-		p = p->pListNext;
 	}
-	ht->pInternalPointer = ht->pListHead;
 }
 
 /* protects reference count, creates copy of statics */
@@ -680,10 +622,10 @@ static int zend_prepare_function_for_execution(zend_op_array *op_array)
 #define zend_update_inherited_handler(handler) \
 { \
 	if (ce->handler != NULL) { \
-		if (accel_xlat_get(ce->handler, new_func) == SUCCESS) { \
-			ce->handler = *new_func; \
+		if ((new_func = accel_xlat_get(ce->handler)) != NULL) { \
+			ce->handler = new_func; \
 		} else { \
-			zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME " class loading error, class %s", ce->name); \
+			zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME " class loading error, class %s", ce->name->val); \
 		} \
 	} \
 }
@@ -693,8 +635,8 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 {
 	zend_class_entry *ce = *pce;
 	zend_class_entry *old_ce = ce;
-	zend_class_entry **new_ce;
-	zend_function **new_func;
+	zend_class_entry *new_ce;
+	zend_function *new_func;
 	TSRMLS_FETCH();
 
 	*pce = ce = emalloc(sizeof(zend_class_entry));
@@ -710,13 +652,10 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 	if (old_ce->default_properties_table) {
 		int i;
 
-		ce->default_properties_table = emalloc(sizeof(zval*) * old_ce->default_properties_count);
+		ce->default_properties_table = emalloc(sizeof(zval) * old_ce->default_properties_count);
 		for (i = 0; i < old_ce->default_properties_count; i++) {
-			if (old_ce->default_properties_table[i]) {
-				ce->default_properties_table[i] = zend_clone_zval(old_ce->default_properties_table[i], 0 TSRMLS_CC);
-			} else {
-				ce->default_properties_table[i] = NULL;
-			}
+			ZVAL_COPY_VALUE(&ce->default_properties_table[i], &old_ce->default_properties_table[i]);
+			zend_clone_zval(&ce->default_properties_table[i], 1 TSRMLS_CC);
 		}
 	}
 #else
@@ -730,13 +669,10 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 	if (old_ce->default_static_members_table) {
 		int i;
 
-		ce->default_static_members_table = emalloc(sizeof(zval*) * old_ce->default_static_members_count);
+		ce->default_static_members_table = emalloc(sizeof(zval) * old_ce->default_static_members_count);
 		for (i = 0; i < old_ce->default_static_members_count; i++) {
-			if (old_ce->default_static_members_table[i]) {
-				ce->default_static_members_table[i] = zend_clone_zval(old_ce->default_static_members_table[i], 1 TSRMLS_CC);
-			} else {
-				ce->default_static_members_table[i] = NULL;
-			}
+			ZVAL_COPY_VALUE(&ce->default_static_members_table[i], &old_ce->default_static_members_table[i]);
+			zend_clone_zval(&ce->default_static_members_table[i], 1 TSRMLS_CC);
 		}
 	}
 	ce->static_members_table = ce->default_static_members_table;
@@ -749,9 +685,9 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 	zend_hash_clone_prop_info(&ce->properties_info, &old_ce->properties_info, old_ce, ce TSRMLS_CC);
 
 	/* constants table */
-	zend_hash_clone_zval(&ce->constants_table, &old_ce->constants_table, 0);
+	zend_hash_clone_zval(&ce->constants_table, &old_ce->constants_table, 1);
 
-	ce->name = interned_estrndup(ce->name, ce->name_length);
+	ce->name = zend_clone_str(ce->name TSRMLS_CC);
 
 	/* interfaces aren't really implemented, so we create a new table */
 	if (ce->num_interfaces) {
@@ -762,17 +698,17 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 	}
 	if (ZEND_CE_DOC_COMMENT(ce)) {
 		if (ZCG(accel_directives).load_comments) {
-			ZEND_CE_DOC_COMMENT(ce) = estrndup(ZEND_CE_DOC_COMMENT(ce), ZEND_CE_DOC_COMMENT_LEN(ce));
+			ZEND_CE_DOC_COMMENT(ce) = STR_DUP(ZEND_CE_DOC_COMMENT(ce), 0);
 		} else {
 			ZEND_CE_DOC_COMMENT(ce) =  NULL;
 		}
 	}
 
 	if (ce->parent) {
-		if (accel_xlat_get(ce->parent, new_ce) == SUCCESS) {
-			ce->parent = *new_ce;
+		if ((new_ce = accel_xlat_get(ce->parent)) != NULL) {
+			ce->parent = new_ce;
 		} else {
-			zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME" class loading error, class %s", ce->name);
+			zend_error(E_ERROR, ACCELERATOR_PRODUCT_NAME" class loading error, class %s", ce->name->val);
 		}
 	}
 
@@ -794,6 +730,7 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 /* 5.3 stuff */
 	zend_update_inherited_handler(__callstatic);
 #endif
+	zend_update_inherited_handler(__debugInfo);
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 /* 5.4 traits */
@@ -814,20 +751,17 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 			if (trait_aliases[i]->trait_method) {
 				if (trait_aliases[i]->trait_method->method_name) {
 					trait_aliases[i]->trait_method->method_name =
-						estrndup(trait_aliases[i]->trait_method->method_name,
-							trait_aliases[i]->trait_method->mname_len);
+						zend_clone_str(trait_aliases[i]->trait_method->method_name TSRMLS_CC);
 				}
 				if (trait_aliases[i]->trait_method->class_name) {
 					trait_aliases[i]->trait_method->class_name =
-						estrndup(trait_aliases[i]->trait_method->class_name,
-							trait_aliases[i]->trait_method->cname_len);
+						zend_clone_str(trait_aliases[i]->trait_method->class_name TSRMLS_CC);
 				}
 			}
 
 			if (trait_aliases[i]->alias) {
 				trait_aliases[i]->alias =
-					estrndup(trait_aliases[i]->alias,
-						trait_aliases[i]->alias_len);
+					zend_clone_str(trait_aliases[i]->alias TSRMLS_CC);
 			}
 			i++;
 		}
@@ -851,29 +785,26 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 			memcpy(trait_precedences[i]->trait_method, ce->trait_precedences[i]->trait_method, sizeof(zend_trait_method_reference));
 
 			trait_precedences[i]->trait_method->method_name =
-				estrndup(trait_precedences[i]->trait_method->method_name,
-					trait_precedences[i]->trait_method->mname_len);
+				zend_clone_str(trait_precedences[i]->trait_method->method_name TSRMLS_CC);
 			trait_precedences[i]->trait_method->class_name =
-				estrndup(trait_precedences[i]->trait_method->class_name,
-					trait_precedences[i]->trait_method->cname_len);
+				zend_clone_str(trait_precedences[i]->trait_method->class_name TSRMLS_CC);
 
 			if (trait_precedences[i]->exclude_from_classes) {
-				zend_class_entry **exclude_from_classes;
+				zend_string **exclude_from_classes;
 				int j = 0;
 
-				while (trait_precedences[i]->exclude_from_classes[j]) {
+				while (trait_precedences[i]->exclude_from_classes[j].class_name) {
 					j++;
 				}
-				exclude_from_classes = emalloc(sizeof(zend_class_entry*) * (j + 1));
+				exclude_from_classes = emalloc(sizeof(zend_string*) * (j + 1));
 				j = 0;
-				while (trait_precedences[i]->exclude_from_classes[j]) {
-					exclude_from_classes[j] = (zend_class_entry*)estrndup(
-						(char*)trait_precedences[i]->exclude_from_classes[j],
-						strlen((char*)trait_precedences[i]->exclude_from_classes[j]));
+				while (trait_precedences[i]->exclude_from_classes[j].class_name) {
+					exclude_from_classes[j] =
+						zend_clone_str(trait_precedences[i]->exclude_from_classes[j].class_name TSRMLS_CC);
 					j++;
 				}
 				exclude_from_classes[j] = NULL;
-				trait_precedences[i]->exclude_from_classes = exclude_from_classes;
+				trait_precedences[i]->exclude_from_classes = (void*)exclude_from_classes;
 			}
 			i++;
 		}
@@ -883,93 +814,119 @@ static void zend_class_copy_ctor(zend_class_entry **pce)
 #endif
 }
 
-static int zend_hash_unique_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor, uint size, int ignore_dups, void **fail_data, void **conflict_data)
+static void zend_accel_function_hash_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor TSRMLS_DC)
 {
+	zend_function *function1, *function2;
+	uint idx;
 	Bucket *p;
-	void *t;
-
-	p = source->pListHead;
-	while (p) {
-		if (p->nKeyLength > 0) {
-			if (zend_hash_quick_add(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t) == SUCCESS) {
-				if (pCopyConstructor) {
-					pCopyConstructor(t);
-				}
-			} else {
-				if (p->nKeyLength > 0 && p->arKey[0] == 0) {
+	zval *t;
+
+	for (idx = 0; idx < source->nNumUsed; idx++) {		
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key) {
+			t = zend_hash_add(target, p->key, &p->val);
+			if (UNEXPECTED(t == NULL)) {
+				if (p->key->len > 0 && p->key->val[0] == 0) {
 					/* Mangled key */
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-					if (((zend_function*)p->pData)->common.fn_flags & ZEND_ACC_CLOSURE) {
+					if (((zend_function*)Z_PTR(p->val))->common.fn_flags & ZEND_ACC_CLOSURE) {
 						/* update closure */
-						if (zend_hash_quick_update(target, p->arKey, p->nKeyLength, p->h, p->pData, size, &t) == SUCCESS) {
-							if (pCopyConstructor) {
-								pCopyConstructor(t);
-							}
-						}
+						t = zend_hash_update(target, p->key, &p->val);
 					} else {
 						/* ignore and wait for runtime */
+						continue;
 					} 
+#else
+					/* ignore and wait for runtime */
+					continue;
 #endif
-				} else if (!ignore_dups && zend_hash_quick_find(target, p->arKey, p->nKeyLength, p->h, &t) == SUCCESS) {
-					*fail_data = p->pData;
-					*conflict_data = t;
-					return FAILURE;
+				} else {
+					t = zend_hash_find(target, p->key);
+					goto failure;
 				}
 			}
 		} else {
-			if (!zend_hash_index_exists(target, p->h) && zend_hash_index_update(target, p->h, p->pData, size, &t) == SUCCESS) {
-				if (pCopyConstructor) {
-					pCopyConstructor(t);
-				}
-			} else if (!ignore_dups && zend_hash_index_find(target,p->h, &t) == SUCCESS) {
-				*fail_data = p->pData;
-				*conflict_data = t;
-				return FAILURE;
+		    t = zend_hash_index_add(target, p->h, &p->val);
+			if (UNEXPECTED(t == NULL)) {
+				t = zend_hash_index_find(target, p->h);				
+				goto failure;
 			}
 		}
-		p = p->pListNext;
+		if (pCopyConstructor) {
+			Z_PTR_P(t) = emalloc(sizeof(zend_function));
+			memcpy(Z_PTR_P(t), Z_PTR(p->val), sizeof(zend_function));
+			pCopyConstructor(Z_PTR_P(t));
+		}
+	}
+	target->nInternalPointer = target->nNumOfElements ? 0 : INVALID_IDX;
+	return;
+
+failure:
+	function1 = Z_PTR(p->val);
+	function2 = Z_PTR_P(t);
+	CG(in_compilation) = 1;
+	zend_set_compiled_filename(function1->op_array.filename TSRMLS_CC);
+	CG(zend_lineno) = function1->op_array.opcodes[0].lineno;
+	if (function2->type == ZEND_USER_FUNCTION
+		&& function2->op_array.last > 0) {
+		zend_error(E_ERROR, "Cannot redeclare %s() (previously declared in %s:%d)",
+				   function1->common.function_name->val,
+				   function2->op_array.filename->val,
+				   (int)function2->op_array.opcodes[0].lineno);
+	} else {
+		zend_error(E_ERROR, "Cannot redeclare %s()", function1->common.function_name->val);
 	}
-	target->pInternalPointer = target->pListHead;
-
-	return SUCCESS;
 }
 
-static void zend_accel_function_hash_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor)
+static void zend_accel_class_hash_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor TSRMLS_DC)
 {
-	zend_function *function1, *function2;
-	TSRMLS_FETCH();
-
-	if (zend_hash_unique_copy(target, source, pCopyConstructor, sizeof(zend_function), 0, (void**)&function1, (void**)&function2) != SUCCESS) {
-		CG(in_compilation) = 1;
-		zend_set_compiled_filename(function1->op_array.filename TSRMLS_CC);
-		CG(zend_lineno) = function1->op_array.opcodes[0].lineno;
-		if (function2->type == ZEND_USER_FUNCTION
-			&& function2->op_array.last > 0) {
-			zend_error(E_ERROR, "Cannot redeclare %s() (previously declared in %s:%d)",
-					   function1->common.function_name,
-					   function2->op_array.filename,
-					   (int)function2->op_array.opcodes[0].lineno);
+	zend_class_entry *ce1;
+	uint idx;
+	Bucket *p;
+	zval *t;
+
+	for (idx = 0; idx < source->nNumUsed; idx++) {		
+		p = source->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key) {
+			t = zend_hash_add(target, p->key, &p->val);
+			if (UNEXPECTED(t == NULL)) {
+				if (p->key->len > 0 && p->key->val[0] == 0) {
+					/* Mangled key - ignore and wait for runtime */
+					continue;
+				} else if (!ZCG(accel_directives).ignore_dups) {
+					t = zend_hash_find(target, p->key);
+					goto failure;
+				}
+			}
 		} else {
-			zend_error(E_ERROR, "Cannot redeclare %s()", function1->common.function_name);
+			t = zend_hash_index_add(target, p->h, &p->val);
+			if (UNEXPECTED(t == NULL)) {
+				if (!ZCG(accel_directives).ignore_dups) {
+					t = zend_hash_index_find(target,p->h);
+					goto failure;
+				}
+			}
+		}
+		if (pCopyConstructor) {
+			pCopyConstructor(&Z_PTR_P(t));
 		}
 	}
-}
-
-static void zend_accel_class_hash_copy(HashTable *target, HashTable *source, unique_copy_ctor_func_t pCopyConstructor TSRMLS_DC)
-{
-	zend_class_entry **pce1, **pce2;
+	target->nInternalPointer = target->nNumOfElements ? 0 : INVALID_IDX;
+	return;
 
-	if (zend_hash_unique_copy(target, source, pCopyConstructor, sizeof(zend_class_entry*), ZCG(accel_directives).ignore_dups, (void**)&pce1, (void**)&pce2) != SUCCESS) {
-		CG(in_compilation) = 1;
+failure:
+	ce1 = Z_PTR(p->val);
+	CG(in_compilation) = 1;
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-		zend_set_compiled_filename((*pce1)->info.user.filename TSRMLS_CC);
-		CG(zend_lineno) = (*pce1)->info.user.line_start;
+	zend_set_compiled_filename(ce1->info.user.filename TSRMLS_CC);
+	CG(zend_lineno) = ce1->info.user.line_start;
 #else
-		zend_set_compiled_filename((*pce1)->filename TSRMLS_CC);
-		CG(zend_lineno) = (*pce1)->line_start;
+	zend_set_compiled_filename(ce1->filename TSRMLS_CC);
+	CG(zend_lineno) = ce1->line_start;
 #endif
-		zend_error(E_ERROR, "Cannot redeclare class %s", (*pce1)->name);
-	}
+	zend_error(E_ERROR, "Cannot redeclare class %s", ce1->name->val);
 }
 
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
@@ -1003,16 +960,16 @@ zend_op_array* zend_accel_load_script(zend_persistent_script *persistent_script,
 	*op_array = persistent_script->main_op_array;
 
 	if (from_shared_memory) {
+		zend_hash_init(&ZCG(bind_hash), 10, NULL, NULL, 0);
+
 		/* Copy all the necessary stuff from shared memory to regular memory, and protect the shared script */
 		if (zend_hash_num_elements(&persistent_script->class_table) > 0) {
-			zend_hash_init(&ZCG(bind_hash), 10, NULL, NULL, 0);
 			zend_accel_class_hash_copy(CG(class_table), &persistent_script->class_table, (unique_copy_ctor_func_t) zend_class_copy_ctor TSRMLS_CC);
-			zend_hash_destroy(&ZCG(bind_hash));
 		}
 		/* we must first to copy all classes and then prepare functions, since functions may try to bind
 		   classes - which depend on pre-bind class entries existent in the class table */
 		if (zend_hash_num_elements(&persistent_script->function_table) > 0) {
-			zend_accel_function_hash_copy(CG(function_table), &persistent_script->function_table, (unique_copy_ctor_func_t)zend_prepare_function_for_execution);
+			zend_accel_function_hash_copy(CG(function_table), &persistent_script->function_table, (unique_copy_ctor_func_t)zend_prepare_function_for_execution TSRMLS_CC);
 		}
 
 		zend_prepare_function_for_execution(op_array);
@@ -1020,19 +977,18 @@ zend_op_array* zend_accel_load_script(zend_persistent_script *persistent_script,
 		/* Register __COMPILER_HALT_OFFSET__ constant */
 		if (persistent_script->compiler_halt_offset != 0 &&
 		    persistent_script->full_path) {
-			char *name, *cfilename;
+			zend_string *name;
 			char haltoff[] = "__COMPILER_HALT_OFFSET__";
-			int len, clen;
 
-			cfilename = persistent_script->full_path;
-			clen = strlen(cfilename);
-			zend_mangle_property_name(&name, &len, haltoff, sizeof(haltoff) - 1, cfilename, clen, 0);
-			if (!zend_hash_exists(EG(zend_constants), name, len + 1)) {
-				zend_register_long_constant(name, len + 1, persistent_script->compiler_halt_offset, CONST_CS, 0 TSRMLS_CC);
+			name = zend_mangle_property_name(haltoff, sizeof(haltoff) - 1, persistent_script->full_path->val, persistent_script->full_path->len, 0);
+			if (!zend_hash_exists(EG(zend_constants), name)) {
+				zend_register_long_constant(name->val, name->len, persistent_script->compiler_halt_offset, CONST_CS, 0 TSRMLS_CC);
 			}
-			efree(name);
+			STR_RELEASE(name);
 		}
 
+		zend_hash_destroy(&ZCG(bind_hash));
+
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
 		if ((int)persistent_script->early_binding != -1) {
 			zend_do_delayed_early_binding(op_array, persistent_script->early_binding TSRMLS_CC);
@@ -1041,7 +997,7 @@ zend_op_array* zend_accel_load_script(zend_persistent_script *persistent_script,
 
 	} else /* if (!from_shared_memory) */ {
 		if (zend_hash_num_elements(&persistent_script->function_table) > 0) {
-			zend_accel_function_hash_copy(CG(function_table), &persistent_script->function_table, NULL);
+			zend_accel_function_hash_copy(CG(function_table), &persistent_script->function_table, NULL TSRMLS_CC);
 		}
 		if (zend_hash_num_elements(&persistent_script->class_table) > 0) {
 			zend_accel_class_hash_copy(CG(class_table), &persistent_script->class_table, NULL TSRMLS_CC);
@@ -1051,7 +1007,7 @@ zend_op_array* zend_accel_load_script(zend_persistent_script *persistent_script,
 
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
 	if (op_array->early_binding != (zend_uint)-1) {
-		char *orig_compiled_filename = CG(compiled_filename);
+		zend_string *orig_compiled_filename = CG(compiled_filename);
 		CG(compiled_filename) = persistent_script->full_path;
 		zend_do_delayed_early_binding(op_array TSRMLS_CC);
 		CG(compiled_filename) = orig_compiled_filename;
diff --git a/ext/opcache/zend_persist.c b/ext/opcache/zend_persist.c
index 17f8e8798f..0130e12d07 100644
--- a/ext/opcache/zend_persist.c
+++ b/ext/opcache/zend_persist.c
@@ -34,12 +34,26 @@
 	    _zend_shared_memdup((void*)p, size, 0 TSRMLS_CC)
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-# define zend_accel_memdup_interned_string(str, len) \
-	IS_INTERNED(str) ? str : zend_accel_memdup(str, len)
-
-# define zend_accel_store_interned_string(str, len) do { \
-		if (!IS_INTERNED(str)) { zend_accel_store(str, len); } \
+# define zend_accel_store_string(str) do { \
+		zend_string *new_str = zend_shared_alloc_get_xlat_entry(str); \
+		if (new_str) { \
+			STR_RELEASE(str); \
+			str = new_str; \
+		} else { \
+	    	new_str = _zend_shared_memdup((void*)str, _STR_HEADER_SIZE + (str)->len + 1, 0 TSRMLS_CC); \
+			STR_RELEASE(str); \
+	    	str = new_str; \
+		} \
+    } while (0)
+# define zend_accel_memdup_string(str) \
+	zend_accel_memdup(str, _STR_HEADER_SIZE + (str)->len + 1)
+# define zend_accel_store_interned_string(str) do { \
+		if (!IS_ACCEL_INTERNED(str)) { \
+			zend_accel_store_string(str); \
+		} \
 	} while (0)
+# define zend_accel_memdup_interned_string(str) \
+	(IS_ACCEL_INTERNED(str) ? str : zend_accel_memdup_string(str))
 #else
 # define zend_accel_memdup_interned_string(str, len) \
 	zend_accel_memdup(str, len)
@@ -48,95 +62,42 @@
 	zend_accel_store(str, len)
 #endif
 
-typedef void (*zend_persist_func_t)(void * TSRMLS_DC);
+typedef void (*zend_persist_func_t)(zval* TSRMLS_DC);
 
-static void zend_persist_zval_ptr(zval **zp TSRMLS_DC);
 static void zend_persist_zval(zval *z TSRMLS_DC);
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-static const Bucket *uninitialized_bucket = NULL;
+static const zend_uint uninitialized_bucket = {INVALID_IDX};
 #endif
 
-static void zend_hash_persist(HashTable *ht, void (*pPersistElement)(void *pElement TSRMLS_DC), size_t el_size TSRMLS_DC)
+static void zend_hash_persist(HashTable *ht, zend_persist_func_t pPersistElement TSRMLS_DC)
 {
-	Bucket *p = ht->pListHead;
-	uint i;
+	uint idx;
+	Bucket *p;
 
-	while (p) {
-		Bucket *q = p;
+	if (!ht->nTableMask) {
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
+		return;
+	}
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		zend_accel_store(ht->arData, sizeof(Bucket) * ht->nTableSize);
+		ht->arHash = (zend_uint*)&uninitialized_bucket;
+	} else {
+		zend_accel_store(ht->arData, (sizeof(Bucket) + sizeof(zend_uint)) * ht->nTableSize);
+		ht->arHash = (zend_uint*)(ht->arData + ht->nTableSize);
+	}
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 
 		/* persist bucket and key */
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-		p = zend_accel_memdup(p, sizeof(Bucket));
-		if (p->nKeyLength) {
-			p->arKey = zend_accel_memdup_interned_string(p->arKey, p->nKeyLength);
-		}
-#else
-		p = zend_accel_memdup(p, sizeof(Bucket) - 1 + p->nKeyLength);
-#endif
-
-		/* persist data pointer in bucket */
-		if (!p->pDataPtr) {
-			zend_accel_store(p->pData, el_size);
-		} else {
-			/* Update p->pData to point to the new p->pDataPtr address, after the bucket relocation */
-			p->pData = &p->pDataPtr;
+		if (p->key) {
+			zend_accel_store_interned_string(p->key);
 		}
 
 		/* persist the data itself */
-		if (pPersistElement) {
-			pPersistElement(p->pData TSRMLS_CC);
-		}
-
-		/* update linked lists */
-		if (p->pLast) {
-			p->pLast->pNext = p;
-		}
-		if (p->pNext) {
-			p->pNext->pLast = p;
-		}
-		if (p->pListLast) {
-			p->pListLast->pListNext = p;
-		}
-		if (p->pListNext) {
-			p->pListNext->pListLast = p;
-		}
-
-		p = p->pListNext;
-
-		/* delete the old non-persistent bucket */
-		efree(q);
-	}
-
-	/* update linked lists */
-	if (ht->pListHead) {
-		ht->pListHead = zend_shared_alloc_get_xlat_entry(ht->pListHead);
-	}
-	if (ht->pListTail) {
-		ht->pListTail = zend_shared_alloc_get_xlat_entry(ht->pListTail);
-	}
-	if (ht->pInternalPointer) {
-		ht->pInternalPointer = zend_shared_alloc_get_xlat_entry(ht->pInternalPointer);
+		pPersistElement(&p->val TSRMLS_CC);
 	}
-
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-	/* Check if HastTable is initialized */
-	if (ht->nTableMask) {
-#endif
-		if (ht->nNumOfElements) {
-			/* update hash table */
-			for (i = 0; i < ht->nTableSize; i++) {
-				if (ht->arBuckets[i]) {
-					ht->arBuckets[i] = zend_shared_alloc_get_xlat_entry(ht->arBuckets[i]);
-				}
-			}
-		}
-		zend_accel_store(ht->arBuckets, sizeof(Bucket*) * ht->nTableSize);
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-	} else {
-		ht->arBuckets = (Bucket**)&uninitialized_bucket;
-	}
-#endif
 }
 
 #if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
@@ -146,9 +107,8 @@ static zend_ast *zend_persist_ast(zend_ast *ast TSRMLS_DC)
 	zend_ast *node;
 
 	if (ast->kind == ZEND_CONST) {
-		node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zval));
-		node->u.val = (zval*)(node + 1);
-		zend_persist_zval(node->u.val TSRMLS_CC);
+		node = zend_accel_memdup(ast, sizeof(zend_ast));
+		zend_persist_zval(&node->u.val TSRMLS_CC);
 	} else {
 		node = zend_accel_memdup(ast, sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 		for (i = 0; i < ast->children; i++) {
@@ -164,59 +124,64 @@ static zend_ast *zend_persist_ast(zend_ast *ast TSRMLS_DC)
 
 static void zend_persist_zval(zval *z TSRMLS_DC)
 {
+	zend_uchar flags;
+	void *new_ptr;
+
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-	switch (z->type & IS_CONSTANT_TYPE_MASK) {
+	switch (Z_TYPE_P(z)) {
 #else
-	switch (z->type & ~IS_CONSTANT_INDEX) {
+	switch (Z_TYPE_P(z)) {
 #endif
 		case IS_STRING:
 		case IS_CONSTANT:
-			zend_accel_store_interned_string(z->value.str.val, z->value.str.len + 1);
+			flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT);
+			zend_accel_store_interned_string(Z_STR_P(z));
+			Z_GC_FLAGS_P(z) |= flags;
 			break;
 		case IS_ARRAY:
-#if ZEND_EXTENSION_API_NO <= PHP_5_5_API_NO
 		case IS_CONSTANT_ARRAY:
-#endif
-			zend_accel_store(z->value.ht, sizeof(HashTable));
-			zend_hash_persist(z->value.ht, (zend_persist_func_t) zend_persist_zval_ptr, sizeof(zval**) TSRMLS_CC);
+			new_ptr = zend_shared_alloc_get_xlat_entry(Z_ARR_P(z));
+			if (new_ptr) {
+				Z_ARR_P(z) = new_ptr;
+			} else {
+				zend_accel_store(Z_ARR_P(z), sizeof(zend_array));
+				zend_hash_persist(Z_ARRVAL_P(z), zend_persist_zval TSRMLS_CC);
+			}
 			break;
 #if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
+		case IS_REFERENCE:
+			new_ptr = zend_shared_alloc_get_xlat_entry(Z_REF_P(z));
+			if (new_ptr) {
+				Z_REF_P(z) = new_ptr;
+			} else {
+				zend_accel_store(Z_REF_P(z), sizeof(zend_reference));
+				zend_persist_zval(Z_REFVAL_P(z) TSRMLS_CC);
+			}
+			break;
 		case IS_CONSTANT_AST:
-			Z_AST_P(z) = zend_persist_ast(Z_AST_P(z) TSRMLS_CC);
+			new_ptr = zend_shared_alloc_get_xlat_entry(Z_AST_P(z));
+			if (new_ptr) {
+				Z_AST_P(z) = new_ptr;
+			} else {
+				zend_accel_store(Z_AST_P(z), sizeof(zend_ast_ref));
+				Z_ASTVAL_P(z) = zend_persist_ast(Z_ASTVAL_P(z) TSRMLS_CC);
+			}
 			break;
 #endif
 	}
 }
 
-static void zend_persist_zval_ptr(zval **zp TSRMLS_DC)
-{
-	zval *new_ptr = zend_shared_alloc_get_xlat_entry(*zp);
-
-	if (new_ptr) {
-		*zp = new_ptr;
-	} else {
-		/* Attempt to store only if we didn't store this zval_ptr yet */
-		zend_accel_store(*zp, sizeof(zval));
-		zend_persist_zval(*zp TSRMLS_CC);
-	}
-}
-
-static void zend_protect_zval(zval *z TSRMLS_DC)
-{
-	PZ_SET_ISREF_P(z);
-	PZ_SET_REFCOUNT_P(z, 2);
-}
-
 static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_script* main_persistent_script TSRMLS_DC)
 {
+	int already_stored = 0;
 	zend_op *persist_ptr;
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
 	int has_jmp = 0;
 #endif
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-	zend_literal *orig_literals = NULL;
+	zval *orig_literals = NULL;
 #endif
-
+	
 	if (op_array->type != ZEND_USER_FUNCTION) {
 		return;
 	}
@@ -230,41 +195,45 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	}
 	op_array->refcount = NULL;
 
-	if (op_array->filename) {
-		/* do not free! PHP has centralized filename storage, compiler will free it */
-		op_array->filename = zend_accel_memdup(op_array->filename, strlen(op_array->filename) + 1);
-	}
-
 	if (main_persistent_script) {
 		zend_bool orig_in_execution = EG(in_execution);
 		zend_op_array *orig_op_array = EG(active_op_array);
-		zval offset;
+		zval *offset;
 
 #if ZEND_EXTENSION_API_NO < PHP_5_3_X_API_NO
 		main_persistent_script->early_binding = -1;
 #endif
 		EG(in_execution) = 1;
 		EG(active_op_array) = op_array;
-		if (zend_get_constant("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1, &offset TSRMLS_CC)) {
-			main_persistent_script->compiler_halt_offset = Z_LVAL(offset);
+		if ((offset = zend_get_constant_str("__COMPILER_HALT_OFFSET__", sizeof("__COMPILER_HALT_OFFSET__") - 1 TSRMLS_CC)) != NULL) {
+			main_persistent_script->compiler_halt_offset = Z_LVAL_P(offset);
 		}
 		EG(active_op_array) = orig_op_array;
 		EG(in_execution) = orig_in_execution;
 	}
 
+	if (op_array->static_variables) {
+		zend_hash_persist(op_array->static_variables, zend_persist_zval TSRMLS_CC);
+		zend_accel_store(op_array->static_variables, sizeof(HashTable));
+	}
+
+	if (zend_shared_alloc_get_xlat_entry(op_array->opcodes)) {
+		already_stored = 1;
+	}
+
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 	if (op_array->literals) {
-		orig_literals = zend_shared_alloc_get_xlat_entry(op_array->literals);
-		if (orig_literals) {
+		if (already_stored) {
+			orig_literals = zend_shared_alloc_get_xlat_entry(op_array->literals);
+			ZEND_ASSERT(orig_literals != NULL);
 			op_array->literals = orig_literals;
 		} else {
-			zend_literal *p = zend_accel_memdup(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
-			zend_literal *end = p + op_array->last_literal;
+			zval *p = zend_accel_memdup(op_array->literals, sizeof(zval) * op_array->last_literal);
+			zval *end = p + op_array->last_literal;
 			orig_literals = op_array->literals;
 			op_array->literals = p;
 			while (p < end) {
-				zend_persist_zval(&p->constant TSRMLS_CC);
-				zend_protect_zval(&p->constant TSRMLS_CC);
+				zend_persist_zval(p TSRMLS_CC);
 				p++;
 			}
 			efree(orig_literals);
@@ -272,7 +241,9 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	}
 #endif
 
-	if ((persist_ptr = zend_shared_alloc_get_xlat_entry(op_array->opcodes))) {
+	if (already_stored) {
+		persist_ptr = zend_shared_alloc_get_xlat_entry(op_array->opcodes);
+		ZEND_ASSERT(persist_ptr != NULL);
 		op_array->opcodes = persist_ptr;
 	} else {
 		zend_op *new_opcodes = zend_accel_memdup(op_array->opcodes, sizeof(zend_op) * op_array->last);
@@ -286,7 +257,6 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 				opline->op1.zv = (zval*)((char*)opline->op1.zv + ((char*)op_array->literals - (char*)orig_literals));
 #else
 				zend_persist_zval(&opline->op1.u.constant TSRMLS_CC);
-				zend_protect_zval(&opline->op1.u.constant TSRMLS_CC);
 #endif
 			}
 			if (ZEND_OP2_TYPE(opline) == IS_CONST) {
@@ -294,7 +264,6 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 				opline->op2.zv = (zval*)((char*)opline->op2.zv + ((char*)op_array->literals - (char*)orig_literals));
 #else
 				zend_persist_zval(&opline->op2.u.constant TSRMLS_CC);
-				zend_protect_zval(&opline->op2.u.constant TSRMLS_CC);
 #endif
 			}
 
@@ -380,18 +349,26 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 #endif
 	}
 
-	if (op_array->function_name) {
-		char *new_name;
-		if ((new_name = zend_shared_alloc_get_xlat_entry(op_array->function_name))) {
+	if (op_array->function_name && !IS_ACCEL_INTERNED(op_array->function_name)) {
+		zend_string *new_name;
+		if (already_stored) {
+			new_name = zend_shared_alloc_get_xlat_entry(op_array->function_name);
+			ZEND_ASSERT(new_name != NULL);
 			op_array->function_name = new_name;
 		} else {
-			zend_accel_store(op_array->function_name, strlen(op_array->function_name) + 1);
+			zend_accel_store_string(op_array->function_name);
 		}
 	}
 
+	if (op_array->filename) {
+		/* do not free! PHP has centralized filename storage, compiler will free it */
+		op_array->filename = zend_accel_memdup_string(op_array->filename);
+	}
+
 	if (op_array->arg_info) {
-		zend_arg_info *new_ptr;
-		if ((new_ptr = zend_shared_alloc_get_xlat_entry(op_array->arg_info))) {
+		if (already_stored) {
+			zend_arg_info *new_ptr = zend_shared_alloc_get_xlat_entry(op_array->arg_info);
+			ZEND_ASSERT(new_ptr != NULL);
 			op_array->arg_info = new_ptr;
 		} else {
 			zend_uint i;
@@ -399,10 +376,12 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 			zend_accel_store(op_array->arg_info, sizeof(zend_arg_info) * op_array->num_args);
 			for (i = 0; i < op_array->num_args; i++) {
 				if (op_array->arg_info[i].name) {
-					zend_accel_store_interned_string(op_array->arg_info[i].name, op_array->arg_info[i].name_len + 1);
+//???					zend_accel_store_interned_string(op_array->arg_info[i].name, op_array->arg_info[i].name_len + 1);
+					zend_accel_store(op_array->arg_info[i].name, op_array->arg_info[i].name_len + 1);
 				}
 				if (op_array->arg_info[i].class_name) {
-					zend_accel_store_interned_string(op_array->arg_info[i].class_name, op_array->arg_info[i].class_name_len + 1);
+//???					zend_accel_store_interned_string(op_array->arg_info[i].class_name, op_array->arg_info[i].class_name_len + 1);
+					zend_accel_store(op_array->arg_info[i].class_name, op_array->arg_info[i].class_name_len + 1);
 				}
 			}
 		}
@@ -412,25 +391,18 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 		zend_accel_store(op_array->brk_cont_array, sizeof(zend_brk_cont_element) * op_array->last_brk_cont);
 	}
 
-	if (op_array->static_variables) {
-		zend_hash_persist(op_array->static_variables, (zend_persist_func_t) zend_persist_zval_ptr, sizeof(zval**) TSRMLS_CC);
-		zend_accel_store(op_array->static_variables, sizeof(HashTable));
-	}
-
 	if (op_array->scope) {
 		op_array->scope = zend_shared_alloc_get_xlat_entry(op_array->scope);
 	}
 
 	if (op_array->doc_comment) {
 		if (ZCG(accel_directives).save_comments) {
-			zend_accel_store(op_array->doc_comment, op_array->doc_comment_len + 1);
+			zend_accel_store_string(op_array->doc_comment);
 		} else {
-			if (!zend_shared_alloc_get_xlat_entry(op_array->doc_comment)) {
-				zend_shared_alloc_register_xlat_entry(op_array->doc_comment, op_array->doc_comment);
-				efree((char*)op_array->doc_comment);
+			if (!already_stored) {
+				STR_RELEASE(op_array->doc_comment);
 			}
 			op_array->doc_comment = NULL;
-			op_array->doc_comment_len = 0;
 		}
 	}
 
@@ -439,13 +411,15 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	}
 
 	if (op_array->vars) {
-		if ((persist_ptr = zend_shared_alloc_get_xlat_entry(op_array->vars))) {
-			op_array->vars = (zend_compiled_variable*)persist_ptr;
+		if (already_stored) {
+			persist_ptr = zend_shared_alloc_get_xlat_entry(op_array->vars);
+			ZEND_ASSERT(persist_ptr != NULL);
+			op_array->vars = (zend_string**)persist_ptr;
 		} else {
 			int i;
-			zend_accel_store(op_array->vars, sizeof(zend_compiled_variable) * op_array->last_var);
+			zend_accel_store(op_array->vars, sizeof(zend_string*) * op_array->last_var);
 			for (i = 0; i < op_array->last_var; i++) {
-				zend_accel_store_interned_string(op_array->vars[i].name, op_array->vars[i].name_len + 1);
+				zend_accel_store_interned_string(op_array->vars[i]);
 			}
 		}
 	}
@@ -462,82 +436,81 @@ static void zend_persist_op_array_ex(zend_op_array *op_array, zend_persistent_sc
 	}
 }
 
-static void zend_persist_op_array(zend_op_array *op_array TSRMLS_DC)
+static void zend_persist_op_array(zval *zv TSRMLS_DC)
 {
-	zend_persist_op_array_ex(op_array, NULL TSRMLS_CC);
+	zend_accel_store(Z_PTR_P(zv), sizeof(zend_op_array));
+	zend_persist_op_array_ex(Z_PTR_P(zv), NULL TSRMLS_CC);
 }
 
-static void zend_persist_property_info(zend_property_info *prop TSRMLS_DC)
+static void zend_persist_property_info(zval *zv TSRMLS_DC)
 {
-	zend_accel_store_interned_string(prop->name, prop->name_length + 1);
+	zend_property_info *prop;
+
+	zend_accel_store(Z_PTR_P(zv), sizeof(zend_property_info));
+	prop = Z_PTR_P(zv);
+	zend_accel_store_interned_string(prop->name);
 	if (prop->doc_comment) {
 		if (ZCG(accel_directives).save_comments) {
-			zend_accel_store(prop->doc_comment, prop->doc_comment_len + 1);
+			zend_accel_store_string(prop->doc_comment);
 		} else {
 			if (!zend_shared_alloc_get_xlat_entry(prop->doc_comment)) {
 				zend_shared_alloc_register_xlat_entry(prop->doc_comment, prop->doc_comment);
-				efree((char*)prop->doc_comment);
 			}
+			STR_RELEASE(prop->doc_comment);
 			prop->doc_comment = NULL;
-			prop->doc_comment_len = 0;
 		}
 	}
 }
 
-static void zend_persist_class_entry(zend_class_entry **pce TSRMLS_DC)
+static void zend_persist_class_entry(zval *zv TSRMLS_DC)
 {
-	zend_class_entry *ce = *pce;
+	zend_class_entry *ce = Z_PTR_P(zv);
 
 	if (ce->type == ZEND_USER_CLASS) {
-		*pce = zend_accel_store(ce, sizeof(zend_class_entry));
-		zend_accel_store_interned_string(ce->name, ce->name_length + 1);
-		zend_hash_persist(&ce->function_table, (zend_persist_func_t) zend_persist_op_array, sizeof(zend_op_array) TSRMLS_CC);
+		Z_PTR_P(zv) = zend_accel_store(ce, sizeof(zend_class_entry));
+		zend_accel_store_interned_string(ce->name);
+		zend_hash_persist(&ce->function_table, zend_persist_op_array TSRMLS_CC);
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 		if (ce->default_properties_table) {
 		    int i;
 
-			zend_accel_store(ce->default_properties_table, sizeof(zval*) * ce->default_properties_count);
+			zend_accel_store(ce->default_properties_table, sizeof(zval) * ce->default_properties_count);
 			for (i = 0; i < ce->default_properties_count; i++) {
-				if (ce->default_properties_table[i]) {
-					zend_persist_zval_ptr(&ce->default_properties_table[i] TSRMLS_CC);
-				}
+				zend_persist_zval(&ce->default_properties_table[i] TSRMLS_CC);
 			}
 		}
 		if (ce->default_static_members_table) {
 		    int i;
 
-			zend_accel_store(ce->default_static_members_table, sizeof(zval*) * ce->default_static_members_count);
+			zend_accel_store(ce->default_static_members_table, sizeof(zval) * ce->default_static_members_count);
 			for (i = 0; i < ce->default_static_members_count; i++) {
-				if (ce->default_static_members_table[i]) {
-					zend_persist_zval_ptr(&ce->default_static_members_table[i] TSRMLS_CC);
-				}
+				zend_persist_zval(&ce->default_static_members_table[i] TSRMLS_CC);
 			}
 		}
 		ce->static_members_table = NULL;
 #else
-		zend_hash_persist(&ce->default_properties, (zend_persist_func_t) zend_persist_zval_ptr, sizeof(zval**) TSRMLS_CC);
-		zend_hash_persist(&ce->default_static_members, (zend_persist_func_t) zend_persist_zval_ptr, sizeof(zval**) TSRMLS_CC);
+		zend_hash_persist(&ce->default_properties, zend_persist_zval TSRMLS_CC);
+		zend_hash_persist(&ce->default_static_members, zend_persist_zval TSRMLS_CC);
 		ce->static_members = NULL;
 #endif
-		zend_hash_persist(&ce->constants_table, (zend_persist_func_t) zend_persist_zval_ptr, sizeof(zval**) TSRMLS_CC);
+		zend_hash_persist(&ce->constants_table, zend_persist_zval TSRMLS_CC);
 
 		if (ZEND_CE_FILENAME(ce)) {
 			/* do not free! PHP has centralized filename storage, compiler will free it */
-			ZEND_CE_FILENAME(ce) = zend_accel_memdup(ZEND_CE_FILENAME(ce), strlen(ZEND_CE_FILENAME(ce)) + 1);
+			ZEND_CE_FILENAME(ce) = zend_accel_memdup_string(ZEND_CE_FILENAME(ce));
 		}
 		if (ZEND_CE_DOC_COMMENT(ce)) {
 			if (ZCG(accel_directives).save_comments) {
-				zend_accel_store(ZEND_CE_DOC_COMMENT(ce), ZEND_CE_DOC_COMMENT_LEN(ce) + 1);
+				zend_accel_store_string(ZEND_CE_DOC_COMMENT(ce));
 			} else {
 				if (!zend_shared_alloc_get_xlat_entry(ZEND_CE_DOC_COMMENT(ce))) {
 					zend_shared_alloc_register_xlat_entry(ZEND_CE_DOC_COMMENT(ce), ZEND_CE_DOC_COMMENT(ce));
-					efree((char*)ZEND_CE_DOC_COMMENT(ce));
+					STR_RELEASE(ZEND_CE_DOC_COMMENT(ce));
 				}
 				ZEND_CE_DOC_COMMENT(ce) = NULL;
-				ZEND_CE_DOC_COMMENT_LEN(ce) = 0;
 			}
 		}
-		zend_hash_persist(&ce->properties_info, (zend_persist_func_t) zend_persist_property_info, sizeof(zend_property_info) TSRMLS_CC);
+		zend_hash_persist(&ce->properties_info, zend_persist_property_info TSRMLS_CC);
 		if (ce->num_interfaces && ce->interfaces) {
 			efree(ce->interfaces);
 		}
@@ -554,12 +527,10 @@ static void zend_persist_class_entry(zend_class_entry **pce TSRMLS_DC)
 			while (ce->trait_aliases[i]) {
 				if (ce->trait_aliases[i]->trait_method) {
 					if (ce->trait_aliases[i]->trait_method->method_name) {
-						zend_accel_store(ce->trait_aliases[i]->trait_method->method_name,
-							ce->trait_aliases[i]->trait_method->mname_len + 1);
+						zend_accel_store_interned_string(ce->trait_aliases[i]->trait_method->method_name);
 					}
 					if (ce->trait_aliases[i]->trait_method->class_name) {
-						zend_accel_store(ce->trait_aliases[i]->trait_method->class_name,
-							ce->trait_aliases[i]->trait_method->cname_len + 1);
+						zend_accel_store_interned_string(ce->trait_aliases[i]->trait_method->class_name);
 					}
 					ce->trait_aliases[i]->trait_method->ce = NULL;
 					zend_accel_store(ce->trait_aliases[i]->trait_method,
@@ -567,8 +538,7 @@ static void zend_persist_class_entry(zend_class_entry **pce TSRMLS_DC)
 				}
 
 				if (ce->trait_aliases[i]->alias) {
-					zend_accel_store(ce->trait_aliases[i]->alias,
-						ce->trait_aliases[i]->alias_len + 1);
+					zend_accel_store_interned_string(ce->trait_aliases[i]->alias);
 				}
 
 #if ZEND_EXTENSION_API_NO <= PHP_5_4_X_API_NO
@@ -585,10 +555,8 @@ static void zend_persist_class_entry(zend_class_entry **pce TSRMLS_DC)
 			int i = 0;
 
 			while (ce->trait_precedences[i]) {
-				zend_accel_store(ce->trait_precedences[i]->trait_method->method_name,
-					ce->trait_precedences[i]->trait_method->mname_len + 1);
-				zend_accel_store(ce->trait_precedences[i]->trait_method->class_name,
-					ce->trait_precedences[i]->trait_method->cname_len + 1);
+				zend_accel_store_interned_string(ce->trait_precedences[i]->trait_method->method_name);
+				zend_accel_store_interned_string(ce->trait_precedences[i]->trait_method->class_name);
 				ce->trait_precedences[i]->trait_method->ce = NULL;
 				zend_accel_store(ce->trait_precedences[i]->trait_method,
 					sizeof(zend_trait_method_reference));
@@ -596,9 +564,8 @@ static void zend_persist_class_entry(zend_class_entry **pce TSRMLS_DC)
 				if (ce->trait_precedences[i]->exclude_from_classes) {
 					int j = 0;
 
-					while (ce->trait_precedences[i]->exclude_from_classes[j]) {
-						zend_accel_store(ce->trait_precedences[i]->exclude_from_classes[j],
-							strlen((char*)ce->trait_precedences[i]->exclude_from_classes[j]) + 1);
+					while (ce->trait_precedences[i]->exclude_from_classes[j].class_name) {
+						zend_accel_store_interned_string(ce->trait_precedences[i]->exclude_from_classes[j].class_name);
 						j++;
 					}
 					zend_accel_store(ce->trait_precedences[i]->exclude_from_classes,
@@ -618,15 +585,17 @@ static void zend_persist_class_entry(zend_class_entry **pce TSRMLS_DC)
 	}
 }
 
-static int zend_update_property_info_ce(zend_property_info *prop TSRMLS_DC)
+static int zend_update_property_info_ce(zval *zv TSRMLS_DC)
 {
+	zend_property_info *prop = Z_PTR_P(zv);
+
 	prop->ce = zend_shared_alloc_get_xlat_entry(prop->ce);
 	return 0;
 }
 
-static int zend_update_parent_ce(zend_class_entry **pce TSRMLS_DC)
+static int zend_update_parent_ce(zval *zv TSRMLS_DC)
 {
-	zend_class_entry *ce = *pce;
+	zend_class_entry *ce = Z_PTR_P(zv);
 
 	if (ce->parent) {
 		ce->parent = zend_shared_alloc_get_xlat_entry(ce->parent);
@@ -686,24 +655,28 @@ static int zend_update_parent_ce(zend_class_entry **pce TSRMLS_DC)
 		ce->__callstatic->op_array.refcount++;
 	}
 #endif
+	if (ce->__debugInfo) {
+		ce->__debugInfo = zend_shared_alloc_get_xlat_entry(ce->__debugInfo);
+		ce->__debugInfo->op_array.refcount++;
+	}
 	zend_hash_apply(&ce->properties_info, (apply_func_t) zend_update_property_info_ce TSRMLS_CC);
 	return 0;
 }
 
 static void zend_accel_persist_class_table(HashTable *class_table TSRMLS_DC)
 {
-    zend_hash_persist(class_table, (zend_persist_func_t) zend_persist_class_entry, sizeof(zend_class_entry*) TSRMLS_CC);
+    zend_hash_persist(class_table, zend_persist_class_entry TSRMLS_CC);
 	zend_hash_apply(class_table, (apply_func_t) zend_update_parent_ce TSRMLS_CC);
 }
 
 zend_persistent_script *zend_accel_script_persist(zend_persistent_script *script, char **key, unsigned int key_length TSRMLS_DC)
 {
 	zend_shared_alloc_clear_xlat_table();
-	zend_hash_persist(&script->function_table, (zend_persist_func_t) zend_persist_op_array, sizeof(zend_op_array) TSRMLS_CC);
+	zend_hash_persist(&script->function_table, zend_persist_op_array TSRMLS_CC);
 	zend_accel_persist_class_table(&script->class_table TSRMLS_CC);
 	zend_persist_op_array_ex(&script->main_op_array, script TSRMLS_CC);
 	*key = zend_accel_memdup(*key, key_length + 1);
-	zend_accel_store(script->full_path, script->full_path_len + 1);
+	zend_accel_store_string(script->full_path);
 	zend_accel_store(script, sizeof(zend_persistent_script));
 
 	return script;
diff --git a/ext/opcache/zend_persist_calc.c b/ext/opcache/zend_persist_calc.c
index a01d834a4e..a347a34cf3 100644
--- a/ext/opcache/zend_persist_calc.c
+++ b/ext/opcache/zend_persist_calc.c
@@ -32,13 +32,18 @@
 #define RETURN_SIZE()      return memory_used
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-# define ADD_INTERNED_STRING(str, len) do { \
-		if (!IS_INTERNED(str)) { \
-			const char *tmp = accel_new_interned_string((str), (len), 1 TSRMLS_CC); \
+# define ADD_STRING(str) \
+		ADD_DUP_SIZE((str), _STR_HEADER_SIZE + (str)->len + 1)
+# define ADD_INTERNED_STRING(str, do_free) do { \
+		if (!IS_ACCEL_INTERNED(str)) { \
+			zend_string *tmp = accel_new_interned_string(str TSRMLS_CC); \
 			if (tmp != (str)) { \
-				(str) = (char*)tmp; \
+				if (do_free) { \
+					/*STR_RELEASE(str);*/ \
+				} \
+				(str) = tmp; \
 			} else { \
-				ADD_DUP_SIZE((str), (len)); \
+				ADD_STRING(str); \
 			} \
 		} \
 	} while (0)
@@ -46,51 +51,37 @@
 # define ADD_INTERNED_STRING(str, len) ADD_DUP_SIZE((str), (len))
 #endif
 
-static uint zend_persist_zval_ptr_calc(zval **zp TSRMLS_DC);
 static uint zend_persist_zval_calc(zval *z TSRMLS_DC);
 
-static uint zend_hash_persist_calc(HashTable *ht, int (*pPersistElement)(void *pElement TSRMLS_DC), size_t el_size TSRMLS_DC)
+static uint zend_hash_persist_calc(HashTable *ht, uint (*pPersistElement)(zval *pElement TSRMLS_DC) TSRMLS_DC)
 {
-	Bucket *p = ht->pListHead;
+	uint idx;
+	Bucket *p;
 	START_SIZE();
 
-	while (p) {
-		/* persist bucket and key */
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-		ADD_DUP_SIZE(p, sizeof(Bucket));
-		if (p->nKeyLength) {
-			const char *tmp = accel_new_interned_string(p->arKey, p->nKeyLength, 0 TSRMLS_CC);
-			if (tmp != p->arKey) {
-				p->arKey = tmp;
-			} else {
-				ADD_DUP_SIZE(p->arKey, p->nKeyLength);
-			}
-		}
-#else
-		ADD_DUP_SIZE(p, sizeof(Bucket) - 1 + p->nKeyLength);
-#endif
+	if (!ht->nTableMask) {
+		RETURN_SIZE();
+	}
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		ADD_DUP_SIZE(ht->arData, sizeof(Bucket) * ht->nTableSize);
+	} else {
+		ADD_DUP_SIZE(ht->arData, (sizeof(Bucket) + sizeof(zend_uint)) * ht->nTableSize);
+	}
 
-		/* persist data pointer in bucket */
-		if (!p->pDataPtr) {
-			ADD_DUP_SIZE(p->pData, el_size);
-		}
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
 
-		/* persist the data itself */
-		if (pPersistElement) {
-			ADD_SIZE(pPersistElement(p->pData TSRMLS_CC));
+		/* persist bucket and key */
+		if (p->key) {
+			zend_uchar flags = GC_FLAGS(p->key) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT);
+			ADD_INTERNED_STRING(p->key, 1);
+			GC_FLAGS(p->key) |= flags;
 		}
 
-		p = p->pListNext;
+		ADD_SIZE(pPersistElement(&p->val TSRMLS_CC));
 	}
 
-#if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-	if (ht->nTableMask) {
-		ADD_DUP_SIZE(ht->arBuckets, sizeof(Bucket*) * ht->nTableSize);
-	}
-#else
-	ADD_DUP_SIZE(ht->arBuckets, sizeof(Bucket*) * ht->nTableSize);
-#endif
-
 	RETURN_SIZE();
 }
 
@@ -101,8 +92,8 @@ static uint zend_persist_ast_calc(zend_ast *ast TSRMLS_DC)
 	START_SIZE();
 
 	if (ast->kind == ZEND_CONST) {
-		ADD_SIZE(sizeof(zend_ast) + sizeof(zval));
-		ADD_SIZE(zend_persist_zval_calc(ast->u.val TSRMLS_CC));
+		ADD_SIZE(sizeof(zend_ast));
+		ADD_SIZE(zend_persist_zval_calc(&ast->u.val TSRMLS_CC));
 	} else {
 		ADD_SIZE(sizeof(zend_ast) + sizeof(zend_ast*) * (ast->children - 1));
 		for (i = 0; i < ast->children; i++) {
@@ -117,46 +108,53 @@ static uint zend_persist_ast_calc(zend_ast *ast TSRMLS_DC)
 
 static uint zend_persist_zval_calc(zval *z TSRMLS_DC)
 {
+	zend_uchar flags;
+	uint size;
 	START_SIZE();
 
 #if ZEND_EXTENSION_API_NO >= PHP_5_3_X_API_NO
-	switch (z->type & IS_CONSTANT_TYPE_MASK) {
+	switch (Z_TYPE_P(z)) {
 #else
-	switch (z->type & ~IS_CONSTANT_INDEX) {
+	switch (Z_TYPE_P(z)) {
 #endif
 		case IS_STRING:
 		case IS_CONSTANT:
-			ADD_INTERNED_STRING(Z_STRVAL_P(z), Z_STRLEN_P(z) + 1);
+			flags = Z_GC_FLAGS_P(z) & ~ (IS_STR_PERSISTENT | IS_STR_INTERNED | IS_STR_PERMANENT);
+			ADD_INTERNED_STRING(Z_STR_P(z), 0);
+			if (IS_INTERNED(Z_STR_P(z))) {
+				Z_TYPE_FLAGS_P(z) &= ~ (IS_TYPE_REFCOUNTED | IS_TYPE_COPYABLE);
+			}
+			Z_GC_FLAGS_P(z) |= flags;
 			break;
 		case IS_ARRAY:
-#if ZEND_EXTENSION_API_NO <= PHP_5_5_API_NO
 		case IS_CONSTANT_ARRAY:
-#endif
-			ADD_DUP_SIZE(z->value.ht, sizeof(HashTable));
-			ADD_SIZE(zend_hash_persist_calc(z->value.ht, (int (*)(void* TSRMLS_DC)) zend_persist_zval_ptr_calc, sizeof(zval**) TSRMLS_CC));
+			size = zend_shared_memdup_size(Z_ARR_P(z), sizeof(zend_array));
+			if (size) {
+				ADD_SIZE(size);
+				ADD_SIZE(zend_hash_persist_calc(Z_ARRVAL_P(z), zend_persist_zval_calc TSRMLS_CC));
+			}
 			break;
 #if ZEND_EXTENSION_API_NO > PHP_5_5_X_API_NO
+		case IS_REFERENCE:
+			size = zend_shared_memdup_size(Z_REF_P(z), sizeof(zend_reference));
+			if (size) {
+				ADD_SIZE(size);
+				ADD_SIZE(zend_persist_zval_calc(Z_REFVAL_P(z) TSRMLS_CC));
+			}
+			break;
 		case IS_CONSTANT_AST:
-			ADD_SIZE(zend_persist_ast_calc(Z_AST_P(z) TSRMLS_CC));
+			size = zend_shared_memdup_size(Z_AST_P(z), sizeof(zend_ast_ref));
+			if (size) {
+				ADD_SIZE(size);
+				ADD_SIZE(zend_persist_ast_calc(Z_ASTVAL_P(z) TSRMLS_CC));
+			}
 			break;
 #endif
 	}
 	RETURN_SIZE();
 }
 
-static uint zend_persist_zval_ptr_calc(zval **zp TSRMLS_DC)
-{
-	START_SIZE();
-	zval *new_ptr = zend_shared_alloc_get_xlat_entry(*zp);
-
-	if (!new_ptr) {
-		ADD_DUP_SIZE(*zp, sizeof(zval));
-		ADD_SIZE(zend_persist_zval_calc(*zp TSRMLS_CC));
-	}
-	RETURN_SIZE();
-}
-
-static uint zend_persist_op_array_calc(zend_op_array *op_array TSRMLS_DC)
+static uint zend_persist_op_array_calc_ex(zend_op_array *op_array TSRMLS_DC)
 {
 	START_SIZE();
 
@@ -164,57 +162,80 @@ static uint zend_persist_op_array_calc(zend_op_array *op_array TSRMLS_DC)
 		return 0;
 	}
 
-	if (op_array->filename) {
-		ADD_DUP_SIZE(op_array->filename, strlen(op_array->filename) + 1);
+	if (op_array->static_variables) {
+		ADD_DUP_SIZE(op_array->static_variables, sizeof(HashTable));
+		ADD_SIZE(zend_hash_persist_calc(op_array->static_variables, zend_persist_zval_calc TSRMLS_CC));
+	}
+
+	if (zend_shared_alloc_get_xlat_entry(op_array->opcodes)) {
+		/* already stored */
+		if (op_array->function_name) {
+			zend_string *new_name = zend_shared_alloc_get_xlat_entry(op_array->function_name);
+			if (IS_ACCEL_INTERNED(new_name)) {
+				op_array->function_name = new_name;
+			}
+		}
+		RETURN_SIZE();
 	}
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
-	if (op_array->literals && !zend_shared_alloc_get_xlat_entry(op_array->literals)) {
-		zend_literal *p = op_array->literals;
-		zend_literal *end = p + op_array->last_literal;
-		ADD_DUP_SIZE(op_array->literals, sizeof(zend_literal) * op_array->last_literal);
+	if (op_array->literals) {
+		zval *p = op_array->literals;
+		zval *end = p + op_array->last_literal;
+		ADD_DUP_SIZE(op_array->literals, sizeof(zval) * op_array->last_literal);
 		while (p < end) {
-			ADD_SIZE(zend_persist_zval_calc(&p->constant TSRMLS_CC));
+			ADD_SIZE(zend_persist_zval_calc(p TSRMLS_CC));
 			p++;
 		}
 	}
 #endif
 
-	if (!zend_shared_alloc_get_xlat_entry(op_array->opcodes)) {
 #if ZEND_EXTENSION_API_NO <= PHP_5_3_X_API_NO
-		zend_op *opline = op_array->opcodes;
-		zend_op *end = op_array->opcodes + op_array->last;
+	opline = op_array->opcodes;
+	end = op_array->opcodes + op_array->last;
 
-		ADD_DUP_SIZE(op_array->opcodes, sizeof(zend_op) * op_array->last);
-		while (opline<end) {
-			if (opline->op1.op_type == IS_CONST) {
-				ADD_SIZE(zend_persist_zval_calc(&opline->op1.u.constant TSRMLS_CC));
-			}
-			if (opline->op2.op_type == IS_CONST) {
-				ADD_SIZE(zend_persist_zval_calc(&opline->op2.u.constant TSRMLS_CC));
-			}
-			opline++;
+	ADD_DUP_SIZE(op_array->opcodes, sizeof(zend_op) * op_array->last);
+	while (opline<end) {
+		if (opline->op1.op_type == IS_CONST) {
+			ADD_SIZE(zend_persist_zval_calc(&opline->op1.u.constant TSRMLS_CC));
 		}
+		if (opline->op2.op_type == IS_CONST) {
+			ADD_SIZE(zend_persist_zval_calc(&opline->op2.u.constant TSRMLS_CC));
+		}
+		opline++;
+	}
 #else
-		ADD_DUP_SIZE(op_array->opcodes, sizeof(zend_op) * op_array->last);
+	ADD_DUP_SIZE(op_array->opcodes, sizeof(zend_op) * op_array->last);
 #endif
-	}
 
 	if (op_array->function_name) {
-		ADD_DUP_SIZE(op_array->function_name, strlen(op_array->function_name) + 1);
+		zend_string *old_name = op_array->function_name;
+		zend_string *new_name = zend_shared_alloc_get_xlat_entry(old_name);
+
+		if (new_name) {
+			op_array->function_name = new_name;
+		} else {
+			ADD_INTERNED_STRING(op_array->function_name, 0);
+			zend_shared_alloc_register_xlat_entry(old_name, op_array->function_name);
+		}
     }
 
-	if (op_array->arg_info &&
-		!zend_shared_alloc_get_xlat_entry(op_array->arg_info)) {
+	if (op_array->filename) {
+		ADD_STRING(op_array->filename);
+	}
+
+	if (op_array->arg_info) {
 		zend_uint i;
 
 		ADD_DUP_SIZE(op_array->arg_info, sizeof(zend_arg_info) * op_array->num_args);
 		for (i = 0; i < op_array->num_args; i++) {
 			if (op_array->arg_info[i].name) {
-				ADD_INTERNED_STRING(op_array->arg_info[i].name, op_array->arg_info[i].name_len + 1);
+//???				ADD_INTERNED_STRING(op_array->arg_info[i].name, op_array->arg_info[i].name_len + 1);
+				ADD_SIZE(op_array->arg_info[i].name_len + 1);
 			}
 			if (op_array->arg_info[i].class_name) {
-				ADD_INTERNED_STRING(op_array->arg_info[i].class_name, op_array->arg_info[i].class_name_len + 1);
+//???				ADD_INTERNED_STRING(op_array->arg_info[i].class_name, op_array->arg_info[i].class_name_len + 1);
+				ADD_SIZE(op_array->arg_info[i].class_name_len + 1);
 			}
 
 		}
@@ -224,85 +245,87 @@ static uint zend_persist_op_array_calc(zend_op_array *op_array TSRMLS_DC)
 		ADD_DUP_SIZE(op_array->brk_cont_array, sizeof(zend_brk_cont_element) * op_array->last_brk_cont);
 	}
 
-	if (op_array->static_variables) {
-		ADD_DUP_SIZE(op_array->static_variables, sizeof(HashTable));
-		ADD_SIZE(zend_hash_persist_calc(op_array->static_variables, (int (*)(void* TSRMLS_DC)) zend_persist_zval_ptr_calc, sizeof(zval**) TSRMLS_CC));
-	}
-
 	if (ZCG(accel_directives).save_comments && op_array->doc_comment) {
-		ADD_DUP_SIZE(op_array->doc_comment, op_array->doc_comment_len + 1);
+		ADD_STRING(op_array->doc_comment);
 	}
 
 	if (op_array->try_catch_array) {
 		ADD_DUP_SIZE(op_array->try_catch_array, sizeof(zend_try_catch_element) * op_array->last_try_catch);
 	}
 
-	if (op_array->vars && !zend_shared_alloc_get_xlat_entry(op_array->vars)) {
+	if (op_array->vars) {
 		int i;
 
-		ADD_DUP_SIZE(op_array->vars, sizeof(zend_compiled_variable) * op_array->last_var);
+		ADD_DUP_SIZE(op_array->vars, sizeof(zend_string*) * op_array->last_var);
 		for (i = 0; i < op_array->last_var; i++) {
-			ADD_INTERNED_STRING(op_array->vars[i].name, op_array->vars[i].name_len + 1);
+			ADD_INTERNED_STRING(op_array->vars[i], 0);
 		}
 	}
 
 	RETURN_SIZE();
 }
 
-static uint zend_persist_property_info_calc(zend_property_info *prop TSRMLS_DC)
+static uint zend_persist_op_array_calc(zval *zv TSRMLS_DC)
+{
+	START_SIZE();
+	ADD_SIZE(sizeof(zend_op_array));
+	ADD_SIZE(zend_persist_op_array_calc_ex(Z_PTR_P(zv) TSRMLS_CC));
+	RETURN_SIZE();
+}
+
+static uint zend_persist_property_info_calc(zval *zv TSRMLS_DC)
 {
+	zend_property_info *prop = Z_PTR_P(zv);
 	START_SIZE();
-	ADD_INTERNED_STRING(prop->name, prop->name_length + 1);
+
+	ADD_SIZE(sizeof(zend_property_info));
+	ADD_INTERNED_STRING(prop->name, 0);
 	if (ZCG(accel_directives).save_comments && prop->doc_comment) {
-		ADD_DUP_SIZE(prop->doc_comment, prop->doc_comment_len + 1);
+		ADD_STRING(prop->doc_comment);
 	}
 	RETURN_SIZE();
 }
 
-static uint zend_persist_class_entry_calc(zend_class_entry **pce TSRMLS_DC)
+static uint zend_persist_class_entry_calc(zval *zv TSRMLS_DC)
 {
-	zend_class_entry *ce = *pce;
+	zend_class_entry *ce = Z_PTR_P(zv);
 	START_SIZE();
 
 	if (ce->type == ZEND_USER_CLASS) {
 		ADD_DUP_SIZE(ce, sizeof(zend_class_entry));
-		ADD_INTERNED_STRING(ce->name, ce->name_length + 1);
-		ADD_SIZE(zend_hash_persist_calc(&ce->function_table, (int (*)(void* TSRMLS_DC)) zend_persist_op_array_calc, sizeof(zend_op_array) TSRMLS_CC));
+		ADD_INTERNED_STRING(ce->name, 0);
+		ADD_SIZE(zend_hash_persist_calc(&ce->function_table, zend_persist_op_array_calc TSRMLS_CC));
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 		if (ce->default_properties_table) {
 		    int i;
 
-			ADD_SIZE(sizeof(zval*) * ce->default_properties_count);
+			ADD_SIZE(sizeof(zval) * ce->default_properties_count);
 			for (i = 0; i < ce->default_properties_count; i++) {
-				if (ce->default_properties_table[i]) {
-					ADD_SIZE(zend_persist_zval_ptr_calc(&ce->default_properties_table[i] TSRMLS_CC));
-				}
+				ADD_SIZE(zend_persist_zval_calc(&ce->default_properties_table[i] TSRMLS_CC));
 			}
 		}
 		if (ce->default_static_members_table) {
 		    int i;
 
-			ADD_SIZE(sizeof(zval*) * ce->default_static_members_count);
+			ADD_SIZE(sizeof(zval) * ce->default_static_members_count);
 			for (i = 0; i < ce->default_static_members_count; i++) {
-				if (ce->default_static_members_table[i]) {
-					ADD_SIZE(zend_persist_zval_ptr_calc(&ce->default_static_members_table[i] TSRMLS_CC));
-				}
+				ADD_SIZE(zend_persist_zval_calc(&ce->default_static_members_table[i] TSRMLS_CC));
 			}
 		}
 #else
 		ADD_SIZE(zend_hash_persist_calc(&ce->default_properties, (int (*)(void* TSRMLS_DC)) zend_persist_zval_ptr_calc, sizeof(zval**) TSRMLS_CC));
 		ADD_SIZE(zend_hash_persist_calc(&ce->default_static_members, (int (*)(void* TSRMLS_DC)) zend_persist_zval_ptr_calc, sizeof(zval**) TSRMLS_CC));
 #endif
-		ADD_SIZE(zend_hash_persist_calc(&ce->constants_table, (int (*)(void* TSRMLS_DC)) zend_persist_zval_ptr_calc, sizeof(zval**) TSRMLS_CC));
+		ADD_SIZE(zend_hash_persist_calc(&ce->constants_table, zend_persist_zval_calc TSRMLS_CC));
 
 		if (ZEND_CE_FILENAME(ce)) {
-			ADD_DUP_SIZE(ZEND_CE_FILENAME(ce), strlen(ZEND_CE_FILENAME(ce)) + 1);
+			ADD_STRING(ZEND_CE_FILENAME(ce));
 		}
 		if (ZCG(accel_directives).save_comments && ZEND_CE_DOC_COMMENT(ce)) {
-			ADD_DUP_SIZE(ZEND_CE_DOC_COMMENT(ce), ZEND_CE_DOC_COMMENT_LEN(ce) + 1);
+			ADD_STRING(ZEND_CE_DOC_COMMENT(ce));
 		}
 
-		ADD_SIZE(zend_hash_persist_calc(&ce->properties_info, (int (*)(void* TSRMLS_DC)) zend_persist_property_info_calc, sizeof(zend_property_info) TSRMLS_CC));
+		ADD_SIZE(zend_hash_persist_calc(&ce->properties_info, zend_persist_property_info_calc TSRMLS_CC));
 
 #if ZEND_EXTENSION_API_NO > PHP_5_3_X_API_NO
 		if (ce->trait_aliases) {
@@ -310,16 +333,16 @@ static uint zend_persist_class_entry_calc(zend_class_entry **pce TSRMLS_DC)
 			while (ce->trait_aliases[i]) {
 				if (ce->trait_aliases[i]->trait_method) {
 					if (ce->trait_aliases[i]->trait_method->method_name) {
-						ADD_SIZE(ce->trait_aliases[i]->trait_method->mname_len + 1);
+						ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method->method_name, 0);
 					}
 					if (ce->trait_aliases[i]->trait_method->class_name) {
-						ADD_SIZE(ce->trait_aliases[i]->trait_method->cname_len + 1);
+						ADD_INTERNED_STRING(ce->trait_aliases[i]->trait_method->class_name, 0);
 					}
 					ADD_SIZE(sizeof(zend_trait_method_reference));
 				}
 
 				if (ce->trait_aliases[i]->alias) {
-					ADD_SIZE(ce->trait_aliases[i]->alias_len + 1);
+					ADD_INTERNED_STRING(ce->trait_aliases[i]->alias, 0);
 				}
 				ADD_SIZE(sizeof(zend_trait_alias));
 				i++;
@@ -331,15 +354,15 @@ static uint zend_persist_class_entry_calc(zend_class_entry **pce TSRMLS_DC)
 			int i = 0;
 
 			while (ce->trait_precedences[i]) {
-				ADD_SIZE(ce->trait_precedences[i]->trait_method->mname_len + 1);
-				ADD_SIZE(ce->trait_precedences[i]->trait_method->cname_len + 1);
+				ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method->method_name, 0);
+				ADD_INTERNED_STRING(ce->trait_precedences[i]->trait_method->class_name, 0);
 				ADD_SIZE(sizeof(zend_trait_method_reference));
 
 				if (ce->trait_precedences[i]->exclude_from_classes) {
 					int j = 0;
 
-					while (ce->trait_precedences[i]->exclude_from_classes[j]) {
-						ADD_SIZE(strlen((char*)ce->trait_precedences[i]->exclude_from_classes[j]) + 1);
+					while (ce->trait_precedences[i]->exclude_from_classes[j].class_name) {
+						ADD_INTERNED_STRING(ce->trait_precedences[i]->exclude_from_classes[j].class_name, 0);
 						j++;
 					}
 					ADD_SIZE(sizeof(zend_class_entry*) * (j + 1));
@@ -356,18 +379,18 @@ static uint zend_persist_class_entry_calc(zend_class_entry **pce TSRMLS_DC)
 
 static uint zend_accel_persist_class_table_calc(HashTable *class_table TSRMLS_DC)
 {
-	return zend_hash_persist_calc(class_table, (int (*)(void* TSRMLS_DC)) zend_persist_class_entry_calc, sizeof(zend_class_entry*) TSRMLS_CC);
+	return zend_hash_persist_calc(class_table, zend_persist_class_entry_calc TSRMLS_CC);
 }
 
 uint zend_accel_script_persist_calc(zend_persistent_script *new_persistent_script, char *key, unsigned int key_length TSRMLS_DC)
 {
 	START_SIZE();
 
-	ADD_SIZE(zend_hash_persist_calc(&new_persistent_script->function_table, (int (*)(void* TSRMLS_DC)) zend_persist_op_array_calc, sizeof(zend_op_array) TSRMLS_CC));
+	ADD_SIZE(zend_hash_persist_calc(&new_persistent_script->function_table, zend_persist_op_array_calc TSRMLS_CC));
 	ADD_SIZE(zend_accel_persist_class_table_calc(&new_persistent_script->class_table TSRMLS_CC));
-	ADD_SIZE(zend_persist_op_array_calc(&new_persistent_script->main_op_array TSRMLS_CC));
+	ADD_SIZE(zend_persist_op_array_calc_ex(&new_persistent_script->main_op_array TSRMLS_CC));
 	ADD_DUP_SIZE(key, key_length + 1);
-	ADD_DUP_SIZE(new_persistent_script->full_path, new_persistent_script->full_path_len + 1);
+	ADD_STRING(new_persistent_script->full_path);
 	ADD_DUP_SIZE(new_persistent_script, sizeof(zend_persistent_script));
 
 	RETURN_SIZE();
diff --git a/ext/opcache/zend_shared_alloc.c b/ext/opcache/zend_shared_alloc.c
index e1a570a3a0..0faabee8b2 100644
--- a/ext/opcache/zend_shared_alloc.c
+++ b/ext/opcache/zend_shared_alloc.c
@@ -325,9 +325,9 @@ void *zend_shared_alloc(size_t size)
 
 int zend_shared_memdup_size(void *source, size_t size)
 {
-	void **old_p;
+	void *old_p;
 
-	if (zend_hash_index_find(&xlat_table, (ulong)source, (void **)&old_p) == SUCCESS) {
+	if ((old_p = zend_hash_index_find_ptr(&xlat_table, (ulong)source)) != NULL) {
 		/* we already duplicated this pointer */
 		return 0;
 	}
@@ -337,17 +337,17 @@ int zend_shared_memdup_size(void *source, size_t size)
 
 void *_zend_shared_memdup(void *source, size_t size, zend_bool free_source TSRMLS_DC)
 {
-	void **old_p, *retval;
+	void *old_p, *retval;
 
-	if (zend_hash_index_find(&xlat_table, (ulong)source, (void **)&old_p) == SUCCESS) {
+	if ((old_p = zend_hash_index_find_ptr(&xlat_table, (ulong)source)) != NULL) {
 		/* we already duplicated this pointer */
-		return *old_p;
+		return old_p;
 	}
 	retval = ZCG(mem);;
 	ZCG(mem) = (void*)(((char*)ZCG(mem)) + ZEND_ALIGNED_SIZE(size));
 	memcpy(retval, source, size);
 	if (free_source) {
-		interned_efree((char*)source);
+		efree(source);
 	}
 	zend_shared_alloc_register_xlat_entry(source, retval);
 	return retval;
@@ -402,7 +402,7 @@ void zend_shared_alloc_lock(TSRMLS_D)
 	 * won't be taken from space which is freed by efree in memdup.
 	 * Otherwise it leads to false matches in memdup check.
 	 */
-	zend_hash_init(&xlat_table, 100, NULL, NULL, 1);
+	zend_hash_init(&xlat_table, 128, NULL, NULL, 1);
 }
 
 void zend_shared_alloc_unlock(TSRMLS_D)
@@ -431,17 +431,17 @@ void zend_shared_alloc_clear_xlat_table(void)
 
 void zend_shared_alloc_register_xlat_entry(const void *old, const void *new)
 {
-	zend_hash_index_update(&xlat_table, (ulong)old, (void*)&new, sizeof(void *), NULL);
+	zend_hash_index_update_ptr(&xlat_table, (ulong)old, (void*)new);
 }
 
 void *zend_shared_alloc_get_xlat_entry(const void *old)
 {
-	void **retval;
+	void *retval;
 
-	if (zend_hash_index_find(&xlat_table, (ulong)old, (void **)&retval) == FAILURE) {
+	if ((retval = zend_hash_index_find_ptr(&xlat_table, (ulong)old)) == NULL) {
 		return NULL;
 	}
-	return *retval;
+	return retval;
 }
 
 size_t zend_shared_alloc_get_free_memory(void)
diff --git a/ext/openssl/openssl.c b/ext/openssl/openssl.c
index 4f8f4b7334..42f8196aa0 100755
--- a/ext/openssl/openssl.c
+++ b/ext/openssl/openssl.c
@@ -668,16 +668,16 @@ static void add_assoc_name_entry(zval * val, char * key, X509_NAME * name, int s
 			if (zend_hash_find(Z_ARRVAL_P(subitem), sname, strlen(sname)+1, (void**)&data) == SUCCESS) {
 				if (Z_TYPE_PP(data) == IS_ARRAY) {
 					subentries = *data;
-					add_next_index_stringl(subentries, (char *)to_add, to_add_len, 1);
+					add_next_index_stringl(subentries, (char *)to_add, to_add_len);
 				} else if (Z_TYPE_PP(data) == IS_STRING) {
 					MAKE_STD_ZVAL(subentries);
 					array_init(subentries);
-					add_next_index_stringl(subentries, Z_STRVAL_PP(data), Z_STRLEN_PP(data), 1);
-					add_next_index_stringl(subentries, (char *)to_add, to_add_len, 1);
+					add_next_index_stringl(subentries, Z_STRVAL_PP(data), Z_STRLEN_PP(data));
+					add_next_index_stringl(subentries, (char *)to_add, to_add_len);
 					zend_hash_update(Z_ARRVAL_P(subitem), sname, strlen(sname)+1, &subentries, sizeof(zval*), NULL);
 				}
 			} else {
-				add_assoc_stringl(subitem, sname, (char *)to_add, to_add_len, 1);
+				add_assoc_stringl(subitem, sname, (char *)to_add, to_add_len);
 			}
 		}
 	}
@@ -689,7 +689,7 @@ static void add_assoc_name_entry(zval * val, char * key, X509_NAME * name, int s
 
 static void add_assoc_asn1_string(zval * val, char * key, ASN1_STRING * str) /* {{{ */
 {
-	add_assoc_stringl(val, key, (char *)str->data, str->length, 1);
+	add_assoc_stringl(val, key, (char *)str->data, str->length);
 }
 /* }}} */
 
@@ -1989,7 +1989,7 @@ PHP_FUNCTION(openssl_x509_parse)
 	array_init(return_value);
 
 	if (cert->name) {
-		add_assoc_string(return_value, "name", cert->name, 1);
+		add_assoc_string(return_value, "name", cert->name);
 	}
 /*	add_assoc_bool(return_value, "valid", cert->valid); */
 
@@ -1998,13 +1998,13 @@ PHP_FUNCTION(openssl_x509_parse)
 	{
 		char buf[32];
 		snprintf(buf, sizeof(buf), "%08lx", X509_subject_name_hash(cert));
-		add_assoc_string(return_value, "hash", buf, 1);
+		add_assoc_string(return_value, "hash", buf);
 	}
 	
 	add_assoc_name_entry(return_value, "issuer", 		X509_get_issuer_name(cert), useshortnames TSRMLS_CC);
 	add_assoc_long(return_value, "version", 			X509_get_version(cert));
 
-	add_assoc_string(return_value, "serialNumber", i2s_ASN1_INTEGER(NULL, X509_get_serialNumber(cert)), 1); 
+	add_assoc_string(return_value, "serialNumber", i2s_ASN1_INTEGER(NULL, X509_get_serialNumber(cert))); 
 
 	add_assoc_asn1_string(return_value, "validFrom", 	X509_get_notBefore(cert));
 	add_assoc_asn1_string(return_value, "validTo", 		X509_get_notAfter(cert));
@@ -2014,12 +2014,12 @@ PHP_FUNCTION(openssl_x509_parse)
 
 	tmpstr = (char *)X509_alias_get0(cert, NULL);
 	if (tmpstr) {
-		add_assoc_string(return_value, "alias", tmpstr, 1);
+		add_assoc_string(return_value, "alias", tmpstr);
 	}
 /*
 	add_assoc_long(return_value, "signaturetypeLONG", X509_get_signature_type(cert));
-	add_assoc_string(return_value, "signaturetype", OBJ_nid2sn(X509_get_signature_type(cert)), 1);
-	add_assoc_string(return_value, "signaturetypeLN", OBJ_nid2ln(X509_get_signature_type(cert)), 1);
+	add_assoc_string(return_value, "signaturetype", OBJ_nid2sn(X509_get_signature_type(cert)));
+	add_assoc_string(return_value, "signaturetypeLN", OBJ_nid2ln(X509_get_signature_type(cert)));
 */
 	MAKE_STD_ZVAL(subitem);
 	array_init(subitem);
@@ -2045,7 +2045,7 @@ PHP_FUNCTION(openssl_x509_parse)
 		add_index_bool(subsub, 1, purpset);
 
 		pname = useshortnames ? X509_PURPOSE_get0_sname(purp) : X509_PURPOSE_get0_name(purp);
-		add_index_string(subsub, 2, pname, 1);
+		add_index_string(subsub, 2, pname);
 
 		/* NOTE: if purpset > 1 then it's a warning - we should mention it ? */
 
@@ -2071,7 +2071,7 @@ PHP_FUNCTION(openssl_x509_parse)
 		if (nid == NID_subject_alt_name) {
 			if (openssl_x509v3_subjectAltName(bio_out, extension) == 0) {
 				BIO_get_mem_ptr(bio_out, &bio_buf);
-				add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length, 1);
+				add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length);
 			} else {
 				zval_dtor(return_value);
 				if (certresource == -1 && cert) {
@@ -2083,7 +2083,7 @@ PHP_FUNCTION(openssl_x509_parse)
 		}
 		else if (X509V3_EXT_print(bio_out, extension, 0, 0)) {
 			BIO_get_mem_ptr(bio_out, &bio_buf);
-			add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length, 1);
+			add_assoc_stringl(subitem, extname, bio_buf->data, bio_buf->length);
 		} else {
 			add_assoc_asn1_string(subitem, extname, X509_EXTENSION_get_data(extension));
 		}
@@ -3534,7 +3534,9 @@ static int php_openssl_is_private_key(EVP_PKEY* pkey TSRMLS_DC)
 			char *str = emalloc(len + 1);								\
 			BN_bn2bin(pkey->pkey._type->_name, (unsigned char*)str);	\
 			str[len] = 0;                                           	\
-			add_assoc_stringl(_type, #_name, str, len, 0);				\
+			/* TODO: avoid reallocation ??? */							\
+			add_assoc_stringl(_type, #_name, str, len);					\
+			efree(str);													\
 		}																\
 	} while (0)
 
@@ -3858,7 +3860,7 @@ PHP_FUNCTION(openssl_pkey_get_details)
 
 	array_init(return_value);
 	add_assoc_long(return_value, "bits", EVP_PKEY_bits(pkey));
-	add_assoc_stringl(return_value, "key", pbio, pbio_len, 1);
+	add_assoc_stringl(return_value, "key", pbio, pbio_len);
 	/*TODO: Use the real values once the openssl constants are used 
 	 * See the enum at the top of this file
 	 */
@@ -4897,7 +4899,8 @@ PHP_FUNCTION(openssl_seal)
 		array_init(ekeys);
 		for (i=0; i<nkeys; i++) {
 			eks[i][eksl[i]] = '\0';
-			add_next_index_stringl(ekeys, erealloc(eks[i], eksl[i] + 1), eksl[i], 0);
+			add_next_index_stringl(ekeys, eks[i], eksl[i]);
+			efree(eks[i]);
 			eks[i] = NULL;
 		}
 #if 0
@@ -4993,14 +4996,14 @@ PHP_FUNCTION(openssl_open)
 
 static void openssl_add_method_or_alias(const OBJ_NAME *name, void *arg) /* {{{ */
 {
-	add_next_index_string((zval*)arg, (char*)name->name, 1);
+	add_next_index_string((zval*)arg, (char*)name->name);
 }
 /* }}} */
 
 static void openssl_add_method(const OBJ_NAME *name, void *arg) /* {{{ */
 {
 	if (name->alias == 0) {
-		add_next_index_string((zval*)arg, (char*)name->name, 1);
+		add_next_index_string((zval*)arg, (char*)name->name);
 	}
 }
 /* }}} */
diff --git a/ext/pcre/php_pcre.c b/ext/pcre/php_pcre.c
index 52d43ced30..b815667238 100644
--- a/ext/pcre/php_pcre.c
+++ b/ext/pcre/php_pcre.c
@@ -86,9 +86,9 @@ static void pcre_handle_exec_error(int pcre_code TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static void php_free_pcre_cache(void *data) /* {{{ */
+static void php_free_pcre_cache(zval *data) /* {{{ */
 {
-	pcre_cache_entry *pce = (pcre_cache_entry *) data;
+	pcre_cache_entry *pce = (pcre_cache_entry *) Z_PTR_P(data);
 	if (!pce) return;
 	pefree(pce->re, 1);
 	if (pce->extra) pefree(pce->extra, 1);
@@ -96,6 +96,7 @@ static void php_free_pcre_cache(void *data) /* {{{ */
 	if ((void*)pce->tables) pefree((void*)pce->tables, 1);
 	pefree(pce->locale, 1);
 #endif
+	pefree(pce, 1);
 }
 /* }}} */
 
@@ -116,7 +117,10 @@ static PHP_GSHUTDOWN_FUNCTION(pcre) /* {{{ */
 
 PHP_INI_BEGIN()
 	STD_PHP_INI_ENTRY("pcre.backtrack_limit", "1000000", PHP_INI_ALL, OnUpdateLong, backtrack_limit, zend_pcre_globals, pcre_globals)
-	STD_PHP_INI_ENTRY("pcre.recursion_limit", "100000", PHP_INI_ALL, OnUpdateLong, recursion_limit, zend_pcre_globals, pcre_globals)
+	STD_PHP_INI_ENTRY("pcre.recursion_limit", "100000",  PHP_INI_ALL, OnUpdateLong, recursion_limit, zend_pcre_globals, pcre_globals)
+#ifdef PCRE_STUDY_JIT_COMPILE
+	STD_PHP_INI_ENTRY("pcre.jit",             "1",       PHP_INI_ALL, OnUpdateBool, jit,             zend_pcre_globals, pcre_globals)
+#endif
 PHP_INI_END()
 
 
@@ -167,7 +171,7 @@ static PHP_MSHUTDOWN_FUNCTION(pcre)
 /* }}} */
 
 /* {{{ static pcre_clean_cache */
-static int pcre_clean_cache(void *data, void *arg TSRMLS_DC)
+static int pcre_clean_cache(zval *data, void *arg TSRMLS_DC)
 {
 	int *num_clean = (int *)arg;
 
@@ -226,7 +230,7 @@ static char **make_subpats_table(int num_subpats, pcre_cache_entry *pce TSRMLS_D
 
 /* {{{ pcre_get_compiled_regex_cache
  */
-PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_len TSRMLS_DC)
+PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(zend_string *regex TSRMLS_DC)
 {
 	pcre				*re = NULL;
 	pcre_extra			*extra;
@@ -248,7 +252,6 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 #endif
 	pcre_cache_entry	*pce;
 	pcre_cache_entry	 new_entry;
-	char                *tmp = NULL;
 
 #if HAVE_SETLOCALE
 # if defined(PHP_WIN32) && defined(ZTS)
@@ -259,7 +262,8 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 
 	/* Try to lookup the cached regex entry, and if successful, just pass
 	   back the compiled pattern, otherwise go on and compile it. */
-	if (zend_hash_find(&PCRE_G(pcre_cache), regex, regex_len+1, (void **)&pce) == SUCCESS) {
+	pce = zend_hash_find_ptr(&PCRE_G(pcre_cache), regex);
+	if (pce) {
 		/*
 		 * We use a quick pcre_fullinfo() check to see whether cache is corrupted, and if it
 		 * is, we flush it and compile the pattern from scratch.
@@ -277,14 +281,14 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 		}
 	}
 	
-	p = regex;
+	p = regex->val;
 	
 	/* Parse through the leading whitespace, and display a warning if we
 	   get to the end without encountering a delimiter. */
 	while (isspace((int)*(unsigned char *)p)) p++;
 	if (*p == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, 
-						 p < regex + regex_len ? "Null byte in regex" : "Empty regular expression");
+						 p < regex->val + regex->len ? "Null byte in regex" : "Empty regular expression");
 		return NULL;
 	}
 	
@@ -331,7 +335,7 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 	}
 
 	if (*pp == 0) {
-		if (pp < regex + regex_len) {
+		if (pp < regex->val + regex->len) {
 			php_error_docref(NULL TSRMLS_CC,E_WARNING, "Null byte in regex");
 		} else if (start_delimiter == end_delimiter) {
 			php_error_docref(NULL TSRMLS_CC,E_WARNING, "No ending delimiter '%c' found", delimiter);
@@ -349,7 +353,7 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 
 	/* Parse through the options, setting appropriate flags.  Display
 	   a warning if we encounter an unknown modifier. */	
-	while (pp < regex + regex_len) {
+	while (pp < regex->val + regex->len) {
 		switch (*pp++) {
 			/* Perl compatible options */
 			case 'i':	coptions |= PCRE_CASELESS;		break;
@@ -411,12 +415,22 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 		return NULL;
 	}
 
+#ifdef PCRE_STUDY_JIT_COMPILE
+	if (PCRE_G(jit)) {
+		/* Enable PCRE JIT compiler */
+		do_study = 1;
+		soptions |= PCRE_STUDY_JIT_COMPILE;
+	}
+#endif
+
 	/* If study option was specified, study the pattern and
 	   store the result in extra for passing to pcre_exec. */
 	if (do_study) {
 		extra = pcre_study(re, soptions, &error);
 		if (extra) {
 			extra->flags |= PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
+			extra->match_limit = PCRE_G(backtrack_limit);
+			extra->match_limit_recursion = PCRE_G(recursion_limit);
 		}
 		if (error != NULL) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error while studying pattern");
@@ -455,16 +469,7 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 	 * as hash keys especually for this table.
 	 * See bug #63180 
 	 */
-	if (IS_INTERNED(regex)) {
-		regex = tmp = estrndup(regex, regex_len);
-	}
-
-	zend_hash_update(&PCRE_G(pcre_cache), regex, regex_len+1, (void *)&new_entry,
-						sizeof(pcre_cache_entry), (void**)&pce);
-
-	if (tmp) {
-		efree(tmp);
-	}
+	pce = zend_hash_str_update_mem(&PCRE_G(pcre_cache), regex->val, regex->len, &new_entry, sizeof(pcre_cache_entry));
 
 	return pce;
 }
@@ -472,9 +477,9 @@ PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_le
 
 /* {{{ pcre_get_compiled_regex
  */
-PHPAPI pcre* pcre_get_compiled_regex(char *regex, pcre_extra **extra, int *preg_options TSRMLS_DC)
+PHPAPI pcre* pcre_get_compiled_regex(zend_string *regex, pcre_extra **extra, int *preg_options TSRMLS_DC)
 {
-	pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC);
+	pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC);
 
 	if (extra) {
 		*extra = pce ? pce->extra : NULL;
@@ -489,9 +494,9 @@ PHPAPI pcre* pcre_get_compiled_regex(char *regex, pcre_extra **extra, int *preg_
 
 /* {{{ pcre_get_compiled_regex_ex
  */
-PHPAPI pcre* pcre_get_compiled_regex_ex(char *regex, pcre_extra **extra, int *preg_options, int *compile_options TSRMLS_DC)
+PHPAPI pcre* pcre_get_compiled_regex_ex(zend_string *regex, pcre_extra **extra, int *preg_options, int *compile_options TSRMLS_DC)
 {
-	pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex, strlen(regex) TSRMLS_CC);
+	pcre_cache_entry * pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC);
 	
 	if (extra) {
 		*extra = pce ? pce->extra : NULL;
@@ -510,46 +515,46 @@ PHPAPI pcre* pcre_get_compiled_regex_ex(char *regex, pcre_extra **extra, int *pr
 /* {{{ add_offset_pair */
 static inline void add_offset_pair(zval *result, char *str, int len, int offset, char *name)
 {
-	zval *match_pair;
+	zval match_pair;
 
-	ALLOC_ZVAL(match_pair);
-	array_init(match_pair);
-	INIT_PZVAL(match_pair);
+	array_init(&match_pair);
 
 	/* Add (match, offset) to the return value */
-	add_next_index_stringl(match_pair, str, len, 1);
-	add_next_index_long(match_pair, offset);
+	add_next_index_stringl(&match_pair, str, len);
+	add_next_index_long(&match_pair, offset);
 	
 	if (name) {
 		zval_add_ref(&match_pair);
-		zend_hash_update(Z_ARRVAL_P(result), name, strlen(name)+1, &match_pair, sizeof(zval *), NULL);
+		zend_hash_str_update(Z_ARRVAL_P(result), name, strlen(name), &match_pair);
 	}
-	zend_hash_next_index_insert(Z_ARRVAL_P(result), &match_pair, sizeof(zval *), NULL);
+	zend_hash_next_index_insert(Z_ARRVAL_P(result), &match_pair);
 }
 /* }}} */
 
 static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ */
 {
 	/* parameters */
-	char			 *regex;			/* Regular expression */
+	zend_string		 *regex;			/* Regular expression */
 	char			 *subject;			/* String to match against */
-	int				  regex_len;
 	int				  subject_len;
 	pcre_cache_entry *pce;				/* Compiled regular expression */
 	zval			 *subpats = NULL;	/* Array for subpatterns */
 	long			  flags = 0;		/* Match control flags */
 	long			  start_offset = 0;	/* Where the new search starts */
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|zll", &regex, &regex_len,
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|zll", &regex,
 							  &subject, &subject_len, &subpats, &flags, &start_offset) == FAILURE) {
 		RETURN_FALSE;
 	}
 	
 	/* Compile regex or get it from cache. */
-	if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
+	if ((pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
 
+	if (subpats) {
+		ZVAL_DEREF(subpats);
+	}
 	php_pcre_match_impl(pce, subject, subject_len, return_value, subpats, 
 		global, ZEND_NUM_ARGS() >= 4, flags, start_offset TSRMLS_CC);
 }
@@ -559,9 +564,9 @@ static void php_do_pcre_match(INTERNAL_FUNCTION_PARAMETERS, int global) /* {{{ *
 PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
 	zval *subpats, int global, int use_flags, long flags, long start_offset TSRMLS_DC)
 {
-	zval			*result_set,		/* Holds a set of subpatterns after
+	zval			 result_set,		/* Holds a set of subpatterns after
 										   a global match */
-				   **match_sets = NULL;	/* An array of sets of matches for each
+				    *match_sets = NULL;	/* An array of sets of matches for each
 										   subpattern after a global match */
 	pcre_extra		*extra = pce->extra;/* Holds results of studying */
 	pcre_extra		 extra_data;		/* Used locally for exec options */
@@ -578,7 +583,9 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
 	int				 subpats_order;		/* Order of subpattern matches */
 	int				 offset_capture;    /* Capture match offsets: yes/no */
 	unsigned char   *mark = NULL;       /* Target for MARK name */
-	zval            *marks = NULL;      /* Array of marks for PREG_PATTERN_ORDER */
+	zval            marks;      		/* Array of marks for PREG_PATTERN_ORDER */
+
+	ZVAL_UNDEF(&marks);
 
 	/* Overwrite the passed-in value for subpatterns with an empty array. */
 	if (subpats != NULL) {
@@ -649,11 +656,9 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
 
 	/* Allocate match sets array and initialize the values. */
 	if (global && subpats && subpats_order == PREG_PATTERN_ORDER) {
-		match_sets = (zval **)safe_emalloc(num_subpats, sizeof(zval *), 0);
+		match_sets = (zval *)safe_emalloc(num_subpats, sizeof(zval), 0);
 		for (i=0; i<num_subpats; i++) {
-			ALLOC_ZVAL(match_sets[i]);
-			array_init(match_sets[i]);
-			INIT_PZVAL(match_sets[i]);
+			array_init(&match_sets[i]);
 		}
 	}
 
@@ -694,20 +699,19 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
 						/* For each subpattern, insert it into the appropriate array. */
 						for (i = 0; i < count; i++) {
 							if (offset_capture) {
-								add_offset_pair(match_sets[i], (char *)stringlist[i],
+								add_offset_pair(&match_sets[i], (char *)stringlist[i],
 												offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], NULL);
 							} else {
-								add_next_index_stringl(match_sets[i], (char *)stringlist[i],
-													   offsets[(i<<1)+1] - offsets[i<<1], 1);
+								add_next_index_stringl(&match_sets[i], (char *)stringlist[i],
+													   offsets[(i<<1)+1] - offsets[i<<1]);
 							}
 						}
 						/* Add MARK, if available */
 						if (mark) {
-							if (!marks) {
-								MAKE_STD_ZVAL(marks);
-								array_init(marks);
+							if (Z_TYPE(marks) == IS_UNDEF) {
+								array_init(&marks);
 							}
-							add_index_string(marks, matched - 1, (char *) mark, 1);
+							add_index_string(&marks, matched - 1, (char *) mark);
 						}
 						/*
 						 * If the number of captured subpatterns on this run is
@@ -716,35 +720,33 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
 						 */
 						if (count < num_subpats) {
 							for (; i < num_subpats; i++) {
-								add_next_index_string(match_sets[i], "", 1);
+								add_next_index_string(&match_sets[i], "");
 							}
 						}
 					} else {
 						/* Allocate the result set array */
-						ALLOC_ZVAL(result_set);
-						array_init(result_set);
-						INIT_PZVAL(result_set);
+						array_init(&result_set);
 						
 						/* Add all the subpatterns to it */
 						for (i = 0; i < count; i++) {
 							if (offset_capture) {
-								add_offset_pair(result_set, (char *)stringlist[i],
+								add_offset_pair(&result_set, (char *)stringlist[i],
 												offsets[(i<<1)+1] - offsets[i<<1], offsets[i<<1], subpat_names[i]);
 							} else {
 								if (subpat_names[i]) {
-									add_assoc_stringl(result_set, subpat_names[i], (char *)stringlist[i],
-														   offsets[(i<<1)+1] - offsets[i<<1], 1);
+									add_assoc_stringl(&result_set, subpat_names[i], (char *)stringlist[i],
+														   offsets[(i<<1)+1] - offsets[i<<1]);
 								}
-								add_next_index_stringl(result_set, (char *)stringlist[i],
-													   offsets[(i<<1)+1] - offsets[i<<1], 1);
+								add_next_index_stringl(&result_set, (char *)stringlist[i],
+													   offsets[(i<<1)+1] - offsets[i<<1]);
 							}
 						}
 						/* Add MARK, if available */
 						if (mark) {
-							add_assoc_string(result_set, "MARK", (char *) mark, 1);
+							add_assoc_string(&result_set, "MARK", (char *) mark);
 						}
 						/* And add it to the output array */
-						zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &result_set, sizeof(zval *), NULL);
+						zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &result_set);
 					}
 				} else {			/* single pattern matching */
 					/* For each subpattern, insert it into the subpatterns array. */
@@ -756,15 +758,15 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
 						} else {
 							if (subpat_names[i]) {
 								add_assoc_stringl(subpats, subpat_names[i], (char *)stringlist[i],
-												  offsets[(i<<1)+1] - offsets[i<<1], 1);
+												  offsets[(i<<1)+1] - offsets[i<<1]);
 							}
 							add_next_index_stringl(subpats, (char *)stringlist[i],
-												   offsets[(i<<1)+1] - offsets[i<<1], 1);
+												   offsets[(i<<1)+1] - offsets[i<<1]);
 						}
 					}
 					/* Add MARK, if available */
 					if (mark) {
-						add_assoc_string(subpats, "MARK", (char *) mark, 1);
+						add_assoc_string(subpats, "MARK", (char *) mark);
 					}
 				}
 
@@ -799,16 +801,16 @@ PHPAPI void php_pcre_match_impl(pcre_cache_entry *pce, char *subject, int subjec
 	if (global && subpats && subpats_order == PREG_PATTERN_ORDER) {
 		for (i = 0; i < num_subpats; i++) {
 			if (subpat_names[i]) {
-				zend_hash_update(Z_ARRVAL_P(subpats), subpat_names[i],
-								 strlen(subpat_names[i])+1, &match_sets[i], sizeof(zval *), NULL);
-				Z_ADDREF_P(match_sets[i]);
+				zend_hash_str_update(Z_ARRVAL_P(subpats), subpat_names[i],
+								 strlen(subpat_names[i]), &match_sets[i]);
+				Z_ADDREF(match_sets[i]);
 			}
-			zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i], sizeof(zval *), NULL);
+			zend_hash_next_index_insert(Z_ARRVAL_P(subpats), &match_sets[i]);
 		}
 		efree(match_sets);
 
-		if (marks) {
-			add_assoc_zval(subpats, "MARK", marks);
+		if (Z_TYPE(marks) != IS_UNDEF) {
+			add_assoc_zval(subpats, "MARK", &marks);
 		}
 	}
 	
@@ -883,30 +885,27 @@ static int preg_get_backref(char **str, int *backref)
  */
 static int preg_do_repl_func(zval *function, char *subject, int *offsets, char **subpat_names, int count, unsigned char *mark, char **result TSRMLS_DC)
 {
-	zval		*retval_ptr;		/* Function return value */
-	zval	   **args[1];			/* Argument to pass to function */
-	zval		*subpats;			/* Captured subpatterns */ 
+	zval		 retval;			/* Function return value */
+	zval	     args[1];			/* Argument to pass to function */
 	int			 result_len;		/* Return value length */
 	int			 i;
 
-	MAKE_STD_ZVAL(subpats);
-	array_init(subpats);
+	array_init(&args[0]);
 	for (i = 0; i < count; i++) {
 		if (subpat_names[i]) {
-			add_assoc_stringl(subpats, subpat_names[i], &subject[offsets[i<<1]] , offsets[(i<<1)+1] - offsets[i<<1], 1);
+			add_assoc_stringl(&args[0], subpat_names[i], &subject[offsets[i<<1]] , offsets[(i<<1)+1] - offsets[i<<1]);
 		}
-		add_next_index_stringl(subpats, &subject[offsets[i<<1]], offsets[(i<<1)+1] - offsets[i<<1], 1);
+		add_next_index_stringl(&args[0], &subject[offsets[i<<1]], offsets[(i<<1)+1] - offsets[i<<1]);
 	}
 	if (mark) {
-		add_assoc_string(subpats, "MARK", (char *) mark, 1);
+		add_assoc_string(&args[0], "MARK", (char *) mark);
 	}
-	args[0] = &subpats;
 
-	if (call_user_function_ex(EG(function_table), NULL, function, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) == SUCCESS && retval_ptr) {
-		convert_to_string_ex(&retval_ptr);
-		*result = estrndup(Z_STRVAL_P(retval_ptr), Z_STRLEN_P(retval_ptr));
-		result_len = Z_STRLEN_P(retval_ptr);
-		zval_ptr_dtor(&retval_ptr);
+	if (call_user_function_ex(EG(function_table), NULL, function, &retval, 1, args, 0, NULL TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		convert_to_string_ex(&retval);
+		*result = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
+		result_len = Z_STRLEN(retval);
+		zval_ptr_dtor(&retval);
 	} else {
 		if (!EG(exception)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call custom replacement function");
@@ -915,7 +914,7 @@ static int preg_do_repl_func(zval *function, char *subject, int *offsets, char *
 		*result = estrndup(&subject[offsets[0]], result_len);
 	}
 
-	zval_ptr_dtor(&subpats);
+	zval_ptr_dtor(&args[0]);
 
 	return result_len;
 }
@@ -929,14 +928,13 @@ static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
 	zval		 retval;			/* Return value from evaluation */
 	char		*eval_str_end,		/* End of eval string */
 				*match,				/* Current match for a backref */
-				*esc_match,			/* Quote-escaped match */
 				*walk,				/* Used to walk the code string */
 				*segment,			/* Start of segment to append while walking */
 				 walk_last;			/* Last walked character */
 	int			 match_len;			/* Length of the match */
-	int			 esc_match_len;		/* Length of the quote-escaped match */
 	int			 result_len;		/* Length of the result of the evaluation */
 	int			 backref;			/* Current backref */
+	zend_string *esc_match;			/* Quote-escaped match */
 	char        *compiled_string_description;
 	smart_str    code = {0};
 	
@@ -949,7 +947,7 @@ static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
 		if ('\\' == *walk || '$' == *walk) {
 			smart_str_appendl(&code, segment, walk - segment);
 			if (walk_last == '\\') {
-				code.c[code.len-1] = *walk++;
+				code.s->val[code.s->len-1] = *walk++;
 				segment = walk;
 				walk_last = 0;
 				continue;
@@ -962,22 +960,19 @@ static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
 					match = subject + offsets[backref<<1];
 					match_len = offsets[(backref<<1)+1] - offsets[backref<<1];
 					if (match_len) {
-						esc_match = php_addslashes(match, match_len, &esc_match_len, 0 TSRMLS_CC);
+						esc_match = php_addslashes(match, match_len, 0 TSRMLS_CC);
 					} else {
-						esc_match = match;
-						esc_match_len = 0;
+						esc_match = STR_INIT(match, match_len, 0);
 					}
 				} else {
-					esc_match = "";
-					esc_match_len = 0;
+					esc_match = STR_EMPTY_ALLOC();
 				}
-				smart_str_appendl(&code, esc_match, esc_match_len);
+				smart_str_appendl(&code, esc_match->val, esc_match->len);
 
 				segment = walk;
 
 				/* Clean up and reassign */
-				if (esc_match_len)
-					efree(esc_match);
+				STR_RELEASE(esc_match);
 				continue;
 			}
 		}
@@ -989,9 +984,9 @@ static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
 
 	compiled_string_description = zend_make_compiled_string_description("regexp code" TSRMLS_CC);
 	/* Run the code */
-	if (zend_eval_stringl(code.c, code.len, &retval, compiled_string_description TSRMLS_CC) == FAILURE) {
+	if (zend_eval_stringl(code.s->val, code.s->len, &retval, compiled_string_description TSRMLS_CC) == FAILURE) {
 		efree(compiled_string_description);
-		php_error_docref(NULL TSRMLS_CC,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, code.c);
+		php_error_docref(NULL TSRMLS_CC,E_ERROR, "Failed evaluating code: %s%s", PHP_EOL, code.s->val);
 		/* zend_error() does not return in this case */
 	}
 	efree(compiled_string_description);
@@ -1011,26 +1006,26 @@ static int preg_do_eval(char *eval_str, int eval_str_len, char *subject,
 
 /* {{{ php_pcre_replace
  */
-PHPAPI char *php_pcre_replace(char *regex,   int regex_len,
+PHPAPI zend_string *php_pcre_replace(zend_string *regex,
 							  char *subject, int subject_len,
 							  zval *replace_val, int is_callable_replace,
-							  int *result_len, int limit, int *replace_count TSRMLS_DC)
+							  int limit, int *replace_count TSRMLS_DC)
 {
 	pcre_cache_entry	*pce;			    /* Compiled regular expression */
 
 	/* Compile regex or get it from cache. */
-	if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
+	if ((pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC)) == NULL) {
 		return NULL;
 	}
 
 	return php_pcre_replace_impl(pce, subject, subject_len, replace_val, 
-		is_callable_replace, result_len, limit, replace_count TSRMLS_CC);
+		is_callable_replace, limit, replace_count TSRMLS_CC);
 }
 /* }}} */
 
 /* {{{ php_pcre_replace_impl() */
-PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *replace_val, 
-	int is_callable_replace, int *result_len, int limit, int *replace_count TSRMLS_DC)
+PHPAPI zend_string *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *replace_val, 
+	int is_callable_replace, int limit, int *replace_count TSRMLS_DC)
 {
 	pcre_extra		*extra = pce->extra;/* Holds results of studying */
 	pcre_extra		 extra_data;		/* Used locally for exec options */
@@ -1050,18 +1045,18 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 	int				 start_offset;		/* Where the new search starts */
 	int				 g_notempty=0;		/* If the match should not be empty */
 	int				 replace_len=0;		/* Length of replacement string */
-	char			*result,			/* Result of replacement */
-					*replace=NULL,		/* Replacement string */
-					*new_buf,			/* Temporary buffer for re-allocation */
+	char			*replace=NULL,		/* Replacement string */
 					*walkbuf,			/* Location of current replacement in the result */
 					*walk,				/* Used to walk the replacement string */
 					*match,				/* The current match */
 					*piece,				/* The current piece of subject */
 					*replace_end=NULL,	/* End of replacement string */
-					*eval_result,		/* Result of eval or custom function */
+					*eval_result=NULL,	/* Result of eval or custom function */
 					 walk_last;			/* Last walked character */
-	int				 rc;
+	int				 rc,
+					 result_len; 		/* Length of result */
 	unsigned char   *mark = NULL;       /* Target for MARK name */
+	zend_string		*result;			/* Result of replacement */
 
 	if (extra == NULL) {
 		extra_data.flags = PCRE_EXTRA_MATCH_LIMIT | PCRE_EXTRA_MATCH_LIMIT_RECURSION;
@@ -1111,13 +1106,13 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 
 	offsets = (int *)safe_emalloc(size_offsets, sizeof(int), 0);
 	
-	alloc_len = 2 * subject_len + 1;
-	result = safe_emalloc(alloc_len, sizeof(char), 0);
+	alloc_len = 2 * subject_len;
+	result = STR_ALLOC(alloc_len * sizeof(char), 0);
 
 	/* Initialize */
 	match = NULL;
-	*result_len = 0;
 	start_offset = 0;
+	result_len = 0;
 	PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
 	
 	while (1) {
@@ -1143,7 +1138,7 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 			/* Set the match location in subject */
 			match = subject + offsets[0];
 
-			new_len = *result_len + offsets[0] - start_offset; /* part before the match */
+			new_len = result_len + offsets[0] - start_offset; /* part before the match */
 			
 			/* If evaluating, do it and add the return string's length */
 			if (eval) {
@@ -1176,26 +1171,23 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 				}
 			}
 
-			if (new_len + 1 > alloc_len) {
-				alloc_len = 1 + alloc_len + 2 * new_len;
-				new_buf = emalloc(alloc_len);
-				memcpy(new_buf, result, *result_len);
-				efree(result);
-				result = new_buf;
+			if (new_len > alloc_len) {
+				alloc_len = alloc_len + 2 * new_len;
+				result = STR_REALLOC(result, alloc_len, 0);
 			}
 			/* copy the part of the string before the match */
-			memcpy(&result[*result_len], piece, match-piece);
-			*result_len += match-piece;
+			memcpy(&result->val[result_len], piece, match-piece);
+			result_len += match-piece;
 
 			/* copy replacement and backrefs */
-			walkbuf = result + *result_len;
+			walkbuf = result->val + result_len;
 			
 			/* If evaluating or using custom function, copy result to the buffer
 			 * and clean up. */
 			if (eval || is_callable_replace) {
 				memcpy(walkbuf, eval_result, eval_result_len);
-				*result_len += eval_result_len;
-				STR_FREE(eval_result);
+				result_len += eval_result_len;
+				if (eval_result) efree(eval_result);
 			} else { /* do regular backreference copying */
 				walk = replace;
 				walk_last = 0;
@@ -1220,7 +1212,7 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 				}
 				*walkbuf = '\0';
 				/* increment the result length by how much we've added to the string */
-				*result_len += walkbuf - (result + *result_len);
+				result_len += walkbuf - (result->val + result_len);
 			}
 
 			if (limit != -1)
@@ -1234,26 +1226,23 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 			if (g_notempty != 0 && start_offset < subject_len) {
 				offsets[0] = start_offset;
 				offsets[1] = start_offset + 1;
-				memcpy(&result[*result_len], piece, 1);
-				(*result_len)++;
+				memcpy(&result->val[result_len], piece, 1);
+				result_len++;
 			} else {
-				new_len = *result_len + subject_len - start_offset;
-				if (new_len + 1 > alloc_len) {
-					alloc_len = new_len + 1; /* now we know exactly how long it is */
-					new_buf = safe_emalloc(alloc_len, sizeof(char), 0);
-					memcpy(new_buf, result, *result_len);
-					efree(result);
-					result = new_buf;
+				new_len = result_len + subject_len - start_offset;
+				if (new_len > alloc_len) {
+					alloc_len = new_len; /* now we know exactly how long it is */
+					result = STR_REALLOC(result, alloc_len, 0);
 				}
 				/* stick that last bit of string on our output */
-				memcpy(&result[*result_len], piece, subject_len - start_offset);
-				*result_len += subject_len - start_offset;
-				result[*result_len] = '\0';
+				memcpy(&result->val[result_len], piece, subject_len - start_offset);
+				result_len += subject_len - start_offset;
+				result->val[result_len] = '\0';
 				break;
 			}
 		} else {
 			pcre_handle_exec_error(count TSRMLS_CC);
-			efree(result);
+			STR_FREE(result);
 			result = NULL;
 			break;
 		}
@@ -1268,6 +1257,9 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 		start_offset = offsets[1];
 	}
 
+	if (result) {
+		result->len = result_len;
+	}
 	efree(offsets);
 	efree(subpat_names);
 
@@ -1277,47 +1269,52 @@ PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int sub
 
 /* {{{ php_replace_in_subject
  */
-static char *php_replace_in_subject(zval *regex, zval *replace, zval **subject, int *result_len, int limit, int is_callable_replace, int *replace_count TSRMLS_DC)
+static zend_string *php_replace_in_subject(zval *regex, zval *replace, zval *subject, int limit, int is_callable_replace, int *replace_count TSRMLS_DC)
 {
-	zval		**regex_entry,
-				**replace_entry = NULL,
-				 *replace_value,
-				  empty_replace;
-	char		*subject_value,
-				*result;
-	int			 subject_len;
-
-	/* Make sure we're dealing with strings. */	
-	convert_to_string_ex(subject);
+	zval		*regex_entry,
+				*replace_entry = NULL,
+				*replace_value,
+				 tmp_subject,
+				 empty_replace;
+	zend_string	*subject_value;
+	zend_string *result;
+
+	/* Make sure we're dealing with strings. */
+	if (Z_ISREF_P(subject)) {
+		subject = Z_REFVAL_P(subject);
+	}
+	ZVAL_UNDEF(&tmp_subject);
+	if (Z_TYPE_P(subject) != IS_STRING) {
+		ZVAL_DUP(&tmp_subject, subject);
+		convert_to_string_ex(&tmp_subject);
+		subject = &tmp_subject;
+	}
+
 	/* FIXME: This might need to be changed to STR_EMPTY_ALLOC(). Check if this zval could be dtor()'ed somehow */
-	ZVAL_STRINGL(&empty_replace, "", 0, 0);
+	ZVAL_EMPTY_STRING(&empty_replace);
 	
 	/* If regex is an array */
 	if (Z_TYPE_P(regex) == IS_ARRAY) {
 		/* Duplicate subject string for repeated replacement */
-		subject_value = estrndup(Z_STRVAL_PP(subject), Z_STRLEN_PP(subject));
-		subject_len = Z_STRLEN_PP(subject);
-		*result_len = subject_len;
+		subject_value = STR_INIT(Z_STRVAL_P(subject), Z_STRLEN_P(subject), 0);
 		
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(regex));
-
 		replace_value = replace;
 		if (Z_TYPE_P(replace) == IS_ARRAY && !is_callable_replace)
 			zend_hash_internal_pointer_reset(Z_ARRVAL_P(replace));
 
 		/* For each entry in the regex array, get the entry */
-		while (zend_hash_get_current_data(Z_ARRVAL_P(regex), (void **)&regex_entry) == SUCCESS) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(regex), regex_entry) {
 			/* Make sure we're dealing with strings. */	
 			convert_to_string_ex(regex_entry);
 		
 			/* If replace is an array and not a callable construct */
 			if (Z_TYPE_P(replace) == IS_ARRAY && !is_callable_replace) {
 				/* Get current entry */
-				if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {
+				if ((replace_entry = zend_hash_get_current_data(Z_ARRVAL_P(replace))) != NULL) {
 					if (!is_callable_replace) {
 						convert_to_string_ex(replace_entry);
 					}
-					replace_value = *replace_entry;
+					replace_value = replace_entry;
 					zend_hash_move_forward(Z_ARRVAL_P(replace));
 				} else {
 					/* We've run out of replacement strings, so use an empty one */
@@ -1327,37 +1324,34 @@ static char *php_replace_in_subject(zval *regex, zval *replace, zval **subject,
 			
 			/* Do the actual replacement and put the result back into subject_value
 			   for further replacements. */
-			if ((result = php_pcre_replace(Z_STRVAL_PP(regex_entry),
-										   Z_STRLEN_PP(regex_entry),
-										   subject_value,
-										   subject_len,
+			if ((result = php_pcre_replace(Z_STR_P(regex_entry),
+										   subject_value->val,
+										   subject_value->len,
 										   replace_value,
 										   is_callable_replace,
-										   result_len,
 										   limit,
 										   replace_count TSRMLS_CC)) != NULL) {
-				efree(subject_value);
+				STR_RELEASE(subject_value);
 				subject_value = result;
-				subject_len = *result_len;
 			} else {
-				efree(subject_value);
+				STR_RELEASE(subject_value);
+				zval_ptr_dtor(&tmp_subject);
 				return NULL;
 			}
 
-			zend_hash_move_forward(Z_ARRVAL_P(regex));
-		}
+		} ZEND_HASH_FOREACH_END();
 
+		zval_ptr_dtor(&tmp_subject);
 		return subject_value;
 	} else {
-		result = php_pcre_replace(Z_STRVAL_P(regex),
-								  Z_STRLEN_P(regex),
-								  Z_STRVAL_PP(subject),
-								  Z_STRLEN_PP(subject),
+		result = php_pcre_replace(Z_STR_P(regex),
+								  Z_STRVAL_P(subject),
+								  Z_STRLEN_P(subject),
 								  replace,
 								  is_callable_replace,
-								  result_len,
 								  limit,
 								  replace_count TSRMLS_CC);
+		zval_ptr_dtor(&tmp_subject);
 		return result;
 	}
 }
@@ -1367,98 +1361,87 @@ static char *php_replace_in_subject(zval *regex, zval *replace, zval **subject,
  */
 static void preg_replace_impl(INTERNAL_FUNCTION_PARAMETERS, int is_callable_replace, int is_filter)
 {
-	zval		   **regex,
-				   **replace,
-				   **subject,
-				   **subject_entry,
-				   **zcount = NULL;
-	char			*result;
-	int				 result_len;
+	zval		    *regex,
+				    *replace,
+				    *subject,
+				    *subject_entry,
+				    *zcount = NULL;
 	int				 limit_val = -1;
-	long			limit = -1;
-	char			*string_key;
-	uint			 string_key_len;
+	long			 limit = -1;
+	zend_string		*result;
+	zend_string		*string_key;
 	ulong			 num_key;
-	char			*callback_name;
+	zend_string		*callback_name;
 	int				 replace_count=0, old_replace_count;
 	
 	/* Get function parameters and do error-checking. */
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|lZ", &regex, &replace, &subject, &limit, &zcount) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|lz", &regex, &replace, &subject, &limit, &zcount) == FAILURE) {
 		return;
 	}
 	
-	if (!is_callable_replace && Z_TYPE_PP(replace) == IS_ARRAY && Z_TYPE_PP(regex) != IS_ARRAY) {
+	if (!is_callable_replace && Z_TYPE_P(replace) == IS_ARRAY && Z_TYPE_P(regex) != IS_ARRAY) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parameter mismatch, pattern is a string while replacement is an array");
 		RETURN_FALSE;
 	}
 
-	SEPARATE_ZVAL(replace);
-	if (Z_TYPE_PP(replace) != IS_ARRAY && (Z_TYPE_PP(replace) != IS_OBJECT || !is_callable_replace)) {
+	if (Z_TYPE_P(replace) != IS_ARRAY && (Z_TYPE_P(replace) != IS_OBJECT || !is_callable_replace)) {
+		SEPARATE_ZVAL(replace);
 		convert_to_string_ex(replace);
 	}
 	if (is_callable_replace) {
-		if (!zend_is_callable(*replace, 0, &callback_name TSRMLS_CC)) {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Requires argument 2, '%s', to be a valid callback", callback_name);
-			efree(callback_name);
-			MAKE_COPY_ZVAL(subject, return_value);
+		if (!zend_is_callable(replace, 0, &callback_name TSRMLS_CC)) {
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Requires argument 2, '%s', to be a valid callback", callback_name->val);
+			STR_RELEASE(callback_name);
+			ZVAL_DUP(return_value, subject);
 			return;
 		}
-		efree(callback_name);
+		STR_RELEASE(callback_name);
 	}
 
-	SEPARATE_ZVAL(regex);
-	SEPARATE_ZVAL(subject);
-
 	if (ZEND_NUM_ARGS() > 3) {
 		limit_val = limit;
 	}
 		
-	if (Z_TYPE_PP(regex) != IS_ARRAY)
+	if (Z_TYPE_P(regex) != IS_ARRAY) {
+		SEPARATE_ZVAL(regex);
 		convert_to_string_ex(regex);
-	
+	}
+		
 	/* if subject is an array */
-	if (Z_TYPE_PP(subject) == IS_ARRAY) {
+	if (Z_TYPE_P(subject) == IS_ARRAY) {
 		array_init(return_value);
-		zend_hash_internal_pointer_reset(Z_ARRVAL_PP(subject));
 
 		/* For each subject entry, convert it to string, then perform replacement
 		   and add the result to the return_value array. */
-		while (zend_hash_get_current_data(Z_ARRVAL_PP(subject), (void **)&subject_entry) == SUCCESS) {
-			SEPARATE_ZVAL(subject_entry);
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(subject), num_key, string_key, subject_entry) {
 			old_replace_count = replace_count;
-			if ((result = php_replace_in_subject(*regex, *replace, subject_entry, &result_len, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
+			if ((result = php_replace_in_subject(regex, replace, subject_entry, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
 				if (!is_filter || replace_count > old_replace_count) {
 					/* Add to return array */
-					switch(zend_hash_get_current_key_ex(Z_ARRVAL_PP(subject), &string_key, &string_key_len, &num_key, 0, NULL))
-					{
-					case HASH_KEY_IS_STRING:
-						add_assoc_stringl_ex(return_value, string_key, string_key_len, result, result_len, 0);
-						break;
-
-					case HASH_KEY_IS_LONG:
-						add_index_stringl(return_value, num_key, result, result_len, 0);
-						break;
+					if (string_key) {
+						add_assoc_str_ex(return_value, string_key->val, string_key->len, result);
+					} else {
+						add_index_str(return_value, num_key, result);
 					}
 				} else {
-					efree(result);
+					STR_FREE(result);
 				}
 			}
-		
-			zend_hash_move_forward(Z_ARRVAL_PP(subject));
-		}
+		} ZEND_HASH_FOREACH_END();
 	} else {	/* if subject is not an array */
 		old_replace_count = replace_count;
-		if ((result = php_replace_in_subject(*regex, *replace, subject, &result_len, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
+		if ((result = php_replace_in_subject(regex, replace, subject, limit_val, is_callable_replace, &replace_count TSRMLS_CC)) != NULL) {
 			if (!is_filter || replace_count > old_replace_count) {
-				RETVAL_STRINGL(result, result_len, 0);
+				RETVAL_STR(result);
 			} else {
-				efree(result);
+				STR_FREE(result);
 			}
 		}
 	}
 	if (ZEND_NUM_ARGS() > 4) {
-		zval_dtor(*zcount);
-		ZVAL_LONG(*zcount, replace_count);
+		ZVAL_DEREF(zcount);
+		zval_dtor(zcount);
+		ZVAL_LONG(zcount, replace_count);
 	}
     	
 }
@@ -1492,22 +1475,21 @@ static PHP_FUNCTION(preg_filter)
    Split string into an array using a perl-style regular expression as a delimiter */
 static PHP_FUNCTION(preg_split)
 {
-	char				*regex;			/* Regular expression */
+	zend_string			*regex;			/* Regular expression */
 	char				*subject;		/* String to match against */
-	int					 regex_len;
 	int					 subject_len;
 	long				 limit_val = -1;/* Integer value of limit */
 	long				 flags = 0;		/* Match control flags */
 	pcre_cache_entry	*pce;			/* Compiled regular expression */
 
 	/* Get function parameters and do error checking */	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|ll", &regex, &regex_len,
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss|ll", &regex,
 							  &subject, &subject_len, &limit_val, &flags) == FAILURE) {
 		RETURN_FALSE;
 	}
 	
 	/* Compile regex or get it from cache. */
-	if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
+	if ((pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
 
@@ -1598,7 +1580,7 @@ PHPAPI void php_pcre_split_impl(pcre_cache_entry *pce, char *subject, int subjec
 				} else {
 					/* Add the piece to the return value */
 					add_next_index_stringl(return_value, last_match,
-								   	   &subject[offsets[0]]-last_match, 1);
+								   	   &subject[offsets[0]]-last_match);
 				}
 
 				/* One less left to do */
@@ -1620,7 +1602,7 @@ PHPAPI void php_pcre_split_impl(pcre_cache_entry *pce, char *subject, int subjec
 						} else {
 							add_next_index_stringl(return_value,
 												   &subject[offsets[i<<1]],
-												   match_len, 1);
+												   match_len);
 						}
 					}
 				}
@@ -1634,8 +1616,10 @@ PHPAPI void php_pcre_split_impl(pcre_cache_entry *pce, char *subject, int subjec
 				if (pce->compile_options & PCRE_UTF8) {
 					if (re_bump == NULL) {
 						int dummy;
-
-						if ((re_bump = pcre_get_compiled_regex("/./us", &extra_bump, &dummy TSRMLS_CC)) == NULL) {
+						zend_string *regex = STR_INIT("/./us", sizeof("/./us")-1, 0);
+						re_bump = pcre_get_compiled_regex(regex, &extra_bump, &dummy TSRMLS_CC);
+						STR_RELEASE(regex);
+						if (re_bump == NULL) {
 							RETURN_FALSE;
 						}
 					}
@@ -1677,7 +1661,7 @@ PHPAPI void php_pcre_split_impl(pcre_cache_entry *pce, char *subject, int subjec
 			add_offset_pair(return_value, &subject[start_offset], subject_len - start_offset, start_offset, NULL);
 		} else {
 			/* Add the last piece to the return value */
-			add_next_index_stringl(return_value, last_match, subject + subject_len - last_match, 1);
+			add_next_index_stringl(return_value, last_match, subject + subject_len - last_match);
 		}
 	}
 
@@ -1696,8 +1680,8 @@ static PHP_FUNCTION(preg_quote)
 	char	*in_str_end;    /* End of the input string */
 	int		 delim_len = 0;
 	char	*delim = NULL;	/* Additional delimiter argument */
-	char	*out_str,		/* Output string with quoted characters */
-		 	*p,				/* Iterator for input string */
+	zend_string	*out_str;	/* Output string with quoted characters */
+	char 	*p,				/* Iterator for input string */
 			*q,				/* Iterator for output string */
 			 delim_char=0,	/* Delimiter character to be quoted */
 			 c;				/* Current character */
@@ -1723,10 +1707,10 @@ static PHP_FUNCTION(preg_quote)
 	
 	/* Allocate enough memory so that even if each character
 	   is quoted, we won't run out of room */
-	out_str = safe_emalloc(4, in_str_len, 1);
+	out_str = STR_SAFE_ALLOC(4, in_str_len, 0, 0);
 	
 	/* Go through the string and quote necessary characters */
-	for(p = in_str, q = out_str; p != in_str_end; p++) {
+	for (p = in_str, q = out_str->val; p != in_str_end; p++) {
 		c = *p;
 		switch(c) {
 			case '.':
@@ -1768,9 +1752,10 @@ static PHP_FUNCTION(preg_quote)
 		}
 	}
 	*q = '\0';
-	
+
 	/* Reallocate string and return it */
-	RETVAL_STRINGL(erealloc(out_str, q - out_str + 1), q - out_str, 0);
+	out_str = STR_REALLOC(out_str, q - out_str->val, 0);
+	RETURN_STR(out_str);
 }
 /* }}} */
 
@@ -1778,20 +1763,19 @@ static PHP_FUNCTION(preg_quote)
    Searches array and returns entries which match regex */
 static PHP_FUNCTION(preg_grep)
 {
-	char				*regex;			/* Regular expression */
-	int				 	 regex_len;
+	zend_string			*regex;			/* Regular expression */
 	zval				*input;			/* Input array */
 	long				 flags = 0;		/* Match control flags */
 	pcre_cache_entry	*pce;			/* Compiled regular expression */
 
 	/* Get arguments and do error checking */
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sa|l", &regex, &regex_len,
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sa|l", &regex,
 							  &input, &flags) == FAILURE) {
 		return;
 	}
 	
 	/* Compile regex or get it from cache. */
-	if ((pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC)) == NULL) {
+	if ((pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
 	
@@ -1801,14 +1785,13 @@ static PHP_FUNCTION(preg_grep)
 
 PHPAPI void  php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return_value, long flags TSRMLS_DC) /* {{{ */
 {
-	zval		   **entry;				/* An entry in the input array */
+	zval		    *entry;				/* An entry in the input array */
 	pcre_extra		*extra = pce->extra;/* Holds results of studying */
 	pcre_extra		 extra_data;		/* Used locally for exec options */
 	int				*offsets;			/* Array of subpattern offsets */
 	int				 size_offsets;		/* Size of the offsets array */
 	int				 count = 0;			/* Count of matched subpatterns */
-	char			*string_key;
-	uint			 string_key_len;
+	zend_string		*string_key;
 	ulong			 num_key;
 	zend_bool		 invert;			/* Whether to return non-matching
 										   entries */
@@ -1841,11 +1824,16 @@ PHPAPI void  php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return
 	PCRE_G(error_code) = PHP_PCRE_NO_ERROR;
 
 	/* Go through the input array */
-	zend_hash_internal_pointer_reset(Z_ARRVAL_P(input));
-	while (zend_hash_get_current_data(Z_ARRVAL_P(input), (void **)&entry) == SUCCESS) {
-		zval subject = **entry;
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(input), num_key, string_key, entry) {
+		zval subject, *ref_entry = entry;
+		
+		if (Z_ISREF_P(entry)) {
+			entry = Z_REFVAL_P(entry);
+		}
+
+		ZVAL_COPY_VALUE(&subject, entry);
 
-		if (Z_TYPE_PP(entry) != IS_STRING) {
+		if (Z_TYPE_P(entry) != IS_STRING) {
 			zval_copy_ctor(&subject);
 			convert_to_string(&subject);
 		}
@@ -1867,30 +1855,24 @@ PHPAPI void  php_pcre_grep_impl(pcre_cache_entry *pce, zval *input, zval *return
 		/* If the entry fits our requirements */
 		if ((count > 0 && !invert) || (count == PCRE_ERROR_NOMATCH && invert)) {
 
-			Z_ADDREF_PP(entry);
+			if (Z_REFCOUNTED_P(ref_entry)) {
+			   	Z_ADDREF_P(ref_entry);
+			}
 
 			/* Add to return array */
-			switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, NULL))
-			{
-				case HASH_KEY_IS_STRING:
-					zend_hash_update(Z_ARRVAL_P(return_value), string_key,
-									 string_key_len, entry, sizeof(zval *), NULL);
-					break;
-
-				case HASH_KEY_IS_LONG:
-					zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry,
-										   sizeof(zval *), NULL);
-					break;
+			if (string_key) {
+				zend_hash_update(Z_ARRVAL_P(return_value), string_key, ref_entry);
+			} else {
+				zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, ref_entry);
 			}
 		}
 
-		if (Z_TYPE_PP(entry) != IS_STRING) {
+		if (Z_TYPE_P(entry) != IS_STRING) {
 			zval_dtor(&subject);
 		}
 
-		zend_hash_move_forward(Z_ARRVAL_P(input));
-	}
-	zend_hash_internal_pointer_reset(Z_ARRVAL_P(input));
+	} ZEND_HASH_FOREACH_END();
+
 	/* Clean up */
 	efree(offsets);
 }
diff --git a/ext/pcre/php_pcre.h b/ext/pcre/php_pcre.h
index 4b261871e2..266f6760c6 100644
--- a/ext/pcre/php_pcre.h
+++ b/ext/pcre/php_pcre.h
@@ -33,9 +33,9 @@
 #include <locale.h>
 #endif
 
-PHPAPI char *php_pcre_replace(char *regex, int regex_len, char *subject, int subject_len, zval *replace_val, int is_callable_replace, int *result_len, int limit, int *replace_count TSRMLS_DC);
-PHPAPI pcre* pcre_get_compiled_regex(char *regex, pcre_extra **extra, int *options TSRMLS_DC);
-PHPAPI pcre* pcre_get_compiled_regex_ex(char *regex, pcre_extra **extra, int *preg_options, int *coptions TSRMLS_DC);
+PHPAPI zend_string *php_pcre_replace(zend_string *regex, char *subject, int subject_len, zval *replace_val, int is_callable_replace, int limit, int *replace_count TSRMLS_DC);
+PHPAPI pcre* pcre_get_compiled_regex(zend_string *regex, pcre_extra **extra, int *options TSRMLS_DC);
+PHPAPI pcre* pcre_get_compiled_regex_ex(zend_string *regex, pcre_extra **extra, int *preg_options, int *coptions TSRMLS_DC);
 
 extern zend_module_entry pcre_module_entry;
 #define pcre_module_ptr &pcre_module_entry
@@ -52,13 +52,13 @@ typedef struct {
 	int refcount;
 } pcre_cache_entry;
 
-PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(char *regex, int regex_len TSRMLS_DC);
+PHPAPI pcre_cache_entry* pcre_get_compiled_regex_cache(zend_string *regex TSRMLS_DC);
 
 PHPAPI void  php_pcre_match_impl(  pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
 	zval *subpats, int global, int use_flags, long flags, long start_offset TSRMLS_DC);
 
-PHPAPI char *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value, 
-	int is_callable_replace, int *result_len, int limit, int *replace_count TSRMLS_DC);
+PHPAPI zend_string *php_pcre_replace_impl(pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value, 
+	int is_callable_replace, int limit, int *replace_count TSRMLS_DC);
 
 PHPAPI void  php_pcre_split_impl(  pcre_cache_entry *pce, char *subject, int subject_len, zval *return_value,
 	long limit_val, long flags TSRMLS_DC);
@@ -70,6 +70,9 @@ ZEND_BEGIN_MODULE_GLOBALS(pcre)
 	HashTable pcre_cache;
 	long backtrack_limit;
 	long recursion_limit;
+#ifdef PCRE_STUDY_JIT_COMPILE
+	zend_bool jit;
+#endif
 	int  error_code;
 ZEND_END_MODULE_GLOBALS(pcre)
 
diff --git a/ext/pdo/pdo.c b/ext/pdo/pdo.c
index f3c9b65766..27ecdd370a 100644
--- a/ext/pdo/pdo.c
+++ b/ext/pdo/pdo.c
@@ -76,11 +76,11 @@ PDO_API zend_class_entry *php_pdo_get_exception_base(int root TSRMLS_DC)
 #if can_handle_soft_dependency_on_SPL && defined(HAVE_SPL) && ((PHP_MAJOR_VERSION > 5) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION >= 1))
 	if (!root) {
 		if (!spl_ce_RuntimeException) {
-			zend_class_entry **pce;
+			zend_class_entry *pce;
 
-			if (zend_hash_find(CG(class_table), "runtimeexception", sizeof("RuntimeException"), (void **) &pce) == SUCCESS) {
-				spl_ce_RuntimeException = *pce;
-				return *pce;
+			if ((pce = zend_hash_str_find_ptr(CG(class_table), "runtimeexception", sizeof("RuntimeException") - 1))) {
+				spl_ce_RuntimeException = pce;
+				return pce;
 			}
 		} else {
 			return spl_ce_RuntimeException;
@@ -100,8 +100,7 @@ zend_class_entry *pdo_dbh_ce, *pdo_dbstmt_ce, *pdo_row_ce;
  Return array of available PDO drivers */
 PHP_FUNCTION(pdo_drivers)
 {
-	HashPosition pos;
-	pdo_driver_t **pdriver;
+	pdo_driver_t *pdriver;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -109,11 +108,9 @@ PHP_FUNCTION(pdo_drivers)
 	
 	array_init(return_value);
 
-	zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos);
-	while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) {
-		add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len, 1);
-		zend_hash_move_forward_ex(&pdo_driver_hash, &pos);
-	}
+	ZEND_HASH_FOREACH_PTR(&pdo_driver_hash, pdriver) {
+		add_next_index_stringl(return_value, (char*)pdriver->driver_name, pdriver->driver_name_len);
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -185,31 +182,26 @@ PDO_API int php_pdo_register_driver(pdo_driver_t *driver)
 			driver->driver_name, driver->api_version, PDO_DRIVER_API);
 		return FAILURE;
 	}
-	if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
+	if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) {
 		zend_error(E_ERROR, "You MUST load PDO before loading any PDO drivers");
 		return FAILURE;	/* NOTREACHED */
 	}
 
-	return zend_hash_add(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len,
-			(void**)&driver, sizeof(pdo_driver_t *), NULL);
+	return zend_hash_str_add_ptr(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len, driver) != NULL;
 }
 
 PDO_API void php_pdo_unregister_driver(pdo_driver_t *driver)
 {
-	if (!zend_hash_exists(&module_registry, "pdo", sizeof("pdo"))) {
+	if (!zend_hash_str_exists(&module_registry, "pdo", sizeof("pdo") - 1)) {
 		return;
 	}
 
-	zend_hash_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len);
+	zend_hash_str_del(&pdo_driver_hash, (char*)driver->driver_name, driver->driver_name_len);
 }
 
 pdo_driver_t *pdo_find_driver(const char *name, int namelen)
 {
-	pdo_driver_t **driver = NULL;
-	
-	zend_hash_find(&pdo_driver_hash, (char*)name, namelen, (void**)&driver);
-
-	return driver ? *driver : NULL;
+	return zend_hash_str_find_ptr(&pdo_driver_hash, (char*)name, namelen);
 }
 
 PDO_API int php_pdo_parse_data_source(const char *data_source,
@@ -372,7 +364,7 @@ PHP_MINIT_FUNCTION(pdo)
 
 	INIT_CLASS_ENTRY(ce, "PDOException", NULL);
 
- 	pdo_exception_ce = zend_register_internal_class_ex(&ce, php_pdo_get_exception_base(0 TSRMLS_CC), NULL TSRMLS_CC);
+ 	pdo_exception_ce = zend_register_internal_class_ex(&ce, php_pdo_get_exception_base(0 TSRMLS_CC) TSRMLS_CC);
 
 	zend_declare_property_null(pdo_exception_ce, "errorInfo", sizeof("errorInfo")-1, ZEND_ACC_PUBLIC TSRMLS_CC);
 
@@ -395,22 +387,19 @@ PHP_MSHUTDOWN_FUNCTION(pdo)
 /* {{{ PHP_MINFO_FUNCTION */
 PHP_MINFO_FUNCTION(pdo)
 {
-	HashPosition pos;
 	char *drivers = NULL, *ldrivers = estrdup("");
-	pdo_driver_t **pdriver;
+	pdo_driver_t *pdriver;
 	
 	php_info_print_table_start();
 	php_info_print_table_header(2, "PDO support", "enabled");
 
-	zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos);
-	while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) {
-		spprintf(&drivers, 0, "%s, %s", ldrivers, (*pdriver)->driver_name);
-		zend_hash_move_forward_ex(&pdo_driver_hash, &pos);
+	ZEND_HASH_FOREACH_PTR(&pdo_driver_hash, pdriver) {
+		spprintf(&drivers, 0, "%s, %s", ldrivers, pdriver->driver_name);
 		efree(ldrivers);
 		ldrivers = drivers;
-	}
+	} ZEND_HASH_FOREACH_END();
 	
-	php_info_print_table_row(2, "PDO drivers", drivers ? drivers+2 : "");
+	php_info_print_table_row(2, "PDO drivers", drivers ? drivers + 2 : "");
 
 	if (drivers) {
 		efree(drivers);
diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 32e6e1bdd0..73431049d6 100644
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -74,25 +74,22 @@ void pdo_raise_impl_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, const char *sqlstate
 	if (dbh && dbh->error_mode != PDO_ERRMODE_EXCEPTION) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
 	} else {
-		zval *ex, *info;
+		zval ex, info;
 		zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *pdo_ex = php_pdo_get_exception();
 
-		MAKE_STD_ZVAL(ex);
-		object_init_ex(ex, pdo_ex);
+		object_init_ex(&ex, pdo_ex);
 
-		zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC);
-		zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
+		zend_update_property_string(def_ex, &ex, "message", sizeof("message")-1, message TSRMLS_CC);
+		zend_update_property_string(def_ex, &ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
 		
-		MAKE_STD_ZVAL(info);
-		array_init(info);
+		array_init(&info);
 
-		add_next_index_string(info, *pdo_err, 1);
-		add_next_index_long(info, 0);
-
-		zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
+		add_next_index_string(&info, *pdo_err);
+		add_next_index_long(&info, 0);
+		zend_update_property(pdo_ex, &ex, "errorInfo", sizeof("errorInfo")-1, &info TSRMLS_CC);
 		zval_ptr_dtor(&info);
 
-		zend_throw_exception_object(ex TSRMLS_CC);
+		zend_throw_exception_object(&ex TSRMLS_CC);
 	}
 	
 	if (message) {
@@ -108,7 +105,7 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{
 	char *supp = NULL;
 	long native_code = 0;
 	char *message = NULL;
-	zval *info = NULL;
+	zval info;
 
 	if (dbh == NULL || dbh->error_mode == PDO_ERRMODE_SILENT) {
 		return;
@@ -124,21 +121,21 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{
 		msg = "<<Unknown error>>";
 	}
 
+	ZVAL_UNDEF(&info);
 	if (dbh->methods->fetch_err) {
-		MAKE_STD_ZVAL(info);
-		array_init(info);
+		array_init(&info);
 
-		add_next_index_string(info, *pdo_err, 1);
+		add_next_index_string(&info, *pdo_err);
 		
-		if (dbh->methods->fetch_err(dbh, stmt, info TSRMLS_CC)) {
-			zval **item;
+		if (dbh->methods->fetch_err(dbh, stmt, &info TSRMLS_CC)) {
+			zval *item;
 
-			if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 1, (void**)&item)) {
-				native_code = Z_LVAL_PP(item);
+			if ((item = zend_hash_index_find(Z_ARRVAL(info), 1)) != NULL) {
+				native_code = Z_LVAL_P(item);
 			}
 			
-			if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(info), 2, (void**)&item)) {
-				supp = estrndup(Z_STRVAL_PP(item), Z_STRLEN_PP(item));
+			if ((item = zend_hash_index_find(Z_ARRVAL(info), 2)) != NULL) {
+				supp = estrndup(Z_STRVAL_P(item), Z_STRLEN_P(item));
 			}
 		}
 	}
@@ -152,23 +149,22 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC) /* {{{
 	if (dbh->error_mode == PDO_ERRMODE_WARNING) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s", message);
 	} else if (EG(exception) == NULL) {
-		zval *ex;
+		zval ex;
 		zend_class_entry *def_ex = php_pdo_get_exception_base(1 TSRMLS_CC), *pdo_ex = php_pdo_get_exception();
 
-		MAKE_STD_ZVAL(ex);
-		object_init_ex(ex, pdo_ex);
+		object_init_ex(&ex, pdo_ex);
 
-		zend_update_property_string(def_ex, ex, "message", sizeof("message")-1, message TSRMLS_CC);
-		zend_update_property_string(def_ex, ex, "code", sizeof("code")-1, *pdo_err TSRMLS_CC);
+		zend_update_property_string(def_ex, &ex, "message", sizeof("message") - 1, message TSRMLS_CC);
+		zend_update_property_string(def_ex, &ex, "code", sizeof("code") - 1, *pdo_err TSRMLS_CC);
 		
-		if (info) {
-			zend_update_property(pdo_ex, ex, "errorInfo", sizeof("errorInfo")-1, info TSRMLS_CC);
+		if (!ZVAL_IS_UNDEF(&info)) {
+			zend_update_property(pdo_ex, &ex, "errorInfo", sizeof("errorInfo") - 1, &info TSRMLS_CC);
 		}
 
-		zend_throw_exception_object(ex TSRMLS_CC);
+		zend_throw_exception_object(&ex TSRMLS_CC);
 	}
 
-	if (info) {
+	if (!ZVAL_IS_UNDEF(&info)) {
 		zval_ptr_dtor(&info);
 	}
 
@@ -202,7 +198,7 @@ static PHP_METHOD(PDO, dbh_constructor)
 {
 	zval *object = getThis();
 	pdo_dbh_t *dbh = NULL;
-	zend_bool is_persistent = FALSE;
+	zend_bool is_persistent = 0;
 	char *data_source;
 	int data_source_len;
 	char *colon;
@@ -212,10 +208,11 @@ static PHP_METHOD(PDO, dbh_constructor)
 	zval *options = NULL;
 	char alt_dsn[512];
 	int call_factory = 1;
+	char tmp;
 
 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s!s!a!", &data_source, &data_source_len,
 				&username, &usernamelen, &password, &passwordlen, &options)) {
-		ZVAL_NULL(object);
+		Z_OBJ_P(object) = NULL;
 		return;
 	}
 
@@ -229,8 +226,7 @@ static PHP_METHOD(PDO, dbh_constructor)
 		snprintf(alt_dsn, sizeof(alt_dsn), "pdo.dsn.%s", data_source);
 		if (FAILURE == cfg_get_string(alt_dsn, &ini_dsn)) {
 			zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name");
-			zval_dtor(object);
-			ZVAL_NULL(object);
+			Z_OBJ_P(object) = NULL;
 			return;
 		}
 
@@ -239,7 +235,7 @@ static PHP_METHOD(PDO, dbh_constructor)
 		
 		if (!colon) {
 			zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name (via INI: %s)", alt_dsn);
-			ZVAL_NULL(object);
+			Z_OBJ_P(object) = NULL;
 			return;
 		}
 	}
@@ -249,58 +245,64 @@ static PHP_METHOD(PDO, dbh_constructor)
 		data_source = dsn_from_uri(data_source + sizeof("uri:")-1, alt_dsn, sizeof(alt_dsn) TSRMLS_CC);
 		if (!data_source) {
 			zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source URI");
-			ZVAL_NULL(object);
+			Z_OBJ_P(object) = NULL;
 			return;
 		}
 		colon = strchr(data_source, ':');
 		if (!colon) {
 			zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "invalid data source name (via URI)");
-			ZVAL_NULL(object);
+			Z_OBJ_P(object) = NULL;
 			return;
 		}
 	}
 
+	tmp = data_source[colon - data_source];
+	data_source[colon - data_source] = '\0';
 	driver = pdo_find_driver(data_source, colon - data_source);
-
+	data_source[colon - data_source] = tmp;
 	if (!driver) {
 		/* NB: don't want to include the data_source in the error message as
 		 * it might contain a password */
 		zend_throw_exception_ex(php_pdo_get_exception(), 0 TSRMLS_CC, "could not find driver");
-		ZVAL_NULL(object);
+		Z_OBJ_P(object) = NULL;
 		return;
 	}
 	
-	dbh = (pdo_dbh_t *) zend_object_store_get_object(object TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(object);
 
 	/* is this supposed to be a persistent connection ? */
 	if (options) {
-		zval **v;
+		zval *v;
 		int plen = 0;
 		char *hashkey = NULL;
-		zend_rsrc_list_entry *le;
+		zend_resource *le;
 		pdo_dbh_t *pdbh = NULL;
 
-		if (SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_PERSISTENT, (void**)&v)) {
-			if (Z_TYPE_PP(v) == IS_STRING && !is_numeric_string(Z_STRVAL_PP(v), Z_STRLEN_PP(v), NULL, NULL, 0) && Z_STRLEN_PP(v) > 0) {
+		//?? let's delay the persistent supports later
+#if 0
+		if ((v = zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_PERSISTENT)) != NULL) {
+			if (Z_TYPE_P(v) == IS_STRING &&
+				!is_numeric_string(Z_STRVAL_P(v), Z_STRLEN_P(v), NULL, NULL, 0) && Z_STRLEN_P(v) > 0) {
 				/* user specified key */
 				plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s:%s", data_source,
 						username ? username : "",
 						password ? password : "",
-						Z_STRVAL_PP(v));
+						Z_STRVAL_P(v));
 				is_persistent = 1;
 			} else {
 				convert_to_long_ex(v);
-				is_persistent = Z_LVAL_PP(v) ? 1 : 0;
+				is_persistent = Z_LVAL_P(v) ? 1 : 0;
 				plen = spprintf(&hashkey, 0, "PDO:DBH:DSN=%s:%s:%s", data_source,
 						username ? username : "",
 						password ? password : "");
 			}
 		}
+#endif
 
 		if (is_persistent) {
 			/* let's see if we have one cached.... */
-			if (SUCCESS == zend_hash_find(&EG(persistent_list), hashkey, plen+1, (void*)&le)) {
-				if (Z_TYPE_P(le) == php_pdo_list_entry()) {
+			if ((le = zend_hash_str_find_ptr(&EG(persistent_list), hashkey, plen)) != NULL) {
+				if (le->type == php_pdo_list_entry()) {
 					pdbh = (pdo_dbh_t*)le->ptr;
 
 					/* is the connection still alive ? */
@@ -327,7 +329,7 @@ static PHP_METHOD(PDO, dbh_constructor)
 					php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO handle");
 				}
 				memcpy((char *)pdbh->persistent_id, hashkey, plen+1);
-				pdbh->persistent_id_len = plen+1;
+				pdbh->persistent_id_len = plen;
 				pdbh->refcount = 1;
 				pdbh->std.properties = NULL;
 			}
@@ -338,21 +340,19 @@ static PHP_METHOD(PDO, dbh_constructor)
 			if (pdbh->std.properties) {
 				zend_hash_destroy(dbh->std.properties);	
 				efree(dbh->std.properties);
-				if (dbh->std.properties_table) {
-					efree(dbh->std.properties_table);
-				}
 			} else {
 				pdbh->std.ce = dbh->std.ce;
 				pdbh->def_stmt_ce = dbh->def_stmt_ce;
-				pdbh->def_stmt_ctor_args = dbh->def_stmt_ctor_args;
+				ZVAL_COPY_VALUE(&pdbh->def_stmt_ctor_args, &dbh->def_stmt_ctor_args);
 				pdbh->std.properties = dbh->std.properties;
-				pdbh->std.properties_table = dbh->std.properties_table;
+				//???
+				//pdbh->std.properties_table = dbh->std.properties_table;
 			}
 			/* kill the non-persistent thingamy */
 			efree(dbh);
 			/* switch over to the persistent one */
 			dbh = pdbh;
-			zend_object_store_set_object(object, dbh TSRMLS_CC);
+			zend_object_store_set_object(object, &dbh->std TSRMLS_CC);
 			dbh->refcount++;
 		}
 
@@ -384,7 +384,7 @@ static PHP_METHOD(PDO, dbh_constructor)
 		/* all set */
 
 		if (is_persistent) {
-			zend_rsrc_list_entry le;
+			zend_resource le;
 
 			/* register in the persistent list etc. */
 			/* we should also need to replace the object store entry,
@@ -393,9 +393,8 @@ static PHP_METHOD(PDO, dbh_constructor)
 			le.type = php_pdo_list_entry();
 			le.ptr = dbh;
 
-			if (FAILURE == zend_hash_update(&EG(persistent_list),
-					(char*)dbh->persistent_id, dbh->persistent_id_len, (void*)&le,
-					sizeof(le), NULL)) {
+			if (zend_hash_str_update_mem(&EG(persistent_list), 
+						(char*)dbh->persistent_id, dbh->persistent_id_len, &le, sizeof(le))) {
 				php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to register persistent entry");
 			}
 		}
@@ -403,17 +402,16 @@ static PHP_METHOD(PDO, dbh_constructor)
 		dbh->driver = driver;
 options:
 		if (options) {
-			zval **attr_value;
-			char *str_key;
+			zval *attr_value;
 			ulong long_key;
+			zend_string *str_key = NULL;
 			
-			zend_hash_internal_pointer_reset(Z_ARRVAL_P(options));
-			while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(options), (void**)&attr_value) 
-				&& HASH_KEY_IS_LONG == zend_hash_get_current_key(Z_ARRVAL_P(options), &str_key, &long_key, 0)) {
-				
-				pdo_dbh_attribute_set(dbh, long_key, *attr_value TSRMLS_CC);
-				zend_hash_move_forward(Z_ARRVAL_P(options));
-			}
+			ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(options), long_key, str_key, attr_value) {
+				if (str_key) {
+					continue;
+				}
+				pdo_dbh_attribute_set(dbh, long_key, attr_value TSRMLS_CC);
+			} ZEND_HASH_FOREACH_END();
 		}
 
 		return;
@@ -421,13 +419,13 @@ options:
 
 	/* the connection failed; things will tidy up in free_storage */
 	/* XXX raise exception */
-	ZVAL_NULL(object);
+	Z_OBJ_P(object) = NULL;
 }
 /* }}} */
 
 static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */
 {
-	if (ctor_args) {
+	if (!ZVAL_IS_UNDEF(ctor_args)) {
 		if (Z_TYPE_P(ctor_args) != IS_ARRAY) {
 			pdo_raise_impl_error(dbh, NULL, "HY000", "constructor arguments must be passed as an array" TSRMLS_CC);
 			return NULL;
@@ -438,36 +436,36 @@ static zval *pdo_stmt_instantiate(pdo_dbh_t *dbh, zval *object, zend_class_entry
 		}
 	}
 
-	Z_TYPE_P(object) = IS_OBJECT;
 	object_init_ex(object, dbstmt_ce);
-	Z_SET_REFCOUNT_P(object, 1);
-	Z_SET_ISREF_P(object);
+	// ??? Z_SET_REFCOUNT_P(object, 1);
+	//Z_SET_ISREF_P(object);
 	
 	return object;
 } /* }}} */
 
 static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry *dbstmt_ce, zval *ctor_args TSRMLS_DC) /* {{{ */
 {	
-	zval *query_string;
+	zval query_string;
 	zval z_key;
 
-	MAKE_STD_ZVAL(query_string);
-	ZVAL_STRINGL(query_string, stmt->query_string, stmt->query_stringlen, 1);
-	ZVAL_STRINGL(&z_key, "queryString", sizeof("queryString")-1, 0);
-	std_object_handlers.write_property(object, &z_key, query_string, 0 TSRMLS_CC);
+	ZVAL_STRINGL(&query_string, stmt->query_string, stmt->query_stringlen);
+	ZVAL_STRINGL(&z_key, "queryString", sizeof("queryString") - 1);
+	std_object_handlers.write_property(object, &z_key, &query_string, -1 TSRMLS_CC);
 	zval_ptr_dtor(&query_string);
+	zval_ptr_dtor(&z_key);
 
 	if (dbstmt_ce->constructor) {
 		zend_fcall_info fci;
 		zend_fcall_info_cache fcc;
-		zval *retval = NULL;
+		zval retval;
 
 		fci.size = sizeof(zend_fcall_info);
 		fci.function_table = &dbstmt_ce->function_table;
-		fci.function_name = NULL;
-		fci.object_ptr = object;
+		ZVAL_UNDEF(&fci.function_name);
+		fci.object = Z_OBJ_P(object);
 		fci.symbol_table = NULL;
-		fci.retval_ptr_ptr = &retval;
+		fci.retval = &retval;
+		fci.param_count = 0;
 		fci.params = NULL;
 		fci.no_separation = 1;
 
@@ -477,13 +475,12 @@ static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry
 		fcc.function_handler = dbstmt_ce->constructor;
 		fcc.calling_scope = EG(scope);
 		fcc.called_scope = Z_OBJCE_P(object);
-		fcc.object_ptr = object;
+		fcc.object = Z_OBJ_P(object);
 
 		if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
-			zval_dtor(object);
-			ZVAL_NULL(object);
+			Z_OBJ_P(object) = NULL;
 			object = NULL; /* marks failure */
-		} else if (retval) {
+		} else if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 			
@@ -498,12 +495,12 @@ static void pdo_stmt_construct(pdo_stmt_t *stmt, zval *object, zend_class_entry
    Prepares a statement for execution and returns a statement object */
 static PHP_METHOD(PDO, prepare)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	pdo_stmt_t *stmt;
 	char *statement;
 	int statement_len;
-	zval *options = NULL, **opt, **item, *ctor_args;
-	zend_class_entry *dbstmt_ce, **pce;
+	zval *options = NULL, *opt, *item, ctor_args;
+	zend_class_entry *dbstmt_ce, *pce;
 
 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|a", &statement,
 			&statement_len, &options)) {
@@ -513,10 +510,10 @@ static PHP_METHOD(PDO, prepare)
 	PDO_DBH_CLEAR_ERR();
 	PDO_CONSTRUCT_CHECK;
 
-	if (ZEND_NUM_ARGS() > 1 && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_STATEMENT_CLASS, (void**)&opt)) {
-		if (Z_TYPE_PP(opt) != IS_ARRAY || zend_hash_index_find(Z_ARRVAL_PP(opt), 0, (void**)&item) == FAILURE
-			|| Z_TYPE_PP(item) != IS_STRING
-			|| zend_lookup_class(Z_STRVAL_PP(item), Z_STRLEN_PP(item), &pce TSRMLS_CC) == FAILURE
+	if (ZEND_NUM_ARGS() > 1 && (opt = zend_hash_index_find(Z_ARRVAL_P(options), PDO_ATTR_STATEMENT_CLASS)) != NULL) {
+		if (Z_TYPE_P(opt) != IS_ARRAY || (item = zend_hash_index_find(Z_ARRVAL_P(opt), 0)) == NULL
+			|| Z_TYPE_P(item) != IS_STRING
+			|| (pce = zend_lookup_class(Z_STR_P(item) TSRMLS_CC)) == NULL
 		) {
 			pdo_raise_impl_error(dbh, NULL, "HY000", 
 				"PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
@@ -525,7 +522,7 @@ static PHP_METHOD(PDO, prepare)
 			PDO_HANDLE_DBH_ERR();
 			RETURN_FALSE;
 		}
-		dbstmt_ce = *pce;
+		dbstmt_ce = pce;
 		if (!instanceof_function(dbstmt_ce, pdo_dbstmt_ce TSRMLS_CC)) {
 			pdo_raise_impl_error(dbh, NULL, "HY000", 
 				"user-supplied statement class must be derived from PDOStatement" TSRMLS_CC);
@@ -538,8 +535,8 @@ static PHP_METHOD(PDO, prepare)
 			PDO_HANDLE_DBH_ERR();
 			RETURN_FALSE;
 		}
-		if (zend_hash_index_find(Z_ARRVAL_PP(opt), 1, (void**)&item) == SUCCESS) {
-			if (Z_TYPE_PP(item) != IS_ARRAY) {
+		if ((item = zend_hash_index_find(Z_ARRVAL_P(opt), 1)) != NULL) {
+			if (Z_TYPE_P(item) != IS_ARRAY) {
 				pdo_raise_impl_error(dbh, NULL, "HY000", 
 					"PDO::ATTR_STATEMENT_CLASS requires format array(classname, ctor_args); "
 					"ctor_args must be an array"
@@ -547,23 +544,23 @@ static PHP_METHOD(PDO, prepare)
 				PDO_HANDLE_DBH_ERR();
 				RETURN_FALSE;
 			}
-			ctor_args = *item;
+			ZVAL_COPY_VALUE(&ctor_args, item);
 		} else {
-			ctor_args = NULL;
+			ZVAL_UNDEF(&ctor_args);
 		}
 	} else {
 		dbstmt_ce = dbh->def_stmt_ce;
-		ctor_args = dbh->def_stmt_ctor_args;
+		ZVAL_COPY_VALUE(&ctor_args, &dbh->def_stmt_ctor_args);
 	}
 
-	if (!pdo_stmt_instantiate(dbh, return_value, dbstmt_ce, ctor_args TSRMLS_CC)) {
+	if (!pdo_stmt_instantiate(dbh, return_value, dbstmt_ce, &ctor_args TSRMLS_CC)) {
 		pdo_raise_impl_error(dbh, NULL, "HY000", 
 			"failed to instantiate user-supplied statement class"
 			TSRMLS_CC);
 		PDO_HANDLE_DBH_ERR();
 		RETURN_FALSE;
 	}
-	stmt = (pdo_stmt_t*)zend_object_store_get_object(return_value TSRMLS_CC);
+	stmt = Z_PDO_STMT_P(return_value);
 	
 	/* unconditionally keep this for later reference */
 	stmt->query_string = estrndup(statement, statement_len);
@@ -571,14 +568,13 @@ static PHP_METHOD(PDO, prepare)
 	stmt->default_fetch_type = dbh->default_fetch_type;
 	stmt->dbh = dbh;
 	/* give it a reference to me */
-	zend_objects_store_add_ref(getThis() TSRMLS_CC);
-	php_pdo_dbh_addref(dbh TSRMLS_CC);
-	stmt->database_object_handle = *getThis();
+	ZVAL_OBJ(&stmt->database_object_handle, &dbh->std);
+	Z_ADDREF(stmt->database_object_handle);
 	/* we haven't created a lazy object yet */
-	ZVAL_NULL(&stmt->lazy_object_ref);
+	ZVAL_UNDEF(&stmt->lazy_object_ref);
 
 	if (dbh->methods->preparer(dbh, statement, statement_len, stmt, options TSRMLS_CC)) {
-		pdo_stmt_construct(stmt, return_value, dbstmt_ce, ctor_args TSRMLS_CC);
+		pdo_stmt_construct(stmt, return_value, dbstmt_ce, &ctor_args TSRMLS_CC);
 		return;
 	}
 
@@ -595,7 +591,7 @@ static PHP_METHOD(PDO, prepare)
    Initiates a transaction */
 static PHP_METHOD(PDO, beginTransaction)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -628,7 +624,7 @@ static PHP_METHOD(PDO, beginTransaction)
    Commit a transaction */
 static PHP_METHOD(PDO, commit)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -654,7 +650,7 @@ static PHP_METHOD(PDO, commit)
    roll back a transaction */
 static PHP_METHOD(PDO, rollBack)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -680,7 +676,7 @@ static PHP_METHOD(PDO, rollBack)
    determine if inside a transaction */
 static PHP_METHOD(PDO, inTransaction)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -746,9 +742,9 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
 
 		case PDO_ATTR_DEFAULT_FETCH_MODE:
 			if (Z_TYPE_P(value) == IS_ARRAY) {
-				zval **tmp;
-				if (zend_hash_index_find(Z_ARRVAL_P(value), 0, (void**)&tmp) == SUCCESS && Z_TYPE_PP(tmp) == IS_LONG) {
-					if (Z_LVAL_PP(tmp) == PDO_FETCH_INTO || Z_LVAL_PP(tmp) == PDO_FETCH_CLASS) {
+				zval *tmp;
+				if ((tmp = zend_hash_index_find(Z_ARRVAL_P(value), 0)) != NULL && Z_TYPE_P(tmp) == IS_LONG) {
+					if (Z_LVAL_P(tmp) == PDO_FETCH_INTO || Z_LVAL_P(tmp) == PDO_FETCH_CLASS) {
 						pdo_raise_impl_error(dbh, NULL, "HY000", "FETCH_INTO and FETCH_CLASS are not yet supported as default fetch modes" TSRMLS_CC);
 						return FAILURE;
 					}
@@ -772,8 +768,8 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
 			
 		case PDO_ATTR_STATEMENT_CLASS: {
 			/* array(string classname, array(mixed ctor_args)) */
-			zend_class_entry **pce;
-			zval **item;
+			zend_class_entry *pce;
+			zval *item;
 
 			if (dbh->is_persistent) {
 				pdo_raise_impl_error(dbh, NULL, "HY000", 
@@ -783,9 +779,9 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
 				return FAILURE;
 			}
 			if (Z_TYPE_P(value) != IS_ARRAY
-				|| zend_hash_index_find(Z_ARRVAL_P(value), 0, (void**)&item) == FAILURE
-				|| Z_TYPE_PP(item) != IS_STRING
-				|| zend_lookup_class(Z_STRVAL_PP(item), Z_STRLEN_PP(item), &pce TSRMLS_CC) == FAILURE
+				|| (item = zend_hash_index_find(Z_ARRVAL_P(value), 0)) == NULL
+				|| Z_TYPE_P(item) != IS_STRING
+				|| (pce = zend_lookup_class(Z_STR_P(item) TSRMLS_CC)) == NULL
 			) {
 				pdo_raise_impl_error(dbh, NULL, "HY000", 
 					"PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
@@ -794,25 +790,25 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
 				PDO_HANDLE_DBH_ERR();
 				return FAILURE;
 			}
-			if (!instanceof_function(*pce, pdo_dbstmt_ce TSRMLS_CC)) {
+			if (!instanceof_function(pce, pdo_dbstmt_ce TSRMLS_CC)) {
 				pdo_raise_impl_error(dbh, NULL, "HY000", 
 					"user-supplied statement class must be derived from PDOStatement" TSRMLS_CC);
 				PDO_HANDLE_DBH_ERR();
 				return FAILURE;
 			}
-			if ((*pce)->constructor && !((*pce)->constructor->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED))) {
+			if (pce->constructor && !(pce->constructor->common.fn_flags & (ZEND_ACC_PRIVATE|ZEND_ACC_PROTECTED))) {
 				pdo_raise_impl_error(dbh, NULL, "HY000", 
 					"user-supplied statement class cannot have a public constructor" TSRMLS_CC);
 				PDO_HANDLE_DBH_ERR();
 				return FAILURE;
 			}
-			dbh->def_stmt_ce = *pce;
-			if (dbh->def_stmt_ctor_args) {
+			dbh->def_stmt_ce = pce;
+			if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) {
 				zval_ptr_dtor(&dbh->def_stmt_ctor_args);
-				dbh->def_stmt_ctor_args = NULL;
+				ZVAL_UNDEF(&dbh->def_stmt_ctor_args);
 			}
-			if (zend_hash_index_find(Z_ARRVAL_P(value), 1, (void**)&item) == SUCCESS) {
-				if (Z_TYPE_PP(item) != IS_ARRAY) {
+			if ((item = zend_hash_index_find(Z_ARRVAL_P(value), 1)) != NULL) {
+				if (Z_TYPE_P(item) != IS_ARRAY) {
 					pdo_raise_impl_error(dbh, NULL, "HY000", 
 						"PDO::ATTR_STATEMENT_CLASS requires format array(classname, array(ctor_args)); "
 						"ctor_args must be an array"
@@ -820,8 +816,7 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
 					PDO_HANDLE_DBH_ERR();
 					return FAILURE;
 				}
-				Z_ADDREF_PP(item);
-				dbh->def_stmt_ctor_args = *item;
+				ZVAL_COPY(&dbh->def_stmt_ctor_args, item);
 			}
 			return SUCCESS;
 		}
@@ -855,7 +850,7 @@ fail:
    Set an attribute */
 static PHP_METHOD(PDO, setAttribute)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	long attr;
 	zval *value;
 
@@ -877,7 +872,7 @@ static PHP_METHOD(PDO, setAttribute)
    Get an attribute */
 static PHP_METHOD(PDO, getAttribute)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	long attr;
 
 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &attr)) {
@@ -902,19 +897,20 @@ static PHP_METHOD(PDO, getAttribute)
 			RETURN_LONG(dbh->error_mode);
 
 		case PDO_ATTR_DRIVER_NAME:
-			RETURN_STRINGL((char*)dbh->driver->driver_name, dbh->driver->driver_name_len, 1);
+			RETURN_STRINGL((char*)dbh->driver->driver_name, dbh->driver->driver_name_len);
 
 		case PDO_ATTR_STATEMENT_CLASS:
 			array_init(return_value);
-			add_next_index_string(return_value, dbh->def_stmt_ce->name, 1);
-			if (dbh->def_stmt_ctor_args) {
-				Z_ADDREF_P(dbh->def_stmt_ctor_args);
-				add_next_index_zval(return_value, dbh->def_stmt_ctor_args);
+			add_next_index_str(return_value, STR_COPY(dbh->def_stmt_ce->name));
+			if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) {
+				Z_ADDREF(dbh->def_stmt_ctor_args);
+				add_next_index_zval(return_value, &dbh->def_stmt_ctor_args);
 			}
 			return;
 		case PDO_ATTR_DEFAULT_FETCH_MODE:
 			RETURN_LONG(dbh->default_fetch_type);
-
+		default:
+			break;
 	}
 	
 	if (!dbh->methods->get_attribute) {
@@ -941,7 +937,7 @@ static PHP_METHOD(PDO, getAttribute)
    Execute a query that does not return a row set, returning the number of affected rows */
 static PHP_METHOD(PDO, exec)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	char *statement;
 	int statement_len;
 	long ret;
@@ -966,12 +962,11 @@ static PHP_METHOD(PDO, exec)
 }
 /* }}} */
 
-
 /* {{{ proto string PDO::lastInsertId([string seqname])
    Returns the id of the last row that we affected on this connection.  Some databases require a sequence or table name to be passed in.  Not always meaningful. */
 static PHP_METHOD(PDO, lastInsertId)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	char *name = NULL;
 	int namelen;
 
@@ -985,12 +980,16 @@ static PHP_METHOD(PDO, lastInsertId)
 		pdo_raise_impl_error(dbh, NULL, "IM001", "driver does not support lastInsertId()" TSRMLS_CC);
 		RETURN_FALSE;
 	} else {
-		Z_STRVAL_P(return_value) = dbh->methods->last_id(dbh, name, (unsigned int *)&Z_STRLEN_P(return_value) TSRMLS_CC);
-		if (!Z_STRVAL_P(return_value)) {
+		int id_len;
+		char *id;
+		id = dbh->methods->last_id(dbh, name, (unsigned int *)&id_len TSRMLS_CC);
+		if (!id) {
 			PDO_HANDLE_DBH_ERR();
 			RETURN_FALSE;
 		} else {
-			Z_TYPE_P(return_value) = IS_STRING;
+			//??? use zend_string ?
+			RETVAL_STRINGL(id, id_len);
+			efree(id);
 		}
 	}
 }
@@ -1000,7 +999,7 @@ static PHP_METHOD(PDO, lastInsertId)
    Fetch the error code associated with the last operation on the database handle */
 static PHP_METHOD(PDO, errorCode)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1008,7 +1007,7 @@ static PHP_METHOD(PDO, errorCode)
 	PDO_CONSTRUCT_CHECK;
 
 	if (dbh->query_stmt) {
-		RETURN_STRING(dbh->query_stmt->error_code, 1);
+		RETURN_STRING(dbh->query_stmt->error_code);
 	}
 	
 	if (dbh->error_code[0] == '\0') {
@@ -1019,7 +1018,7 @@ static PHP_METHOD(PDO, errorCode)
 	 * Making sure that we fallback to the default implementation
 	 * if the dbh->error_code is not null.
 	 */
-	RETURN_STRING(dbh->error_code, 1);
+	RETURN_STRING(dbh->error_code);
 }
 /* }}} */
 
@@ -1031,7 +1030,7 @@ static PHP_METHOD(PDO, errorInfo)
 	int error_count_diff 	 = 0;
 	int error_expected_count = 3;
 
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1042,9 +1041,9 @@ static PHP_METHOD(PDO, errorInfo)
 	array_init(return_value);
 
 	if (dbh->query_stmt) {
-		add_next_index_string(return_value, dbh->query_stmt->error_code, 1);
+		add_next_index_string(return_value, dbh->query_stmt->error_code);
 	} else {
-		add_next_index_string(return_value, dbh->error_code, 1);
+		add_next_index_string(return_value, dbh->error_code);
 	}
 
 	if (dbh->methods->fetch_err) {
@@ -1073,7 +1072,7 @@ static PHP_METHOD(PDO, errorInfo)
    Prepare and execute $sql; returns the statement object for iteration */
 static PHP_METHOD(PDO, query)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	pdo_stmt_t *stmt;
 	char *statement;
 	int statement_len;
@@ -1092,11 +1091,11 @@ static PHP_METHOD(PDO, query)
 	PDO_DBH_CLEAR_ERR();
 	PDO_CONSTRUCT_CHECK;
 
-	if (!pdo_stmt_instantiate(dbh, return_value, dbh->def_stmt_ce, dbh->def_stmt_ctor_args TSRMLS_CC)) {
+	if (!pdo_stmt_instantiate(dbh, return_value, dbh->def_stmt_ce, &dbh->def_stmt_ctor_args TSRMLS_CC)) {
 		pdo_raise_impl_error(dbh, NULL, "HY000", "failed to instantiate user supplied statement class" TSRMLS_CC);
 		return;
 	}
-	stmt = (pdo_stmt_t*)zend_object_store_get_object(return_value TSRMLS_CC);
+	stmt = Z_PDO_STMT_P(return_value);
 	
 	/* unconditionally keep this for later reference */
 	stmt->query_string = estrndup(statement, statement_len);
@@ -1107,11 +1106,10 @@ static PHP_METHOD(PDO, query)
 	stmt->active_query_stringlen = statement_len;
 	stmt->dbh = dbh;
 	/* give it a reference to me */
-	zend_objects_store_add_ref(getThis() TSRMLS_CC);
-	php_pdo_dbh_addref(dbh TSRMLS_CC);
-	stmt->database_object_handle = *getThis();
+	ZVAL_OBJ(&stmt->database_object_handle, &dbh->std);
+	Z_ADDREF(stmt->database_object_handle);
 	/* we haven't created a lazy object yet */
-	ZVAL_NULL(&stmt->lazy_object_ref);
+	ZVAL_UNDEF(&stmt->lazy_object_ref);
 
 	if (dbh->methods->preparer(dbh, statement, statement_len, stmt, NULL TSRMLS_CC)) {
 		PDO_STMT_CLEAR_ERR();
@@ -1128,18 +1126,18 @@ static PHP_METHOD(PDO, query)
 					stmt->executed = 1;
 				}
 				if (ret) {
-					pdo_stmt_construct(stmt, return_value, dbh->def_stmt_ce, dbh->def_stmt_ctor_args TSRMLS_CC);
+					pdo_stmt_construct(stmt, return_value, dbh->def_stmt_ce, &dbh->def_stmt_ctor_args TSRMLS_CC);
 					return;
 				}
 			}
 		}
 		/* something broke */
 		dbh->query_stmt = stmt;
-		dbh->query_stmt_zval = *return_value;
+		ZVAL_COPY_VALUE(&dbh->query_stmt_zval, return_value);
 		PDO_HANDLE_STMT_ERR();
 	} else {
 		PDO_HANDLE_DBH_ERR();
-		zval_dtor(return_value);
+		zval_ptr_dtor(return_value);
 	}
 
 	RETURN_FALSE;
@@ -1150,7 +1148,7 @@ static PHP_METHOD(PDO, query)
    quotes string for use in a query.  The optional paramtype acts as a hint for drivers that have alternate quoting styles.  The default value is PDO_PARAM_STR */
 static PHP_METHOD(PDO, quote)
 {
-	pdo_dbh_t *dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	pdo_dbh_t *dbh = Z_PDO_DBH_P(getThis());
 	char *str;
 	int str_len;
 	long paramtype = PDO_PARAM_STR;
@@ -1169,7 +1167,9 @@ static PHP_METHOD(PDO, quote)
 	}
 
 	if (dbh->methods->quoter(dbh, str, str_len, &qstr, &qlen, paramtype TSRMLS_CC)) {
-		RETURN_STRINGL(qstr, qlen, 0);
+		RETVAL_STRINGL(qstr, qlen);
+		efree(qstr);
+		return;
 	}
 	PDO_HANDLE_DBH_ERR();
 	RETURN_FALSE;
@@ -1196,8 +1196,7 @@ static PHP_METHOD(PDO, __sleep)
    Return array of available PDO drivers */
 static PHP_METHOD(PDO, getAvailableDrivers)
 {
-	HashPosition pos;
-	pdo_driver_t **pdriver;
+	pdo_driver_t *pdriver;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1205,11 +1204,9 @@ static PHP_METHOD(PDO, getAvailableDrivers)
 	
 	array_init(return_value);
 
-	zend_hash_internal_pointer_reset_ex(&pdo_driver_hash, &pos);
-	while (SUCCESS == zend_hash_get_current_data_ex(&pdo_driver_hash, (void**)&pdriver, &pos)) {
-		add_next_index_stringl(return_value, (char*)(*pdriver)->driver_name, (*pdriver)->driver_name_len, 1);
-		zend_hash_move_forward_ex(&pdo_driver_hash, &pos);
-	}
+	ZEND_HASH_FOREACH_PTR(&pdo_driver_hash, pdriver) {
+		add_next_index_stringl(return_value, (char*)pdriver->driver_name, pdriver->driver_name_len);
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -1273,6 +1270,14 @@ const zend_function_entry pdo_dbh_functions[] = {
 	{NULL, NULL, NULL}
 };
 
+static void cls_method_dtor(zval *el) {
+	zend_function *func = (zend_function*)Z_PTR_P(el);
+	if (func->common.function_name) {
+		STR_RELEASE(func->common.function_name);
+	}
+	efree(func);
+}
+
 /* {{{ overloaded object handlers for PDO class */
 int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
 {
@@ -1293,12 +1298,12 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
 	if (!(dbh->cls_methods[kind] = pemalloc(sizeof(HashTable), dbh->is_persistent))) {
 		php_error_docref(NULL TSRMLS_CC, E_ERROR, "out of memory while allocating PDO methods.");
 	}
-	zend_hash_init_ex(dbh->cls_methods[kind], 8, NULL, NULL, dbh->is_persistent, 0);
+	zend_hash_init_ex(dbh->cls_methods[kind], 8, NULL, cls_method_dtor, dbh->is_persistent, 0);
 
 	while (funcs->fname) {
 		ifunc->type = ZEND_INTERNAL_FUNCTION;
 		ifunc->handler = funcs->handler;
-		ifunc->function_name = (char*)funcs->fname;
+		ifunc->function_name = STR_INIT(funcs->fname, strlen(funcs->fname), 0);
 		ifunc->scope = dbh->std.ce;
 		ifunc->prototype = NULL;
 		if (funcs->flags) {
@@ -1330,7 +1335,7 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
 		namelen = strlen(funcs->fname);
 		lc_name = emalloc(namelen+1);
 		zend_str_tolower_copy(lc_name, funcs->fname, namelen);
-		zend_hash_add(dbh->cls_methods[kind], lc_name, namelen+1, &func, sizeof(func), NULL);
+		zend_hash_str_add_mem(dbh->cls_methods[kind], lc_name, namelen, &func, sizeof(func));
 		efree(lc_name);
 		funcs++;
 	}
@@ -1338,25 +1343,16 @@ int pdo_hash_methods(pdo_dbh_t *dbh, int kind TSRMLS_DC)
 	return 1;
 }
 
-static union _zend_function *dbh_method_get(
-#if PHP_API_VERSION >= 20041225
-	zval **object_pp,
-#else
-	zval *object,
-#endif
-	char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
+static union _zend_function *dbh_method_get(zend_object **object, zend_string *method_name, const zval *key TSRMLS_DC)
 {
 	zend_function *fbc = NULL;
-	char *lc_method_name;
-#if PHP_API_VERSION >= 20041225
-	zval *object = *object_pp;
-#endif
-	pdo_dbh_t *dbh = zend_object_store_get_object(object TSRMLS_CC);
+	pdo_dbh_t *dbh = php_pdo_dbh_fetch_object(*object);
+	zend_string *lc_method_name;
 
-	lc_method_name = emalloc(method_len + 1);
-	zend_str_tolower_copy(lc_method_name, method_name, method_len);
+	lc_method_name = STR_INIT(method_name->val, method_name->len, 0);
+	zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len);
 
-	if ((fbc = std_object_handlers.get_method(object_pp, method_name, method_len, key TSRMLS_CC)) == NULL) {
+	if ((fbc = std_object_handlers.get_method(object, method_name, key TSRMLS_CC)) == NULL) {
 		/* not a pre-defined method, nor a user-defined method; check
 		 * the driver specific methods */
 		if (!dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH]) {
@@ -1367,16 +1363,11 @@ static union _zend_function *dbh_method_get(
 			}
 		}
 
-		if (zend_hash_find(dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH],
-				lc_method_name, method_len+1, (void**)&fbc) == FAILURE) {
-			if (!fbc) {
-				fbc = NULL;
-			}
-		}
+		fbc = zend_hash_find_ptr(dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_DBH], lc_method_name);
 	}
 
 out:
-	efree(lc_method_name);
+	STR_RELEASE(lc_method_name);
 	return fbc;
 }
 
@@ -1386,6 +1377,7 @@ static int dbh_compare(zval *object1, zval *object2 TSRMLS_DC)
 }
 
 static zend_object_handlers pdo_dbh_object_handlers;
+static void pdo_dbh_free_storage(zend_object *std TSRMLS_DC);
 
 void pdo_dbh_init(TSRMLS_D)
 {
@@ -1396,6 +1388,9 @@ void pdo_dbh_init(TSRMLS_D)
 	pdo_dbh_ce->create_object = pdo_dbh_new;
 
 	memcpy(&pdo_dbh_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	pdo_dbh_object_handlers.offset = XtOffsetOf(pdo_dbh_t, std);
+	pdo_dbh_object_handlers.dtor_obj = zend_objects_destroy_object;
+	pdo_dbh_object_handlers.free_obj = pdo_dbh_free_storage;
 	pdo_dbh_object_handlers.get_method = dbh_method_get;
 	pdo_dbh_object_handlers.compare_objects = dbh_compare;
 	
@@ -1500,11 +1495,8 @@ static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
 {
 	int i;
 
-	if (--dbh->refcount)
-		return;
-
 	if (dbh->query_stmt) {
-		zval_dtor(&dbh->query_stmt_zval);
+		zval_ptr_dtor(&dbh->query_stmt_zval);
 		dbh->query_stmt = NULL;
 	}
 
@@ -1526,7 +1518,7 @@ static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
 		pefree((char *)dbh->persistent_id, dbh->is_persistent);
 	}
 
-	if (dbh->def_stmt_ctor_args) {
+	if (!ZVAL_IS_UNDEF(&dbh->def_stmt_ctor_args)) {
 		zval_ptr_dtor(&dbh->def_stmt_ctor_args);
 	}
 	
@@ -1537,21 +1529,12 @@ static void dbh_free(pdo_dbh_t *dbh TSRMLS_DC)
 		}
 	}
 
-	pefree(dbh, dbh->is_persistent);
-}
-
-PDO_API void php_pdo_dbh_addref(pdo_dbh_t *dbh TSRMLS_DC)
-{
-	dbh->refcount++;
-}
-
-PDO_API void php_pdo_dbh_delref(pdo_dbh_t *dbh TSRMLS_DC)
-{
-	dbh_free(dbh TSRMLS_CC);
+	//???pefree(dbh, dbh->is_persistent);
 }
 
-static void pdo_dbh_free_storage(pdo_dbh_t *dbh TSRMLS_DC)
+static void pdo_dbh_free_storage(zend_object *std TSRMLS_DC)
 {
+	pdo_dbh_t *dbh = php_pdo_dbh_fetch_object(std);
 	if (dbh->in_txn && dbh->methods && dbh->methods->rollback) {
 		dbh->methods->rollback(dbh TSRMLS_CC);
 		dbh->in_txn = 0;
@@ -1560,39 +1543,34 @@ static void pdo_dbh_free_storage(pdo_dbh_t *dbh TSRMLS_DC)
 	if (dbh->is_persistent && dbh->methods && dbh->methods->persistent_shutdown) {
 		dbh->methods->persistent_shutdown(dbh TSRMLS_CC);
 	}
-	zend_object_std_dtor(&dbh->std TSRMLS_CC);
-	dbh->std.properties = NULL;
-	dbh->std.properties_table = NULL;
-	dbh_free(dbh TSRMLS_CC);
+	zend_object_std_dtor(std TSRMLS_CC);
+	dbh_free(dbh);
 }
 
-zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *pdo_dbh_new(zend_class_entry *ce TSRMLS_DC)
 {
-	zend_object_value retval;
 	pdo_dbh_t *dbh;
 
-	dbh = emalloc(sizeof(*dbh));
-	memset(dbh, 0, sizeof(*dbh));
+	dbh = ecalloc(1, sizeof(pdo_dbh_t) + sizeof(zval) * (ce->default_properties_count - 1));
 	zend_object_std_init(&dbh->std, ce TSRMLS_CC);
 	object_properties_init(&dbh->std, ce);
 	rebuild_object_properties(&dbh->std);
 	dbh->refcount = 1;
 	dbh->def_stmt_ce = pdo_dbstmt_ce;
 	
-	retval.handle = zend_objects_store_put(dbh, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_dbh_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &pdo_dbh_object_handlers;
+	dbh->std.handlers = &pdo_dbh_object_handlers;
 	
-	return retval;
+	return &dbh->std;
 }
 
 /* }}} */
 
 ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor)
 {
-	if (rsrc->ptr) {
-		pdo_dbh_t *dbh = (pdo_dbh_t*)rsrc->ptr;
+	if (res->ptr) {
+		pdo_dbh_t *dbh = (pdo_dbh_t*)res->ptr;
 		dbh_free(dbh TSRMLS_CC);
-		rsrc->ptr = NULL;
+		res->ptr = NULL;
 	}
 }
 
diff --git a/ext/pdo/pdo_sql_parser.c b/ext/pdo/pdo_sql_parser.c
index 341e664bbe..be2fa35501 100644
--- a/ext/pdo/pdo_sql_parser.c
+++ b/ext/pdo/pdo_sql_parser.c
@@ -4,7 +4,7 @@
   +----------------------------------------------------------------------+
   | PHP Version 5                                                        |
   +----------------------------------------------------------------------+
-  | Copyright (c) 1997-2014 The PHP Group                                |
+  | Copyright (c) 1997-2013 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -523,7 +523,7 @@ PDO_API int pdo_parse_params(pdo_stmt_t *stmt, char *inquery, int inquery_len,
 		if (query_type != PDO_PLACEHOLDER_POSITIONAL && bindno > zend_hash_num_elements(params)) {
 			int ok = 1;
 			for (plc = placeholders; plc; plc = plc->next) {
-				if (zend_hash_find(params, plc->pos, plc->len, (void**) &param) == FAILURE) {
+				if ((params = zend_hash_str_find_ptr(params, plc->pos, plc->len)) == NULL) {
 					ok = 0;
 					break;
 				}
@@ -546,38 +546,37 @@ safe:
 		/* let's quote all the values */	
 		for (plc = placeholders; plc; plc = plc->next) {
 			if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
-				ret = zend_hash_index_find(params, plc->bindno, (void**) &param);
+				param = zend_hash_index_find_ptr(params, plc->bindno);
 			} else {
-				ret = zend_hash_find(params, plc->pos, plc->len, (void**) &param);
+				param = zend_hash_str_find_ptr(params, plc->pos, plc->len);
 			}
-			if (ret == FAILURE) {
+			if (param == NULL) {
 				/* parameter was not defined */
 				ret = -1;
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC);
 				goto clean_up;
 			}
 			if (stmt->dbh->methods->quoter) {
-				if (param->param_type == PDO_PARAM_LOB && Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+				if (param->param_type == PDO_PARAM_LOB && Z_TYPE(param->parameter) == IS_RESOURCE) {
 					php_stream *stm;
 
 					php_stream_from_zval_no_verify(stm, &param->parameter);
 					if (stm) {
-						size_t len;
-						char *buf = NULL;
+						zend_string *buf;
 					
-						len = php_stream_copy_to_mem(stm, &buf, PHP_STREAM_COPY_ALL, 0);
-						if (!stmt->dbh->methods->quoter(stmt->dbh, buf, len, &plc->quoted, &plc->qlen,
+						buf = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
+						if (!stmt->dbh->methods->quoter(stmt->dbh, buf->val, buf->len, &plc->quoted, &plc->qlen,
 								param->param_type TSRMLS_CC)) {
 							/* bork */
 							ret = -1;
 							strncpy(stmt->error_code, stmt->dbh->error_code, 6);
 							if (buf) {
-								efree(buf);
+								STR_RELEASE(buf);
 							}
 							goto clean_up;
 						}
 						if (buf) {
-							efree(buf);
+							STR_RELEASE(buf);
 						}
 					} else {
 						pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
@@ -586,8 +585,8 @@ safe:
 					}
 					plc->freeq = 1;
 				} else {
-					zval tmp_param = *param->parameter;
-					zval_copy_ctor(&tmp_param);
+					zval tmp_param;
+				   	ZVAL_DUP(&tmp_param, &param->parameter);
 					switch (Z_TYPE(tmp_param)) {
 						case IS_NULL:
 							plc->quoted = "NULL";
@@ -621,8 +620,8 @@ safe:
 					zval_dtor(&tmp_param);
 				}
 			} else {
-				plc->quoted = Z_STRVAL_P(param->parameter);
-				plc->qlen = Z_STRLEN_P(param->parameter);
+				plc->quoted = Z_STRVAL(param->parameter);
+				plc->qlen = Z_STRLEN(param->parameter);
 			}
 			newbuffer_len += plc->qlen;
 		}
@@ -679,7 +678,7 @@ rewrite:
 			name = estrndup(plc->pos, plc->len);
 
 			/* check if bound parameter is already available */
-			if (!strcmp(name, "?") || zend_hash_find(stmt->bound_param_map, name, plc->len + 1, (void**) &p) == FAILURE) {
+			if (!strcmp(name, "?") || (p = zend_hash_str_find_ptr(stmt->bound_param_map, name, plc->len)) == NULL) {
 				spprintf(&idxbuf, 0, tmpl, bind_no++);
 			} else {
 				idxbuf = estrdup(p);
@@ -693,11 +692,11 @@ rewrite:
 
 			if (!skip_map && stmt->named_rewrite_template) {
 				/* create a mapping */
-				zend_hash_update(stmt->bound_param_map, name, plc->len + 1, idxbuf, plc->qlen + 1, NULL);
+				zend_hash_str_update_mem(stmt->bound_param_map, name, plc->len, idxbuf, plc->qlen + 1);
 			}
 
 			/* map number to name */
-			zend_hash_index_update(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1, NULL);
+			zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1);
 			
 			efree(name);
 		}
@@ -718,7 +717,7 @@ rewrite:
 			char *name;
 			
 			name = estrndup(plc->pos, plc->len);
-			zend_hash_index_update(stmt->bound_param_map, plc->bindno, name, plc->len + 1, NULL);
+			zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, name, plc->len + 1);
 			efree(name);
 			plc->quoted = "?";
 			plc->qlen = 1;
diff --git a/ext/pdo/pdo_sql_parser.re b/ext/pdo/pdo_sql_parser.re
index fa8ef187fa..e182bf65d1 100644
--- a/ext/pdo/pdo_sql_parser.re
+++ b/ext/pdo/pdo_sql_parser.re
@@ -165,7 +165,7 @@ PDO_API int pdo_parse_params(pdo_stmt_t *stmt, char *inquery, int inquery_len,
 		if (query_type != PDO_PLACEHOLDER_POSITIONAL && bindno > zend_hash_num_elements(params)) {
 			int ok = 1;
 			for (plc = placeholders; plc; plc = plc->next) {
-				if (zend_hash_find(params, plc->pos, plc->len, (void**) &param) == FAILURE) {
+				if ((params = zend_hash_str_find_ptr(params, plc->pos, plc->len)) == NULL) {
 					ok = 0;
 					break;
 				}
@@ -188,38 +188,37 @@ safe:
 		/* let's quote all the values */	
 		for (plc = placeholders; plc; plc = plc->next) {
 			if (query_type == PDO_PLACEHOLDER_POSITIONAL) {
-				ret = zend_hash_index_find(params, plc->bindno, (void**) &param);
+				param = zend_hash_index_find_ptr(params, plc->bindno);
 			} else {
-				ret = zend_hash_find(params, plc->pos, plc->len, (void**) &param);
+				param = zend_hash_str_find_ptr(params, plc->pos, plc->len);
 			}
-			if (ret == FAILURE) {
+			if (param == NULL) {
 				/* parameter was not defined */
 				ret = -1;
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC);
 				goto clean_up;
 			}
 			if (stmt->dbh->methods->quoter) {
-				if (param->param_type == PDO_PARAM_LOB && Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+				if (param->param_type == PDO_PARAM_LOB && Z_TYPE(param->parameter) == IS_RESOURCE) {
 					php_stream *stm;
 
 					php_stream_from_zval_no_verify(stm, &param->parameter);
 					if (stm) {
-						size_t len;
-						char *buf = NULL;
+						zend_string *buf;
 					
-						len = php_stream_copy_to_mem(stm, &buf, PHP_STREAM_COPY_ALL, 0);
-						if (!stmt->dbh->methods->quoter(stmt->dbh, buf, len, &plc->quoted, &plc->qlen,
+						buf = php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0);
+						if (!stmt->dbh->methods->quoter(stmt->dbh, buf->val, buf->len, &plc->quoted, &plc->qlen,
 								param->param_type TSRMLS_CC)) {
 							/* bork */
 							ret = -1;
 							strncpy(stmt->error_code, stmt->dbh->error_code, 6);
 							if (buf) {
-								efree(buf);
+								STR_RELEASE(buf);
 							}
 							goto clean_up;
 						}
 						if (buf) {
-							efree(buf);
+							STR_RELEASE(buf);
 						}
 					} else {
 						pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
@@ -228,8 +227,8 @@ safe:
 					}
 					plc->freeq = 1;
 				} else {
-					zval tmp_param = *param->parameter;
-					zval_copy_ctor(&tmp_param);
+					zval tmp_param;
+				   	ZVAL_DUP(&tmp_param, &param->parameter);
 					switch (Z_TYPE(tmp_param)) {
 						case IS_NULL:
 							plc->quoted = "NULL";
@@ -263,8 +262,8 @@ safe:
 					zval_dtor(&tmp_param);
 				}
 			} else {
-				plc->quoted = Z_STRVAL_P(param->parameter);
-				plc->qlen = Z_STRLEN_P(param->parameter);
+				plc->quoted = Z_STRVAL(param->parameter);
+				plc->qlen = Z_STRLEN(param->parameter);
 			}
 			newbuffer_len += plc->qlen;
 		}
@@ -321,7 +320,7 @@ rewrite:
 			name = estrndup(plc->pos, plc->len);
 
 			/* check if bound parameter is already available */
-			if (!strcmp(name, "?") || zend_hash_find(stmt->bound_param_map, name, plc->len + 1, (void**) &p) == FAILURE) {
+			if (!strcmp(name, "?") || (p = zend_hash_str_find_ptr(stmt->bound_param_map, name, plc->len)) == NULL) {
 				spprintf(&idxbuf, 0, tmpl, bind_no++);
 			} else {
 				idxbuf = estrdup(p);
@@ -335,11 +334,11 @@ rewrite:
 
 			if (!skip_map && stmt->named_rewrite_template) {
 				/* create a mapping */
-				zend_hash_update(stmt->bound_param_map, name, plc->len + 1, idxbuf, plc->qlen + 1, NULL);
+				zend_hash_str_update_mem(stmt->bound_param_map, name, plc->len, idxbuf, plc->qlen + 1);
 			}
 
 			/* map number to name */
-			zend_hash_index_update(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1, NULL);
+			zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, idxbuf, plc->qlen + 1);
 			
 			efree(name);
 		}
@@ -360,7 +359,7 @@ rewrite:
 			char *name;
 			
 			name = estrndup(plc->pos, plc->len);
-			zend_hash_index_update(stmt->bound_param_map, plc->bindno, name, plc->len + 1, NULL);
+			zend_hash_index_update_mem(stmt->bound_param_map, plc->bindno, name, plc->len + 1);
 			efree(name);
 			plc->quoted = "?";
 			plc->qlen = 1;
diff --git a/ext/pdo/pdo_sqlstate.c b/ext/pdo/pdo_sqlstate.c
index 533a35c404..4d6a01011c 100644
--- a/ext/pdo/pdo_sqlstate.c
+++ b/ext/pdo/pdo_sqlstate.c
@@ -314,15 +314,12 @@ int pdo_sqlstate_init_error_table(void)
 	int i;
 	const struct pdo_sqlstate_info *info;
 
-	if (FAILURE == zend_hash_init(&err_hash,
-			sizeof(err_initializer)/sizeof(err_initializer[0]), NULL, NULL, 1)) {
-		return FAILURE;
-	}
+	zend_hash_init(&err_hash, sizeof(err_initializer)/sizeof(err_initializer[0]), NULL, NULL, 1);
 
 	for (i = 0; i < sizeof(err_initializer)/sizeof(err_initializer[0]); i++) {
 		info = &err_initializer[i];
 
-		zend_hash_add(&err_hash, info->state, sizeof(info->state), &info, sizeof(info), NULL);
+		zend_hash_str_add_ptr(&err_hash, info->state, sizeof(info->state), info);
 	}
 
 	return SUCCESS;
@@ -330,10 +327,9 @@ int pdo_sqlstate_init_error_table(void)
 
 const char *pdo_sqlstate_state_to_description(char *state)
 {
-	const struct pdo_sqlstate_info **info;
-	if (SUCCESS == zend_hash_find(&err_hash, state, sizeof(err_initializer[0].state),
-			(void**)&info)) {
-		return (*info)->desc;
+	const struct pdo_sqlstate_info *info;
+	if ((info = zend_hash_str_find_ptr(&err_hash, state, sizeof(err_initializer[0].state))) != NULL) {
+		return info->desc;
 	}
 	return NULL;
 }
diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index 2593d02e96..8ec246926c 100644
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -108,9 +108,9 @@ ZEND_END_ARG_INFO()
 /* }}} */
 
 #define PHP_STMT_GET_OBJ	\
-  pdo_stmt_t *stmt = (pdo_stmt_t*)zend_object_store_get_object(getThis() TSRMLS_CC);	\
+  pdo_stmt_t *stmt = Z_PDO_STMT_P(getThis());	\
   if (!stmt->dbh) {	\
-    RETURN_FALSE;	\
+	  RETURN_FALSE;	\
   }	\
 
 static PHP_FUNCTION(dbstmt_constructor) /* {{{ */
@@ -128,7 +128,7 @@ static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_pa
 		 * we will raise an error, as we can't be sure that it is safe
 		 * to bind multiple parameters onto the same zval in the underlying
 		 * driver */
-		char *name;
+		zval *name;
 		int position = 0;
 
 		if (stmt->named_rewrite_template) {
@@ -137,20 +137,17 @@ static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_pa
 		}
 		if (!param->name) {
 			/* do the reverse; map the parameter number to the name */
-			if (SUCCESS == zend_hash_index_find(stmt->bound_param_map, param->paramno, (void**)&name)) {
-				param->name = estrdup(name);
-				param->namelen = strlen(param->name);
+			if ((name = zend_hash_index_find(stmt->bound_param_map, param->paramno)) != NULL) {
+				param->name = STR_COPY(Z_STR_P(name));
 				return 1;
 			}
 			pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC);
 			return 0;
 		}
     
-		zend_hash_internal_pointer_reset(stmt->bound_param_map);
-		while (SUCCESS == zend_hash_get_current_data(stmt->bound_param_map, (void**)&name)) {
-			if (strcmp(name, param->name)) {
+		ZEND_HASH_FOREACH_VAL(stmt->bound_param_map, name) {
+			if (strncmp(Z_STRVAL_P(name), param->name->val, param->name->len + 1)) {
 				position++;
-				zend_hash_move_forward(stmt->bound_param_map);
 				continue;
 			}
 			if (param->paramno >= 0) {
@@ -159,7 +156,7 @@ static inline int rewrite_name_to_position(pdo_stmt_t *stmt, struct pdo_bound_pa
 			}
 			param->paramno = position;
 			return 1;
-		}
+		} ZEND_HASH_FOREACH_END();
 		pdo_raise_impl_error(stmt->dbh, stmt, "HY093", "parameter was not defined" TSRMLS_CC);
 		return 0;
 	}
@@ -182,15 +179,12 @@ static int dispatch_param_event(pdo_stmt_t *stmt, enum pdo_param_event event_typ
 
 iterate:
 	if (ht) {
-		zend_hash_internal_pointer_reset(ht);
-		while (SUCCESS == zend_hash_get_current_data(ht, (void**)&param)) {
+		ZEND_HASH_FOREACH_PTR(ht, param) {
 			if (!stmt->methods->param_hook(stmt, param, event_type TSRMLS_CC)) {
 				ret = 0;
 				break;
 			}
-			
-			zend_hash_move_forward(ht);
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 	if (ret && is_param) {
 		ht = stmt->bound_columns;
@@ -249,8 +243,8 @@ int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 		if (stmt->bound_columns) {
 			struct pdo_bound_param_data *param;
 
-			if (SUCCESS == zend_hash_find(stmt->bound_columns, stmt->columns[col].name,
-						stmt->columns[col].namelen, (void**)&param)) {
+			if ((param = zend_hash_str_find_ptr(stmt->bound_columns,
+					stmt->columns[col].name, stmt->columns[col].namelen)) != NULL) {
 				param->paramno = col;
 			}
 		}
@@ -262,46 +256,47 @@ int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 
 static void get_lazy_object(pdo_stmt_t *stmt, zval *return_value TSRMLS_DC) /* {{{ */
 {
-	if (Z_TYPE(stmt->lazy_object_ref) == IS_NULL) {
-		Z_TYPE(stmt->lazy_object_ref) = IS_OBJECT;
-		Z_OBJ_HANDLE(stmt->lazy_object_ref) = zend_objects_store_put(stmt, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_row_free_storage, NULL TSRMLS_CC);
-		Z_OBJ_HT(stmt->lazy_object_ref) = &pdo_row_object_handlers;
-		stmt->refcount++;
+	if (ZVAL_IS_UNDEF(&stmt->lazy_object_ref)) {
+		pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t));
+		row->stmt = stmt;
+		zend_object_std_init(&row->std, pdo_row_ce TSRMLS_CC);
+		ZVAL_OBJ(&stmt->lazy_object_ref, &row->std);
+		row->std.handlers = &pdo_row_object_handlers;
+		stmt->std.gc.refcount++;
 	}
-	Z_TYPE_P(return_value) = IS_OBJECT;
-	Z_OBJ_HANDLE_P(return_value) = Z_OBJ_HANDLE(stmt->lazy_object_ref);
-	Z_OBJ_HT_P(return_value) = Z_OBJ_HT(stmt->lazy_object_ref);
-	zend_objects_store_add_ref(return_value TSRMLS_CC);
+	ZVAL_COPY(return_value, &stmt->lazy_object_ref);
 }
 /* }}} */
 
-static void param_dtor(void *data) /* {{{ */
+static void param_dtor(zval *el) /* {{{ */
 {
-	struct pdo_bound_param_data *param = (struct pdo_bound_param_data *)data;
-	TSRMLS_FETCH();
+	struct pdo_bound_param_data *param = (struct pdo_bound_param_data *)Z_PTR_P(el);
 
 	/* tell the driver that it is going away */
 	if (param->stmt->methods->param_hook) {
+		TSRMLS_FETCH();
 		param->stmt->methods->param_hook(param->stmt, param, PDO_PARAM_EVT_FREE TSRMLS_CC);
 	}
 
 	if (param->name) {
-		efree(param->name);
+		STR_RELEASE(param->name);
 	}
 
-	if (param->parameter) {
-		zval_ptr_dtor(&(param->parameter));
-		param->parameter = NULL;
+	if (!ZVAL_IS_UNDEF(&param->parameter)) {
+		zval_ptr_dtor(&param->parameter);
+		ZVAL_UNDEF(&param->parameter);
 	}
-	if (param->driver_params) {
-		zval_ptr_dtor(&(param->driver_params));
+	if (!ZVAL_IS_UNDEF(&param->driver_params)) {
+		zval_ptr_dtor(&param->driver_params);
 	}
+	efree(param);
 }
 /* }}} */
 
 static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_stmt_t *stmt, int is_param TSRMLS_DC) /* {{{ */
 {
 	HashTable *hash;
+	zval *parameter;
 	struct pdo_bound_param_data *pparam = NULL;
 
 	hash = is_param ? stmt->bound_params : stmt->bound_columns;
@@ -317,25 +312,32 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 		}
 	}
 
-	if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_STR && param->max_value_len <= 0 && ! ZVAL_IS_NULL(param->parameter)) {
-		if (Z_TYPE_P(param->parameter) == IS_DOUBLE) {
+	if (!Z_ISREF(param->parameter)) {
+		parameter = &param->parameter;
+	} else {
+		parameter = Z_REFVAL(param->parameter);
+	}
+
+	if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_STR && param->max_value_len <= 0 && !ZVAL_IS_NULL(parameter)) {
+		if (Z_TYPE_P(parameter) == IS_DOUBLE) {
 			char *p;
-			int len = spprintf(&p, 0, "%.*H", (int) EG(precision), Z_DVAL_P(param->parameter));
-			ZVAL_STRINGL(param->parameter, p, len, 0);
+			int len = spprintf(&p, 0, "%.*H", (int) EG(precision), Z_DVAL_P(parameter));
+			ZVAL_STRINGL(parameter, p, len);
+			efree(p);
 		} else {
-			convert_to_string(param->parameter);
+			convert_to_string(parameter);
 		}
-	} else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_INT && Z_TYPE_P(param->parameter) == IS_BOOL) {
-		convert_to_long(param->parameter);
-	} else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_BOOL && Z_TYPE_P(param->parameter) == IS_LONG) {
-		convert_to_boolean(param->parameter);
+	} else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_INT && Z_TYPE_P(parameter) == IS_BOOL) {
+		convert_to_long(parameter);
+	} else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_BOOL && Z_TYPE_P(parameter) == IS_LONG) {
+		convert_to_boolean(parameter);
 	}
 
 	param->stmt = stmt;
 	param->is_param = is_param;
 
-	if (param->driver_params) {
-		Z_ADDREF_P(param->driver_params);
+	if (Z_REFCOUNTED(param->driver_params)) {
+		Z_ADDREF(param->driver_params);
 	}
 
 	if (!is_param && param->name && stmt->columns) {
@@ -343,7 +345,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 		int i;
 
 		for (i = 0; i < stmt->column_count; i++) {
-			if (strcmp(stmt->columns[i].name, param->name) == 0) {
+			if (strncmp(stmt->columns[i].name, param->name->val, param->name->len + 1) == 0) {
 				param->paramno = i;
 				break;
 			}
@@ -353,26 +355,26 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 		 * then this will trigger, and we don't want that */
 		if (param->paramno == -1) {
 			char *tmp;
-			spprintf(&tmp, 0, "Did not find column name '%s' in the defined columns; it will not be bound", param->name);
+			spprintf(&tmp, 0, "Did not find column name '%s' in the defined columns; it will not be bound", param->name->val);
 			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", tmp TSRMLS_CC);
 			efree(tmp);
 		}
 	}
 
 	if (param->name) {
-		if (is_param && param->name[0] != ':') {
-			char *temp = emalloc(++param->namelen + 1);
-			temp[0] = ':';
-			memmove(temp+1, param->name, param->namelen);
+		if (is_param && param->name->val[0] != ':') {
+			zend_string *temp = STR_ALLOC(param->name->len + 1, 0);
+			temp->val[0] = ':';
+			memmove(temp->val + 1, param->name->val, param->name->len + 1);
 			param->name = temp;
 		} else {
-			param->name = estrndup(param->name, param->namelen);
+			param->name = STR_INIT(param->name->val, param->name->len, 0);
 		}
 	}
 
 	if (is_param && !rewrite_name_to_position(stmt, param TSRMLS_CC)) {
 		if (param->name) {
-			efree(param->name);
+			STR_RELEASE(param->name);
 			param->name = NULL;
 		}
 		return 0;
@@ -386,7 +388,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 		if (!stmt->methods->param_hook(stmt, param, PDO_PARAM_EVT_NORMALIZE
 				TSRMLS_CC)) {
 			if (param->name) {
-				efree(param->name);
+				STR_RELEASE(param->name);
 				param->name = NULL;
 			}
 			return 0;
@@ -402,11 +404,13 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 
 	/* allocate storage for the parameter, keyed by its "canonical" name */
 	if (param->name) {
-		zend_hash_update(hash, param->name, param->namelen, param,
-			sizeof(*param), (void**)&pparam);
+		zval *zv;
+		zv = zend_hash_update_mem(hash, param->name, param, sizeof(struct pdo_bound_param_data));
+		pparam = Z_PTR_P(zv);
 	} else {
-		zend_hash_index_update(hash, param->paramno, param, sizeof(*param),
-			(void**)&pparam);
+		zval *zv;
+		zv = zend_hash_index_update_mem(hash, param->paramno, param, sizeof(struct pdo_bound_param_data));
+		pparam = Z_PTR_P(zv);
 	}
 
 	/* tell the driver we just created a parameter */
@@ -416,12 +420,12 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
 			/* undo storage allocation; the hash will free the parameter
 			 * name if required */
 			if (pparam->name) {
-				zend_hash_del(hash, pparam->name, pparam->namelen);
+				zend_hash_del(hash, pparam->name);
 			} else {
 				zend_hash_index_del(hash, pparam->paramno);
 			}
 			/* param->parameter is freed by hash dtor */
-			param->parameter = NULL;
+			ZVAL_UNDEF(&param->parameter);
 			return 0;
 		}
 	}
@@ -445,8 +449,8 @@ static PHP_METHOD(PDOStatement, execute)
 	
 	if (input_params) {
 		struct pdo_bound_param_data param;
-		zval **tmp;
-		uint str_length;
+		zval *tmp;
+		zend_string *key = NULL;
 		ulong num_index;
 	
 		if (stmt->bound_params) {	
@@ -455,14 +459,12 @@ static PHP_METHOD(PDOStatement, execute)
 			stmt->bound_params = NULL;
 		}
 
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(input_params));
-		while (SUCCESS == zend_hash_get_current_data(Z_ARRVAL_P(input_params), (void*)&tmp)) {
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(input_params), num_index, key, tmp) {
 			memset(&param, 0, sizeof(param));
 
-			if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_P(input_params),
-						&param.name, &str_length, &num_index, 0, NULL)) {
+			if (key) {
 				/* yes this is correct.  we don't want to count the null byte.  ask wez */
-				param.namelen = str_length - 1;
+				param.name = STR_COPY(key);
 				param.paramno = -1;
 			} else {
 				/* we're okay to be zero based here */
@@ -474,18 +476,15 @@ static PHP_METHOD(PDOStatement, execute)
 			}
 
 			param.param_type = PDO_PARAM_STR;
-			MAKE_STD_ZVAL(param.parameter);
-			MAKE_COPY_ZVAL(tmp, param.parameter);
+			ZVAL_COPY(&param.parameter, tmp);
 
 			if (!really_register_bound_param(&param, stmt, 1 TSRMLS_CC)) {
-				if (param.parameter) {
+				if (!ZVAL_IS_UNDEF(&param.parameter)) {
 					zval_ptr_dtor(&param.parameter);
 				}
 				RETURN_FALSE;
 			}
-
-			zend_hash_move_forward(Z_ARRVAL_P(input_params));
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	if (PDO_PLACEHOLDER_NONE == stmt->supports_placeholders) {
@@ -597,13 +596,12 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ
 			} else if (value_len == 0) {
 				/* Warning, empty strings need to be passed as stream */
 				if (stmt->dbh->stringify || new_type == PDO_PARAM_STR) {
-					char *buf = NULL;
-					size_t len;
-					len = php_stream_copy_to_mem((php_stream*)value, &buf, PHP_STREAM_COPY_ALL, 0);
-					if(buf == NULL) {
+					zend_string *buf;
+					buf = php_stream_copy_to_mem((php_stream*)value, PHP_STREAM_COPY_ALL, 0);
+					if (buf == NULL) {
 						ZVAL_EMPTY_STRING(dest);
 					} else {
-						ZVAL_STRINGL(dest, buf, len, 0);
+						ZVAL_STR(dest, buf);
 					}
 					php_stream_close((php_stream*)value);
 				} else {
@@ -629,19 +627,13 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ
 					ZVAL_NULL(dest);
 				}
 			} else {
-				ZVAL_STRINGL(dest, value, value_len, !caller_frees);
-				if (caller_frees) {
-					caller_frees = 0;
-				}
+				ZVAL_STRINGL(dest, value, value_len);
 			}
 			break;
 		
 		case PDO_PARAM_STR:
 			if (value && !(value_len == 0 && stmt->dbh->oracle_nulls == PDO_NULL_EMPTY_STRING)) {
-				ZVAL_STRINGL(dest, value, value_len, !caller_frees);
-				if (caller_frees) {
-					caller_frees = 0;
-				}
+				ZVAL_STRINGL(dest, value, value_len);
 				break;
 			}
 		default:
@@ -651,16 +643,16 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ
 	if (type != new_type) {
 		switch (new_type) {
 			case PDO_PARAM_INT:
-				convert_to_long_ex(&dest);
+				convert_to_long_ex(dest);
 				break;
 			case PDO_PARAM_BOOL:
-				convert_to_boolean_ex(&dest);
+				convert_to_boolean_ex(dest);
 				break;
 			case PDO_PARAM_STR:
-				convert_to_string_ex(&dest);
+				convert_to_string_ex(dest);
 				break;
 			case PDO_PARAM_NULL:
-				convert_to_null_ex(&dest);
+				convert_to_null_ex(dest);
 				break;
 			default:
 				;
@@ -686,8 +678,7 @@ static inline void fetch_value(pdo_stmt_t *stmt, zval *dest, int colno, int *typ
 }
 /* }}} */
 
-static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori,
-	long offset, int do_bind TSRMLS_DC) /* {{{ */
+static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori, long offset, int do_bind TSRMLS_DC) /* {{{ */
 {
 	if (!stmt->executed) {
 		return 0;
@@ -714,25 +705,25 @@ static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori,
 		/* update those bound column variables now */
 		struct pdo_bound_param_data *param;
 
-		zend_hash_internal_pointer_reset(stmt->bound_columns);
-		while (SUCCESS == zend_hash_get_current_data(stmt->bound_columns, (void**)&param)) {
+		ZEND_HASH_FOREACH_PTR(stmt->bound_columns, param) {
 			if (param->paramno >= 0) {
-				convert_to_string(param->parameter);
+				if (!Z_ISREF(param->parameter)) {
+					continue;
+				}
+				// ???? convert_to_string(&param->parameter);
 
 				/* delete old value */
-				zval_dtor(param->parameter);
+				zval_dtor(Z_REFVAL(param->parameter));
 
 				/* set new value */
-				fetch_value(stmt, param->parameter, param->paramno, (int *)&param->param_type TSRMLS_CC);
+				fetch_value(stmt, Z_REFVAL(param->parameter), param->paramno, (int *)&param->param_type TSRMLS_CC);
 
 				/* TODO: some smart thing that avoids duplicating the value in the
 				 * general loop below.  For now, if you're binding output columns,
 				 * it's better to use LAZY or BOUND fetches if you want to shave
 				 * off those cycles */
 			}
-
-			zend_hash_move_forward(stmt->bound_columns);
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	return 1;
@@ -741,9 +732,9 @@ static int do_fetch_common(pdo_stmt_t *stmt, enum pdo_fetch_orientation ori,
 
 static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 {
-	zend_class_entry * ce = stmt->fetch.cls.ce;
-	zend_fcall_info * fci = &stmt->fetch.cls.fci;
-	zend_fcall_info_cache * fcc = &stmt->fetch.cls.fcc;
+	zend_class_entry *ce = stmt->fetch.cls.ce;
+	zend_fcall_info *fci = &stmt->fetch.cls.fci;
+	zend_fcall_info_cache *fcc = &stmt->fetch.cls.fcc;
 
 	fci->size = sizeof(zend_fcall_info);
 
@@ -754,20 +745,21 @@ static int do_fetch_class_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 	
 	if (ce->constructor) {
 		fci->function_table = &ce->function_table;
-		fci->function_name = NULL;
+		ZVAL_UNDEF(&fci->function_name);
 		fci->symbol_table = NULL;
-		fci->retval_ptr_ptr = &stmt->fetch.cls.retval_ptr;
+		fci->retval = &stmt->fetch.cls.retval;
+		fci->param_count = 0;
 		fci->params = NULL;
 		fci->no_separation = 1;
 
-		zend_fcall_info_args(fci, stmt->fetch.cls.ctor_args TSRMLS_CC);
+		zend_fcall_info_args(fci, &stmt->fetch.cls.ctor_args TSRMLS_CC);
 
 		fcc->initialized = 1;
 		fcc->function_handler = ce->constructor;
 		fcc->calling_scope = EG(scope);
 		fcc->called_scope = ce;
 		return 1;
-	} else if (stmt->fetch.cls.ctor_args) {
+	} else if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.ctor_args)) {
 		pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "user-supplied class does not have a constructor, use NULL for the ctor_params parameter, or simply omit it" TSRMLS_CC);
 		return 0;
 	} else {
@@ -795,7 +787,7 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info *
 	}
 	
 	fci->param_count = num_args; /* probably less */
-	fci->params = safe_emalloc(sizeof(zval**), num_args, 0);
+	fci->params = safe_emalloc(sizeof(zval), num_args, 0);
 	
 	return 1;
 }
@@ -803,13 +795,13 @@ static int make_callable_ex(pdo_stmt_t *stmt, zval *callable, zend_fcall_info *
 
 static int do_fetch_func_prepare(pdo_stmt_t *stmt TSRMLS_DC) /* {{{ */
 {
-	zend_fcall_info * fci = &stmt->fetch.cls.fci;
-	zend_fcall_info_cache * fcc = &stmt->fetch.cls.fcc;
+	zend_fcall_info *fci = &stmt->fetch.cls.fci;
+	zend_fcall_info_cache *fcc = &stmt->fetch.cls.fcc;
 
-	if (!make_callable_ex(stmt, stmt->fetch.func.function, fci, fcc, stmt->column_count TSRMLS_CC)) {
+	if (!make_callable_ex(stmt, &stmt->fetch.func.function, fci, fcc, stmt->column_count TSRMLS_CC)) {
 		return 0;
 	} else {
-		stmt->fetch.func.values = safe_emalloc(sizeof(zval*), stmt->column_count, 0);
+		stmt->fetch.func.values = safe_emalloc(sizeof(zval), stmt->column_count, 0);
 		return 1;
 	}
 }
@@ -822,10 +814,11 @@ static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs TSRMLS_DC) /
 		efree(stmt->fetch.cls.fci.params);
 		stmt->fetch.cls.fci.params = NULL;
 	}
+
 	stmt->fetch.cls.fci.size = 0;
-	if (stmt->fetch.cls.ctor_args && free_ctor_agrs) {
+	if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.ctor_args) && free_ctor_agrs) {
 		zval_ptr_dtor(&stmt->fetch.cls.ctor_args);
-		stmt->fetch.cls.ctor_args = NULL;
+		ZVAL_UNDEF(&stmt->fetch.cls.ctor_args);
 		stmt->fetch.cls.fci.param_count = 0;
 	}
 	if (stmt->fetch.func.values) {
@@ -838,12 +831,11 @@ static int do_fetch_opt_finish(pdo_stmt_t *stmt, int free_ctor_agrs TSRMLS_DC) /
 
 /* perform a fetch.  If do_bind is true, update any bound columns.
  * If return_value is not null, store values into it according to HOW. */
-static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
-	enum pdo_fetch_type how, enum pdo_fetch_orientation ori, long offset, zval *return_all TSRMLS_DC) /* {{{ */
+static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value, enum pdo_fetch_type how, enum pdo_fetch_orientation ori, long offset, zval *return_all TSRMLS_DC) /* {{{ */
 {
 	int flags, idx, old_arg_count = 0;
 	zend_class_entry *ce = NULL, *old_ce = NULL;
-	zval grp_val, *grp, **pgrp, *retval, *old_ctor_args = NULL;
+	zval grp_val, *pgrp, retval, old_ctor_args;
 	int colno;
 
 	if (how == PDO_FETCH_USE_DEFAULT) {
@@ -884,9 +876,8 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 			case PDO_FETCH_NUM:
 			case PDO_FETCH_NAMED:
 				if (!return_all) {
-					ALLOC_HASHTABLE(return_value->value.ht);
-					zend_hash_init(return_value->value.ht, stmt->column_count, NULL, ZVAL_PTR_DTOR, 0);
-					Z_TYPE_P(return_value) = IS_ARRAY;
+					ZVAL_NEW_ARR(return_value);
+					zend_hash_init(Z_ARRVAL_P(return_value), stmt->column_count, NULL, ZVAL_PTR_DTOR, 0);;
 				} else {
 					array_init(return_value);
 				}
@@ -928,21 +919,20 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 			case PDO_FETCH_CLASS:
 				if (flags & PDO_FETCH_CLASSTYPE) {
 					zval val;
-					zend_class_entry **cep;
+					zend_class_entry *cep;
 
 					old_ce = stmt->fetch.cls.ce;
-					old_ctor_args = stmt->fetch.cls.ctor_args;
+					ZVAL_COPY_VALUE(&old_ctor_args, &stmt->fetch.cls.ctor_args);
 					old_arg_count = stmt->fetch.cls.fci.param_count;
 					do_fetch_opt_finish(stmt, 0 TSRMLS_CC);
 
-					INIT_PZVAL(&val);
 					fetch_value(stmt, &val, i++, NULL TSRMLS_CC);
 					if (Z_TYPE(val) != IS_NULL) {
 						convert_to_string(&val);
-						if (zend_lookup_class(Z_STRVAL(val), Z_STRLEN(val), &cep TSRMLS_CC) == FAILURE) {
+						if ((cep = zend_lookup_class(Z_STR(val) TSRMLS_CC)) == NULL) {
 							stmt->fetch.cls.ce = ZEND_STANDARD_CLASS_DEF_PTR;
 						} else {
-							stmt->fetch.cls.ce = *cep;
+							stmt->fetch.cls.ce = cep;
 						}
 					}
 
@@ -963,14 +953,15 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 						}
 					}
 					if (ce->constructor && (flags & PDO_FETCH_PROPS_LATE)) {
-						stmt->fetch.cls.fci.object_ptr = return_value;
-						stmt->fetch.cls.fcc.object_ptr = return_value;
+						stmt->fetch.cls.fci.object = Z_OBJ_P(return_value);
+						stmt->fetch.cls.fcc.object = Z_OBJ_P(return_value);
 						if (zend_call_function(&stmt->fetch.cls.fci, &stmt->fetch.cls.fcc TSRMLS_CC) == FAILURE) {
 							pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor" TSRMLS_CC);
 							return 0;
 						} else {
-							if (stmt->fetch.cls.retval_ptr) {
-								zval_ptr_dtor(&stmt->fetch.cls.retval_ptr);
+							if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.retval)) {
+								zval_ptr_dtor(&stmt->fetch.cls.retval);
+								ZVAL_UNDEF(&stmt->fetch.cls.retval);
 							}
 						}
 					}
@@ -978,24 +969,21 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 				break;
 			
 			case PDO_FETCH_INTO:
-				if (!stmt->fetch.into) {
+				if (ZVAL_IS_UNDEF(&stmt->fetch.into)) {
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch-into object specified." TSRMLS_CC);
 					return 0;
 					break;
 				}
 
-				Z_TYPE_P(return_value) = IS_OBJECT;
-				Z_OBJ_HANDLE_P(return_value) = Z_OBJ_HANDLE_P(stmt->fetch.into);
-				Z_OBJ_HT_P(return_value) = Z_OBJ_HT_P(stmt->fetch.into);
-				zend_objects_store_add_ref(stmt->fetch.into TSRMLS_CC);
+				ZVAL_COPY(return_value, &stmt->fetch.into);
 
-				if (zend_get_class_entry(return_value TSRMLS_CC) == ZEND_STANDARD_CLASS_DEF_PTR) {
+				if (zend_get_class_entry(Z_OBJ_P(return_value) TSRMLS_CC) == ZEND_STANDARD_CLASS_DEF_PTR) {
 					how = PDO_FETCH_OBJ;
 				}
 				break;
 
 			case PDO_FETCH_FUNC:
-				if (!stmt->fetch.func.function) {
+				if (ZVAL_IS_UNDEF(&stmt->fetch.func.function)) {
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "No fetch function specified" TSRMLS_CC);
 					return 0;
 				}
@@ -1014,7 +1002,8 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 		}
 		
 		if (return_all && how != PDO_FETCH_KEY_PAIR) {
-			INIT_PZVAL(&grp_val);
+			//???
+			//ZVAL_NULL(&grp_val);
 			if (flags == PDO_FETCH_GROUP && how == PDO_FETCH_COLUMN && stmt->fetch.column > 0) {
 				fetch_value(stmt, &grp_val, colno, NULL TSRMLS_CC);
 			} else {
@@ -1029,26 +1018,24 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 		}
 
 		for (idx = 0; i < stmt->column_count; i++, idx++) {
-			zval *val;
-			MAKE_STD_ZVAL(val);
-			fetch_value(stmt, val, i, NULL TSRMLS_CC);
+			zval val;
+			fetch_value(stmt, &val, i, NULL TSRMLS_CC);
 
 			switch (how) {
 				case PDO_FETCH_ASSOC:
-					add_assoc_zval(return_value, stmt->columns[i].name, val);
+					add_assoc_zval(return_value, stmt->columns[i].name, &val);
 					break;
 					
 				case PDO_FETCH_KEY_PAIR:
 					{
-						zval *tmp;
-						MAKE_STD_ZVAL(tmp);
-						fetch_value(stmt, tmp, ++i, NULL TSRMLS_CC);
+						zval tmp;
+						fetch_value(stmt, &tmp, ++i, NULL TSRMLS_CC);
 
-						if (Z_TYPE_P(val) == IS_LONG) {
-							zend_hash_index_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_LVAL_P(val), &tmp, sizeof(zval *), NULL);
+						if (Z_TYPE(val) == IS_LONG) {
+							zend_hash_index_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_LVAL(val), &tmp);
 						} else {
-							convert_to_string(val);
-							zend_symtable_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_STRVAL_P(val), Z_STRLEN_P(val) + 1, &tmp, sizeof(zval *), NULL);
+							convert_to_string(&val);
+							zend_symtable_update((return_all ? Z_ARRVAL_P(return_all) : Z_ARRVAL_P(return_value)), Z_STR(val), &tmp);
 						}
 						zval_ptr_dtor(&val);
 						return 1;
@@ -1057,20 +1044,21 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 
 				case PDO_FETCH_USE_DEFAULT:
 				case PDO_FETCH_BOTH:
-					add_assoc_zval(return_value, stmt->columns[i].name, val);
-					Z_ADDREF_P(val);
-					add_next_index_zval(return_value, val);
+					add_assoc_zval(return_value, stmt->columns[i].name, &val);
+					if (Z_REFCOUNTED(val)) {
+						Z_ADDREF(val);
+					}
+					add_next_index_zval(return_value, &val);
 					break;
 
 				case PDO_FETCH_NAMED:
 					/* already have an item with this name? */
 					{
-						zval **curr_val = NULL;
-						if (zend_hash_find(Z_ARRVAL_P(return_value), stmt->columns[i].name,
-									strlen(stmt->columns[i].name)+1,
-									(void**)&curr_val) == SUCCESS) {
-							zval *arr;
-							if (Z_TYPE_PP(curr_val) != IS_ARRAY) {
+						zval *curr_val;
+						if ((curr_val = zend_hash_str_find(Z_ARRVAL_P(return_value), stmt->columns[i].name,
+									strlen(stmt->columns[i].name)))) {
+							zval arr;
+							if (Z_TYPE_P(curr_val) != IS_ARRAY) {
 								/* a little bit of black magic here:
 								 * we're creating a new array and swapping it for the
 								 * zval that's already stored in the hash under the name
@@ -1080,34 +1068,33 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 								 *   $hash[$name] = array($hash[$name]);
 								 * }
 								 * */
-								zval *cur;
+								zval cur;
 
-								MAKE_STD_ZVAL(arr);
-								array_init(arr);
+								array_init(&arr);
 
-								cur = *curr_val;
-								*curr_val = arr;
+								ZVAL_COPY_VALUE(&cur, curr_val);
+								ZVAL_COPY_VALUE(curr_val, &arr);
 
-								add_next_index_zval(arr, cur);
+								add_next_index_zval(&arr, &cur);
 							} else {
-								arr = *curr_val;
+								ZVAL_COPY_VALUE(&arr, curr_val);
 							}
-							add_next_index_zval(arr, val);
+							add_next_index_zval(&arr, &val);
 						} else {
-							add_assoc_zval(return_value, stmt->columns[i].name, val);
+							add_assoc_zval(return_value, stmt->columns[i].name, &val);
 						}
 					}
 					break;
 
 				case PDO_FETCH_NUM:
-					add_next_index_zval(return_value, val);
+					add_next_index_zval(return_value, &val);
 					break;
 
 				case PDO_FETCH_OBJ:
 				case PDO_FETCH_INTO:
 					zend_update_property(NULL, return_value,
 						stmt->columns[i].name, stmt->columns[i].namelen,
-						val TSRMLS_CC);
+						&val TSRMLS_CC);
 					zval_ptr_dtor(&val);
 					break;
 
@@ -1115,14 +1102,14 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 					if ((flags & PDO_FETCH_SERIALIZE) == 0 || idx) {
 						zend_update_property(ce, return_value,
 							stmt->columns[i].name, stmt->columns[i].namelen,
-							val TSRMLS_CC);
+							&val TSRMLS_CC);
 						zval_ptr_dtor(&val);
 					} else {
 #ifdef MBO_0
 						php_unserialize_data_t var_hash;
 
 						PHP_VAR_UNSERIALIZE_INIT(var_hash);
-						if (php_var_unserialize(&return_value, (const unsigned char**)&Z_STRVAL_P(val), Z_STRVAL_P(val)+Z_STRLEN_P(val), NULL TSRMLS_CC) == FAILURE) {
+						if (php_var_unserialize(return_value, (const unsigned char**)&Z_STRVAL(val), Z_STRVAL(val)+Z_STRLEN(val), NULL TSRMLS_CC) == FAILURE) {
 							pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize data" TSRMLS_CC);
 							PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
 							return 0;
@@ -1134,7 +1121,7 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 							zval_ptr_dtor(&val);
 							pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize class" TSRMLS_CC);
 							return 0;
-						} else if (ce->unserialize(&return_value, ce, (unsigned char *)(Z_TYPE_P(val) == IS_STRING ? Z_STRVAL_P(val) : ""), Z_TYPE_P(val) == IS_STRING ? Z_STRLEN_P(val) : 0, NULL TSRMLS_CC) == FAILURE) {
+						} else if (ce->unserialize(return_value, ce, (unsigned char *)(Z_TYPE(val) == IS_STRING ? Z_STRVAL(val) : ""), Z_TYPE(val) == IS_STRING ? Z_STRLEN(val) : 0, NULL TSRMLS_CC) == FAILURE) {
 							zval_ptr_dtor(&val);
 							pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "cannot unserialize class" TSRMLS_CC);
 							zval_dtor(return_value);
@@ -1148,8 +1135,8 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 					break;
 				
 				case PDO_FETCH_FUNC:
-					stmt->fetch.func.values[idx] = val;
-					stmt->fetch.cls.fci.params[idx] = &stmt->fetch.func.values[idx];
+					ZVAL_COPY_VALUE(&stmt->fetch.func.values[idx], &val);
+					ZVAL_COPY_VALUE(&stmt->fetch.cls.fci.params[idx], &stmt->fetch.func.values[idx]);
 					break;
 				
 				default:
@@ -1163,41 +1150,40 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 		switch (how) {
 			case PDO_FETCH_CLASS:
 				if (ce->constructor && !(flags & (PDO_FETCH_PROPS_LATE | PDO_FETCH_SERIALIZE))) {
-					stmt->fetch.cls.fci.object_ptr = return_value;
-					stmt->fetch.cls.fcc.object_ptr = return_value;
+					stmt->fetch.cls.fci.object = Z_OBJ_P(return_value);
+					stmt->fetch.cls.fcc.object = Z_OBJ_P(return_value);
 					if (zend_call_function(&stmt->fetch.cls.fci, &stmt->fetch.cls.fcc TSRMLS_CC) == FAILURE) {
 						pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call class constructor" TSRMLS_CC);
 						return 0;
 					} else {
-						if (stmt->fetch.cls.retval_ptr) {
-							zval_ptr_dtor(&stmt->fetch.cls.retval_ptr);
+						if (!ZVAL_IS_UNDEF(&stmt->fetch.cls.retval)) {
+							zval_ptr_dtor(&stmt->fetch.cls.retval);
 						}
 					}
 				}
 				if (flags & PDO_FETCH_CLASSTYPE) {
 					do_fetch_opt_finish(stmt, 0 TSRMLS_CC);
 					stmt->fetch.cls.ce = old_ce;
-					stmt->fetch.cls.ctor_args = old_ctor_args;
+					ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, &old_ctor_args);
 					stmt->fetch.cls.fci.param_count = old_arg_count;
 				}
 				break;
 
 			case PDO_FETCH_FUNC:
 				stmt->fetch.func.fci.param_count = idx;
-				stmt->fetch.func.fci.retval_ptr_ptr = &retval;
+				stmt->fetch.func.fci.retval = &retval;
 				if (zend_call_function(&stmt->fetch.func.fci, &stmt->fetch.func.fcc TSRMLS_CC) == FAILURE) {
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not call user-supplied function" TSRMLS_CC);
 					return 0;
 				} else {
 					if (return_all) {
-						zval_ptr_dtor(&return_value); /* we don't need that */
-						return_value = retval;
-					} else if (retval) {
-						MAKE_COPY_ZVAL(&retval, return_value);
-						zval_ptr_dtor(&retval);
+						zval_ptr_dtor(return_value); /* we don't need that */
+						ZVAL_COPY_VALUE(return_value, &retval);
+					} else if (!ZVAL_IS_UNDEF(&retval)) {
+						ZVAL_COPY_VALUE(return_value, &retval);
 					}
 				}
-				while(idx--) {
+				while (idx--) {
 					zval_ptr_dtor(&stmt->fetch.func.values[idx]);
 				}
 				break;
@@ -1210,14 +1196,14 @@ static int do_fetch(pdo_stmt_t *stmt, int do_bind, zval *return_value,
 			if ((flags & PDO_FETCH_UNIQUE) == PDO_FETCH_UNIQUE) {
 				add_assoc_zval(return_all, Z_STRVAL(grp_val), return_value);
 			} else {
-				if (zend_symtable_find(Z_ARRVAL_P(return_all), Z_STRVAL(grp_val), Z_STRLEN(grp_val)+1, (void**)&pgrp) == FAILURE) {
-					MAKE_STD_ZVAL(grp);
-					array_init(grp);
-					add_assoc_zval(return_all, Z_STRVAL(grp_val), grp);
+				zval grp;
+				if ((pgrp = zend_symtable_find(Z_ARRVAL_P(return_all), Z_STR(grp_val))) == NULL) {
+					array_init(&grp);
+					add_assoc_zval(return_all, Z_STRVAL(grp_val), &grp);
 				} else {
-					grp = *pgrp;
+					ZVAL_COPY_VALUE(&grp, pgrp);
 				}
-				add_next_index_zval(grp, return_value);
+				add_next_index_zval(&grp, return_value);
 			}
 			zval_dtor(&grp_val);
 		}
@@ -1252,37 +1238,37 @@ static int pdo_stmt_verify_mode(pdo_stmt_t *stmt, long mode, int fetch_all TSRML
 #endif
 
 	switch(mode) {
-	case PDO_FETCH_FUNC:
-		if (!fetch_all) {
-			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_FUNC is only allowed in PDOStatement::fetchAll()" TSRMLS_CC);
-			return 0;
-		}
-		return 1;
+		case PDO_FETCH_FUNC:
+			if (!fetch_all) {
+				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_FUNC is only allowed in PDOStatement::fetchAll()" TSRMLS_CC);
+				return 0;
+			}
+			return 1;
 
-	case PDO_FETCH_LAZY:
-		if (fetch_all) {
-			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_LAZY can't be used with PDOStatement::fetchAll()" TSRMLS_CC);
-			return 0;
-		}
-		/* fall through */
-	
-	default:
-		if ((flags & PDO_FETCH_SERIALIZE) == PDO_FETCH_SERIALIZE) {
-			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_SERIALIZE can only be used together with PDO::FETCH_CLASS" TSRMLS_CC);
-			return 0;
-		}
-		if ((flags & PDO_FETCH_CLASSTYPE) == PDO_FETCH_CLASSTYPE) {
-			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_CLASSTYPE can only be used together with PDO::FETCH_CLASS" TSRMLS_CC);
-			return 0;
-		}
-		if (mode >= PDO_FETCH__MAX) {
-			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode" TSRMLS_CC);
-			return 0;
-		}
-		/* no break; */
+		case PDO_FETCH_LAZY:
+			if (fetch_all) {
+				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_LAZY can't be used with PDOStatement::fetchAll()" TSRMLS_CC);
+				return 0;
+			}
+			/* fall through */
+		
+		default:
+			if ((flags & PDO_FETCH_SERIALIZE) == PDO_FETCH_SERIALIZE) {
+				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_SERIALIZE can only be used together with PDO::FETCH_CLASS" TSRMLS_CC);
+				return 0;
+			}
+			if ((flags & PDO_FETCH_CLASSTYPE) == PDO_FETCH_CLASSTYPE) {
+				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "PDO::FETCH_CLASSTYPE can only be used together with PDO::FETCH_CLASS" TSRMLS_CC);
+				return 0;
+			}
+			if (mode >= PDO_FETCH__MAX) {
+				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "invalid fetch mode" TSRMLS_CC);
+				return 0;
+			}
+			/* no break; */
 
-	case PDO_FETCH_CLASS:
-		return 1;
+		case PDO_FETCH_CLASS:
+			return 1;
 	}
 }
 /* }}} */
@@ -1294,7 +1280,7 @@ static PHP_METHOD(PDOStatement, fetch)
 	long how = PDO_FETCH_USE_DEFAULT;
 	long ori = PDO_FETCH_ORI_NEXT;
 	long off = 0;
-        PHP_STMT_GET_OBJ;
+    PHP_STMT_GET_OBJ;
 
 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|lll", &how,
 			&ori, &off)) {
@@ -1321,15 +1307,14 @@ static PHP_METHOD(PDOStatement, fetchObject)
 	long how = PDO_FETCH_CLASS;
 	long ori = PDO_FETCH_ORI_NEXT;
 	long off = 0;
-	char *class_name = NULL;
-	int class_name_len;
+	zend_string *class_name = NULL;
 	zend_class_entry *old_ce;
-	zval *old_ctor_args, *ctor_args = NULL;
+	zval old_ctor_args, *ctor_args = NULL;
 	int error = 0, old_arg_count;
 
 	PHP_STMT_GET_OBJ;
 
-	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s!a", &class_name, &class_name_len, &ctor_args)) {
+	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S!a", &class_name, &ctor_args)) {
 		RETURN_FALSE;
 	}
 
@@ -1340,22 +1325,20 @@ static PHP_METHOD(PDOStatement, fetchObject)
 	}
 
 	old_ce = stmt->fetch.cls.ce;
-	old_ctor_args = stmt->fetch.cls.ctor_args;
+	ZVAL_COPY_VALUE(&old_ctor_args, &stmt->fetch.cls.ctor_args);
 	old_arg_count = stmt->fetch.cls.fci.param_count;
 	
 	do_fetch_opt_finish(stmt, 0 TSRMLS_CC);
 
 	if (ctor_args) {
 		if (Z_TYPE_P(ctor_args) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_P(ctor_args))) {
-			ALLOC_ZVAL(stmt->fetch.cls.ctor_args);
-			*stmt->fetch.cls.ctor_args = *ctor_args;
-			zval_copy_ctor(stmt->fetch.cls.ctor_args);
+			ZVAL_DUP(&stmt->fetch.cls.ctor_args, ctor_args);
 		} else {
-			stmt->fetch.cls.ctor_args = NULL;
+			ZVAL_UNDEF(&stmt->fetch.cls.ctor_args);
 		}
 	}
 	if (class_name && !error) {
-		stmt->fetch.cls.ce = zend_fetch_class(class_name, class_name_len, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
+		stmt->fetch.cls.ce = zend_fetch_class(class_name, ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
 
 		if (!stmt->fetch.cls.ce) {
 			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Could not find user-supplied class" TSRMLS_CC);
@@ -1374,7 +1357,7 @@ static PHP_METHOD(PDOStatement, fetchObject)
 	do_fetch_opt_finish(stmt, 1 TSRMLS_CC);
 
 	stmt->fetch.cls.ce = old_ce;
-	stmt->fetch.cls.ctor_args = old_ctor_args;
+	ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, &old_ctor_args);
 	stmt->fetch.cls.fci.param_count = old_arg_count;
 	if (error) {
 		RETURN_FALSE;
@@ -1409,10 +1392,10 @@ static PHP_METHOD(PDOStatement, fetchColumn)
 static PHP_METHOD(PDOStatement, fetchAll)
 {
 	long how = PDO_FETCH_USE_DEFAULT;
-	zval *data, *return_all;
+	zval data, *return_all;
 	zval *arg2;
 	zend_class_entry *old_ce;
-	zval *old_ctor_args, *ctor_args = NULL;
+	zval old_ctor_args, *ctor_args = NULL;
 	int error = 0, flags, old_arg_count;
 	PHP_STMT_GET_OBJ;    	  
 
@@ -1425,7 +1408,7 @@ static PHP_METHOD(PDOStatement, fetchAll)
 	}
 
 	old_ce = stmt->fetch.cls.ce;
-	old_ctor_args = stmt->fetch.cls.ctor_args;
+	ZVAL_COPY_VALUE(&old_ctor_args, &stmt->fetch.cls.ctor_args);
 	old_arg_count = stmt->fetch.cls.fci.param_count;
 
 	do_fetch_opt_finish(stmt, 0 TSRMLS_CC);
@@ -1448,13 +1431,17 @@ static PHP_METHOD(PDOStatement, fetchAll)
 			}
 			/* no break */
 		case 2:
-			stmt->fetch.cls.ctor_args = ctor_args; /* we're not going to free these */
+			if (ctor_args) {
+				ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, ctor_args); /* we're not going to free these */
+			} else {
+				ZVAL_UNDEF(&stmt->fetch.cls.ctor_args);
+			}
 			if (Z_TYPE_P(arg2) != IS_STRING) {
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "Invalid class name (should be a string)" TSRMLS_CC);
 				error = 1;
 				break;
 			} else {
-				stmt->fetch.cls.ce = zend_fetch_class(Z_STRVAL_P(arg2), Z_STRLEN_P(arg2), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
+				stmt->fetch.cls.ce = zend_fetch_class(Z_STR_P(arg2), ZEND_FETCH_CLASS_AUTO TSRMLS_CC);
 				if (!stmt->fetch.cls.ce) {
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "could not find user-specified class" TSRMLS_CC);
 					error = 1;
@@ -1468,19 +1455,19 @@ static PHP_METHOD(PDOStatement, fetchAll)
 		break;
 
 	case PDO_FETCH_FUNC:
-		switch(ZEND_NUM_ARGS()) {
-		case 0:
-		case 1:
-			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "no fetch function specified" TSRMLS_CC);
-			error = 1;
-			break;
-		case 3:
-		case 2:
-			stmt->fetch.func.function = arg2;
-			if (do_fetch_func_prepare(stmt TSRMLS_CC) == 0) {
+		switch (ZEND_NUM_ARGS()) {
+			case 0:
+			case 1:
+				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "no fetch function specified" TSRMLS_CC);
 				error = 1;
-			}
-			break;
+				break;
+			case 3:
+			case 2:
+				ZVAL_COPY_VALUE(&stmt->fetch.func.function, arg2);
+				if (do_fetch_func_prepare(stmt TSRMLS_CC) == 0) {
+					error = 1;
+				}
+				break;
 		}
 		break;
 	
@@ -1516,8 +1503,7 @@ static PHP_METHOD(PDOStatement, fetchAll)
 
 	if (!error)	{
 		PDO_STMT_CLEAR_ERR();
-		MAKE_STD_ZVAL(data);
-		if (	(how & PDO_FETCH_GROUP) || how == PDO_FETCH_KEY_PAIR || 
+		if ((how & PDO_FETCH_GROUP) || how == PDO_FETCH_KEY_PAIR || 
 			(how == PDO_FETCH_USE_DEFAULT && stmt->default_fetch_type == PDO_FETCH_KEY_PAIR)
 		) {
 			array_init(return_value);
@@ -1525,32 +1511,29 @@ static PHP_METHOD(PDOStatement, fetchAll)
 		} else {
 			return_all = 0;
 		}
-		if (!do_fetch(stmt, TRUE, data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC)) {
-			FREE_ZVAL(data);
+		if (!do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC)) {
 			error = 2;
 		}
 	}
 	if (!error) {
 		if ((how & PDO_FETCH_GROUP)) {
 			do {
-				MAKE_STD_ZVAL(data);
-			} while (do_fetch(stmt, TRUE, data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC));
+				//??? MAKE_STD_ZVAL(data);
+			} while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC));
 		} else if (how == PDO_FETCH_KEY_PAIR || (how == PDO_FETCH_USE_DEFAULT && stmt->default_fetch_type == PDO_FETCH_KEY_PAIR)) {
-			while (do_fetch(stmt, TRUE, data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC));
+			while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, return_all TSRMLS_CC));
 		} else {
 			array_init(return_value);
 			do {
-				add_next_index_zval(return_value, data);
-				MAKE_STD_ZVAL(data);
-			} while (do_fetch(stmt, TRUE, data, how | flags, PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC));
+				add_next_index_zval(return_value, &data);
+			} while (do_fetch(stmt, 1, &data, how | flags, PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC));
 		}
-		FREE_ZVAL(data);
 	}
 	
 	do_fetch_opt_finish(stmt, 0 TSRMLS_CC);
 
 	stmt->fetch.cls.ce = old_ce;
-	stmt->fetch.cls.ctor_args = old_ctor_args;
+	ZVAL_COPY_VALUE(&stmt->fetch.cls.ctor_args, &old_ctor_args);
 	stmt->fetch.cls.fci.param_count = old_arg_count;
 	
 	if (error) {
@@ -1571,14 +1554,15 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt,
 {
 	struct pdo_bound_param_data param = {0};
 	long param_type = PDO_PARAM_STR;
+	zval *parameter;
 
 	param.paramno = -1;
 
 	if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
-			"lz|llz!", &param.paramno, &param.parameter, &param_type, &param.max_value_len,
+			"lz|llz!", &param.paramno, &parameter, &param_type, &param.max_value_len,
 			&param.driver_params)) {
-		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|llz!", &param.name,
-				&param.namelen, &param.parameter, &param_type, &param.max_value_len, 
+		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|llz!", &param.name,
+				&parameter, &param_type, &param.max_value_len, 
 				&param.driver_params)) {
 			return 0;
 		}	
@@ -1593,11 +1577,10 @@ static int register_bound_param(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt,
 		return 0;
 	}
 
-	Z_ADDREF_P(param.parameter);
+	ZVAL_COPY(&param.parameter, parameter);
 	if (!really_register_bound_param(&param, stmt, is_param TSRMLS_CC)) {
-		if (param.parameter) {
+		if (!ZVAL_IS_UNDEF(&param.parameter)) {
 			zval_ptr_dtor(&(param.parameter));
-			param.parameter = NULL;
 		}
 		return 0;
 	}
@@ -1610,14 +1593,15 @@ static PHP_METHOD(PDOStatement, bindValue)
 {
 	struct pdo_bound_param_data param = {0};
 	long param_type = PDO_PARAM_STR;
+	zval *parameter;
 	PHP_STMT_GET_OBJ;
 
 	param.paramno = -1;
 	
 	if (FAILURE == zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC,
-			"lz/|l", &param.paramno, &param.parameter, &param_type)) {
-		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", &param.name,
-				&param.namelen, &param.parameter, &param_type)) {
+			"lz/|l", &param.paramno, &parameter, &param_type)) {
+		if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz/|l", &param.name,
+				&parameter, &param_type)) {
 			RETURN_FALSE;
 		}
 	}
@@ -1631,11 +1615,11 @@ static PHP_METHOD(PDOStatement, bindValue)
 		RETURN_FALSE;
 	}
 	
-	Z_ADDREF_P(param.parameter);
+	ZVAL_COPY(&param.parameter, parameter);
 	if (!really_register_bound_param(&param, stmt, TRUE TSRMLS_CC)) {
-		if (param.parameter) {
+		if (!ZVAL_IS_UNDEF(&param.parameter)) {
 			zval_ptr_dtor(&(param.parameter));
-			param.parameter = NULL;
+			ZVAL_UNDEF(&param.parameter);
 		}
 		RETURN_FALSE;
 	}
@@ -1643,7 +1627,6 @@ static PHP_METHOD(PDOStatement, bindValue)
 }
 /* }}} */
 
-
 /* {{{ proto bool PDOStatement::bindParam(mixed $paramno, mixed &$param [, int $type [, int $maxlen [, mixed $driverdata]]])
    bind a parameter to a PHP variable.  $paramno is the 1-based position of the placeholder in the SQL statement (but can be the parameter name for drivers that support named placeholders).  This isn't supported by all drivers.  It should be called prior to execute(). */
 static PHP_METHOD(PDOStatement, bindParam)
@@ -1658,7 +1641,7 @@ static PHP_METHOD(PDOStatement, bindParam)
 static PHP_METHOD(PDOStatement, bindColumn)
 {
 	PHP_STMT_GET_OBJ;
-	RETURN_BOOL(register_bound_param(INTERNAL_FUNCTION_PARAM_PASSTHRU, stmt, FALSE));
+	RETURN_BOOL(register_bound_param(INTERNAL_FUNCTION_PARAM_PASSTHRU, stmt, 0));
 }
 /* }}} */
 
@@ -1686,7 +1669,7 @@ static PHP_METHOD(PDOStatement, errorCode)
 		RETURN_NULL();
 	}
 
-	RETURN_STRING(stmt->error_code, 1);
+	RETURN_STRING(stmt->error_code);
 }
 /* }}} */
 
@@ -1705,7 +1688,7 @@ static PHP_METHOD(PDOStatement, errorInfo)
 	}
 
 	array_init(return_value);
-	add_next_index_string(return_value, stmt->error_code, 1);
+	add_next_index_string(return_value, stmt->error_code);
 
 	if (stmt->dbh->methods->fetch_err) {
 		stmt->dbh->methods->fetch_err(stmt->dbh, stmt, return_value TSRMLS_CC);
@@ -1848,7 +1831,7 @@ static PHP_METHOD(PDOStatement, getColumnMeta)
 
 	/* add stock items */
 	col = &stmt->columns[colno];
-	add_assoc_string(return_value, "name", col->name, 1);
+	add_assoc_string(return_value, "name", col->name);
 	add_assoc_long(return_value, "len", col->maxlen); /* FIXME: unsigned ? */
 	add_assoc_long(return_value, "precision", col->precision);
 	if (col->param_type != PDO_PARAM_ZVAL) {
@@ -1865,17 +1848,17 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
 {
 	long mode = PDO_FETCH_BOTH;
 	int flags = 0, argc = ZEND_NUM_ARGS() - skip;
-	zval ***args;
-	zend_class_entry **cep;
+	zval *args;
+	zend_class_entry *cep;
 	int retval;
 	
 	do_fetch_opt_finish(stmt, 1 TSRMLS_CC);
 
 	switch (stmt->default_fetch_type) {
 		case PDO_FETCH_INTO:
-			if (stmt->fetch.into) {
+			if (!ZVAL_IS_UNDEF(&stmt->fetch.into)) {
 				zval_ptr_dtor(&stmt->fetch.into);
-				stmt->fetch.into = NULL;
+				ZVAL_UNDEF(&stmt->fetch.into);
 			}
 			break;
 		default:
@@ -1888,16 +1871,16 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
 		return SUCCESS;
 	}
 
-	args = safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval*), 0);
+	args = safe_emalloc(ZEND_NUM_ARGS(), sizeof(zval), 0);
 
 	retval = zend_get_parameters_array_ex(ZEND_NUM_ARGS(), args);
 	
 	if (SUCCESS == retval) {
-		if (Z_TYPE_PP(args[skip]) != IS_LONG) {
+		if (Z_TYPE(args[skip]) != IS_LONG) {
 			pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "mode must be an integer" TSRMLS_CC);
 			retval = FAILURE;
 		} else {
-			mode = Z_LVAL_PP(args[skip]);
+			mode = Z_LVAL(args[skip]);
 			flags = mode & PDO_FETCH_FLAGS;
 	
 			retval = pdo_stmt_verify_mode(stmt, mode, 0 TSRMLS_CC);
@@ -1931,10 +1914,10 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
 		case PDO_FETCH_COLUMN:
 			if (argc != 2) {
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the colno argument" TSRMLS_CC);
-			} else	if (Z_TYPE_PP(args[skip+1]) != IS_LONG) {
+			} else	if (Z_TYPE(args[skip+1]) != IS_LONG) {
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "colno must be an integer" TSRMLS_CC);
 			} else {
-				stmt->fetch.column = Z_LVAL_PP(args[skip+1]);
+				stmt->fetch.column = Z_LVAL(args[skip+1]);
 				retval = SUCCESS;
 			}
 			break;
@@ -1953,33 +1936,30 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the classname argument" TSRMLS_CC);
 				} else if (argc > 3) {
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "too many arguments" TSRMLS_CC);
-				} else if (Z_TYPE_PP(args[skip+1]) != IS_STRING) {
+				} else if (Z_TYPE(args[skip+1]) != IS_STRING) {
 					pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "classname must be a string" TSRMLS_CC);
 				} else {
-					retval = zend_lookup_class(Z_STRVAL_PP(args[skip+1]),
-						Z_STRLEN_PP(args[skip+1]), &cep TSRMLS_CC);
-
-					if (SUCCESS == retval && cep && *cep) {
-						stmt->fetch.cls.ce = *cep;
+					cep = zend_lookup_class(Z_STR(args[skip+1]) TSRMLS_CC);
+					if (cep) {
+						retval = SUCCESS;
+						stmt->fetch.cls.ce = cep;
 					}
 				}
 			}
 
 			if (SUCCESS == retval) {
-				stmt->fetch.cls.ctor_args = NULL;
+				ZVAL_UNDEF(&stmt->fetch.cls.ctor_args);
 #ifdef ilia_0 /* we'll only need this when we have persistent statements, if ever */
 				if (stmt->dbh->is_persistent) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP might crash if you don't call $stmt->setFetchMode() to reset to defaults on this persistent statement.  This will be fixed in a later release");
 				}
 #endif
 				if (argc == 3) {
-					if (Z_TYPE_PP(args[skip+2]) != IS_NULL && Z_TYPE_PP(args[skip+2]) != IS_ARRAY) {
+					if (Z_TYPE(args[skip+2]) != IS_NULL && Z_TYPE(args[skip+2]) != IS_ARRAY) {
 						pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "ctor_args must be either NULL or an array" TSRMLS_CC);
 						retval = FAILURE;
-					} else if (Z_TYPE_PP(args[skip+2]) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL_PP(args[skip+2]))) {
-						ALLOC_ZVAL(stmt->fetch.cls.ctor_args);
-						*stmt->fetch.cls.ctor_args = **args[skip+2];
-						zval_copy_ctor(stmt->fetch.cls.ctor_args);
+					} else if (Z_TYPE(args[skip+2]) == IS_ARRAY && zend_hash_num_elements(Z_ARRVAL(args[skip+2]))) {
+						ZVAL_DUP(&stmt->fetch.cls.ctor_args, &args[skip+2]);
 					}
 				}
 
@@ -1993,7 +1973,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
 		case PDO_FETCH_INTO:
 			if (argc != 2) {
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "fetch mode requires the object parameter" TSRMLS_CC);
-			} else if (Z_TYPE_PP(args[skip+1]) != IS_OBJECT) {
+			} else if (Z_TYPE(args[skip+1]) != IS_OBJECT) {
 				pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "object must be an object" TSRMLS_CC);
 			} else {
 				retval = SUCCESS;
@@ -2005,12 +1985,7 @@ int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, in
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "PHP might crash if you don't call $stmt->setFetchMode() to reset to defaults on this persistent statement.  This will be fixed in a later release");
 				}
 #endif	
-				MAKE_STD_ZVAL(stmt->fetch.into);
-
-				Z_TYPE_P(stmt->fetch.into) = IS_OBJECT;
-				Z_OBJ_HANDLE_P(stmt->fetch.into) = Z_OBJ_HANDLE_PP(args[skip+1]);
-				Z_OBJ_HT_P(stmt->fetch.into) = Z_OBJ_HT_PP(args[skip+1]);
-				zend_objects_store_add_ref(stmt->fetch.into TSRMLS_CC);
+				ZVAL_COPY(&stmt->fetch.into, &args[skip+1]);
 			}
 			
 			break;
@@ -2137,7 +2112,6 @@ static PHP_METHOD(PDOStatement, closeCursor)
 static PHP_METHOD(PDOStatement, debugDumpParams)
 {
 	php_stream *out = php_stream_open_wrapper("php://output", "w", 0, NULL);
-	HashPosition pos;
 	struct pdo_bound_param_data *param;
 	PHP_STMT_GET_OBJ;
 
@@ -2153,28 +2127,22 @@ static PHP_METHOD(PDOStatement, debugDumpParams)
 		stmt->bound_params ? zend_hash_num_elements(stmt->bound_params) : 0);
 	
 	if (stmt->bound_params) {
-		zend_hash_internal_pointer_reset_ex(stmt->bound_params, &pos);
-		while (SUCCESS == zend_hash_get_current_data_ex(stmt->bound_params,
-				(void**)&param, &pos)) {
-			char *str;
-			uint len;
-			ulong num;
-			int res;
-
-			res = zend_hash_get_current_key_ex(stmt->bound_params, &str, &len, &num, 0, &pos);
-			if (res == HASH_KEY_IS_LONG) {
+		ulong num;
+		zend_string *key = NULL;
+		ZEND_HASH_FOREACH_KEY_PTR(stmt->bound_params, num, key, param) {
+			if (key) {
+				php_stream_printf(out TSRMLS_CC, "Key: Name: [%d] %.*s\n", key->len, key->len, key->val);
+			} else {
 				php_stream_printf(out TSRMLS_CC, "Key: Position #%ld:\n", num);
-			} else if (res == HASH_KEY_IS_STRING) {
-				php_stream_printf(out TSRMLS_CC, "Key: Name: [%d] %.*s\n", len, len, str);
 			}
 
 			php_stream_printf(out TSRMLS_CC, "paramno=%ld\nname=[%d] \"%.*s\"\nis_param=%d\nparam_type=%d\n",
-				param->paramno, param->namelen, param->namelen, param->name ? param->name : "",
-				param->is_param,
-				param->param_type);
-			
-			zend_hash_move_forward_ex(stmt->bound_params, &pos);
-		}
+					param->paramno, param->name? param->name->len : 0, param->name? param->name->len : 0,
+					param->name ? param->name->val : "",
+					param->is_param,
+					param->param_type);
+
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	php_stream_close(out);
@@ -2223,52 +2191,43 @@ const zend_function_entry pdo_dbstmt_functions[] = {
 };
 
 /* {{{ overloaded handlers for PDOStatement class */
-static void dbstmt_prop_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void dbstmt_prop_write(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
-	pdo_stmt_t * stmt = (pdo_stmt_t *) zend_object_store_get_object(object TSRMLS_CC);
+	pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
 
 	convert_to_string(member);
 
-	if(strcmp(Z_STRVAL_P(member), "queryString") == 0) {
+	if (strcmp(Z_STRVAL_P(member), "queryString") == 0) {
 		pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only" TSRMLS_CC);
 	} else {
-		std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
+		std_object_handlers.write_property(object, member, value, cache_slot TSRMLS_CC);
 	}
 }
 
-static void dbstmt_prop_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
+static void dbstmt_prop_delete(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC)
 {
-	pdo_stmt_t * stmt = (pdo_stmt_t *) zend_object_store_get_object(object TSRMLS_CC);
+	pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
 
 	convert_to_string(member);
 
-	if(strcmp(Z_STRVAL_P(member), "queryString") == 0) {
+	if (strcmp(Z_STRVAL_P(member), "queryString") == 0) {
 		pdo_raise_impl_error(stmt->dbh, stmt, "HY000", "property queryString is read only" TSRMLS_CC);
 	} else {
-		std_object_handlers.unset_property(object, member, key TSRMLS_CC);
+		std_object_handlers.unset_property(object, member, cache_slot TSRMLS_CC);
 	}
 }
 
-static union _zend_function *dbstmt_method_get(
-#if PHP_API_VERSION >= 20041225
-	zval **object_pp,
-#else
-	zval *object,
-#endif
-   	char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
+static union _zend_function *dbstmt_method_get(zend_object **object_pp, zend_string *method_name, const zval *key TSRMLS_DC)
 {
 	zend_function *fbc = NULL;
-	char *lc_method_name;
-#if PHP_API_VERSION >= 20041225
-	zval *object = *object_pp;
-#endif
+	zend_string *lc_method_name;
+	zend_object *object = *object_pp;
 
-	lc_method_name = emalloc(method_len + 1);
-	zend_str_tolower_copy(lc_method_name, method_name, method_len);
+	lc_method_name = STR_ALLOC(method_name->len, 0);
+	zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len);
 
-	if (zend_hash_find(&Z_OBJCE_P(object)->function_table, lc_method_name, 
-			method_len+1, (void**)&fbc) == FAILURE) {
-		pdo_stmt_t *stmt = (pdo_stmt_t*)zend_object_store_get_object(object TSRMLS_CC);
+	if ((fbc = zend_hash_find_ptr(&object->ce->function_table, lc_method_name)) == NULL) {
+		pdo_stmt_t *stmt = php_pdo_stmt_fetch_object(object);
 		/* instance not created by PDO object */
 		if (!stmt->dbh) {
 			goto out;
@@ -2283,16 +2242,14 @@ static union _zend_function *dbstmt_method_get(
 			}
 		}
 
-		if (zend_hash_find(stmt->dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_STMT],
-				lc_method_name, method_len+1, (void**)&fbc) == FAILURE) {
-			fbc = NULL;
+		if ((fbc = zend_hash_find_ptr(stmt->dbh->cls_methods[PDO_DBH_DRIVER_METHOD_KIND_STMT], lc_method_name)) == NULL) {
 			goto out;
 		}
 		/* got it */
 	}
 	
 out:
-	efree(lc_method_name);
+	STR_RELEASE(lc_method_name);
 	return fbc;
 }
 
@@ -2301,29 +2258,20 @@ static int dbstmt_compare(zval *object1, zval *object2 TSRMLS_DC)
 	return -1;
 }
 
-static zend_object_value dbstmt_clone_obj(zval *zobject TSRMLS_DC)
+static zend_object *dbstmt_clone_obj(zval *zobject TSRMLS_DC)
 {
-	zend_object_value retval;
 	pdo_stmt_t *stmt;
 	pdo_stmt_t *old_stmt;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
 
-	stmt = ecalloc(1, sizeof(*stmt));
+	stmt = ecalloc(1, sizeof(pdo_stmt_t) + sizeof(zval) * (Z_OBJCE_P(zobject)->default_properties_count - 1));
 	zend_object_std_init(&stmt->std, Z_OBJCE_P(zobject) TSRMLS_CC);
 	object_properties_init(&stmt->std, Z_OBJCE_P(zobject));
-	stmt->refcount = 1;
 
-	old_stmt = (pdo_stmt_t *)zend_object_store_get_object(zobject TSRMLS_CC);
+	old_stmt = Z_PDO_STMT_P(zobject);
 	
-	retval.handle = zend_objects_store_put(stmt, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_dbstmt_free_storage, (zend_objects_store_clone_t)dbstmt_clone_obj TSRMLS_CC);
-	retval.handlers = Z_OBJ_HT_P(zobject);
-
-	zend_objects_clone_members((zend_object *)stmt, retval, (zend_object *)old_stmt, handle TSRMLS_CC);
+	zend_objects_clone_members(&stmt->std, &old_stmt->std TSRMLS_CC);
 	
-	zend_objects_store_add_ref(&old_stmt->database_object_handle TSRMLS_CC);
-	stmt->database_object_handle = old_stmt->database_object_handle;
-			
-	return retval;
+	return &stmt->std;
 }
 
 zend_object_handlers pdo_dbstmt_object_handlers;
@@ -2341,6 +2289,9 @@ void pdo_stmt_init(TSRMLS_D)
 	zend_declare_property_null(pdo_dbstmt_ce, "queryString", sizeof("queryString")-1, ZEND_ACC_PUBLIC TSRMLS_CC);
 
 	memcpy(&pdo_dbstmt_object_handlers, &std_object_handlers, sizeof(zend_object_handlers));
+	pdo_dbstmt_object_handlers.offset = XtOffsetOf(pdo_stmt_t, std);
+	pdo_dbstmt_object_handlers.dtor_obj = zend_objects_destroy_object;
+	pdo_dbstmt_object_handlers.free_obj = pdo_dbstmt_free_storage;
 	pdo_dbstmt_object_handlers.write_property = dbstmt_prop_write;
 	pdo_dbstmt_object_handlers.unset_property = dbstmt_prop_delete;
 	pdo_dbstmt_object_handlers.get_method = dbstmt_method_get;
@@ -2393,53 +2344,35 @@ static void free_statement(pdo_stmt_t *stmt TSRMLS_DC)
 		stmt->columns = NULL;
 	}
 
-	if (stmt->fetch.into && stmt->default_fetch_type == PDO_FETCH_INTO) {
-		FREE_ZVAL(stmt->fetch.into);
-		stmt->fetch.into = NULL;
+	if (!ZVAL_IS_UNDEF(&stmt->fetch.into) && stmt->default_fetch_type == PDO_FETCH_INTO) {
+		ZVAL_UNDEF(&stmt->fetch.into);
 	}
 	
 	do_fetch_opt_finish(stmt, 1 TSRMLS_CC);
 
-	zend_objects_store_del_ref(&stmt->database_object_handle TSRMLS_CC);
-	if (stmt->dbh) {
-		php_pdo_dbh_delref(stmt->dbh TSRMLS_CC);
+	if (!ZVAL_IS_UNDEF(&stmt->database_object_handle)) {
+		zval_ptr_dtor(&stmt->database_object_handle);
 	}
 	zend_object_std_dtor(&stmt->std TSRMLS_CC);
-	efree(stmt);
 }
 
-PDO_API void php_pdo_stmt_addref(pdo_stmt_t *stmt TSRMLS_DC)
+void pdo_dbstmt_free_storage(zend_object *std TSRMLS_DC)
 {
-	stmt->refcount++;
+	pdo_stmt_t *stmt = php_pdo_stmt_fetch_object(std);
+	free_statement(stmt TSRMLS_CC);
 }
 
-PDO_API void php_pdo_stmt_delref(pdo_stmt_t *stmt TSRMLS_DC)
+zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC)
 {
-	if (--stmt->refcount == 0) {
-		free_statement(stmt TSRMLS_CC);
-	}
-}
-
-void pdo_dbstmt_free_storage(pdo_stmt_t *stmt TSRMLS_DC)
-{
-	php_pdo_stmt_delref(stmt TSRMLS_CC);
-}
-
-zend_object_value pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC)
-{
-	zend_object_value retval;
-
 	pdo_stmt_t *stmt;
-	stmt = emalloc(sizeof(*stmt));
-	memset(stmt, 0, sizeof(*stmt));
+
+	stmt = ecalloc(1, sizeof(pdo_stmt_t) + sizeof(zval) * (ce->default_properties_count - 1));
 	zend_object_std_init(&stmt->std, ce TSRMLS_CC);
 	object_properties_init(&stmt->std, ce);
-	stmt->refcount = 1;
 
-	retval.handle = zend_objects_store_put(stmt, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_dbstmt_free_storage, (zend_objects_store_clone_t)dbstmt_clone_obj TSRMLS_CC);
-	retval.handlers = &pdo_dbstmt_object_handlers;
+	stmt->std.handlers = &pdo_dbstmt_object_handlers;
 
-	return retval;
+	return &stmt->std;
 }
 /* }}} */
 
@@ -2447,49 +2380,43 @@ zend_object_value pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC)
 
 struct php_pdo_iterator {
 	zend_object_iterator iter;
-	pdo_stmt_t *stmt;
 	ulong key;
-	zval *fetch_ahead;
+	zval fetch_ahead;
 };
 
 static void pdo_stmt_iter_dtor(zend_object_iterator *iter TSRMLS_DC)
 {
-	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter->data;
+	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
-	if (--I->stmt->refcount == 0) {
-		free_statement(I->stmt TSRMLS_CC);
-	}
+	zval_ptr_dtor(&I->iter.data);
 		
-	if (I->fetch_ahead) {
+	if (!ZVAL_IS_UNDEF(&I->fetch_ahead)) {
 		zval_ptr_dtor(&I->fetch_ahead);
 	}
-
-	efree(I);
 }
 
 static int pdo_stmt_iter_valid(zend_object_iterator *iter TSRMLS_DC)
 {
-	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter->data;
+	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
-	return I->fetch_ahead ? SUCCESS : FAILURE;
+	return ZVAL_IS_UNDEF(&I->fetch_ahead) ? FAILURE : SUCCESS;
 }
 
-static void pdo_stmt_iter_get_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
+static zval *pdo_stmt_iter_get_data(zend_object_iterator *iter TSRMLS_DC)
 {
-	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter->data;
+	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
 	/* sanity */
-	if (!I->fetch_ahead) {
-		*data = NULL;
-		return;
+	if (ZVAL_IS_UNDEF(&I->fetch_ahead)) {
+		return NULL;
 	}
 
-	*data = &I->fetch_ahead;
+	return &I->fetch_ahead;
 }
 
 static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 {
-	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter->data;
+	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
 
 	if (I->key == (ulong)-1) {
 		ZVAL_NULL(key);
@@ -2500,23 +2427,19 @@ static void pdo_stmt_iter_get_key(zend_object_iterator *iter, zval *key TSRMLS_D
 
 static void pdo_stmt_iter_move_forwards(zend_object_iterator *iter TSRMLS_DC)
 {
-	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter->data;
+	struct php_pdo_iterator *I = (struct php_pdo_iterator*)iter;
+	pdo_stmt_t *stmt = Z_PDO_STMT_P(&I->iter.data); /* for PDO_HANDLE_STMT_ERR() */
 
-	if (I->fetch_ahead) {
+	if (!ZVAL_IS_UNDEF(&I->fetch_ahead)) {
 		zval_ptr_dtor(&I->fetch_ahead);
-		I->fetch_ahead = NULL;
 	}
 
-	MAKE_STD_ZVAL(I->fetch_ahead);
-
-	if (!do_fetch(I->stmt, TRUE, I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
+	if (!do_fetch(stmt, TRUE, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
 			PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)) {
-		pdo_stmt_t *stmt = I->stmt; /* for PDO_HANDLE_STMT_ERR() */
 
 		PDO_HANDLE_STMT_ERR();
 		I->key = (ulong)-1;
-		FREE_ZVAL(I->fetch_ahead);
-		I->fetch_ahead = NULL;
+		ZVAL_UNDEF(&I->fetch_ahead);
 
 		return;
 	}
@@ -2535,26 +2458,23 @@ static zend_object_iterator_funcs pdo_stmt_iter_funcs = {
 
 zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
 {
-	pdo_stmt_t *stmt = (pdo_stmt_t*)zend_object_store_get_object(object TSRMLS_CC);
+	pdo_stmt_t *stmt = Z_PDO_STMT_P(object);
 	struct php_pdo_iterator *I;
 
 	if (by_ref) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
 
-	I = ecalloc(1, sizeof(*I));
+	I = ecalloc(1, sizeof(struct php_pdo_iterator));
+	zend_iterator_init(&I->iter TSRMLS_CC);
 	I->iter.funcs = &pdo_stmt_iter_funcs;
-	I->iter.data = I;
-	I->stmt = stmt;
-	stmt->refcount++;
+	ZVAL_COPY(&I->iter.data, object);
 
-	MAKE_STD_ZVAL(I->fetch_ahead);
-	if (!do_fetch(I->stmt, TRUE, I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
+	if (!do_fetch(stmt, 1, &I->fetch_ahead, PDO_FETCH_USE_DEFAULT,
 			PDO_FETCH_ORI_NEXT, 0, 0 TSRMLS_CC)) {
 		PDO_HANDLE_STMT_ERR();
 		I->key = (ulong)-1;
-		FREE_ZVAL(I->fetch_ahead);
-		I->fetch_ahead = NULL;
+		ZVAL_UNDEF(&I->fetch_ahead);
 	}
 
 	return &I->iter;
@@ -2568,19 +2488,18 @@ const zend_function_entry pdo_row_functions[] = {
 	{NULL, NULL, NULL}
 };
 
-static zval *row_prop_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
+static zval *row_prop_read(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
-	zval *return_value;
-	pdo_stmt_t * stmt = (pdo_stmt_t *) zend_object_store_get_object(object TSRMLS_CC);
+	pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object);
+	pdo_stmt_t *stmt = row->stmt;
 	int colno = -1;
+	zval zobj;
 
-	MAKE_STD_ZVAL(return_value);
-	RETVAL_NULL();
-
+	ZVAL_NULL(rv);
 	if (stmt) {
 		if (Z_TYPE_P(member) == IS_LONG) {
 			if (Z_LVAL_P(member) >= 0 && Z_LVAL_P(member) < stmt->column_count) {
-				fetch_value(stmt, return_value, Z_LVAL_P(member), NULL TSRMLS_CC);
+				fetch_value(stmt, rv, Z_LVAL_P(member), NULL TSRMLS_CC);
 			}
 		} else {
 			convert_to_string(member);
@@ -2588,31 +2507,34 @@ static zval *row_prop_read(zval *object, zval *member, int type, const zend_lite
 			 * numbers */
 			for (colno = 0; colno < stmt->column_count; colno++) {
 				if (strcmp(stmt->columns[colno].name, Z_STRVAL_P(member)) == 0) {
-					fetch_value(stmt, return_value, colno, NULL TSRMLS_CC);
-					Z_SET_REFCOUNT_P(return_value, 0);
-					Z_UNSET_ISREF_P(return_value);
-					return return_value;
+					fetch_value(stmt, rv, colno, NULL TSRMLS_CC);
+					//???
+					//Z_SET_REFCOUNT_P(rv, 0);
+					//Z_UNSET_ISREF_P(rv);
+					return rv;
 				}
 			}
 			if (strcmp(Z_STRVAL_P(member), "queryString") == 0) {
-				zval_ptr_dtor(&return_value);
-				return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
+				ZVAL_OBJ(&zobj, &stmt->std);
+				//zval_ptr_dtor(rv);
+				return std_object_handlers.read_property(&zobj, member, type, cache_slot, rv TSRMLS_CC);
 			}
 		}
 	}
 
-	Z_SET_REFCOUNT_P(return_value, 0);
-	Z_UNSET_ISREF_P(return_value);
+	//???
+	//Z_SET_REFCOUNT_P(return_value, 0);
+	//Z_UNSET_ISREF_P(return_value);
 	
-	return return_value;
+	return rv;
 }
 
-static zval *row_dim_read(zval *object, zval *member, int type TSRMLS_DC)
+static zval *row_dim_read(zval *object, zval *member, int type, zval *rv TSRMLS_DC)
 {
-	return row_prop_read(object, member, type, NULL TSRMLS_CC);
+	return row_prop_read(object, member, type, -1, rv TSRMLS_CC);
 }
 
-static void row_prop_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void row_prop_write(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
 	php_error_docref(NULL TSRMLS_CC, E_WARNING, "This PDORow is not from a writable result set");
 }
@@ -2622,9 +2544,10 @@ static void row_dim_write(zval *object, zval *member, zval *value TSRMLS_DC)
 	php_error_docref(NULL TSRMLS_CC, E_WARNING, "This PDORow is not from a writable result set");
 }
 
-static int row_prop_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
+static int row_prop_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)
 {
-	pdo_stmt_t * stmt = (pdo_stmt_t *) zend_object_store_get_object(object TSRMLS_CC);
+	pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object);
+	pdo_stmt_t *stmt = row->stmt;
 	int colno = -1;
 
 	if (stmt) {
@@ -2648,10 +2571,10 @@ static int row_prop_exists(zval *object, zval *member, int check_empty, const ze
 
 static int row_dim_exists(zval *object, zval *member, int check_empty TSRMLS_DC)
 {
-	return row_prop_exists(object, member, check_empty, NULL TSRMLS_CC);
+	return row_prop_exists(object, member, check_empty, -1 TSRMLS_CC);
 }
 
-static void row_prop_delete(zval *object, zval *offset, const zend_literal *key TSRMLS_DC)
+static void row_prop_delete(zval *object, zval *offset, zend_uint cache_slot TSRMLS_DC)
 {
 	php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot delete properties from a PDORow");
 }
@@ -2663,7 +2586,8 @@ static void row_dim_delete(zval *object, zval *offset TSRMLS_DC)
 
 static HashTable *row_get_properties(zval *object TSRMLS_DC)
 {
-	pdo_stmt_t * stmt = (pdo_stmt_t *) zend_object_store_get_object(object TSRMLS_CC);
+	pdo_row_t *row = (pdo_row_t *)Z_OBJ_P(object);
+	pdo_stmt_t *stmt = row->stmt;
 	int i;
 
 	if (stmt == NULL) {
@@ -2674,50 +2598,45 @@ static HashTable *row_get_properties(zval *object TSRMLS_DC)
 		rebuild_object_properties(&stmt->std);
 	}
 	for (i = 0; i < stmt->column_count; i++) {
-		zval *val;
-		MAKE_STD_ZVAL(val);
-		fetch_value(stmt, val, i, NULL TSRMLS_CC);
+		zval val;
+		fetch_value(stmt, &val, i, NULL TSRMLS_CC);
 
-		zend_hash_update(stmt->std.properties, stmt->columns[i].name, stmt->columns[i].namelen + 1, (void *)&val, sizeof(zval *), NULL);
+		zend_hash_str_update(stmt->std.properties, stmt->columns[i].name, stmt->columns[i].namelen, &val);
 	}
 
 	return stmt->std.properties;
 }
 
 static union _zend_function *row_method_get(
-#if PHP_API_VERSION >= 20041225
-	zval **object_pp,
-#else
-	zval *object,
-#endif
-	char *method_name, int method_len, const zend_literal *key TSRMLS_DC)
+	zend_object **object_pp,
+	zend_string *method_name, const zval *key TSRMLS_DC)
 {
 	zend_function *fbc;
-	char *lc_method_name;
+	zend_string *lc_method_name;
 
-	lc_method_name = emalloc(method_len + 1);
-	zend_str_tolower_copy(lc_method_name, method_name, method_len);
+	lc_method_name = STR_ALLOC(method_name->len, 0);
+	zend_str_tolower_copy(lc_method_name->val, method_name->val, method_name->len);
 
-	if (zend_hash_find(&pdo_row_ce->function_table, lc_method_name, method_len+1, (void**)&fbc) == FAILURE) {
-		efree(lc_method_name);
+	if ((fbc = zend_hash_find_ptr(&pdo_row_ce->function_table, lc_method_name)) == NULL) {
+		STR_RELEASE(lc_method_name);
 		return NULL;
 	}
 	
-	efree(lc_method_name);
+	STR_RELEASE(lc_method_name);
 	return fbc;
 }
 
-static int row_call_method(const char *method, INTERNAL_FUNCTION_PARAMETERS)
+static int row_call_method(zend_string *method, zend_object *object, INTERNAL_FUNCTION_PARAMETERS)
 {
 	return FAILURE;
 }
 
-static union _zend_function *row_get_ctor(zval *object TSRMLS_DC)
+static union _zend_function *row_get_ctor(zend_object *object TSRMLS_DC)
 {
 	static zend_internal_function ctor = {0};
 
 	ctor.type = ZEND_INTERNAL_FUNCTION;
-	ctor.function_name = "__construct";
+	ctor.function_name = STR_INIT("__construct", sizeof("__construct") - 1, 0);
 	ctor.scope = pdo_row_ce;
 	ctor.handler = ZEND_FN(dbstmt_constructor);
 	ctor.fn_flags = ZEND_ACC_PUBLIC;
@@ -2725,19 +2644,17 @@ static union _zend_function *row_get_ctor(zval *object TSRMLS_DC)
 	return (union _zend_function*)&ctor;
 }
 
-static zend_class_entry *row_get_ce(const zval *object TSRMLS_DC)
+static zend_class_entry *row_get_ce(const zend_object *object TSRMLS_DC)
 {
 	return pdo_row_ce;
 }
 
-static int row_get_classname(const zval *object, const char **class_name, zend_uint *class_name_len, int parent TSRMLS_DC)
+static zend_string *row_get_classname(const zend_object *object, int parent TSRMLS_DC)
 {
 	if (parent) {
-		return FAILURE;
+		return NULL;
 	} else {
-		*class_name = estrndup("PDORow", sizeof("PDORow")-1);
-		*class_name_len = sizeof("PDORow")-1;
-		return SUCCESS;
+		return STR_INIT("PDORow", sizeof("PDORow") - 1, 0);
 	}
 }
 
@@ -2747,8 +2664,9 @@ static int row_compare(zval *object1, zval *object2 TSRMLS_DC)
 }
 
 zend_object_handlers pdo_row_object_handlers = {
-	zend_objects_store_add_ref,
-	zend_objects_store_del_ref,
+	0, 
+	zend_objects_destroy_object,	
+	pdo_row_free_storage,
 	NULL,
 	row_prop_read,
 	row_prop_write,
@@ -2772,25 +2690,22 @@ zend_object_handlers pdo_row_object_handlers = {
 	NULL
 };
 
-void pdo_row_free_storage(pdo_stmt_t *stmt TSRMLS_DC)
+void pdo_row_free_storage(zend_object *std TSRMLS_DC)
 {
-	if (stmt) {
-		ZVAL_NULL(&stmt->lazy_object_ref);
-		
-		if (--stmt->refcount == 0) {
-			free_statement(stmt TSRMLS_CC);
-		}
+	pdo_row_t *row = (pdo_row_t *)std;
+	if (row->stmt) {
+		ZVAL_UNDEF(&row->stmt->lazy_object_ref);
+		OBJ_RELEASE(&row->stmt->std);
 	}
 }
 
-zend_object_value pdo_row_new(zend_class_entry *ce TSRMLS_DC)
+zend_object *pdo_row_new(zend_class_entry *ce TSRMLS_DC)
 {
-	zend_object_value retval;
-
-	retval.handle = zend_objects_store_put(NULL, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t)pdo_row_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &pdo_row_object_handlers;
+	pdo_row_t *row = ecalloc(1, sizeof(pdo_row_t));
+	zend_object_std_init(&row->std, ce TSRMLS_CC);
+	row->std.handlers = &pdo_row_object_handlers;
 
-	return retval;
+	return &row->std;
 }
 
 static int pdo_row_serialize(zval *object, unsigned char **buffer, zend_uint *buf_len, zend_serialize_data *data TSRMLS_DC)
diff --git a/ext/pdo/php_pdo_driver.h b/ext/pdo/php_pdo_driver.h
index 56a69cac30..6a0faaa121 100644
--- a/ext/pdo/php_pdo_driver.h
+++ b/ext/pdo/php_pdo_driver.h
@@ -26,6 +26,7 @@
 /* forward declarations */
 typedef struct _pdo_dbh_t 	pdo_dbh_t;
 typedef struct _pdo_stmt_t	pdo_stmt_t;
+typedef struct _pdo_row_t	pdo_row_t;
 struct pdo_bound_param_data;
 
 #ifdef PHP_WIN32
@@ -194,21 +195,21 @@ enum pdo_null_handling {
 /* {{{ utils for reading attributes set as driver_options */
 static inline long pdo_attr_lval(zval *options, enum pdo_attribute_type option_name, long defval TSRMLS_DC)
 {
-	zval **v;
+	zval *v;
 
-	if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) {
+	if (options && (v = zend_hash_index_find(Z_ARRVAL_P(options), option_name))) {
 		convert_to_long_ex(v);
-		return Z_LVAL_PP(v);
+		return Z_LVAL_P(v);
 	}
 	return defval;
 }
 static inline char *pdo_attr_strval(zval *options, enum pdo_attribute_type option_name, char *defval TSRMLS_DC)
 {
-	zval **v;
+	zval *v;
 
-	if (options && SUCCESS == zend_hash_index_find(Z_ARRVAL_P(options), option_name, (void**)&v)) {
+	if (options && (v = zend_hash_index_find(Z_ARRVAL_P(options), option_name))) {
 		convert_to_string_ex(v);
-		return estrndup(Z_STRVAL_PP(v), Z_STRLEN_PP(v));
+		return estrndup(Z_STRVAL_P(v), Z_STRLEN_P(v));
 	}
 	return defval ? estrdup(defval) : NULL;
 }
@@ -426,13 +427,6 @@ enum pdo_placeholder_support {
 
 /* represents a connection to a database */
 struct _pdo_dbh_t {
-	/* these items must appear in this order at the beginning of the
-       struct so that this can be cast as a zend_object.  we need this
-       to allow the extending class to escape all the custom handlers
-	   that PDO declares.
-    */
-	zend_object std;
-
 	/* driver specific methods */
 	struct pdo_dbh_methods *methods;
 	/* driver specific data */
@@ -496,7 +490,7 @@ struct _pdo_dbh_t {
 	
 	zend_class_entry *def_stmt_ce;
 
-	zval *def_stmt_ctor_args;
+	zval def_stmt_ctor_args;
 
 	/* when calling PDO::query(), we need to keep the error
 	 * context from the statement around until we next clear it.
@@ -507,8 +501,21 @@ struct _pdo_dbh_t {
 
 	/* defaults for fetches */
 	enum pdo_fetch_type default_fetch_type;
+
+	/* these items must appear in this order at the beginning of the
+       struct so that this can be cast as a zend_object.  we need this
+       to allow the extending class to escape all the custom handlers
+	   that PDO declares.
+    */
+	zend_object std;
 };
 
+static inline pdo_dbh_t *php_pdo_dbh_fetch_object(zend_object *obj) {
+	return (pdo_dbh_t *)((char*)(obj) - XtOffsetOf(pdo_dbh_t, std));
+}
+
+#define Z_PDO_DBH_P(zv) php_pdo_dbh_fetch_object(Z_OBJ_P((zv)))
+
 /* describes a column */
 struct pdo_column_data {
 	char *name;
@@ -524,15 +531,14 @@ struct pdo_column_data {
 /* describes a bound parameter */
 struct pdo_bound_param_data {
 	long paramno; /* if -1, then it has a name, and we don't know the index *yet* */
-	char *name;
-	int namelen;
+	zend_string *name;
 
 	long max_value_len;	/* as a hint for pre-allocation */
 	
-	zval *parameter;				/* the variable itself */
+	zval parameter;				/* the variable itself */
 	enum pdo_param_type param_type; /* desired or suggested type */
 
-	zval *driver_params;			/* optional parameter(s) for the driver */
+	zval driver_params;			/* optional parameter(s) for the driver */
 	void *driver_data;
 
 	pdo_stmt_t *stmt;	/* for convenience in dtor */
@@ -541,13 +547,6 @@ struct pdo_bound_param_data {
 
 /* represents a prepared statement */
 struct _pdo_stmt_t {
-	/* these items must appear in this order at the beginning of the
-       struct so that this can be cast as a zend_object.  we need this
-       to allow the extending class to escape all the custom handlers
-	   that PDO declares.
-    */
-	zend_object std;
-
 	/* driver specifics */
 	struct pdo_stmt_methods *methods;
 	void *driver_data;
@@ -607,25 +606,44 @@ struct _pdo_stmt_t {
 		int column;
 		struct {
 			zend_class_entry *ce;	
-			zval *ctor_args;            /* freed */
-			zval *retval_ptr; 
+			void *_reserved;
+			zval ctor_args;            /* freed */
+			zval retval; 
 			zend_fcall_info fci;
 			zend_fcall_info_cache fcc;
 		} cls;
 		struct {
-			zval *function;
-			zval *fetch_args;           /* freed */
-			zval *object;
+			zval function;
+			zval fetch_args;           /* freed */
+			zval object;
 			zend_fcall_info fci;
 			zend_fcall_info_cache fcc;
-			zval **values;              /* freed */
+			zval *values;              /* freed */
 		} func;
-		zval *into;
+		zval into;
 	} fetch;
 
 	/* used by the query parser for driver specific
 	 * parameter naming (see pgsql driver for example) */
 	const char *named_rewrite_template;
+
+	/* these items must appear in this order at the beginning of the
+       struct so that this can be cast as a zend_object.  we need this
+       to allow the extending class to escape all the custom handlers
+	   that PDO declares.
+    */
+	zend_object std;
+};
+
+static inline pdo_stmt_t *php_pdo_stmt_fetch_object(zend_object *obj) {
+	return (pdo_stmt_t *)((char*)(obj) - XtOffsetOf(pdo_stmt_t, std));
+}
+
+#define Z_PDO_STMT_P(zv) php_pdo_stmt_fetch_object(Z_OBJ_P((zv)))
+
+struct _pdo_row_t {
+	zend_object std;
+	pdo_stmt_t *stmt;
 };
 
 /* call this in MINIT to register your PDO driver */
diff --git a/ext/pdo/php_pdo_error.h b/ext/pdo/php_pdo_error.h
index 74fe0ad0fe..60bb89a8f8 100644
--- a/ext/pdo/php_pdo_error.h
+++ b/ext/pdo/php_pdo_error.h
@@ -29,7 +29,7 @@ PDO_API void pdo_handle_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt TSRMLS_DC);
 	strlcpy(dbh->error_code, PDO_ERR_NONE, sizeof(PDO_ERR_NONE)); \
 	if (dbh->query_stmt) { \
 		dbh->query_stmt = NULL; \
-		zend_objects_store_del_ref(&dbh->query_stmt_zval TSRMLS_CC); \
+		zval_ptr_dtor(&dbh->query_stmt_zval); \
 	} \
 } while (0)
 #define PDO_STMT_CLEAR_ERR()    strcpy(stmt->error_code, PDO_ERR_NONE)
diff --git a/ext/pdo/php_pdo_int.h b/ext/pdo/php_pdo_int.h
index e1868644a3..a428a74a3a 100644
--- a/ext/pdo/php_pdo_int.h
+++ b/ext/pdo/php_pdo_int.h
@@ -33,24 +33,24 @@ int php_pdo_list_entry(void);
 void pdo_dbh_init(TSRMLS_D);
 void pdo_stmt_init(TSRMLS_D);
 
-extern zend_object_value pdo_dbh_new(zend_class_entry *ce TSRMLS_DC);
+extern zend_object *pdo_dbh_new(zend_class_entry *ce TSRMLS_DC);
 extern const zend_function_entry pdo_dbh_functions[];
 extern zend_class_entry *pdo_dbh_ce;
 extern ZEND_RSRC_DTOR_FUNC(php_pdo_pdbh_dtor);
 
-extern zend_object_value pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC);
+extern zend_object *pdo_dbstmt_new(zend_class_entry *ce TSRMLS_DC);
 extern const zend_function_entry pdo_dbstmt_functions[];
 extern zend_class_entry *pdo_dbstmt_ce;
-void pdo_dbstmt_free_storage(pdo_stmt_t *stmt TSRMLS_DC);
+void pdo_dbstmt_free_storage(zend_object *std TSRMLS_DC);
 zend_object_iterator *pdo_stmt_iter_get(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 extern zend_object_handlers pdo_dbstmt_object_handlers;
 int pdo_stmt_describe_columns(pdo_stmt_t *stmt TSRMLS_DC);
 int pdo_stmt_setup_fetch_mode(INTERNAL_FUNCTION_PARAMETERS, pdo_stmt_t *stmt, int skip_first_arg);
 
-extern zend_object_value pdo_row_new(zend_class_entry *ce TSRMLS_DC);
+extern zend_object *pdo_row_new(zend_class_entry *ce TSRMLS_DC);
 extern const zend_function_entry pdo_row_functions[];
 extern zend_class_entry *pdo_row_ce;
-void pdo_row_free_storage(pdo_stmt_t *stmt TSRMLS_DC);
+void pdo_row_free_storage(zend_object *std TSRMLS_DC);
 extern zend_object_handlers pdo_row_object_handlers;
 
 zend_object_iterator *php_pdo_dbstmt_iter_get(zend_class_entry *ce, zval *object TSRMLS_DC);
diff --git a/ext/pdo/tests/pdo_014.phpt b/ext/pdo/tests/pdo_014.phpt
index 794fdae7db..7b93fb83a8 100644
--- a/ext/pdo/tests/pdo_014.phpt
+++ b/ext/pdo/tests/pdo_014.phpt
@@ -71,14 +71,14 @@ foreach($stmt as $data)
 ?>
 --EXPECTF--
 Test::__construct(WOW)
-object(Test)#4 (2) {
+object(Test)#%d (2) {
   ["val"]=>
   string(1) "A"
   ["grp"]=>
   string(6) "Group1"
 }
 Test::__construct(WOW)
-object(Test)#6 (2) {
+object(Test)#%d (2) {
   ["val"]=>
   string(1) "B"
   ["grp"]=>
diff --git a/ext/pdo_dblib/dblib_driver.c b/ext/pdo_dblib/dblib_driver.c
index 0fa68900b0..350a3c670d 100644
--- a/ext/pdo_dblib/dblib_driver.c
+++ b/ext/pdo_dblib/dblib_driver.c
@@ -61,11 +61,13 @@ static int dblib_fetch_error(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info TSRMLS
 		msg, einfo->dberr, einfo->severity, stmt ? stmt->active_query_string : "");
 
 	add_next_index_long(info, einfo->dberr);
-	add_next_index_string(info, message, 0);
+	// TODO: avoid reallocation ???
+	add_next_index_string(info, message);
+	efree(message);
 	add_next_index_long(info, einfo->oserr);
 	add_next_index_long(info, einfo->severity);
 	if (einfo->oserrstr) {
-		add_next_index_string(info, einfo->oserrstr, 1);
+		add_next_index_string(info, einfo->oserrstr);
 	}
 
 	return 1;
diff --git a/ext/pdo_dblib/dblib_stmt.c b/ext/pdo_dblib/dblib_stmt.c
index 18e9e679cc..c13d58bd57 100644
--- a/ext/pdo_dblib/dblib_stmt.c
+++ b/ext/pdo_dblib/dblib_stmt.c
@@ -306,8 +306,8 @@ static int pdo_dblib_stmt_get_column_meta(pdo_stmt_t *stmt, long colno, zval *re
 	add_assoc_long(return_value, "max_length", dbcollen(H->link, colno+1) );
 	add_assoc_long(return_value, "precision", (int) dbtypeinfo->precision );
 	add_assoc_long(return_value, "scale", (int) dbtypeinfo->scale );
-	add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1), 1);
-	add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(dbcoltype(H->link, colno+1)), 1);
+	add_assoc_string(return_value, "column_source", dbcolsource(H->link, colno+1));
+	add_assoc_string(return_value, "native_type", pdo_dblib_get_field_name(dbcoltype(H->link, colno+1)));
 	add_assoc_long(return_value, "native_type_id", dbcoltype(H->link, colno+1));
 	add_assoc_long(return_value, "native_usertype_id", dbcolutype(H->link, colno+1));
 
diff --git a/ext/pdo_firebird/firebird_driver.c b/ext/pdo_firebird/firebird_driver.c
index 2053a07005..aa6634058a 100644
--- a/ext/pdo_firebird/firebird_driver.c
+++ b/ext/pdo_firebird/firebird_driver.c
@@ -616,10 +616,10 @@ static int pdo_firebird_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval
 			i += l;
 			strcpy(&buf[i++], " ");
 		}
-		add_next_index_string(info, buf, 1);
+		add_next_index_string(info, buf);
 	} else if (H->last_app_error) {
 		add_next_index_long(info, -999);
-		add_next_index_string(info, const_cast(H->last_app_error),1);
+		add_next_index_string(info, const_cast(H->last_app_error));
 	}
 	return 1;
 }
diff --git a/ext/pdo_mysql/mysql_driver.c b/ext/pdo_mysql/mysql_driver.c
index 581766b38a..2201620817 100644
--- a/ext/pdo_mysql/mysql_driver.c
+++ b/ext/pdo_mysql/mysql_driver.c
@@ -130,7 +130,7 @@ static int pdo_mysql_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *in
 
 	if (einfo->errcode) {
 		add_next_index_long(info, einfo->errcode);
-		add_next_index_string(info, einfo->errmsg, 1);
+		add_next_index_string(info, einfo->errmsg);
 	}
 
 	PDO_DBG_RETURN(1);
diff --git a/ext/pdo_mysql/mysql_statement.c b/ext/pdo_mysql/mysql_statement.c
index 95501c22c7..1830a46c13 100644
--- a/ext/pdo_mysql/mysql_statement.c
+++ b/ext/pdo_mysql/mysql_statement.c
@@ -827,26 +827,26 @@ static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_va
 	F = S->fields + colno;
 
 	if (F->def) {
-		add_assoc_string(return_value, "mysql:def", F->def, 1);
+		add_assoc_string(return_value, "mysql:def", F->def);
 	}
 	if (IS_NOT_NULL(F->flags)) {
-		add_next_index_string(flags, "not_null", 1);
+		add_next_index_string(flags, "not_null");
 	}
 	if (IS_PRI_KEY(F->flags)) {
-		add_next_index_string(flags, "primary_key", 1);
+		add_next_index_string(flags, "primary_key");
 	}
 	if (F->flags & MULTIPLE_KEY_FLAG) {
-		add_next_index_string(flags, "multiple_key", 1);
+		add_next_index_string(flags, "multiple_key");
 	}
 	if (F->flags & UNIQUE_KEY_FLAG) {
-		add_next_index_string(flags, "unique_key", 1);
+		add_next_index_string(flags, "unique_key");
 	}
 	if (IS_BLOB(F->flags)) {
-		add_next_index_string(flags, "blob", 1);
+		add_next_index_string(flags, "blob");
 	}
 	str = type_to_name_native(F->type);
 	if (str) {
-		add_assoc_string(return_value, "native_type", str, 1);
+		add_assoc_string(return_value, "native_type", str);
 	}
 
 #ifdef PDO_USE_MYSQLND
@@ -869,7 +869,7 @@ static int pdo_mysql_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_va
 #endif
 
 	add_assoc_zval(return_value, "flags", flags);
-	add_assoc_string(return_value, "table", (char *) (F->table?F->table:""), 1);
+	add_assoc_string(return_value, "table", (char *) (F->table?F->table:""));
 	PDO_DBG_RETURN(SUCCESS);
 } /* }}} */
 
diff --git a/ext/pdo_oci/oci_driver.c b/ext/pdo_oci/oci_driver.c
index 8f56c674d1..a8e7913fa7 100644
--- a/ext/pdo_oci/oci_driver.c
+++ b/ext/pdo_oci/oci_driver.c
@@ -50,7 +50,7 @@ static int pdo_oci_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *info
 
 	if (einfo->errcode) {
 		add_next_index_long(info, einfo->errcode);
-		add_next_index_string(info, einfo->errmsg, 1);
+		add_next_index_string(info, einfo->errmsg);
 	}
 
 	return 1;
diff --git a/ext/pdo_odbc/odbc_driver.c b/ext/pdo_odbc/odbc_driver.c
index 339db5698a..d4bf234689 100644
--- a/ext/pdo_odbc/odbc_driver.c
+++ b/ext/pdo_odbc/odbc_driver.c
@@ -49,8 +49,10 @@ static int pdo_odbc_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *inf
 				einfo->file, einfo->line);
 
 	add_next_index_long(info, einfo->last_error);
-	add_next_index_string(info, message, 0);
-	add_next_index_string(info, einfo->last_state, 1);
+	// TODO: avoid reallocation ???
+	add_next_index_string(info, message);
+	efree(message);
+	add_next_index_string(info, einfo->last_state);
 
 	return 1;
 }
diff --git a/ext/pdo_pgsql/pgsql_driver.c b/ext/pdo_pgsql/pgsql_driver.c
index 96f6fa7f72..24a5865c75 100644
--- a/ext/pdo_pgsql/pgsql_driver.c
+++ b/ext/pdo_pgsql/pgsql_driver.c
@@ -114,7 +114,7 @@ static int pdo_pgsql_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *in
 
 	if (einfo->errcode) {
 		add_next_index_long(info, einfo->errcode);
-		add_next_index_string(info, einfo->errmsg, 1);
+		add_next_index_string(info, einfo->errmsg);
 	}
 
 	return 1;
@@ -869,7 +869,7 @@ static PHP_METHOD(PDO, pgsqlCopyToArray)
 			if (ret == -1) {
 				break; /* copy done */
 			} else if (ret > 0) {
-				add_next_index_stringl(return_value, csv, ret, 1);
+				add_next_index_stringl(return_value, csv, ret);
 				PQfreemem(csv);
 			} else {
 				pdo_pgsql_error(dbh, PGRES_FATAL_ERROR, NULL);
@@ -1056,11 +1056,11 @@ static PHP_METHOD(PDO, pgsqlGetNotify)
 
 	array_init(return_value);
 	if (result_type == PDO_FETCH_NUM || result_type == PDO_FETCH_BOTH) {
-		add_index_string(return_value, 0, pgsql_notify->relname, 1);
+		add_index_string(return_value, 0, pgsql_notify->relname);
 		add_index_long(return_value, 1, pgsql_notify->be_pid);
 	}
 	if (result_type == PDO_FETCH_ASSOC || result_type == PDO_FETCH_BOTH) {
-		add_assoc_string(return_value, "message", pgsql_notify->relname, 1);
+		add_assoc_string(return_value, "message", pgsql_notify->relname);
 		add_assoc_long(return_value, "pid", pgsql_notify->be_pid);
 	}
 
diff --git a/ext/pdo_pgsql/pgsql_statement.c b/ext/pdo_pgsql/pgsql_statement.c
index 35e69a3c02..c9c9e5c450 100644
--- a/ext/pdo_pgsql/pgsql_statement.c
+++ b/ext/pdo_pgsql/pgsql_statement.c
@@ -603,7 +603,7 @@ static int pgsql_stmt_get_column_meta(pdo_stmt_t *stmt, long colno, zval *return
 		goto done;
 	}
 
-	add_assoc_string(return_value, "native_type", PQgetvalue(res, 0, 0), 1);
+	add_assoc_string(return_value, "native_type", PQgetvalue(res, 0, 0));
 done:
 	PQclear(res);
 	return 1;
diff --git a/ext/pdo_sqlite/php_pdo_sqlite_int.h b/ext/pdo_sqlite/php_pdo_sqlite_int.h
index 288cc6335e..188856a3d1 100644
--- a/ext/pdo_sqlite/php_pdo_sqlite_int.h
+++ b/ext/pdo_sqlite/php_pdo_sqlite_int.h
@@ -38,7 +38,7 @@ struct pdo_sqlite_fci {
 struct pdo_sqlite_func {
 	struct pdo_sqlite_func *next;
 
-	zval *func, *step, *fini;
+	zval func, step, fini;
 	int argc;
 	const char *funcname;
 	
@@ -50,7 +50,7 @@ struct pdo_sqlite_collation {
 	struct pdo_sqlite_collation *next;
 
 	const char *name;
-	zval *callback;
+	zval callback;
 	struct pdo_sqlite_fci fc;
 };
 
diff --git a/ext/pdo_sqlite/sqlite_driver.c b/ext/pdo_sqlite/sqlite_driver.c
index 35fa547f27..25a6c7053e 100644
--- a/ext/pdo_sqlite/sqlite_driver.c
+++ b/ext/pdo_sqlite/sqlite_driver.c
@@ -93,7 +93,7 @@ static int pdo_sqlite_fetch_error_func(pdo_dbh_t *dbh, pdo_stmt_t *stmt, zval *i
 
 	if (einfo->errcode) {
 		add_next_index_long(info, einfo->errcode);
-		add_next_index_string(info, einfo->errmsg, 1);
+		add_next_index_string(info, einfo->errmsg);
 	}
 
 	return 1;
@@ -118,13 +118,13 @@ static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
 		}
 
 		efree((char*)func->funcname);
-		if (func->func) {
+		if (!ZVAL_IS_UNDEF(&func->func)) {
 			zval_ptr_dtor(&func->func);
 		}
-		if (func->step) {
+		if (!ZVAL_IS_UNDEF(&func->step)) {
 			zval_ptr_dtor(&func->step);
 		}
-		if (func->fini) {
+		if (!ZVAL_IS_UNDEF(&func->fini)) {
 			zval_ptr_dtor(&func->fini);
 		}
 		efree(func);
@@ -145,7 +145,7 @@ static void pdo_sqlite_cleanup_callbacks(pdo_sqlite_db_handle *H TSRMLS_DC)
 		}
 
 		efree((char*)collation->name);
-		if (collation->callback) {
+		if (!ZVAL_IS_UNDEF(&collation->callback)) {
 			zval_ptr_dtor(&collation->callback);
 		}
 		efree(collation);
@@ -285,7 +285,7 @@ static int pdo_sqlite_get_attribute(pdo_dbh_t *dbh, long attr, zval *return_valu
 	switch (attr) {
 		case PDO_ATTR_CLIENT_VERSION:
 		case PDO_ATTR_SERVER_VERSION:
-			ZVAL_STRING(return_value, (char *)sqlite3_libversion(), 1);
+			ZVAL_STRING(return_value, (char *)sqlite3_libversion());
 			break;
 		
 		default:
@@ -312,12 +312,12 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 		int argc, sqlite3_value **argv, sqlite3_context *context,
 		int is_agg TSRMLS_DC)
 {
-	zval ***zargs = NULL;
-	zval *retval = NULL;
+	zval *zargs = NULL;
+	zval retval;
 	int i;
 	int ret;
 	int fake_argc;
-	zval **agg_context = NULL;
+	zend_reference *agg_context = NULL;
 	
 	if (is_agg) {
 		is_agg = 2;
@@ -327,63 +327,58 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 	
 	fc->fci.size = sizeof(fc->fci);
 	fc->fci.function_table = EG(function_table);
-	fc->fci.function_name = cb;
+	ZVAL_COPY_VALUE(&fc->fci.function_name, cb);
 	fc->fci.symbol_table = NULL;
-	fc->fci.object_ptr = NULL;
-	fc->fci.retval_ptr_ptr = &retval;
+	fc->fci.object = NULL;
+	fc->fci.retval = &retval;
 	fc->fci.param_count = fake_argc;
 	
 	/* build up the params */
 
 	if (fake_argc) {
-		zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
+		zargs = safe_emalloc(fake_argc, sizeof(zval), 0);
 	}
 
 	if (is_agg) {
-		/* summon the aggregation context */
-		agg_context = (zval**)sqlite3_aggregate_context(context, sizeof(zval*));
-		if (!*agg_context) {
-			MAKE_STD_ZVAL(*agg_context);
-			ZVAL_NULL(*agg_context);
+		agg_context = (zend_reference*)sqlite3_aggregate_context(context, sizeof(zend_reference));
+		if (!agg_context) {
+			ZVAL_NULL(&zargs[0]);
+		} else {
+			if (ZVAL_IS_UNDEF(&agg_context->val)) {
+				GC_REFCOUNT(agg_context) = 1;
+				GC_TYPE_INFO(agg_context) = IS_REFERENCE;
+				ZVAL_NULL(&agg_context->val);
+			}
+			ZVAL_REF(&zargs[0], agg_context);
 		}
-		zargs[0] = agg_context;
-
-		zargs[1] = emalloc(sizeof(zval*));
-		MAKE_STD_ZVAL(*zargs[1]);
-		ZVAL_LONG(*zargs[1], sqlite3_aggregate_count(context));
+		ZVAL_LONG(&zargs[1], sqlite3_aggregate_count(context));
 	}
 	
 	for (i = 0; i < argc; i++) {
-		zargs[i + is_agg] = emalloc(sizeof(zval *));
-		MAKE_STD_ZVAL(*zargs[i + is_agg]);
-
 		/* get the value */
 		switch (sqlite3_value_type(argv[i])) {
 			case SQLITE_INTEGER:
-				ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
+				ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int(argv[i]));
 				break;
 
 			case SQLITE_FLOAT:
-				ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
+				ZVAL_DOUBLE(&zargs[i + is_agg], sqlite3_value_double(argv[i]));
 				break;
 
 			case SQLITE_NULL:
-				ZVAL_NULL(*zargs[i + is_agg]);
+				ZVAL_NULL(&zargs[i + is_agg]);
 				break;
 
 			case SQLITE_BLOB:
 			case SQLITE3_TEXT:
 			default:
-				ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]),
-						sqlite3_value_bytes(argv[i]), 1);
+				ZVAL_STRINGL(&zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]));
 				break;
 		}
 	}
 
-
 	fc->fci.params = zargs;
 
-
 	if ((ret = zend_call_function(&fc->fci, &fc->fcc TSRMLS_CC)) == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
 	}
@@ -391,12 +386,10 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 	/* clean up the params */
 	if (zargs) {
 		for (i = is_agg; i < fake_argc; i++) {
-			zval_ptr_dtor(zargs[i]);
-			efree(zargs[i]);
+			zval_ptr_dtor(&zargs[i]);
 		}
 		if (is_agg) {
-			zval_ptr_dtor(zargs[1]);
-			efree(zargs[1]);
+			zval_ptr_dtor(&zargs[1]);
 		}
 		efree(zargs);
 	}
@@ -404,10 +397,10 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 	if (!is_agg || !argv) {
 		/* only set the sqlite return value if we are a scalar function,
 		 * or if we are finalizing an aggregate */
-		if (retval) {
-			switch (Z_TYPE_P(retval)) {
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			switch (Z_TYPE(retval)) {
 				case IS_LONG:
-					sqlite3_result_int(context, Z_LVAL_P(retval));
+					sqlite3_result_int(context, Z_LVAL(retval));
 					break;
 
 				case IS_NULL:
@@ -415,13 +408,12 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 					break;
 
 				case IS_DOUBLE:
-					sqlite3_result_double(context, Z_DVAL_P(retval));
+					sqlite3_result_double(context, Z_DVAL(retval));
 					break;
 
 				default:
 					convert_to_string_ex(&retval);
-					sqlite3_result_text(context, Z_STRVAL_P(retval),
-						Z_STRLEN_P(retval), SQLITE_TRANSIENT);
+					sqlite3_result_text(context, Z_STRVAL(retval), Z_STRLEN(retval), SQLITE_TRANSIENT);
 					break;
 			}
 		} else {
@@ -429,23 +421,23 @@ static int do_callback(struct pdo_sqlite_fci *fc, zval *cb,
 		}
 
 		if (agg_context) {
-			zval_ptr_dtor(agg_context);
+			zval_ptr_dtor(&agg_context->val);
 		}
 	} else {
 		/* we're stepping in an aggregate; the return value goes into
 		 * the context */
 		if (agg_context) {
-			zval_ptr_dtor(agg_context);
+			zval_ptr_dtor(&agg_context->val);
 		}
-		if (retval) {
-			*agg_context = retval;
-			retval = NULL;
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			ZVAL_COPY_VALUE(&agg_context->val, &retval);
+			ZVAL_UNDEF(&retval);
 		} else {
-			*agg_context = NULL;
+			ZVAL_UNDEF(&agg_context->val);
 		}
 	}
 
-	if (retval) {
+	if (!ZVAL_IS_UNDEF(&retval)) {
 		zval_ptr_dtor(&retval);
 	}
 
@@ -458,7 +450,7 @@ static void php_sqlite3_func_callback(sqlite3_context *context, int argc,
 	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
+	do_callback(&func->afunc, &func->func, argc, argv, context, 0 TSRMLS_CC);
 }
 
 static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
@@ -467,7 +459,7 @@ static void php_sqlite3_func_step_callback(sqlite3_context *context, int argc,
 	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
+	do_callback(&func->astep, &func->step, argc, argv, context, 1 TSRMLS_CC);
 }
 
 static void php_sqlite3_func_final_callback(sqlite3_context *context)
@@ -475,7 +467,7 @@ static void php_sqlite3_func_final_callback(sqlite3_context *context)
 	struct pdo_sqlite_func *func = (struct pdo_sqlite_func*)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
+	do_callback(&func->afini, &func->fini, 0, NULL, context, 1 TSRMLS_CC);
 }
 
 static int php_sqlite3_collation_callback(void *context,
@@ -483,48 +475,41 @@ static int php_sqlite3_collation_callback(void *context,
 	int string2_len, const void *string2)
 {
 	int ret;
-	zval *zstring1, *zstring2;
-	zval **zargs[2];
-	zval *retval = NULL;
+	zval zargs[2];
+	zval retval;
 	struct pdo_sqlite_collation *collation = (struct pdo_sqlite_collation*) context;
 	TSRMLS_FETCH();
 
 	collation->fc.fci.size = sizeof(collation->fc.fci);
 	collation->fc.fci.function_table = EG(function_table);
-	collation->fc.fci.function_name = collation->callback;
+	ZVAL_COPY_VALUE(&collation->fc.fci.function_name, &collation->callback);
 	collation->fc.fci.symbol_table = NULL;
-	collation->fc.fci.object_ptr = NULL;
-	collation->fc.fci.retval_ptr_ptr = &retval;
+	collation->fc.fci.object = NULL;
+	collation->fc.fci.retval = &retval;
 
 	// Prepare the arguments.
-	MAKE_STD_ZVAL(zstring1);
-	ZVAL_STRINGL(zstring1, (char *) string1, string1_len, 1);
-	zargs[0] = &zstring1;
-	MAKE_STD_ZVAL(zstring2);
-	ZVAL_STRINGL(zstring2, (char *) string2, string2_len, 1);
-	zargs[1] = &zstring2;
+	ZVAL_STRINGL(&zargs[0], (char *) string1, string1_len);
+	ZVAL_STRINGL(&zargs[1], (char *) string2, string2_len);
 	collation->fc.fci.param_count = 2;
 	collation->fc.fci.params = zargs;
 
 	if ((ret = zend_call_function(&collation->fc.fci, &collation->fc.fcc TSRMLS_CC)) == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the callback");
-	}
-	else if (retval) {
-		if (Z_TYPE_P(retval) != IS_LONG) {
+	} else if (!ZVAL_IS_UNDEF(&retval)) {
+		if (Z_TYPE(retval) != IS_LONG) {
 			convert_to_long_ex(&retval);
 		}
 		ret = 0;
-		if (Z_LVAL_P(retval) > 0) {
+		if (Z_LVAL(retval) > 0) {
 			ret = 1;
-		}
-		else if (Z_LVAL_P(retval) < 0) {
+		} else if (Z_LVAL(retval) < 0) {
 			ret = -1;
 		}
 		zval_ptr_dtor(&retval);
 	}
 
-	zval_ptr_dtor(zargs[0]);
-	zval_ptr_dtor(zargs[1]);
+	zval_ptr_dtor(&zargs[0]);
+	zval_ptr_dtor(&zargs[1]);
 
 	return ret;
 }
@@ -538,7 +523,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	char *func_name;
 	int func_name_len;
 	long argc = -1;
-	char *cbname = NULL;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -548,15 +533,15 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 		RETURN_FALSE;
 	}
 	
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis() TSRMLS_CC);
 	PDO_CONSTRUCT_CHECK;
 
 	if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 	
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -567,8 +552,7 @@ static PHP_METHOD(SQLite, sqliteCreateFunction)
 	if (ret == SQLITE_OK) {
 		func->funcname = estrdup(func_name);
 		
-		MAKE_STD_ZVAL(func->func);
-		MAKE_COPY_ZVAL(&callback, func->func);
+		ZVAL_COPY(&func->func, callback);
 		
 		func->argc = argc;
 
@@ -609,7 +593,7 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	char *func_name;
 	int func_name_len;
 	long argc = -1;
-	char *cbname = NULL;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -619,21 +603,21 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 		RETURN_FALSE;
 	}
 	
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis() TSRMLS_CC);
 	PDO_CONSTRUCT_CHECK;
 
 	if (!zend_is_callable(step_callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 	if (!zend_is_callable(fini_callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 	
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -644,11 +628,9 @@ static PHP_METHOD(SQLite, sqliteCreateAggregate)
 	if (ret == SQLITE_OK) {
 		func->funcname = estrdup(func_name);
 		
-		MAKE_STD_ZVAL(func->step);
-		MAKE_COPY_ZVAL(&step_callback, func->step);
+		ZVAL_COPY(&func->step, step_callback);
 
-		MAKE_STD_ZVAL(func->fini);
-		MAKE_COPY_ZVAL(&fini_callback, func->fini);
+		ZVAL_COPY(&func->fini, fini_callback);
 		
 		func->argc = argc;
 
@@ -671,7 +653,7 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 	zval *callback;
 	char *collation_name;
 	int collation_name_len;
-	char *cbname = NULL;
+	zend_string *cbname = NULL;
 	pdo_dbh_t *dbh;
 	pdo_sqlite_db_handle *H;
 	int ret;
@@ -681,15 +663,15 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 		RETURN_FALSE;
 	}
 
-	dbh = zend_object_store_get_object(getThis() TSRMLS_CC);
+	dbh = Z_PDO_DBH_P(getThis());
 	PDO_CONSTRUCT_CHECK;
 
 	if (!zend_is_callable(callback, 0, &cbname TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname);
-		efree(cbname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "function '%s' is not callable", cbname->val);
+		STR_RELEASE(cbname);
 		RETURN_FALSE;
 	}
-	efree(cbname);
+	STR_RELEASE(cbname);
 
 	H = (pdo_sqlite_db_handle *)dbh->driver_data;
 
@@ -699,8 +681,7 @@ static PHP_METHOD(SQLite, sqliteCreateCollation)
 	if (ret == SQLITE_OK) {
 		collation->name = estrdup(collation_name);
 
-		MAKE_STD_ZVAL(collation->callback);
-		MAKE_COPY_ZVAL(&callback, collation->callback);
+		ZVAL_COPY(&collation->callback, callback);
 
 		collation->next = H->collations;
 		H->collations = collation;
diff --git a/ext/pdo_sqlite/sqlite_statement.c b/ext/pdo_sqlite/sqlite_statement.c
index ba49f7324c..5f18c8a0cf 100644
--- a/ext/pdo_sqlite/sqlite_statement.c
+++ b/ext/pdo_sqlite/sqlite_statement.c
@@ -79,6 +79,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
 		enum pdo_param_event event_type TSRMLS_DC)
 {
 	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
+	zval *parameter;
 
 	switch (event_type) {
 		case PDO_PARAM_EVT_EXEC_PRE:
@@ -90,7 +91,7 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
 			if (param->is_param) {
 				
 				if (param->paramno == -1) {
-					param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name) - 1;
+					param->paramno = sqlite3_bind_parameter_index(S->stmt, param->name->val) - 1;
 				}
 
 				switch (PDO_PARAM_TYPE(param->param_type)) {
@@ -106,18 +107,23 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
 					
 					case PDO_PARAM_INT:
 					case PDO_PARAM_BOOL:
-						if (Z_TYPE_P(param->parameter) == IS_NULL) {
+						if (Z_ISREF(param->parameter)) {
+							parameter = Z_REFVAL(param->parameter);
+						} else {
+							parameter = &param->parameter;
+						}
+						if (Z_TYPE_P(parameter) == IS_NULL) {
 							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
 								return 1;
 							}
 						} else {
-							convert_to_long(param->parameter);
+							convert_to_long(parameter);
 #if LONG_MAX > 2147483647
-							if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+							if (SQLITE_OK == sqlite3_bind_int64(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
 								return 1;
 							}
 #else
-							if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(param->parameter))) {
+							if (SQLITE_OK == sqlite3_bind_int(S->stmt, param->paramno + 1, Z_LVAL_P(parameter))) {
 								return 1;
 							}
 #endif
@@ -126,48 +132,55 @@ static int pdo_sqlite_stmt_param_hook(pdo_stmt_t *stmt, struct pdo_bound_param_d
 						return 0;
 					
 					case PDO_PARAM_LOB:
-						if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
+						if (Z_ISREF(param->parameter)) {
+							parameter = Z_REFVAL(param->parameter);
+						} else {
+							parameter = &param->parameter;
+						}
+						if (Z_TYPE_P(parameter) == IS_RESOURCE) {
 							php_stream *stm;
-							php_stream_from_zval_no_verify(stm, &param->parameter);
+							php_stream_from_zval_no_verify(stm, parameter);
 							if (stm) {
-								SEPARATE_ZVAL(&param->parameter);
-								Z_TYPE_P(param->parameter) = IS_STRING;
-								Z_STRLEN_P(param->parameter) = php_stream_copy_to_mem(stm,
-									&Z_STRVAL_P(param->parameter), PHP_STREAM_COPY_ALL, 0);
+								zval_ptr_dtor(parameter);
+								ZVAL_STR(parameter, php_stream_copy_to_mem(stm, PHP_STREAM_COPY_ALL, 0));
 							} else {
 								pdo_raise_impl_error(stmt->dbh, stmt, "HY105", "Expected a stream resource" TSRMLS_CC);
 								return 0;
 							}
-						} else if (Z_TYPE_P(param->parameter) == IS_NULL) {
+						} else if (Z_TYPE_P(parameter) == IS_NULL) {
 							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
 								return 1;
 							}
 							pdo_sqlite_error_stmt(stmt);
 							return 0;
 						} else {
-							convert_to_string(param->parameter);
+							convert_to_string(parameter);
 						}
 						
 						if (SQLITE_OK == sqlite3_bind_blob(S->stmt, param->paramno + 1,
-								Z_STRVAL_P(param->parameter),
-								Z_STRLEN_P(param->parameter),
+								Z_STRVAL_P(parameter),
+								Z_STRLEN_P(parameter),
 								SQLITE_STATIC)) {
 							return 1;	
 						}
-						pdo_sqlite_error_stmt(stmt);
 						return 0;
 							
 					case PDO_PARAM_STR:
 					default:
-						if (Z_TYPE_P(param->parameter) == IS_NULL) {
+						if (Z_ISREF(param->parameter)) {
+							parameter = Z_REFVAL(param->parameter);
+						} else {
+							parameter = &param->parameter;
+						}
+						if (Z_TYPE_P(parameter) == IS_NULL) {
 							if (sqlite3_bind_null(S->stmt, param->paramno + 1) == SQLITE_OK) {
 								return 1;
 							}
 						} else {
-							convert_to_string(param->parameter);
-							if(SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
-									Z_STRVAL_P(param->parameter),
-									Z_STRLEN_P(param->parameter),
+							convert_to_string(parameter);
+							if (SQLITE_OK == sqlite3_bind_text(S->stmt, param->paramno + 1,
+									Z_STRVAL_P(parameter),
+									Z_STRLEN_P(parameter),
 									SQLITE_STATIC)) {
 								return 1;	
 							}
@@ -279,7 +292,7 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 {
 	pdo_sqlite_stmt *S = (pdo_sqlite_stmt*)stmt->driver_data;
 	const char *str;
-	zval *flags;
+	zval flags;
 	
 	if (!S->stmt) {
 		return FAILURE;
@@ -291,42 +304,41 @@ static int pdo_sqlite_stmt_col_meta(pdo_stmt_t *stmt, long colno, zval *return_v
 	}
 
 	array_init(return_value);
-	MAKE_STD_ZVAL(flags);
-	array_init(flags);
+	array_init(&flags);
 
 	switch (sqlite3_column_type(S->stmt, colno)) {
 		case SQLITE_NULL:
-			add_assoc_string(return_value, "native_type", "null", 1);
+			add_assoc_string(return_value, "native_type", "null");
 			break;
 
 		case SQLITE_FLOAT:
-			add_assoc_string(return_value, "native_type", "double", 1);
+			add_assoc_string(return_value, "native_type", "double");
 			break;
 
 		case SQLITE_BLOB:
-			add_next_index_string(flags, "blob", 1);
+			add_next_index_string(&flags, "blob");
 		case SQLITE_TEXT:
-			add_assoc_string(return_value, "native_type", "string", 1);
+			add_assoc_string(return_value, "native_type", "string");
 			break;
 
 		case SQLITE_INTEGER:
-			add_assoc_string(return_value, "native_type", "integer", 1);
+			add_assoc_string(return_value, "native_type", "integer");
 			break;
 	}
 
 	str = sqlite3_column_decltype(S->stmt, colno);
 	if (str) {
-		add_assoc_string(return_value, "sqlite:decl_type", (char *)str, 1);
+		add_assoc_string(return_value, "sqlite:decl_type", (char *)str);
 	}
 
 #ifdef SQLITE_ENABLE_COLUMN_METADATA
 	str = sqlite3_column_table_name(S->stmt, colno);
 	if (str) {
-		add_assoc_string(return_value, "table", (char *)str, 1);
+		add_assoc_string(return_value, "table", (char *)str);
 	}
 #endif
 
-	add_assoc_zval(return_value, "flags", flags);
+	add_assoc_zval(return_value, "flags", &flags);
 
 	return SUCCESS;
 }
diff --git a/ext/pgsql/pgsql.c b/ext/pgsql/pgsql.c
index d867f433b2..fcf5b4799b 100644
--- a/ext/pgsql/pgsql.c
+++ b/ext/pgsql/pgsql.c
@@ -1639,34 +1639,34 @@ static void php_pgsql_get_link_info(INTERNAL_FUNCTION_PARAMETERS, int entry_type
 			break;
 		case PHP_PG_VERSION:
 			array_init(return_value);
-			add_assoc_string(return_value, "client", PG_VERSION, 1);
+			add_assoc_string(return_value, "client", PG_VERSION);
 #if HAVE_PQPROTOCOLVERSION
 			add_assoc_long(return_value, "protocol", PQprotocolVersion(pgsql));
 #if HAVE_PQPARAMETERSTATUS
 			if (PQprotocolVersion(pgsql) >= 3) {
 				/* 8.0 or grater supports protorol version 3 */
 				char *tmp;
-				add_assoc_string(return_value, "server", (char*)PQparameterStatus(pgsql, "server_version"), 1);
+				add_assoc_string(return_value, "server", (char*)PQparameterStatus(pgsql, "server_version"));
 				tmp = (char*)PQparameterStatus(pgsql, "server_encoding");
-				add_assoc_string(return_value, "server_encoding", tmp, 1);
+				add_assoc_string(return_value, "server_encoding", tmp);
 				tmp = (char*)PQparameterStatus(pgsql, "client_encoding");
-				add_assoc_string(return_value, "client_encoding", tmp, 1);
+				add_assoc_string(return_value, "client_encoding", tmp);
 				tmp = (char*)PQparameterStatus(pgsql, "is_superuser");
-				add_assoc_string(return_value, "is_superuser", tmp, 1);
+				add_assoc_string(return_value, "is_superuser", tmp);
 				tmp = (char*)PQparameterStatus(pgsql, "session_authorization");
-				add_assoc_string(return_value, "session_authorization", tmp, 1);
+				add_assoc_string(return_value, "session_authorization", tmp);
 				tmp = (char*)PQparameterStatus(pgsql, "DateStyle");
-				add_assoc_string(return_value, "DateStyle", tmp, 1);
+				add_assoc_string(return_value, "DateStyle", tmp);
 				tmp = (char*)PQparameterStatus(pgsql, "IntervalStyle");
-				add_assoc_string(return_value, "IntervalStyle", tmp ? tmp : "", 1);
+				add_assoc_string(return_value, "IntervalStyle", tmp ? tmp : "");
 				tmp = (char*)PQparameterStatus(pgsql, "TimeZone");
-				add_assoc_string(return_value, "TimeZone", tmp ? tmp : "", 1);
+				add_assoc_string(return_value, "TimeZone", tmp ? tmp : "");
 				tmp = (char*)PQparameterStatus(pgsql, "integer_datetimes");
-				add_assoc_string(return_value, "integer_datetimes", tmp ? tmp : "", 1);
+				add_assoc_string(return_value, "integer_datetimes", tmp ? tmp : "");
 				tmp = (char*)PQparameterStatus(pgsql, "standard_conforming_strings");
-				add_assoc_string(return_value, "standard_conforming_strings", tmp ? tmp : "", 1);
+				add_assoc_string(return_value, "standard_conforming_strings", tmp ? tmp : "");
 				tmp = (char*)PQparameterStatus(pgsql, "application_name");
-				add_assoc_string(return_value, "application_name", tmp ? tmp : "", 1);
+				add_assoc_string(return_value, "application_name", tmp ? tmp : "");
 			}
 #endif
 #endif
@@ -2756,22 +2756,18 @@ static void php_pgsql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 		} else {
 			char *element = PQgetvalue(pgsql_result, pgsql_row, i);
 			if (element) {
-				char *data;
-				int data_len;
-				int should_copy=0;
 				const uint element_len = strlen(element);
 
 				data = safe_estrndup(element, element_len);
 				data_len = element_len;
 
 				if (result_type & PGSQL_NUM) {
-					add_index_stringl(return_value, i, data, data_len, should_copy);
-					should_copy=1;
+					add_index_stringl(return_value, i, element, element_len);
 				}
 
 				if (result_type & PGSQL_ASSOC) {
 					field_name = PQfname(pgsql_result, i);
-					add_assoc_stringl(return_value, field_name, data, data_len, should_copy);
+					add_assoc_stringl(return_value, field_name, element, element_len);
 				}
 			}
 		}
@@ -2929,7 +2925,7 @@ PHP_FUNCTION(pg_fetch_all_columns)
 		if (PQgetisnull(pgsql_result, pg_row, colno)) {
 			add_next_index_null(return_value);
 		} else {
-			add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, colno), 1); 
+			add_next_index_string(return_value, PQgetvalue(pgsql_result, pg_row, colno)); 
 		}
 	}
 }
@@ -4088,7 +4084,7 @@ PHP_FUNCTION(pg_copy_to)
 							RETURN_FALSE;
 							break;
 						default:
-							add_next_index_string(return_value, csv, 1);
+							add_next_index_string(return_value, csv);
 							PQfreemem(csv);
 							break;
 					}
@@ -4121,7 +4117,7 @@ PHP_FUNCTION(pg_copy_to)
 							case EOF:
 								copydone = 1;
 							case 0:
-								add_next_index_string(return_value, csv, 1);
+								add_next_index_string(return_value, csv);
 								efree(csv);
 								csv = (char *)NULL;
 								break;
@@ -5258,7 +5254,7 @@ PHP_FUNCTION(pg_get_notify)
 	}
 	array_init(return_value);
 	if (result_type & PGSQL_NUM) {
-		add_index_string(return_value, 0, pgsql_notify->relname, 1);
+		add_index_string(return_value, 0, pgsql_notify->relname);
 		add_index_long(return_value, 1, pgsql_notify->be_pid);
 #if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS 
 		if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 9.0) {
@@ -5266,12 +5262,12 @@ PHP_FUNCTION(pg_get_notify)
 		if (atof(PG_VERSION) >= 9.0) {
 #endif 
 #if HAVE_PQPARAMETERSTATUS
-			add_index_string(return_value, 2, pgsql_notify->extra, 1);
+			add_index_string(return_value, 2, pgsql_notify->extra);
 #endif
 		}
 	}
 	if (result_type & PGSQL_ASSOC) {
-		add_assoc_string(return_value, "message", pgsql_notify->relname, 1);
+		add_assoc_string(return_value, "message", pgsql_notify->relname);
 		add_assoc_long(return_value, "pid", pgsql_notify->be_pid);
 #if HAVE_PQPROTOCOLVERSION && HAVE_PQPARAMETERSTATUS 
 		if (PQprotocolVersion(pgsql) >= 3 && atof(PQparameterStatus(pgsql, "server_version")) >= 9.0) {
@@ -5279,7 +5275,7 @@ PHP_FUNCTION(pg_get_notify)
 		if (atof(PG_VERSION) >= 9.0) {
 #endif 
 #if HAVE_PQPARAMETERSTATUS
-			add_assoc_string(return_value, "payload", pgsql_notify->extra, 1);
+			add_assoc_string(return_value, "payload", pgsql_notify->extra);
 #endif
 		}
 	}
@@ -5522,7 +5518,7 @@ PHP_PGSQL_API int php_pgsql_meta_data(PGconn *pg_link, const char *table_name, z
 		/* pg_attribute.attnum */
 		add_assoc_long(elem, "num", atoi(PQgetvalue(pg_result,i,1)));
 		/* pg_type.typname */
-		add_assoc_string(elem, "type", PQgetvalue(pg_result,i,2), 1);
+		add_assoc_string(elem, "type", PQgetvalue(pg_result,i,2));
 		/* pg_attribute.attlen */
 		add_assoc_long(elem, "len", atoi(PQgetvalue(pg_result,i,3)));
 		/* pg_attribute.attnonull */
@@ -7007,15 +7003,10 @@ PHP_PGSQL_API int php_pgsql_result2array(PGresult *pg_result, zval *ret_array TS
 			} else {
 				char *element = PQgetvalue(pg_result, pg_row, i);
 				if (element) {
-					char *data;
-					size_t data_len;
 					const size_t element_len = strlen(element);
 
-					data = safe_estrndup(element, element_len);
-					data_len = element_len;
-					
 					field_name = PQfname(pg_result, i);
-					add_assoc_stringl(row, field_name, data, data_len, 0);
+					add_assoc_stringl(row, field_name, element, element_len);
 				}
 			}
 		}
diff --git a/ext/phar/dirstream.c b/ext/phar/dirstream.c
index 2a9f11203b..c2a2b7d7f9 100644
--- a/ext/phar/dirstream.c
+++ b/ext/phar/dirstream.c
@@ -44,9 +44,9 @@ static int phar_dir_close(php_stream *stream, int close_handle TSRMLS_DC)  /* {{
 {
 	HashTable *data = (HashTable *)stream->abstract;
 
-	if (data && data->arBuckets) {
+	if (data && data->arHash) {
 		zend_hash_destroy(data);
-		data->arBuckets = 0;
+		data->arHash = 0;
 		FREE_HASHTABLE(data);
 		stream->abstract = NULL;
 	}
@@ -158,8 +158,8 @@ static int phar_compare_dir_name(const void *a, const void *b TSRMLS_DC)  /* {{{
 	Bucket *s;
 	int result;
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
 	result = zend_binary_strcmp(f->arKey, f->nKeyLength, s->arKey, s->nKeyLength);
 
 	if (result < 0) {
@@ -359,7 +359,7 @@ php_stream *phar_wrapper_open_dir(php_stream_wrapper *wrapper, const char *path,
 		return ret;
 	}
 
-	if (!phar->manifest.arBuckets) {
+	if (!phar->manifest.arHash) {
 		php_url_free(resource);
 		return NULL;
 	}
diff --git a/ext/phar/func_interceptors.c b/ext/phar/func_interceptors.c
index 87411fc98d..5080ddf7c8 100644
--- a/ext/phar/func_interceptors.c
+++ b/ext/phar/func_interceptors.c
@@ -33,8 +33,8 @@ PHAR_FUNC(phar_opendir) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
-		&& !cached_phars.arBuckets) {
+	if ((PHAR_GLOBALS->phar_fname_map.arHash && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+		&& !cached_phars.arHash) {
 		goto skip_phar;
 	}
 
@@ -107,8 +107,8 @@ PHAR_FUNC(phar_file_get_contents) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
-		&& !cached_phars.arBuckets) {
+	if ((PHAR_GLOBALS->phar_fname_map.arHash && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+		&& !cached_phars.arHash) {
 		goto skip_phar;
 	}
 
@@ -203,14 +203,8 @@ phar_it:
 
 			/* uses mmap if possible */
 			if ((len = php_stream_copy_to_mem(stream, &contents, maxlen, 0)) > 0) {
-#if PHP_API_VERSION < 20100412
-				if (PG(magic_quotes_runtime)) {
-					int newlen;
-					contents = php_addslashes(contents, len, &newlen, 1 TSRMLS_CC); /* 1 = free source string */
-					len = newlen;
-				}
-#endif
 				RETVAL_STRINGL(contents, len, 0);
+				efree(contents);
 			} else if (len == 0) {
 				RETVAL_EMPTY_STRING();
 			} else {
@@ -240,8 +234,8 @@ PHAR_FUNC(phar_readfile) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
-		&& !cached_phars.arBuckets) {
+	if ((PHAR_GLOBALS->phar_fname_map.arHash && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+		&& !cached_phars.arHash) {
 		goto skip_phar;
 	}
 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "p|br!", &filename, &filename_len, &use_include_path, &zcontext) == FAILURE) {
@@ -335,8 +329,8 @@ PHAR_FUNC(phar_fopen) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
-		&& !cached_phars.arBuckets) {
+	if ((PHAR_GLOBALS->phar_fname_map.arHash && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+		&& !cached_phars.arHash) {
 		/* no need to check, include_path not even specified in fopen/ no active phars */
 		goto skip_phar;
 	}
@@ -901,8 +895,8 @@ PHAR_FUNC(phar_is_file) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
-		&& !cached_phars.arBuckets) {
+	if ((PHAR_GLOBALS->phar_fname_map.arHash && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+		&& !cached_phars.arHash) {
 		goto skip_phar;
 	}
 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) {
@@ -968,8 +962,8 @@ PHAR_FUNC(phar_is_link) /* {{{ */
 		goto skip_phar;
 	}
 
-	if ((PHAR_GLOBALS->phar_fname_map.arBuckets && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
-		&& !cached_phars.arBuckets) {
+	if ((PHAR_GLOBALS->phar_fname_map.arHash && !zend_hash_num_elements(&(PHAR_GLOBALS->phar_fname_map)))
+		&& !cached_phars.arHash) {
 		goto skip_phar;
 	}
 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "p", &filename, &filename_len) == FAILURE) {
diff --git a/ext/phar/phar.c b/ext/phar/phar.c
index 5bfb278881..a23c1b89c2 100644
--- a/ext/phar/phar.c
+++ b/ext/phar/phar.c
@@ -82,7 +82,7 @@ ZEND_INI_MH(phar_ini_modify_handler) /* {{{ */
 
 	if (entry->name_length == 14) {
 		PHAR_G(readonly) = ini;
-		if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arBuckets) {
+		if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arHash) {
 			zend_hash_apply_with_argument(&(PHAR_GLOBALS->phar_fname_map), phar_set_writeable_bit, (void *)&ini TSRMLS_CC);
 		}
 	} else {
@@ -147,9 +147,9 @@ finish_error:
 				PHAR_GLOBALS->manifest_cached = 0;
 				efree(tmp);
 				zend_hash_destroy(&(PHAR_G(phar_fname_map)));
-				PHAR_GLOBALS->phar_fname_map.arBuckets = 0;
+				PHAR_GLOBALS->phar_fname_map.arHash = 0;
 				zend_hash_destroy(&(PHAR_G(phar_alias_map)));
-				PHAR_GLOBALS->phar_alias_map.arBuckets = 0;
+				PHAR_GLOBALS->phar_alias_map.arHash = 0;
 				zend_hash_destroy(&cached_phars);
 				zend_hash_destroy(&cached_alias);
 				zend_hash_graceful_reverse_destroy(&EG(regular_list));
@@ -174,8 +174,8 @@ finish_error:
 	zend_hash_destroy(&cached_alias);
 	cached_phars = PHAR_GLOBALS->phar_fname_map;
 	cached_alias = PHAR_GLOBALS->phar_alias_map;
-	PHAR_GLOBALS->phar_fname_map.arBuckets = 0;
-	PHAR_GLOBALS->phar_alias_map.arBuckets = 0;
+	PHAR_GLOBALS->phar_fname_map.arHash = 0;
+	PHAR_GLOBALS->phar_alias_map.arHash = 0;
 	zend_hash_graceful_reverse_destroy(&EG(regular_list));
 	memset(&EG(regular_list), 0, sizeof(HashTable));
 	efree(tmp);
@@ -221,19 +221,19 @@ void phar_destroy_phar_data(phar_archive_data *phar TSRMLS_DC) /* {{{ */
 		phar->signature = NULL;
 	}
 
-	if (phar->manifest.arBuckets) {
+	if (phar->manifest.arHash) {
 		zend_hash_destroy(&phar->manifest);
-		phar->manifest.arBuckets = NULL;
+		phar->manifest.arHash = NULL;
 	}
 
-	if (phar->mounted_dirs.arBuckets) {
+	if (phar->mounted_dirs.arHash) {
 		zend_hash_destroy(&phar->mounted_dirs);
-		phar->mounted_dirs.arBuckets = NULL;
+		phar->mounted_dirs.arHash = NULL;
 	}
 
-	if (phar->virtual_dirs.arBuckets) {
+	if (phar->virtual_dirs.arHash) {
 		zend_hash_destroy(&phar->virtual_dirs);
-		phar->virtual_dirs.arBuckets = NULL;
+		phar->virtual_dirs.arHash = NULL;
 	}
 
 	if (phar->metadata) {
@@ -2604,6 +2604,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert,
 	}
 
 	if (user_stub) {
+		zend_string *suser_stub;
 		if (len < 0) {
 			/* resource passed in */
 			if (!(php_stream_from_zval_no_verify(stubfile, (zval **)user_stub))) {
@@ -2623,7 +2624,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert,
 			}
 			user_stub = 0;
 
-			if (!(len = php_stream_copy_to_mem(stubfile, &user_stub, len, 0)) || !user_stub) {
+			if (!(suser_stub = php_stream_copy_to_mem(stubfile, len, 0))) {
 				if (closeoldfile) {
 					php_stream_close(oldfile);
 				}
@@ -2634,6 +2635,8 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert,
 				return EOF;
 			}
 			free_user_stub = 1;
+			user_stub = suser_stub->val;
+			len = suser_stub->len;
 		} else {
 			free_user_stub = 0;
 		}
@@ -2648,7 +2651,7 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert,
 				spprintf(error, 0, "illegal stub for phar \"%s\"", phar->fname);
 			}
 			if (free_user_stub) {
-				efree(user_stub);
+				STR_FREE(suser_stub);
 			}
 			return EOF;
 		}
@@ -2665,13 +2668,13 @@ int phar_flush(phar_archive_data *phar, char *user_stub, long len, int convert,
 				spprintf(error, 0, "unable to create stub from string in new phar \"%s\"", phar->fname);
 			}
 			if (free_user_stub) {
-				efree(user_stub);
+				STR_FREE(suser_stub);
 			}
 			return EOF;
 		}
 		phar->halt_offset = len + 5;
 		if (free_user_stub) {
-			efree(user_stub);
+			STR_FREE(suser_stub);
 		}
 	} else {
 		size_t written;
@@ -3527,11 +3530,11 @@ PHP_RSHUTDOWN_FUNCTION(phar) /* {{{ */
 	{
 		phar_release_functions(TSRMLS_C);
 		zend_hash_destroy(&(PHAR_GLOBALS->phar_alias_map));
-		PHAR_GLOBALS->phar_alias_map.arBuckets = NULL;
+		PHAR_GLOBALS->phar_alias_map.arHash = NULL;
 		zend_hash_destroy(&(PHAR_GLOBALS->phar_fname_map));
-		PHAR_GLOBALS->phar_fname_map.arBuckets = NULL;
+		PHAR_GLOBALS->phar_fname_map.arHash = NULL;
 		zend_hash_destroy(&(PHAR_GLOBALS->phar_persist_map));
-		PHAR_GLOBALS->phar_persist_map.arBuckets = NULL;
+		PHAR_GLOBALS->phar_persist_map.arHash = NULL;
 		PHAR_GLOBALS->phar_SERVER_mung_list = 0;
 
 		if (PHAR_GLOBALS->cached_fp) {
diff --git a/ext/phar/phar_object.c b/ext/phar/phar_object.c
index 407edda0fb..bb2b4a1098 100644
--- a/ext/phar/phar_object.c
+++ b/ext/phar/phar_object.c
@@ -536,7 +536,7 @@ carry_on:
 		}
 
 		return;
-	} else if (PHAR_GLOBALS->phar_fname_map.arBuckets && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, (void **)&pphar)) {
+	} else if (PHAR_GLOBALS->phar_fname_map.arHash && SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), fname, fname_len, (void **)&pphar)) {
 		goto carry_on;
 	} else if (PHAR_G(manifest_cached) && SUCCESS == zend_hash_find(&cached_phars, fname, fname_len, (void **)&pphar)) {
 		if (SUCCESS == phar_copy_on_write(pphar TSRMLS_CC)) {
@@ -1278,17 +1278,17 @@ PHP_METHOD(Phar, getSupportedSignatures)
 	
 	array_init(return_value);
 
-	add_next_index_stringl(return_value, "MD5", 3, 1);
-	add_next_index_stringl(return_value, "SHA-1", 5, 1);
+	add_next_index_stringl(return_value, "MD5", 3);
+	add_next_index_stringl(return_value, "SHA-1", 5);
 #ifdef PHAR_HASH_OK
-	add_next_index_stringl(return_value, "SHA-256", 7, 1);
-	add_next_index_stringl(return_value, "SHA-512", 7, 1);
+	add_next_index_stringl(return_value, "SHA-256", 7);
+	add_next_index_stringl(return_value, "SHA-512", 7);
 #endif
 #if PHAR_HAVE_OPENSSL
-	add_next_index_stringl(return_value, "OpenSSL", 7, 1);
+	add_next_index_stringl(return_value, "OpenSSL", 7);
 #else
 	if (zend_hash_exists(&module_registry, "openssl", sizeof("openssl"))) {
-		add_next_index_stringl(return_value, "OpenSSL", 7, 1);
+		add_next_index_stringl(return_value, "OpenSSL", 7);
 	}
 #endif
 }
@@ -1307,11 +1307,11 @@ PHP_METHOD(Phar, getSupportedCompression)
 	phar_request_initialize(TSRMLS_C);
 
 	if (PHAR_G(has_zlib)) {
-		add_next_index_stringl(return_value, "GZ", 2, 1);
+		add_next_index_stringl(return_value, "GZ", 2);
 	}
 
 	if (PHAR_G(has_bz2)) {
-		add_next_index_stringl(return_value, "BZIP2", 5, 1);
+		add_next_index_stringl(return_value, "BZIP2", 5);
 	}
 }
 /* }}} */
@@ -1716,7 +1716,9 @@ after_open_fp:
 		php_stream_close(fp);
 	}
 
-	add_assoc_string(p_obj->ret, str_key, opened, 0);
+	// TODO: avoid reallocation ???
+	add_assoc_string(p_obj->ret, str_key, opened);
+	efree(opened);
 
 	if (save) {
 		efree(save);
@@ -3087,26 +3089,28 @@ PHP_METHOD(Phar, getSignature)
 		int unknown_len;
 
 		array_init(return_value);
-		add_assoc_stringl(return_value, "hash", phar_obj->arc.archive->signature, phar_obj->arc.archive->sig_len, 1);
+		add_assoc_stringl(return_value, "hash", phar_obj->arc.archive->signature, phar_obj->arc.archive->sig_len);
 		switch(phar_obj->arc.archive->sig_flags) {
 			case PHAR_SIG_MD5:
-				add_assoc_stringl(return_value, "hash_type", "MD5", 3, 1);
+				add_assoc_stringl(return_value, "hash_type", "MD5", 3);
 				break;
 			case PHAR_SIG_SHA1:
-				add_assoc_stringl(return_value, "hash_type", "SHA-1", 5, 1);
+				add_assoc_stringl(return_value, "hash_type", "SHA-1", 5);
 				break;
 			case PHAR_SIG_SHA256:
-				add_assoc_stringl(return_value, "hash_type", "SHA-256", 7, 1);
+				add_assoc_stringl(return_value, "hash_type", "SHA-256", 7);
 				break;
 			case PHAR_SIG_SHA512:
-				add_assoc_stringl(return_value, "hash_type", "SHA-512", 7, 1);
+				add_assoc_stringl(return_value, "hash_type", "SHA-512", 7);
 				break;
 			case PHAR_SIG_OPENSSL:
-				add_assoc_stringl(return_value, "hash_type", "OpenSSL", 7, 1);
+				add_assoc_stringl(return_value, "hash_type", "OpenSSL", 7);
 				break;
 			default:
 				unknown_len = spprintf(&unknown, 0, "Unknown (%u)", phar_obj->arc.archive->sig_flags);
-				add_assoc_stringl(return_value, "hash_type", unknown, unknown_len, 0);
+				// TODO: avoid reallocation ???
+				add_assoc_stringl(return_value, "hash_type", unknown, unknown_len);
+				efree(unknown);
 				break;
 		}
 	} else {
@@ -3608,7 +3612,7 @@ PHP_METHOD(Phar, offsetGet)
 		fname_len = spprintf(&fname, 0, "phar://%s/%s", phar_obj->arc.archive->fname, fname);
 		MAKE_STD_ZVAL(zfname);
 		ZVAL_STRINGL(zfname, fname, fname_len, 0);
-		spl_instantiate_arg_ex1(phar_obj->spl.info_class, &return_value, 0, zfname TSRMLS_CC);
+		spl_instantiate_arg_ex1(phar_obj->spl.info_class, return_value, zfname TSRMLS_CC);
 		zval_ptr_dtor(&zfname);
 	}
 }
@@ -5351,21 +5355,21 @@ void phar_object_init(TSRMLS_D) /* {{{ */
 	zend_class_entry ce;
 
 	INIT_CLASS_ENTRY(ce, "PharException", phar_exception_methods);
-	phar_ce_PharException = zend_register_internal_class_ex(&ce, phar_exception_get_default(), NULL  TSRMLS_CC);
+	phar_ce_PharException = zend_register_internal_class_ex(&ce, phar_exception_get_default() TSRMLS_CC);
 
 #if HAVE_SPL
 	INIT_CLASS_ENTRY(ce, "Phar", php_archive_methods);
-	phar_ce_archive = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator, NULL  TSRMLS_CC);
+	phar_ce_archive = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator TSRMLS_CC);
 
 	zend_class_implements(phar_ce_archive TSRMLS_CC, 2, spl_ce_Countable, zend_ce_arrayaccess);
 
 	INIT_CLASS_ENTRY(ce, "PharData", php_archive_methods);
-	phar_ce_data = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator, NULL  TSRMLS_CC);
+	phar_ce_data = zend_register_internal_class_ex(&ce, spl_ce_RecursiveDirectoryIterator TSRMLS_CC);
 
 	zend_class_implements(phar_ce_data TSRMLS_CC, 2, spl_ce_Countable, zend_ce_arrayaccess);
 
 	INIT_CLASS_ENTRY(ce, "PharFileInfo", php_entry_methods);
-	phar_ce_entry = zend_register_internal_class_ex(&ce, spl_ce_SplFileInfo, NULL  TSRMLS_CC);
+	phar_ce_entry = zend_register_internal_class_ex(&ce, spl_ce_SplFileInfo TSRMLS_CC);
 #else
 	INIT_CLASS_ENTRY(ce, "Phar", php_archive_methods);
 	phar_ce_archive = zend_register_internal_class(&ce TSRMLS_CC);
diff --git a/ext/phar/stream.c b/ext/phar/stream.c
index bbd6ed00b6..c38c20d635 100644
--- a/ext/phar/stream.c
+++ b/ext/phar/stream.c
@@ -103,7 +103,7 @@ php_url* phar_parse_url(php_stream_wrapper *wrapper, const char *filename, const
 	if (mode[0] == 'w' || (mode[0] == 'r' && mode[1] == '+')) {
 		phar_archive_data **pphar = NULL, *phar;
 
-		if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arBuckets && FAILURE == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **)&pphar)) {
+		if (PHAR_GLOBALS->request_init && PHAR_GLOBALS->phar_fname_map.arHash && FAILURE == zend_hash_find(&(PHAR_GLOBALS->phar_fname_map), arch, arch_len, (void **)&pphar)) {
 			pphar = NULL;
 		}
 		if (PHAR_G(readonly) && (!pphar || !(*pphar)->is_data)) {
@@ -609,7 +609,7 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int f
 		php_url_free(resource);
 		return SUCCESS;
 	}
-	if (!phar->manifest.arBuckets) {
+	if (!phar->manifest.arHash) {
 		php_url_free(resource);
 		return FAILURE;
 	}
@@ -626,7 +626,7 @@ static int phar_wrapper_stat(php_stream_wrapper *wrapper, const char *url, int f
 		return SUCCESS;
 	}
 	/* check for mounted directories */
-	if (phar->mounted_dirs.arBuckets && zend_hash_num_elements(&phar->mounted_dirs)) {
+	if (phar->mounted_dirs.arHash && zend_hash_num_elements(&phar->mounted_dirs)) {
 		char *str_key;
 		ulong unused;
 		uint keylen;
diff --git a/ext/phar/util.c b/ext/phar/util.c
index 7029c6f26b..8aa0cf8ae0 100644
--- a/ext/phar/util.c
+++ b/ext/phar/util.c
@@ -925,7 +925,7 @@ phar_entry_info * phar_open_jit(phar_archive_data *phar, phar_entry_info *entry,
 
 PHP_PHAR_API int phar_resolve_alias(char *alias, int alias_len, char **filename, int *filename_len TSRMLS_DC) /* {{{ */ {
 	phar_archive_data **fd_ptr;
-	if (PHAR_GLOBALS->phar_alias_map.arBuckets
+	if (PHAR_GLOBALS->phar_alias_map.arHash
 			&& SUCCESS == zend_hash_find(&(PHAR_GLOBALS->phar_alias_map), alias, alias_len, (void**)&fd_ptr)) {
 		*filename = (*fd_ptr)->fname;
 		*filename_len = (*fd_ptr)->fname_len;
@@ -1253,7 +1253,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
 		return NULL;
 	}
 
-	if (!phar->manifest.arBuckets) {
+	if (!phar->manifest.arHash) {
 		return NULL;
 	}
 
@@ -1298,7 +1298,7 @@ phar_entry_info *phar_get_entry_info_dir(phar_archive_data *phar, char *path, in
 		}
 	}
 
-	if (phar->mounted_dirs.arBuckets && zend_hash_num_elements(&phar->mounted_dirs)) {
+	if (phar->mounted_dirs.arHash && zend_hash_num_elements(&phar->mounted_dirs)) {
 		char *str_key;
 		ulong unused;
 		uint keylen;
diff --git a/ext/phar/zip.c b/ext/phar/zip.c
index f8f1d5120f..2fc692c33e 100644
--- a/ext/phar/zip.c
+++ b/ext/phar/zip.c
@@ -301,11 +301,11 @@ foundit:
 	entry.is_persistent = mydata->is_persistent;
 #define PHAR_ZIP_FAIL_FREE(errmsg, save) \
 			zend_hash_destroy(&mydata->manifest); \
-			mydata->manifest.arBuckets = 0; \
+			mydata->manifest.arHash = 0; \
 			zend_hash_destroy(&mydata->mounted_dirs); \
-			mydata->mounted_dirs.arBuckets = 0; \
+			mydata->mounted_dirs.arHash = 0; \
 			zend_hash_destroy(&mydata->virtual_dirs); \
-			mydata->virtual_dirs.arBuckets = 0; \
+			mydata->virtual_dirs.arHash = 0; \
 			php_stream_close(fp); \
 			if (mydata->metadata) { \
 				zval_dtor(mydata->metadata); \
@@ -325,11 +325,11 @@ foundit:
 			return FAILURE;
 #define PHAR_ZIP_FAIL(errmsg) \
 			zend_hash_destroy(&mydata->manifest); \
-			mydata->manifest.arBuckets = 0; \
+			mydata->manifest.arHash = 0; \
 			zend_hash_destroy(&mydata->mounted_dirs); \
-			mydata->mounted_dirs.arBuckets = 0; \
+			mydata->mounted_dirs.arHash = 0; \
 			zend_hash_destroy(&mydata->virtual_dirs); \
-			mydata->virtual_dirs.arBuckets = 0; \
+			mydata->virtual_dirs.arHash = 0; \
 			php_stream_close(fp); \
 			if (mydata->metadata) { \
 				zval_dtor(mydata->metadata); \
diff --git a/ext/posix/posix.c b/ext/posix/posix.c
index 1dfa9997ed..64ef62742e 100644
--- a/ext/posix/posix.c
+++ b/ext/posix/posix.c
@@ -626,14 +626,14 @@ PHP_FUNCTION(posix_uname)
 
 	array_init(return_value);
 
-	add_assoc_string(return_value, "sysname",  u.sysname,  1);
-	add_assoc_string(return_value, "nodename", u.nodename, 1);
-	add_assoc_string(return_value, "release",  u.release,  1);
-	add_assoc_string(return_value, "version",  u.version,  1);
-	add_assoc_string(return_value, "machine",  u.machine,  1);
+	add_assoc_string(return_value, "sysname",  u.sysname);
+	add_assoc_string(return_value, "nodename", u.nodename);
+	add_assoc_string(return_value, "release",  u.release);
+	add_assoc_string(return_value, "version",  u.version);
+	add_assoc_string(return_value, "machine",  u.machine);
 
 #if defined(_GNU_SOURCE) && !defined(DARWIN) && defined(HAVE_UTSNAME_DOMAINNAME)
-	add_assoc_string(return_value, "domainname", u.domainname, 1);
+	add_assoc_string(return_value, "domainname", u.domainname);
 #endif
 }
 /* }}} */
@@ -925,10 +925,10 @@ int php_posix_group_to_array(struct group *g, zval *array_group) /* {{{ */
 	MAKE_STD_ZVAL(array_members);
 	array_init(array_members);
 	
-	add_assoc_string(array_group, "name", g->gr_name, 1);
-	add_assoc_string(array_group, "passwd", g->gr_passwd, 1);
+	add_assoc_string(array_group, "name", g->gr_name);
+	add_assoc_string(array_group, "passwd", g->gr_passwd);
 	for (count=0; g->gr_mem[count] != NULL; count++) {
-		add_next_index_string(array_members, g->gr_mem[count], 1);
+		add_next_index_string(array_members, g->gr_mem[count]);
 	}
 	zend_hash_update(Z_ARRVAL_P(array_group), "members", sizeof("members"), (void*)&array_members, sizeof(zval*), NULL);
 	add_assoc_long(array_group, "gid", g->gr_gid);
@@ -1094,13 +1094,13 @@ int php_posix_passwd_to_array(struct passwd *pw, zval *return_value) /* {{{ */
 	if (NULL == return_value || Z_TYPE_P(return_value) != IS_ARRAY)
 		return 0;
 
-	add_assoc_string(return_value, "name",      pw->pw_name, 1);
-	add_assoc_string(return_value, "passwd",    pw->pw_passwd, 1);
+	add_assoc_string(return_value, "name",      pw->pw_name);
+	add_assoc_string(return_value, "passwd",    pw->pw_passwd);
 	add_assoc_long  (return_value, "uid",       pw->pw_uid);
 	add_assoc_long  (return_value, "gid",		pw->pw_gid);
-	add_assoc_string(return_value, "gecos",     pw->pw_gecos, 1);
-	add_assoc_string(return_value, "dir",       pw->pw_dir, 1);
-	add_assoc_string(return_value, "shell",     pw->pw_shell, 1);
+	add_assoc_string(return_value, "gecos",     pw->pw_gecos);
+	add_assoc_string(return_value, "dir",       pw->pw_dir);
+	add_assoc_string(return_value, "shell",     pw->pw_shell);
 	return 1;
 }
 /* }}} */
@@ -1227,13 +1227,13 @@ static int posix_addlimit(int limit, char *name, zval *return_value TSRMLS_DC) {
 	}
 
 	if (rl.rlim_cur == RLIM_INFINITY) {
-		add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
+		add_assoc_stringl(return_value, soft, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
 	} else {
 		add_assoc_long(return_value, soft, rl.rlim_cur);
 	}
 
 	if (rl.rlim_max == RLIM_INFINITY) {
-		add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1, 1);
+		add_assoc_stringl(return_value, hard, UNLIMITED_STRING, sizeof(UNLIMITED_STRING)-1);
 	} else {
 		add_assoc_long(return_value, hard, rl.rlim_max);
 	}
diff --git a/ext/pspell/pspell.c b/ext/pspell/pspell.c
index 85199d621d..0d053e5532 100644
--- a/ext/pspell/pspell.c
+++ b/ext/pspell/pspell.c
@@ -534,7 +534,7 @@ static PHP_FUNCTION(pspell_suggest)
 	if (wl) {
 		PspellStringEmulation *els = pspell_word_list_elements(wl);
 		while ((sug = pspell_string_emulation_next(els)) != 0) {
-			add_next_index_string(return_value,(char *)sug,1);
+			add_next_index_string(return_value,(char *)sug);
 		}
 		delete_pspell_string_emulation(els);
 	} else {
diff --git a/ext/readline/readline.c b/ext/readline/readline.c
index 4bd9103462..3af1caabea 100644
--- a/ext/readline/readline.c
+++ b/ext/readline/readline.c
@@ -247,21 +247,21 @@ PHP_FUNCTION(readline_info)
 
 	if (!what) {
 		array_init(return_value);
-		add_assoc_string(return_value,"line_buffer",SAFE_STRING(rl_line_buffer),1);
+		add_assoc_string(return_value,"line_buffer",SAFE_STRING(rl_line_buffer));
 		add_assoc_long(return_value,"point",rl_point);
 		add_assoc_long(return_value,"end",rl_end);
 #ifdef HAVE_LIBREADLINE
 		add_assoc_long(return_value,"mark",rl_mark);
 		add_assoc_long(return_value,"done",rl_done);
 		add_assoc_long(return_value,"pending_input",rl_pending_input);
-		add_assoc_string(return_value,"prompt",SAFE_STRING(rl_prompt),1);
-		add_assoc_string(return_value,"terminal_name",(char *)SAFE_STRING(rl_terminal_name),1);
+		add_assoc_string(return_value,"prompt",SAFE_STRING(rl_prompt));
+		add_assoc_string(return_value,"terminal_name",(char *)SAFE_STRING(rl_terminal_name));
 #endif
 #if HAVE_ERASE_EMPTY_LINE
 		add_assoc_long(return_value,"erase_empty_line",rl_erase_empty_line);
 #endif
-		add_assoc_string(return_value,"library_version",(char *)SAFE_STRING(rl_library_version),1);
-		add_assoc_string(return_value,"readline_name",(char *)SAFE_STRING(rl_readline_name),1);
+		add_assoc_string(return_value,"library_version",(char *)SAFE_STRING(rl_library_version));
+		add_assoc_string(return_value,"readline_name",(char *)SAFE_STRING(rl_readline_name));
 		add_assoc_long(return_value,"attempted_completion_over",rl_attempted_completion_over);
 	} else {
 		if (!strcasecmp(what,"line_buffer")) {
@@ -383,7 +383,7 @@ PHP_FUNCTION(readline_list_history)
 	if (history) {
 		int i;
 		for (i = 0; history[i]; i++) {
-			add_next_index_string(return_value,history[i]->line,1);
+			add_next_index_string(return_value,history[i]->line);
 		}
 	}
 }
diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index 703e14113f..c3f02fe079 100644
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -42,11 +42,10 @@
 #include "zend_extensions.h"
 
 #define reflection_update_property(object, name, value) do { \
-		zval *member; \
-		MAKE_STD_ZVAL(member); \
-		ZVAL_STRINGL(member, name, sizeof(name)-1, 1); \
-		zend_std_write_property(object, member, value, NULL TSRMLS_CC); \
-		Z_DELREF_P(value); \
+		zval member; \
+		ZVAL_STRINGL(&member, name, sizeof(name)-1); \
+		zend_std_write_property(object, &member, value, -1 TSRMLS_CC); \
+		if (Z_REFCOUNTED_P(value)) Z_DELREF_P(value); \
 		zval_ptr_dtor(&member); \
 	} while (0)
 
@@ -84,7 +83,7 @@ ZEND_DECLARE_MODULE_GLOBALS(reflection)
 /* Method macros */
 
 #define METHOD_NOTSTATIC(ce)                                                                                \
-	if (!this_ptr || !instanceof_function(Z_OBJCE_P(this_ptr), ce TSRMLS_CC)) {                             \
+	if (!Z_OBJ(EG(This)) || !instanceof_function(Z_OBJCE(EG(This)), ce TSRMLS_CC)) {           \
 		php_error_docref(NULL TSRMLS_CC, E_ERROR, "%s() cannot be called statically", get_active_function_name(TSRMLS_C));        \
 		return;                                                                                             \
 	}                                                                                                       \
@@ -95,16 +94,19 @@ ZEND_DECLARE_MODULE_GLOBALS(reflection)
 	return;                                                                                                 \
 
 #define RETURN_ON_EXCEPTION                                                                                 \
-	if (EG(exception) && Z_OBJCE_P(EG(exception)) == reflection_exception_ptr) {                            \
+	if (EG(exception) && EG(exception)->ce == reflection_exception_ptr) {                            \
 		return;                                                                                             \
 	}
 
-#define GET_REFLECTION_OBJECT_PTR(target)                                                                   \
-	intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC);                       \
+#define GET_REFLECTION_OBJECT()	                                                                   			\
+	intern = Z_REFLECTION_P(getThis());                                                      				\
 	if (intern == NULL || intern->ptr == NULL) {                                                            \
 		RETURN_ON_EXCEPTION                                                                                 \
 		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the reflection object");                    \
 	}                                                                                                       \
+
+#define GET_REFLECTION_OBJECT_PTR(target)                                                                   \
+	GET_REFLECTION_OBJECT()																					\
 	target = intern->ptr;                                                                                   \
 
 /* Class constants */
@@ -113,17 +115,16 @@ ZEND_DECLARE_MODULE_GLOBALS(reflection)
 
 /* {{{ Smart string functions */
 typedef struct _string {
-	char *string;
-	int len;
+	zend_string *buf;
 	int alloced;
 } string;
 
 static void string_init(string *str)
 {
-	str->string = (char *) emalloc(1024);
-	str->len = 1;
+	str->buf= STR_ALLOC(1024, 0);
 	str->alloced = 1024;
-	*str->string = '\0';
+	str->buf->val[0] = '\0';
+	str->buf->len = 0;
 }
 
 static string *string_printf(string *str, const char *format, ...)
@@ -135,13 +136,15 @@ static string *string_printf(string *str, const char *format, ...)
 	va_start(arg, format);
 	len = zend_vspprintf(&s_tmp, 0, format, arg);
 	if (len) {
-		register int nlen = (str->len + len + (1024 - 1)) & ~(1024 - 1);
+		register int nlen = (str->buf->len + 1 + len + (1024 - 1)) & ~(1024 - 1);
 		if (str->alloced < nlen) {
+			int old_len = str->buf->len;
 			str->alloced = nlen;
-			str->string = erealloc(str->string, str->alloced);
+			str->buf = STR_REALLOC(str->buf, str->alloced, 0);
+			str->buf->len = old_len;
 		}
-		memcpy(str->string + str->len - 1, s_tmp, len + 1);
-		str->len += len;
+		memcpy(str->buf->val + str->buf->len, s_tmp, len + 1);
+		str->buf->len += len;
 	}
 	efree(s_tmp);
 	va_end(arg);
@@ -150,31 +153,32 @@ static string *string_printf(string *str, const char *format, ...)
 
 static string *string_write(string *str, char *buf, int len)
 {
-	register int nlen = (str->len + len + (1024 - 1)) & ~(1024 - 1);
+	register int nlen = (str->buf->len + 1 + len + (1024 - 1)) & ~(1024 - 1);
 	if (str->alloced < nlen) {
+		int old_len = str->buf->len;
 		str->alloced = nlen;
-		str->string = erealloc(str->string, str->alloced);
+		str->buf = STR_REALLOC(str->buf, str->alloced, 0);
+		str->buf->len = old_len;
 	}
-	memcpy(str->string + str->len - 1, buf, len);
-	str->len += len;
-	str->string[str->len - 1] = '\0';
+	memcpy(str->buf->val + str->buf->len, buf, len);
+	str->buf->len += len;
+	str->buf->val[str->buf->len] = '\0';
 	return str;
 }
 
 static string *string_append(string *str, string *append)
 {
-	if (append->len > 1) {
-		string_write(str, append->string, append->len - 1);
+	if (append->buf->len > 0) {
+		string_write(str, append->buf->val, append->buf->len);
 	}
 	return str;
 }
 
 static void string_free(string *str)
 {
-	efree(str->string);
-	str->len = 0;
+	STR_RELEASE(str->buf);
 	str->alloced = 0;
-	str->string = NULL;
+	str->buf = NULL;
 }
 /* }}} */
 
@@ -204,27 +208,42 @@ typedef enum {
 
 /* Struct for reflection objects */
 typedef struct {
-	zend_object zo;
+	zval dummy; /* holder for the second property */
 	void *ptr;
 	reflection_type_t ref_type;
-	zval *obj;
+	zval obj;
 	zend_class_entry *ce;
 	unsigned int ignore_visibility:1;
+	zend_object zo;
 } reflection_object;
 
+static inline reflection_object *reflection_object_from_obj(zend_object *obj) /* {{{ */ {
+	return (reflection_object*)((char*)(obj) - XtOffsetOf(reflection_object, zo));
+}
+
+#define Z_REFLECTION_P(zv)  reflection_object_from_obj(Z_OBJ_P((zv)))
 /* }}} */
 
 static zend_object_handlers reflection_object_handlers;
 
+static zval *_default_load_entry(zval *object, char *name, int name_len TSRMLS_DC) /* {{{ */
+{
+	zval *value;
+
+	if ((value = zend_hash_str_find_ind(Z_OBJPROP_P(object), name, name_len)) == NULL) {
+		return NULL;
+	}
+	return value;
+}
+
 static void _default_get_entry(zval *object, char *name, int name_len, zval *return_value TSRMLS_DC) /* {{{ */
 {
-	zval **value;
+	zval *value;
 
-	if (zend_hash_find(Z_OBJPROP_P(object), name, name_len, (void **) &value) == FAILURE) {
+	if ((value = _default_load_entry(object, name, name_len TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-
-	MAKE_COPY_ZVAL(value, return_value);
+	ZVAL_DUP(return_value, value);
 }
 /* }}} */
 
@@ -260,7 +279,7 @@ static zend_function *_copy_function(zend_function *fptr TSRMLS_DC) /* {{{ */
 		zend_function *copy_fptr;
 		copy_fptr = emalloc(sizeof(zend_function));
 		memcpy(copy_fptr, fptr, sizeof(zend_function));
-		copy_fptr->internal_function.function_name = estrdup(fptr->internal_function.function_name);
+		copy_fptr->internal_function.function_name = STR_COPY(fptr->internal_function.function_name);
 		return copy_fptr;
 	} else {
 		/* no copy needed */
@@ -275,15 +294,15 @@ static void _free_function(zend_function *fptr TSRMLS_DC) /* {{{ */
 		&& fptr->type == ZEND_INTERNAL_FUNCTION
 		&& (fptr->internal_function.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) != 0)
 	{
-		efree((char*)fptr->internal_function.function_name);
+		STR_RELEASE(fptr->internal_function.function_name);
 		efree(fptr);
 	}
 }
 /* }}} */
 
-static void reflection_free_objects_storage(void *object TSRMLS_DC) /* {{{ */
+static void reflection_free_objects_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	reflection_object *intern = (reflection_object *) object;
+	reflection_object *intern = reflection_object_from_obj(object);
 	parameter_reference *reference;
 	property_reference *prop_reference;
 
@@ -302,7 +321,7 @@ static void reflection_free_objects_storage(void *object TSRMLS_DC) /* {{{ */
 			break;
 		case REF_TYPE_DYNAMIC_PROPERTY:
 			prop_reference = (property_reference*)intern->ptr;
-			efree((char*)prop_reference->prop.name);
+			STR_RELEASE(prop_reference->prop.name);
 			efree(intern->ptr);
 			break;
 		case REF_TYPE_OTHER:
@@ -310,38 +329,28 @@ static void reflection_free_objects_storage(void *object TSRMLS_DC) /* {{{ */
 		}
 	}
 	intern->ptr = NULL;
-	if (intern->obj) {
-		zval_ptr_dtor(&intern->obj);
-	}
-	zend_objects_free_object_storage(object TSRMLS_CC);
+	zval_ptr_dtor(&intern->obj);
+	zend_object_std_dtor(object TSRMLS_CC);
 }
 /* }}} */
 
-static zend_object_value reflection_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *reflection_objects_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	zend_object_value retval;
 	reflection_object *intern;
 
-	intern = ecalloc(1, sizeof(reflection_object));
+	intern = ecalloc(1, sizeof(reflection_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 	intern->zo.ce = class_type;
 
 	zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
 	object_properties_init(&intern->zo, class_type);
-	retval.handle = zend_objects_store_put(intern, NULL, reflection_free_objects_storage, NULL TSRMLS_CC);
-	retval.handlers = &reflection_object_handlers;
-	return retval;
+	intern->zo.handlers = &reflection_object_handlers;
+	return &intern->zo;
 }
 /* }}} */
 
-static zval * reflection_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC) /* {{{ */
+static zval *reflection_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC) /* {{{ */
 {
-	if (!object) {
-		ALLOC_ZVAL(object);
-	}
-	Z_TYPE_P(object) = IS_OBJECT;
 	object_init_ex(object, pce);
-	Z_SET_REFCOUNT_P(object, 1);
-	Z_SET_ISREF_P(object);
 	return object;
 }
 /* }}} */
@@ -368,7 +377,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 		string_write(str, "\n", 1);
 	}
 
-	if (obj) {
+	if (obj && Z_TYPE_P(obj) == IS_OBJECT) {
 		string_printf(str, "%sObject of class [ ", indent);
 	} else {
 		char *kind = "Class";
@@ -400,28 +409,28 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 		}
 		string_printf(str, "class ");
 	}
-	string_printf(str, "%s", ce->name);
+	string_printf(str, "%s", ce->name->val);
 	if (ce->parent) {
-		string_printf(str, " extends %s", ce->parent->name);
+		string_printf(str, " extends %s", ce->parent->name->val);
 	}
 
 	if (ce->num_interfaces) {
 		zend_uint i;
 
 		if (ce->ce_flags & ZEND_ACC_INTERFACE) {
-			string_printf(str, " extends %s", ce->interfaces[0]->name);
+			string_printf(str, " extends %s", ce->interfaces[0]->name->val);
 		} else {
-			string_printf(str, " implements %s", ce->interfaces[0]->name);
+			string_printf(str, " implements %s", ce->interfaces[0]->name->val);
 		}
 		for (i = 1; i < ce->num_interfaces; ++i) {
-			string_printf(str, ", %s", ce->interfaces[i]->name);
+			string_printf(str, ", %s", ce->interfaces[i]->name->val);
 		}
 	}
 	string_printf(str, " ] {\n");
 
 	/* The information where a class is declared is only available for user classes */
 	if (ce->type == ZEND_USER_CLASS) {
-		string_printf(str, "%s  @@ %s %d-%d\n", indent, ce->info.user.filename,
+		string_printf(str, "%s  @@ %s %d-%d\n", indent, ce->info.user.filename->val,
 						ce->info.user.line_start, ce->info.user.line_end);
 	}
 
@@ -433,17 +442,16 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 		string_printf(str, "%s  - Constants [%d] {\n", indent, count);
 		if (count > 0) {
 			HashPosition pos;
-			zval **value;
-			char *key;
-			uint key_len;
+			zval *value;
+			zend_string *key;
 			ulong num_index;
 
 			zend_hash_internal_pointer_reset_ex(&ce->constants_table, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->constants_table, (void **) &value, &pos) == SUCCESS) {
-				zend_hash_get_current_key_ex(&ce->constants_table, &key, &key_len, &num_index, 0, &pos);
+			while ((value = zend_hash_get_current_data_ex(&ce->constants_table, &pos)) != NULL) {
+				zend_hash_get_current_key_ex(&ce->constants_table, &key, &num_index, 0, &pos);
 
-				_const_string(str, key, *value, indent TSRMLS_CC);
+				_const_string(str, key->val, value, indent TSRMLS_CC);
 				zend_hash_move_forward_ex(&ce->constants_table, &pos);
 			}
 		}
@@ -460,7 +468,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 
 			zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop, &pos) == SUCCESS) {
+			while ((prop = zend_hash_get_current_data_ptr_ex(&ce->properties_info, &pos)) != NULL) {
 				if(prop->flags & ZEND_ACC_SHADOW) {
 					count_shadow_props++;
 				} else if (prop->flags & ZEND_ACC_STATIC) {
@@ -478,9 +486,9 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 
 			zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop, &pos) == SUCCESS) {
+			while ((prop = zend_hash_get_current_data_ptr_ex(&ce->properties_info, &pos)) != NULL) {
 				if ((prop->flags & ZEND_ACC_STATIC) && !(prop->flags & ZEND_ACC_SHADOW)) {
-					_property_string(str, prop, NULL, sub_indent.string TSRMLS_CC);
+					_property_string(str, prop, NULL, sub_indent.buf->val TSRMLS_CC);
 				}
 
 				zend_hash_move_forward_ex(&ce->properties_info, &pos);
@@ -499,7 +507,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 
 			zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
+			while ((mptr = zend_hash_get_current_data_ptr_ex(&ce->function_table, &pos)) != NULL) {
 				if (mptr->common.fn_flags & ZEND_ACC_STATIC
 					&& ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))
 				{
@@ -517,12 +525,12 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 
 			zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
+			while ((mptr = zend_hash_get_current_data_ptr_ex(&ce->function_table, &pos)) != NULL) {
 				if (mptr->common.fn_flags & ZEND_ACC_STATIC
 					&& ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))
 				{
 					string_printf(str, "\n");
-					_function_string(str, mptr, ce, sub_indent.string TSRMLS_CC);
+					_function_string(str, mptr, ce, sub_indent.buf->val TSRMLS_CC);
 				}
 				zend_hash_move_forward_ex(&ce->function_table, &pos);
 			}
@@ -542,9 +550,9 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 
 			zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop, &pos) == SUCCESS) {
+			while ((prop = zend_hash_get_current_data_ptr_ex(&ce->properties_info, &pos)) != NULL) {
 				if (!(prop->flags & (ZEND_ACC_STATIC|ZEND_ACC_SHADOW))) {
-					_property_string(str, prop, NULL, sub_indent.string TSRMLS_CC);
+					_property_string(str, prop, NULL, sub_indent.buf->val TSRMLS_CC);
 				}
 				zend_hash_move_forward_ex(&ce->properties_info, &pos);
 			}
@@ -552,7 +560,7 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 		string_printf(str, "%s  }\n", indent);
 	}
 
-	if (obj && Z_OBJ_HT_P(obj)->get_properties) {
+	if (obj && Z_TYPE_P(obj) == IS_OBJECT && Z_OBJ_HT_P(obj)->get_properties) {
 		string       dyn;
 		HashTable    *properties = Z_OBJ_HT_P(obj)->get_properties(obj TSRMLS_CC);
 		HashPosition pos;
@@ -564,19 +572,17 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 		if (properties && zend_hash_num_elements(properties)) {
 			zend_hash_internal_pointer_reset_ex(properties, &pos);
 
-			while (zend_hash_get_current_data_ex(properties, (void **) &prop, &pos) == SUCCESS) {
-				char  *prop_name;
-				uint  prop_name_size;
+			while ((prop = zend_hash_get_current_data_ptr_ex(properties, &pos)) != NULL) {
+				zend_string *prop_name;
 				ulong index;
 
-				if (zend_hash_get_current_key_ex(properties, &prop_name, &prop_name_size, &index, 1, &pos) == HASH_KEY_IS_STRING) {
-					if (prop_name_size && prop_name[0]) { /* skip all private and protected properties */
-						if (!zend_hash_quick_exists(&ce->properties_info, prop_name, prop_name_size, zend_get_hash_value(prop_name, prop_name_size))) {
+				if (zend_hash_get_current_key_ex(properties, &prop_name, &index, 0, &pos) == HASH_KEY_IS_STRING) {
+					if (prop_name->len && prop_name->val[0]) { /* skip all private and protected properties */
+						if (!zend_hash_exists(&ce->properties_info, prop_name)) {
 							count++;
-							_property_string(&dyn, NULL, prop_name, sub_indent.string TSRMLS_CC);
+							_property_string(&dyn, NULL, prop_name->val, sub_indent.buf->val TSRMLS_CC);
 						}
 					}
-					efree(prop_name);
 				}
 				zend_hash_move_forward_ex(properties, &pos);
 			}
@@ -600,33 +606,32 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 			string_init(&dyn);
 			zend_hash_internal_pointer_reset_ex(&ce->function_table, &pos);
 
-			while (zend_hash_get_current_data_ex(&ce->function_table, (void **) &mptr, &pos) == SUCCESS) {
+			while ((mptr = zend_hash_get_current_data_ptr_ex(&ce->function_table, &pos)) != NULL) {
 				if ((mptr->common.fn_flags & ZEND_ACC_STATIC) == 0
 					&& ((mptr->common.fn_flags & ZEND_ACC_PRIVATE) == 0 || mptr->common.scope == ce))
 				{
-					char *key;
-					uint key_len;
+					zend_string *key;
 					ulong num_index;
-					uint len = strlen(mptr->common.function_name);
+					uint len = mptr->common.function_name->len;
 
 					/* Do not display old-style inherited constructors */
 					if ((mptr->common.fn_flags & ZEND_ACC_CTOR) == 0
 						|| mptr->common.scope == ce
-						|| zend_hash_get_current_key_ex(&ce->function_table, &key, &key_len, &num_index, 0, &pos) != HASH_KEY_IS_STRING
-						|| zend_binary_strcasecmp(key, key_len-1, mptr->common.function_name, len) == 0)
+						|| zend_hash_get_current_key_ex(&ce->function_table, &key, &num_index, 0, &pos) != HASH_KEY_IS_STRING
+						|| zend_binary_strcasecmp(key->val, key->len, mptr->common.function_name->val, len) == 0)
 					{
 						zend_function *closure;
 						/* see if this is a closure */
 						if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
-							&& memcmp(mptr->common.function_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
-							&& (closure = zend_get_closure_invoke_method(obj TSRMLS_CC)) != NULL)
+							&& memcmp(mptr->common.function_name->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
+							&& (closure = zend_get_closure_invoke_method(Z_OBJ_P(obj) TSRMLS_CC)) != NULL)
 						{
 							mptr = closure;
 						} else {
 							closure = NULL;
 						}
 						string_printf(&dyn, "\n");
-						_function_string(&dyn, mptr, ce, sub_indent.string TSRMLS_CC);
+						_function_string(&dyn, mptr, ce, sub_indent.buf->val TSRMLS_CC);
 						count++;
 						_free_function(closure TSRMLS_CC);
 					}
@@ -653,23 +658,13 @@ static void _class_string(string *str, zend_class_entry *ce, zval *obj, char *in
 /* {{{ _const_string */
 static void _const_string(string *str, char *name, zval *value, char *indent TSRMLS_DC)
 {
-	char *type;
-	zval value_copy;
-	int use_copy;
-
-	type = zend_zval_type_name(value);
-
-	zend_make_printable_zval(value, &value_copy, &use_copy);
-	if (use_copy) {
-		value = &value_copy;
-	}
+	char *type = zend_zval_type_name(value);
+	zend_string *value_str = zval_get_string(value);
 
 	string_printf(str, "%s    Constant [ %s %s ] { %s }\n",
-					indent, type, name, Z_STRVAL_P(value));
+					indent, type, name, value_str->val);
 
-	if (use_copy) {
-		zval_dtor(value);
-	}
+	STR_RELEASE(value_str);
 }
 /* }}} */
 
@@ -726,37 +721,31 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg
 	if (fptr->type == ZEND_USER_FUNCTION && offset >= required) {
 		zend_op *precv = _get_recv_op((zend_op_array*)fptr, offset);
 		if (precv && precv->opcode == ZEND_RECV_INIT && precv->op2_type != IS_UNUSED) {
-			zval *zv, zv_copy;
-			int use_copy;
+			zval zv;
 			string_write(str, " = ", sizeof(" = ")-1);
-			ALLOC_ZVAL(zv);
-			*zv = *precv->op2.zv;
-			zval_copy_ctor(zv);
-			INIT_PZVAL(zv);
+			ZVAL_DUP(&zv, precv->op2.zv);
 			zval_update_constant_ex(&zv, 1, fptr->common.scope TSRMLS_CC);
-			if (Z_TYPE_P(zv) == IS_BOOL) {
-				if (Z_LVAL_P(zv)) {
+			if (Z_TYPE(zv) == IS_BOOL) {
+				if (Z_LVAL(zv)) {
 					string_write(str, "true", sizeof("true")-1);
 				} else {
 					string_write(str, "false", sizeof("false")-1);
 				}
-			} else if (Z_TYPE_P(zv) == IS_NULL) {
+			} else if (Z_TYPE(zv) == IS_NULL) {
 				string_write(str, "NULL", sizeof("NULL")-1);
-			} else if (Z_TYPE_P(zv) == IS_STRING) {
+			} else if (Z_TYPE(zv) == IS_STRING) {
 				string_write(str, "'", sizeof("'")-1);
-				string_write(str, Z_STRVAL_P(zv), MIN(Z_STRLEN_P(zv), 15));
-				if (Z_STRLEN_P(zv) > 15) {
+				string_write(str, Z_STRVAL(zv), MIN(Z_STRLEN(zv), 15));
+				if (Z_STRLEN(zv) > 15) {
 					string_write(str, "...", sizeof("...")-1);
 				}
 				string_write(str, "'", sizeof("'")-1);
-			} else if (Z_TYPE_P(zv) == IS_ARRAY) {
+			} else if (Z_TYPE(zv) == IS_ARRAY) {
 				string_write(str, "Array", sizeof("Array")-1);
 			} else {
-				zend_make_printable_zval(zv, &zv_copy, &use_copy);
-				string_write(str, Z_STRVAL(zv_copy), Z_STRLEN(zv_copy));
-				if (use_copy) {
-					zval_dtor(&zv_copy);
-				}
+				zend_string *zv_str = zval_get_string(&zv);
+				string_write(str, zv_str->val, zv_str->len);
+				STR_RELEASE(zv_str);
 			}
 			zval_ptr_dtor(&zv);
 		}
@@ -792,8 +781,7 @@ static void _function_closure_string(string *str, zend_function *fptr, char* ind
 {
 	zend_uint i, count;
 	ulong num_index;
-	char *key;
-	uint key_len;
+	zend_string *key;
 	HashTable *static_variables;
 	HashPosition pos;
 
@@ -813,8 +801,8 @@ static void _function_closure_string(string *str, zend_function *fptr, char* ind
 	zend_hash_internal_pointer_reset_ex(static_variables, &pos);
 	i = 0;
 	while (i < count) {
-		zend_hash_get_current_key_ex(static_variables, &key, &key_len, &num_index, 0, &pos);
-		string_printf(str, "%s    Variable #%d [ $%s ]\n", indent, i++, key);
+		zend_hash_get_current_key_ex(static_variables, &key, &num_index, 0, &pos);
+		string_printf(str, "%s    Variable #%d [ $%s ]\n", indent, i++, key->val);
 		zend_hash_move_forward_ex(static_variables, &pos);
 	}
 	string_printf(str, "%s}\n", indent);
@@ -826,7 +814,7 @@ static void _function_string(string *str, zend_function *fptr, zend_class_entry
 {
 	string param_indent;
 	zend_function *overwrites;
-	char *lc_name;
+	zend_string *lc_name;
 	unsigned int lc_name_len;
 
 	/* TBD: Repair indenting of doc comment (or is this to be done in the parser?)
@@ -834,7 +822,7 @@ static void _function_string(string *str, zend_function *fptr, zend_class_entry
 	 * swallowed, leading to an unaligned comment.
 	 */
 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
-		string_printf(str, "%s%s\n", indent, fptr->op_array.doc_comment);
+		string_printf(str, "%s%s\n", indent, fptr->op_array.doc_comment->val);
 	}
 
 	string_write(str, indent, strlen(indent));
@@ -849,20 +837,21 @@ static void _function_string(string *str, zend_function *fptr, zend_class_entry
 
 	if (scope && fptr->common.scope) {
 		if (fptr->common.scope != scope) {
-			string_printf(str, ", inherits %s", fptr->common.scope->name);
+			string_printf(str, ", inherits %s", fptr->common.scope->name->val);
 		} else if (fptr->common.scope->parent) {
-			lc_name_len = strlen(fptr->common.function_name);
-			lc_name = zend_str_tolower_dup(fptr->common.function_name, lc_name_len);
-			if (zend_hash_find(&fptr->common.scope->parent->function_table, lc_name, lc_name_len + 1, (void**) &overwrites) == SUCCESS) {
+			lc_name_len = fptr->common.function_name->len;
+			lc_name = STR_ALLOC(lc_name_len, 0);
+			zend_str_tolower_copy(lc_name->val, fptr->common.function_name->val, lc_name_len);
+			if ((overwrites = zend_hash_find_ptr(&fptr->common.scope->parent->function_table, lc_name)) != NULL) {
 				if (fptr->common.scope != overwrites->common.scope) {
-					string_printf(str, ", overwrites %s", overwrites->common.scope->name);
+					string_printf(str, ", overwrites %s", overwrites->common.scope->name->val);
 				}
 			}
 			efree(lc_name);
 		}
 	}
 	if (fptr->common.prototype && fptr->common.prototype->common.scope) {
-		string_printf(str, ", prototype %s", fptr->common.prototype->common.scope->name);
+		string_printf(str, ", prototype %s", fptr->common.prototype->common.scope->name->val);
 	}
 	if (fptr->common.fn_flags & ZEND_ACC_CTOR) {
 		string_printf(str, ", ctor");
@@ -906,20 +895,20 @@ static void _function_string(string *str, zend_function *fptr, zend_class_entry
 	if (fptr->op_array.fn_flags & ZEND_ACC_RETURN_REFERENCE) {
 		string_printf(str, "&");
 	}
-	string_printf(str, "%s ] {\n", fptr->common.function_name);
+	string_printf(str, "%s ] {\n", fptr->common.function_name->val);
 	/* The information where a function is declared is only available for user classes */
 	if (fptr->type == ZEND_USER_FUNCTION) {
 		string_printf(str, "%s  @@ %s %d - %d\n", indent,
-						fptr->op_array.filename,
+						fptr->op_array.filename->val,
 						fptr->op_array.line_start,
 						fptr->op_array.line_end);
 	}
 	string_init(&param_indent);
 	string_printf(&param_indent, "%s  ", indent);
 	if (fptr->common.fn_flags & ZEND_ACC_CLOSURE) {
-		_function_closure_string(str, fptr, param_indent.string TSRMLS_CC);
+		_function_closure_string(str, fptr, param_indent.buf->val TSRMLS_CC);
 	}
-	_function_parameter_string(str, fptr, param_indent.string TSRMLS_CC);
+	_function_parameter_string(str, fptr, param_indent.buf->val TSRMLS_CC);
 	string_free(&param_indent);
 	string_printf(str, "%s}\n", indent);
 }
@@ -958,7 +947,7 @@ static void _property_string(string *str, zend_property_info *prop, char *prop_n
 			string_printf(str, "static ");
 		}
 
-		zend_unmangle_property_name(prop->name, prop->name_length, &class_name, (const char**)&prop_name);
+		zend_unmangle_property_name(prop->name->val, prop->name->len, &class_name, (const char**)&prop_name);
 		string_printf(str, "$%s", prop_name);
 	}
 
@@ -966,8 +955,9 @@ static void _property_string(string *str, zend_property_info *prop, char *prop_n
 }
 /* }}} */
 
-static int _extension_ini_string(zend_ini_entry *ini_entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int _extension_ini_string(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
+	zend_ini_entry *ini_entry = (zend_ini_entry*)Z_PTR_P(el);
 	string *str = va_arg(args, string *);
 	char *indent = va_arg(args, char *);
 	int number = va_arg(args, int);
@@ -1002,39 +992,40 @@ static int _extension_ini_string(zend_ini_entry *ini_entry TSRMLS_DC, int num_ar
 }
 /* }}} */
 
-static int _extension_class_string(zend_class_entry **pce TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int _extension_class_string(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
+	zend_class_entry *ce = (zend_class_entry*)Z_PTR_P(el);
 	string *str = va_arg(args, string *);
 	char *indent = va_arg(args, char *);
 	struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);
 	int *num_classes = va_arg(args, int*);
 
-	if (((*pce)->type == ZEND_INTERNAL_CLASS) && (*pce)->info.internal.module && !strcasecmp((*pce)->info.internal.module->name, module->name)) {
+	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) {
 		string_printf(str, "\n");
-		_class_string(str, *pce, NULL, indent TSRMLS_CC);
+		_class_string(str, ce, NULL, indent TSRMLS_CC);
 		(*num_classes)++;
 	}
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
 
-static int _extension_const_string(zend_constant *constant TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int _extension_const_string(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
+	zend_constant *constant = (zend_constant*)Z_PTR_P(el);
 	string *str = va_arg(args, string *);
 	char *indent = va_arg(args, char *);
 	struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);
 	int *num_classes = va_arg(args, int*);
 
 	if (constant->module_number  == module->module_number) {
-		_const_string(str, constant->name, &constant->value, indent TSRMLS_CC);
+		_const_string(str, constant->name->val, &constant->value, indent TSRMLS_CC);
 		(*num_classes)++;
 	}
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
 
-/* {{{ _extension_string */
-static void _extension_string(string *str, zend_module_entry *module, char *indent TSRMLS_DC)
+static void _extension_string(string *str, zend_module_entry *module, char *indent TSRMLS_DC) /* {{{ */
 {
 	string_printf(str, "%sExtension [ ", indent);
 	if (module->type == MODULE_PERSISTENT) {
@@ -1086,7 +1077,7 @@ static void _extension_string(string *str, zend_module_entry *module, char *inde
 		string str_ini;
 		string_init(&str_ini);
 		zend_hash_apply_with_arguments(EG(ini_directives) TSRMLS_CC, (apply_func_args_t) _extension_ini_string, 3, &str_ini, indent, module->module_number);
-		if (str_ini.len > 1) {
+		if (str_ini.buf->len > 0) {
 			string_printf(str, "\n  - INI {\n");
 			string_append(str, &str_ini);
 			string_printf(str, "%s  }\n", indent);
@@ -1114,7 +1105,7 @@ static void _extension_string(string *str, zend_module_entry *module, char *inde
 		int first = 1;
 
 		zend_hash_internal_pointer_reset_ex(CG(function_table), &iterator);
-		while (zend_hash_get_current_data_ex(CG(function_table), (void **) &fptr, &iterator) == SUCCESS) {
+		while ((fptr = zend_hash_get_current_data_ptr_ex(CG(function_table), &iterator)) != NULL) {
 			if (fptr->common.type==ZEND_INTERNAL_FUNCTION
 				&& fptr->internal_function.module == module) {
 				if (first) {
@@ -1138,7 +1129,7 @@ static void _extension_string(string *str, zend_module_entry *module, char *inde
 		string_init(&sub_indent);
 		string_printf(&sub_indent, "%s    ", indent);
 		string_init(&str_classes);
-		zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) _extension_class_string, 4, &str_classes, sub_indent.string, module, &num_classes);
+		zend_hash_apply_with_arguments(EG(class_table) TSRMLS_CC, (apply_func_args_t) _extension_class_string, 4, &str_classes, sub_indent.buf->val, module, &num_classes);
 		if (num_classes) {
 			string_printf(str, "\n  - Classes [%d] {", num_classes);
 			string_append(str, &str_classes);
@@ -1191,16 +1182,15 @@ static void _function_check_flag(INTERNAL_FUNCTION_PARAMETERS, int mask)
 PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object TSRMLS_DC)
 {
 	reflection_object *intern;
-	zval *name;
+	zval name;
 
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRINGL(name, ce->name, ce->name_length, 1);
+	ZVAL_STR(&name, STR_COPY(ce->name));
 	reflection_instantiate(reflection_class_ptr, object TSRMLS_CC);
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	intern->ptr = ce;
 	intern->ref_type = REF_TYPE_OTHER;
 	intern->ce = ce;
-	reflection_update_property(object, "name", name);
+	reflection_update_property(object, "name", &name);
 }
 /* }}} */
 
@@ -1208,28 +1198,26 @@ PHPAPI void zend_reflection_class_factory(zend_class_entry *ce, zval *object TSR
 static void reflection_extension_factory(zval *object, const char *name_str TSRMLS_DC)
 {
 	reflection_object *intern;
-	zval *name;
+	zval name;
 	int name_len = strlen(name_str);
-	char *lcname;
+	zend_string *lcname;
 	struct _zend_module_entry *module;
-	ALLOCA_FLAG(use_heap)
 
-	lcname = do_alloca(name_len + 1, use_heap);
-	zend_str_tolower_copy(lcname, name_str, name_len);
-	if (zend_hash_find(&module_registry, lcname, name_len + 1, (void **)&module) == FAILURE) {
-		free_alloca(lcname, use_heap);
+	lcname = STR_ALLOC(name_len, 0);
+	zend_str_tolower_copy(lcname->val, name_str, name_len);
+	module = zend_hash_find_ptr(&module_registry, lcname);
+	STR_FREE(lcname);
+	if (!module) {
 		return;
 	}
-	free_alloca(lcname, use_heap);
 
 	reflection_instantiate(reflection_extension_ptr, object TSRMLS_CC);
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRINGL(name, module->name, name_len, 1);
+	intern = Z_REFLECTION_P(object);
+	ZVAL_STRINGL(&name, module->name, name_len);
 	intern->ptr = module;
 	intern->ref_type = REF_TYPE_OTHER;
 	intern->ce = NULL;
-	reflection_update_property(object, "name", name);
+	reflection_update_property(object, "name", &name);
 }
 /* }}} */
 
@@ -1238,19 +1226,15 @@ static void reflection_parameter_factory(zend_function *fptr, zval *closure_obje
 {
 	reflection_object *intern;
 	parameter_reference *reference;
-	zval *name;
+	zval name;
 
-	if (closure_object) {
-		Z_ADDREF_P(closure_object);
-	}
-	MAKE_STD_ZVAL(name);
 	if (arg_info->name) {
-		ZVAL_STRINGL(name, arg_info->name, arg_info->name_len, 1);
+		ZVAL_STRINGL(&name, arg_info->name, arg_info->name_len);
 	} else {
-		ZVAL_NULL(name);
+		ZVAL_NULL(&name);
 	}
 	reflection_instantiate(reflection_parameter_ptr, object TSRMLS_CC);
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	reference = (parameter_reference*) emalloc(sizeof(parameter_reference));
 	reference->arg_info = arg_info;
 	reference->offset = offset;
@@ -1259,8 +1243,11 @@ static void reflection_parameter_factory(zend_function *fptr, zval *closure_obje
 	intern->ptr = reference;
 	intern->ref_type = REF_TYPE_PARAMETER;
 	intern->ce = fptr->common.scope;
-	intern->obj = closure_object;
-	reflection_update_property(object, "name", name);
+	if (closure_object) {
+		Z_ADDREF_P(closure_object);
+		ZVAL_COPY_VALUE(&intern->obj, closure_object);
+	}
+	reflection_update_property(object, "name", &name);
 }
 /* }}} */
 
@@ -1268,21 +1255,20 @@ static void reflection_parameter_factory(zend_function *fptr, zval *closure_obje
 static void reflection_function_factory(zend_function *function, zval *closure_object, zval *object TSRMLS_DC)
 {
 	reflection_object *intern;
-	zval *name;
+	zval name;
 
-	if (closure_object) {
-		Z_ADDREF_P(closure_object);
-	}
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRING(name, function->common.function_name, 1);
+	ZVAL_STR(&name, STR_COPY(function->common.function_name));
 
 	reflection_instantiate(reflection_function_ptr, object TSRMLS_CC);
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	intern->ptr = function;
 	intern->ref_type = REF_TYPE_FUNCTION;
 	intern->ce = NULL;
-	intern->obj = closure_object;
-	reflection_update_property(object, "name", name);
+	if (closure_object) {
+		Z_ADDREF_P(closure_object);
+		ZVAL_COPY_VALUE(&intern->obj, closure_object);
+	}
+	reflection_update_property(object, "name", &name);
 }
 /* }}} */
 
@@ -1290,25 +1276,23 @@ static void reflection_function_factory(zend_function *function, zval *closure_o
 static void reflection_method_factory(zend_class_entry *ce, zend_function *method, zval *closure_object, zval *object TSRMLS_DC)
 {
 	reflection_object *intern;
-	zval *name;
-	zval *classname;
+	zval name;
+	zval classname;
 
-	if (closure_object) {
-		Z_ADDREF_P(closure_object);
-	}
-	MAKE_STD_ZVAL(name);
-	MAKE_STD_ZVAL(classname);
-	ZVAL_STRING(name, (method->common.scope && method->common.scope->trait_aliases)?
-			zend_resolve_method_name(ce, method) : method->common.function_name, 1);
-	ZVAL_STRINGL(classname, method->common.scope->name, method->common.scope->name_length, 1);
+	ZVAL_STR(&name, STR_COPY((method->common.scope && method->common.scope->trait_aliases)?
+			zend_resolve_method_name(ce, method) : method->common.function_name));
+	ZVAL_STR(&classname, STR_COPY(method->common.scope->name));
 	reflection_instantiate(reflection_method_ptr, object TSRMLS_CC);
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	intern->ptr = method;
 	intern->ref_type = REF_TYPE_FUNCTION;
 	intern->ce = ce;
-	intern->obj = closure_object;
-	reflection_update_property(object, "name", name);
-	reflection_update_property(object, "class", classname);
+	if (closure_object) {
+		Z_ADDREF_P(closure_object);
+		ZVAL_COPY_VALUE(&intern->obj, closure_object);
+	}
+	reflection_update_property(object, "name", &name);
+	reflection_update_property(object, "class", &classname);
 }
 /* }}} */
 
@@ -1316,19 +1300,19 @@ static void reflection_method_factory(zend_class_entry *ce, zend_function *metho
 static void reflection_property_factory(zend_class_entry *ce, zend_property_info *prop, zval *object TSRMLS_DC)
 {
 	reflection_object *intern;
-	zval *name;
-	zval *classname;
+	zval name;
+	zval classname;
 	property_reference *reference;
 	const char *class_name, *prop_name;
 
-	zend_unmangle_property_name(prop->name, prop->name_length, &class_name, &prop_name);
+	zend_unmangle_property_name(prop->name->val, prop->name->len, &class_name, &prop_name);
 
 	if (!(prop->flags & ZEND_ACC_PRIVATE)) {
 		/* we have to search the class hierarchy for this (implicit) public or protected property */
 		zend_class_entry *tmp_ce = ce, *store_ce = ce;
 		zend_property_info *tmp_info = NULL;
 
-		while (tmp_ce && zend_hash_find(&tmp_ce->properties_info, prop_name, strlen(prop_name) + 1, (void **) &tmp_info) != SUCCESS) {
+		while (tmp_ce && (tmp_info = zend_hash_str_find_ptr(&tmp_ce->properties_info, prop_name, strlen(prop_name))) == NULL) {
 			ce = tmp_ce;
 			tmp_ce = tmp_ce->parent;
 		}
@@ -1340,13 +1324,11 @@ static void reflection_property_factory(zend_class_entry *ce, zend_property_info
 		}
 	}
 
-	MAKE_STD_ZVAL(name);
-	MAKE_STD_ZVAL(classname);
-	ZVAL_STRING(name, prop_name, 1);
-	ZVAL_STRINGL(classname, prop->ce->name, prop->ce->name_length, 1);
+	ZVAL_STRING(&name, prop_name);
+	ZVAL_STR(&classname, STR_COPY(prop->ce->name));
 
 	reflection_instantiate(reflection_property_ptr, object TSRMLS_CC);
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	reference = (property_reference*) emalloc(sizeof(property_reference));
 	reference->ce = ce;
 	reference->prop = *prop;
@@ -1354,52 +1336,50 @@ static void reflection_property_factory(zend_class_entry *ce, zend_property_info
 	intern->ref_type = REF_TYPE_PROPERTY;
 	intern->ce = ce;
 	intern->ignore_visibility = 0;
-	reflection_update_property(object, "name", name);
-	reflection_update_property(object, "class", classname);
+	reflection_update_property(object, "name", &name);
+	reflection_update_property(object, "class", &classname);
 }
 /* }}} */
 
 /* {{{ _reflection_export */
 static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_ptr, int ctor_argc)
 {
-	zval *reflector_ptr;
+	zval reflector;
 	zval output, *output_ptr = &output;
 	zval *argument_ptr, *argument2_ptr;
-	zval *retval_ptr, **params[2];
+	zval retval, params[2];
 	int result;
 	int return_output = 0;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcc;
-	zval fname;
 
 	if (ctor_argc == 1) {
 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &argument_ptr, &return_output) == FAILURE) {
 			return;
 		}
+		ZVAL_COPY_VALUE(&params[0], argument_ptr);
+		ZVAL_NULL(&params[1]);
 	} else {
 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz|b", &argument_ptr, &argument2_ptr, &return_output) == FAILURE) {
 			return;
 		}
+		ZVAL_COPY_VALUE(&params[0], argument_ptr);
+		ZVAL_COPY_VALUE(&params[1], argument2_ptr);
 	}
 
-	INIT_PZVAL(&output);
-
 	/* Create object */
-	MAKE_STD_ZVAL(reflector_ptr);
-	if (object_and_properties_init(reflector_ptr, ce_ptr, NULL) == FAILURE) {
+	if (object_and_properties_init(&reflector, ce_ptr, NULL) == FAILURE) {
 		_DO_THROW("Could not create reflector");
 	}
 
 	/* Call __construct() */
-	params[0] = &argument_ptr;
-	params[1] = &argument2_ptr;
 
 	fci.size = sizeof(fci);
 	fci.function_table = NULL;
-	fci.function_name = NULL;
+	ZVAL_UNDEF(&fci.function_name);
 	fci.symbol_table = NULL;
-	fci.object_ptr = reflector_ptr;
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.object = Z_OBJ(reflector);
+	fci.retval = &retval;
 	fci.param_count = ctor_argc;
 	fci.params = params;
 	fci.no_separation = 1;
@@ -1407,54 +1387,53 @@ static void _reflection_export(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *c
 	fcc.initialized = 1;
 	fcc.function_handler = ce_ptr->constructor;
 	fcc.calling_scope = ce_ptr;
-	fcc.called_scope = Z_OBJCE_P(reflector_ptr);
-	fcc.object_ptr = reflector_ptr;
+	fcc.called_scope = Z_OBJCE(reflector);
+	fcc.object = Z_OBJ(reflector);
 
 	result = zend_call_function(&fci, &fcc TSRMLS_CC);
 
-	if (retval_ptr) {
-		zval_ptr_dtor(&retval_ptr);
-	}
+	zval_ptr_dtor(&retval);
 
 	if (EG(exception)) {
-		zval_ptr_dtor(&reflector_ptr);
+		zval_ptr_dtor(&reflector);
 		return;
 	}
 	if (result == FAILURE) {
-		zval_ptr_dtor(&reflector_ptr);
+		zval_ptr_dtor(&reflector);
 		_DO_THROW("Could not create reflector");
 	}
 
 	/* Call static reflection::export */
 	ZVAL_BOOL(&output, return_output);
-	params[0] = &reflector_ptr;
-	params[1] = &output_ptr;
+	ZVAL_COPY_VALUE(&params[0], &reflector);
+	ZVAL_COPY_VALUE(&params[1], output_ptr);
 
-	ZVAL_STRINGL(&fname, "reflection::export", sizeof("reflection::export") - 1, 0);
+	ZVAL_STRINGL(&fci.function_name, "reflection::export", sizeof("reflection::export") - 1);
 	fci.function_table = &reflection_ptr->function_table;
-	fci.function_name = &fname;
-	fci.object_ptr = NULL;
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.object = NULL;
+	fci.retval = &retval;
 	fci.param_count = 2;
 	fci.params = params;
 	fci.no_separation = 1;
 
 	result = zend_call_function(&fci, NULL TSRMLS_CC);
 
+	zval_ptr_dtor(&fci.function_name);
+
 	if (result == FAILURE && EG(exception) == NULL) {
-		zval_ptr_dtor(&reflector_ptr);
-		zval_ptr_dtor(&retval_ptr);
+		zval_ptr_dtor(&reflector);
+		zval_ptr_dtor(&retval);
 		_DO_THROW("Could not execute reflection::export()");
 	}
 
 	if (return_output) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+		ZVAL_COPY_VALUE(return_value, &retval);
 	} else {
-		zval_ptr_dtor(&retval_ptr);
+		zval_ptr_dtor(&retval);
 	}
 
 	/* Destruct reflector which is no longer needed */
-	zval_ptr_dtor(&reflector_ptr);
+	zval_ptr_dtor(&reflector);
 }
 /* }}} */
 
@@ -1464,9 +1443,9 @@ static parameter_reference *_reflection_param_get_default_param(INTERNAL_FUNCTIO
 	reflection_object *intern;
 	parameter_reference *param;
 
-	intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_REFLECTION_P(getThis());
 	if (intern == NULL || intern->ptr == NULL) {
-		if (EG(exception) && Z_OBJCE_P(EG(exception)) == reflection_exception_ptr) {
+		if (EG(exception) && EG(exception)->ce == reflection_exception_ptr) {
 			return NULL;
 		}
 		php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the reflection object");
@@ -1513,7 +1492,7 @@ ZEND_METHOD(reflection, __clone)
    Exports a reflection object. Returns the output if TRUE is specified for return, printing it otherwise. */
 ZEND_METHOD(reflection, export)
 {
-	zval *object, fname, *retval_ptr;
+	zval *object, fname, retval;
 	int result;
 	zend_bool return_output = 0;
 
@@ -1522,8 +1501,8 @@ ZEND_METHOD(reflection, export)
 	}
 
 	/* Invoke the __toString() method */
-	ZVAL_STRINGL(&fname, "__tostring", sizeof("__tostring") - 1, 1);
-	result= call_user_function_ex(NULL, &object, &fname, &retval_ptr, 0, NULL, 0, NULL TSRMLS_CC);
+	ZVAL_STRINGL(&fname, "__tostring", sizeof("__tostring") - 1);
+	result= call_user_function_ex(NULL, object, &fname, &retval, 0, NULL, 0, NULL TSRMLS_CC);
 	zval_dtor(&fname);
 
 	if (result == FAILURE) {
@@ -1531,18 +1510,18 @@ ZEND_METHOD(reflection, export)
 		/* Returns from this function */
 	}
 
-	if (!retval_ptr) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::__toString() did not return anything", Z_OBJCE_P(object)->name);
+	if (Z_TYPE(retval) == IS_UNDEF) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::__toString() did not return anything", Z_OBJCE_P(object)->name->val);
 		RETURN_FALSE;
 	}
 
 	if (return_output) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+		ZVAL_COPY_VALUE(return_value, &retval);
 	} else {
 		/* No need for _r variant, return of __toString should always be a string */
-		zend_print_zval(retval_ptr, 0);
+		zend_print_zval(&retval, 0 TSRMLS_CC);
 		zend_printf("\n");
-		zval_ptr_dtor(&retval_ptr);
+		zval_ptr_dtor(&retval);
 	}
 }
 /* }}} */
@@ -1560,30 +1539,30 @@ ZEND_METHOD(reflection, getModifierNames)
 	array_init(return_value);
 
 	if (modifiers & (ZEND_ACC_ABSTRACT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)) {
-		add_next_index_stringl(return_value, "abstract", sizeof("abstract")-1, 1);
+		add_next_index_stringl(return_value, "abstract", sizeof("abstract")-1);
 	}
 	if (modifiers & (ZEND_ACC_FINAL | ZEND_ACC_FINAL_CLASS)) {
-		add_next_index_stringl(return_value, "final", sizeof("final")-1, 1);
+		add_next_index_stringl(return_value, "final", sizeof("final")-1);
 	}
 	if (modifiers & ZEND_ACC_IMPLICIT_PUBLIC) {
-		add_next_index_stringl(return_value, "public", sizeof("public")-1, 1);
+		add_next_index_stringl(return_value, "public", sizeof("public")-1);
 	}
 
 	/* These are mutually exclusive */
 	switch (modifiers & ZEND_ACC_PPP_MASK) {
 		case ZEND_ACC_PUBLIC:
-			add_next_index_stringl(return_value, "public", sizeof("public")-1, 1);
+			add_next_index_stringl(return_value, "public", sizeof("public")-1);
 			break;
 		case ZEND_ACC_PRIVATE:
-			add_next_index_stringl(return_value, "private", sizeof("private")-1, 1);
+			add_next_index_stringl(return_value, "private", sizeof("private")-1);
 			break;
 		case ZEND_ACC_PROTECTED:
-			add_next_index_stringl(return_value, "protected", sizeof("protected")-1, 1);
+			add_next_index_stringl(return_value, "protected", sizeof("protected")-1);
 			break;
 	}
 
 	if (modifiers & ZEND_ACC_STATIC) {
-		add_next_index_stringl(return_value, "static", sizeof("static")-1, 1);
+		add_next_index_stringl(return_value, "static", sizeof("static")-1);
 	}
 }
 /* }}} */
@@ -1600,7 +1579,7 @@ ZEND_METHOD(reflection_function, export)
    Constructor. Throws an Exception in case the given function does not exist */
 ZEND_METHOD(reflection_function, __construct)
 {
-	zval *name;
+	zval name;
 	zval *object;
 	zval *closure = NULL;
 	char *lcname;
@@ -1610,7 +1589,7 @@ ZEND_METHOD(reflection_function, __construct)
 	int name_len;
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
@@ -1630,7 +1609,7 @@ ZEND_METHOD(reflection_function, __construct)
 			name_len--;
 		}
 
-		if (zend_hash_find(EG(function_table), nsname, name_len + 1, (void **)&fptr) == FAILURE) {
+		if ((fptr = zend_hash_str_find_ptr(EG(function_table), nsname, name_len)) == NULL) {
 			efree(lcname);
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 				"Function %s() does not exist", name_str);
@@ -1641,12 +1620,15 @@ ZEND_METHOD(reflection_function, __construct)
 		return;
 	}
 
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRING(name, fptr->common.function_name, 1);
-	reflection_update_property(object, "name", name);
+	ZVAL_STR(&name, STR_COPY(fptr->common.function_name));
+	reflection_update_property(object, "name", &name);
 	intern->ptr = fptr;
 	intern->ref_type = REF_TYPE_FUNCTION;
-	intern->obj = closure;
+	if (closure) {
+		ZVAL_COPY_VALUE(&intern->obj, closure);
+	} else {
+		ZVAL_UNDEF(&intern->obj);
+	}
 	intern->ce = NULL;
 }
 /* }}} */
@@ -1665,7 +1647,7 @@ ZEND_METHOD(reflection_function, __toString)
 	GET_REFLECTION_OBJECT_PTR(fptr);
 	string_init(&str);
 	_function_string(&str, fptr, intern->ce, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -1676,7 +1658,7 @@ ZEND_METHOD(reflection_function, getName)
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	_default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
+	_default_get_entry(getThis(), "name", sizeof("name")-1, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -1700,16 +1682,15 @@ ZEND_METHOD(reflection_function, isClosure)
 ZEND_METHOD(reflection_function, getClosureThis)
 {
 	reflection_object *intern;
-	zend_function *fptr;
 	zval* closure_this;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	GET_REFLECTION_OBJECT_PTR(fptr);
-	if (intern->obj) {
-		closure_this = zend_get_closure_this_ptr(intern->obj TSRMLS_CC);
-		if (closure_this) {
+	GET_REFLECTION_OBJECT();
+	if (!ZVAL_IS_UNDEF(&intern->obj)) {
+		closure_this = zend_get_closure_this_ptr(&intern->obj TSRMLS_CC);
+		if (!ZVAL_IS_UNDEF(closure_this)) {
 			RETURN_ZVAL(closure_this, 1, 0);
 		}
 	}
@@ -1721,15 +1702,14 @@ ZEND_METHOD(reflection_function, getClosureThis)
 ZEND_METHOD(reflection_function, getClosureScopeClass)
 {
 	reflection_object *intern;
-	zend_function *fptr;
 	const zend_function *closure_func;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	GET_REFLECTION_OBJECT_PTR(fptr);
-	if (intern->obj) {
-		closure_func = zend_get_closure_method_def(intern->obj TSRMLS_CC);
+	GET_REFLECTION_OBJECT();
+	if (!ZVAL_IS_UNDEF(&intern->obj)) {
+		closure_func = zend_get_closure_method_def(&intern->obj TSRMLS_CC);
 		if (closure_func && closure_func->common.scope) {
 			zend_reflection_class_factory(closure_func->common.scope, return_value TSRMLS_CC);
 		}
@@ -1753,7 +1733,6 @@ ZEND_METHOD(reflection_function, getClosure)
 }
 /* }}} */
 
-
 /* {{{ proto public bool ReflectionFunction::isInternal()
    Returns whether this is an internal function */
 ZEND_METHOD(reflection_function, isInternal)
@@ -1809,7 +1788,8 @@ ZEND_METHOD(reflection_function, getFileName)
 	}
 	GET_REFLECTION_OBJECT_PTR(fptr);
 	if (fptr->type == ZEND_USER_FUNCTION) {
-		RETURN_STRING(fptr->op_array.filename, 1);
+// TODO: we have to duplicate it, becaise it may be in opcache SHM ???
+		RETURN_STR(STR_DUP(fptr->op_array.filename, 0));
 	}
 	RETURN_FALSE;
 }
@@ -1863,7 +1843,8 @@ ZEND_METHOD(reflection_function, getDocComment)
 	}
 	GET_REFLECTION_OBJECT_PTR(fptr);
 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.doc_comment) {
-		RETURN_STRINGL(fptr->op_array.doc_comment, fptr->op_array.doc_comment_len, 1);
+// TODO: we have to duplicate it, becaise it may be stored in opcache SHM ???
+		RETURN_STR(STR_DUP(fptr->op_array.doc_comment, 0));
 	}
 	RETURN_FALSE;
 }
@@ -1873,7 +1854,6 @@ ZEND_METHOD(reflection_function, getDocComment)
    Returns an associative array containing this function's static variables and their values */
 ZEND_METHOD(reflection_function, getStaticVariables)
 {
-	zval *tmp_copy;
 	reflection_object *intern;
 	zend_function *fptr;
 
@@ -1886,7 +1866,7 @@ ZEND_METHOD(reflection_function, getStaticVariables)
 	array_init(return_value);
 	if (fptr->type == ZEND_USER_FUNCTION && fptr->op_array.static_variables != NULL) {
 		zend_hash_apply_with_argument(fptr->op_array.static_variables, (apply_func_arg_t) zval_update_constant_inline_change, fptr->common.scope TSRMLS_CC);
-		zend_hash_copy(Z_ARRVAL_P(return_value), fptr->op_array.static_variables, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_copy, sizeof(zval *));
+		zend_hash_copy(Z_ARRVAL_P(return_value), fptr->op_array.static_variables, zval_add_ref);
 	}
 }
 /* }}} */
@@ -1895,8 +1875,8 @@ ZEND_METHOD(reflection_function, getStaticVariables)
    Invokes the function */
 ZEND_METHOD(reflection_function, invoke)
 {
-	zval *retval_ptr;
-	zval ***params = NULL;
+	zval retval;
+	zval *params = NULL;
 	int result, num_args = 0;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcc;
@@ -1912,10 +1892,10 @@ ZEND_METHOD(reflection_function, invoke)
 
 	fci.size = sizeof(fci);
 	fci.function_table = NULL;
-	fci.function_name = NULL;
+	ZVAL_UNDEF(&fci.function_name);
 	fci.symbol_table = NULL;
-	fci.object_ptr = NULL;
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.object = NULL;
+	fci.retval = &retval;
 	fci.param_count = num_args;
 	fci.params = params;
 	fci.no_separation = 1;
@@ -1924,29 +1904,26 @@ ZEND_METHOD(reflection_function, invoke)
 	fcc.function_handler = fptr;
 	fcc.calling_scope = EG(scope);
 	fcc.called_scope = NULL;
-	fcc.object_ptr = NULL;
+	fcc.object = NULL;
 
 	result = zend_call_function(&fci, &fcc TSRMLS_CC);
 
-	if (num_args) {
-		efree(params);
-	}
-
 	if (result == FAILURE) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Invocation of function %s() failed", fptr->common.function_name);
+			"Invocation of function %s() failed", fptr->common.function_name->val);
 		return;
 	}
 
-	if (retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 }
 /* }}} */
 
-static int _zval_array_to_c_array(zval **arg, zval ****params TSRMLS_DC) /* {{{ */
+static int _zval_array_to_c_array(zval *arg, zval **params TSRMLS_DC) /* {{{ */
 {
-	*(*params)++ = arg;
+	ZVAL_COPY((*params), arg);
+	(*params)++;
 	return ZEND_HASH_APPLY_KEEP;
 } /* }}} */
 
@@ -1954,10 +1931,10 @@ static int _zval_array_to_c_array(zval **arg, zval ****params TSRMLS_DC) /* {{{
    Invokes the function and pass its arguments as array. */
 ZEND_METHOD(reflection_function, invokeArgs)
 {
-	zval *retval_ptr;
-	zval ***params;
+	zval retval;
+	zval *params;
 	int result;
-	int argc;
+	int i, argc;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcc;
 	reflection_object *intern;
@@ -1973,16 +1950,16 @@ ZEND_METHOD(reflection_function, invokeArgs)
 
 	argc = zend_hash_num_elements(Z_ARRVAL_P(param_array));
 
-	params = safe_emalloc(sizeof(zval **), argc, 0);
+	params = safe_emalloc(sizeof(zval), argc, 0);
 	zend_hash_apply_with_argument(Z_ARRVAL_P(param_array), (apply_func_arg_t)_zval_array_to_c_array, &params TSRMLS_CC);
 	params -= argc;
 
 	fci.size = sizeof(fci);
 	fci.function_table = NULL;
-	fci.function_name = NULL;
+	ZVAL_UNDEF(&fci.function_name);
 	fci.symbol_table = NULL;
-	fci.object_ptr = NULL;
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.object = NULL;
+	fci.retval = &retval;
 	fci.param_count = argc;
 	fci.params = params;
 	fci.no_separation = 1;
@@ -1991,20 +1968,23 @@ ZEND_METHOD(reflection_function, invokeArgs)
 	fcc.function_handler = fptr;
 	fcc.calling_scope = EG(scope);
 	fcc.called_scope = NULL;
-	fcc.object_ptr = NULL;
+	fcc.object = NULL;
 
 	result = zend_call_function(&fci, &fcc TSRMLS_CC);
 
+	for (i = 0; i < argc; i++) {
+		zval_ptr_dtor(&params[i]);
+	}
 	efree(params);
 
 	if (result == FAILURE) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Invocation of function %s() failed", fptr->common.function_name);
+			"Invocation of function %s() failed", fptr->common.function_name->val);
 		return;
 	}
 
-	if (retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 }
 /* }}} */
@@ -2067,11 +2047,10 @@ ZEND_METHOD(reflection_function, getParameters)
 
 	array_init(return_value);
 	for (i = 0; i < fptr->common.num_args; i++) {
-		zval *parameter;
+		zval parameter;
 
-		ALLOC_ZVAL(parameter);
-		reflection_parameter_factory(_copy_function(fptr TSRMLS_CC), intern->obj, arg_info, i, fptr->common.required_num_args, parameter TSRMLS_CC);
-		add_next_index_zval(return_value, parameter);
+		reflection_parameter_factory(_copy_function(fptr TSRMLS_CC), ZVAL_IS_UNDEF(&intern->obj)? NULL : &intern->obj, arg_info, i, fptr->common.required_num_args, &parameter TSRMLS_CC);
+		add_next_index_zval(return_value, &parameter);
 
 		arg_info++;
 	}
@@ -2119,7 +2098,7 @@ ZEND_METHOD(reflection_function, getExtensionName)
 
 	internal = (zend_internal_function *)fptr;
 	if (internal->module) {
-		RETURN_STRING(internal->module->name, 1);
+		RETURN_STRING(internal->module->name);
 	} else {
 		RETURN_FALSE;
 	}
@@ -2139,9 +2118,9 @@ ZEND_METHOD(reflection_parameter, export)
 ZEND_METHOD(reflection_parameter, __construct)
 {
 	parameter_reference *ref;
-	zval *reference, **parameter;
+	zval *reference, *parameter;
 	zval *object;
-	zval *name;
+	zval name;
 	reflection_object *intern;
 	zend_function *fptr;
 	struct _zend_arg_info *arg_info;
@@ -2149,12 +2128,12 @@ ZEND_METHOD(reflection_parameter, __construct)
 	zend_class_entry *ce = NULL;
 	zend_bool is_closure = 0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zZ", &reference, &parameter) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &reference, &parameter) == FAILURE) {
 		return;
 	}
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
@@ -2167,7 +2146,7 @@ ZEND_METHOD(reflection_parameter, __construct)
 
 				lcname_len = Z_STRLEN_P(reference);
 				lcname = zend_str_tolower_dup(Z_STRVAL_P(reference), lcname_len);
-				if (zend_hash_find(EG(function_table), lcname, lcname_len + 1, (void**) &fptr) == FAILURE) {
+				if ((fptr = zend_hash_str_find_ptr(EG(function_table), lcname, lcname_len)) == NULL) {
 					efree(lcname);
 					zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 						"Function %s() does not exist", Z_STRVAL_P(reference));
@@ -2179,45 +2158,43 @@ ZEND_METHOD(reflection_parameter, __construct)
 			break;
 
 		case IS_ARRAY: {
-				zval **classref;
-				zval **method;
-				zend_class_entry **pce;
+				zval *classref;
+				zval *method;
 				unsigned int lcname_len;
 				char *lcname;
 
-				if ((zend_hash_index_find(Z_ARRVAL_P(reference), 0, (void **) &classref) == FAILURE)
-					|| (zend_hash_index_find(Z_ARRVAL_P(reference), 1, (void **) &method) == FAILURE))
+				if (((classref =zend_hash_index_find(Z_ARRVAL_P(reference), 0)) == NULL)
+					|| ((method = zend_hash_index_find(Z_ARRVAL_P(reference), 1)) == NULL))
 				{
 					_DO_THROW("Expected array($object, $method) or array($classname, $method)");
 					/* returns out of this function */
 				}
 
-				if (Z_TYPE_PP(classref) == IS_OBJECT) {
-					ce = Z_OBJCE_PP(classref);
+				if (Z_TYPE_P(classref) == IS_OBJECT) {
+					ce = Z_OBJCE_P(classref);
 				} else {
 					convert_to_string_ex(classref);
-					if (zend_lookup_class(Z_STRVAL_PP(classref), Z_STRLEN_PP(classref), &pce TSRMLS_CC) == FAILURE) {
+					if ((ce = zend_lookup_class(Z_STR_P(classref) TSRMLS_CC)) == NULL) {
 						zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-								"Class %s does not exist", Z_STRVAL_PP(classref));
+								"Class %s does not exist", Z_STRVAL_P(classref));
 						return;
 					}
-					ce = *pce;
 				}
 
 				convert_to_string_ex(method);
-				lcname_len = Z_STRLEN_PP(method);
-				lcname = zend_str_tolower_dup(Z_STRVAL_PP(method), lcname_len);
-				if (ce == zend_ce_closure && Z_TYPE_PP(classref) == IS_OBJECT
+				lcname_len = Z_STRLEN_P(method);
+				lcname = zend_str_tolower_dup(Z_STRVAL_P(method), lcname_len);
+				if (ce == zend_ce_closure && Z_TYPE_P(classref) == IS_OBJECT
 					&& (lcname_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
 					&& memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
-					&& (fptr = zend_get_closure_invoke_method(*classref TSRMLS_CC)) != NULL)
+					&& (fptr = zend_get_closure_invoke_method(Z_OBJ_P(classref) TSRMLS_CC)) != NULL)
 				{
 					/* nothing to do. don't set is_closure since is the invoke handler,
 -					   not the closure itself */
-				} else if (zend_hash_find(&ce->function_table, lcname, lcname_len + 1, (void **) &fptr) == FAILURE) {
+				} else if ((fptr = zend_hash_str_find_ptr(&ce->function_table, lcname, lcname_len)) == NULL) {
 					efree(lcname);
 					zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-						"Method %s::%s() does not exist", ce->name, Z_STRVAL_PP(method));
+						"Method %s::%s() does not exist", ce->name->val, Z_STRVAL_P(method));
 					return;
 				}
 				efree(lcname);
@@ -2231,9 +2208,9 @@ ZEND_METHOD(reflection_parameter, __construct)
 					fptr = (zend_function *)zend_get_closure_method_def(reference TSRMLS_CC);
 					Z_ADDREF_P(reference);
 					is_closure = 1;
-				} else if (zend_hash_find(&ce->function_table, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME), (void **)&fptr) == FAILURE) {
+				} else if ((fptr = zend_hash_str_find_ptr(&ce->function_table, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME))) == NULL) {
 					zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-						"Method %s::%s() does not exist", ce->name, ZEND_INVOKE_FUNC_NAME);
+						"Method %s::%s() does not exist", ce->name->val, ZEND_INVOKE_FUNC_NAME);
 					return;
 				}
 			}
@@ -2246,17 +2223,17 @@ ZEND_METHOD(reflection_parameter, __construct)
 
 	/* Now, search for the parameter */
 	arg_info = fptr->common.arg_info;
-	if (Z_TYPE_PP(parameter) == IS_LONG) {
-		position= Z_LVAL_PP(parameter);
+	if (Z_TYPE_P(parameter) == IS_LONG) {
+		position= Z_LVAL_P(parameter);
 		if (position < 0 || (zend_uint)position >= fptr->common.num_args) {
 			if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
 				if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
-					efree((char*)fptr->common.function_name);
+					STR_RELEASE(fptr->common.function_name);
 				}
 				efree(fptr);
 			}
 			if (is_closure) {
-				zval_ptr_dtor(&reference);
+				zval_ptr_dtor(reference);
 			}
 			_DO_THROW("The parameter specified by its offset could not be found");
 			/* returns out of this function */
@@ -2267,7 +2244,7 @@ ZEND_METHOD(reflection_parameter, __construct)
 		position= -1;
 		convert_to_string_ex(parameter);
 		for (i = 0; i < fptr->common.num_args; i++) {
-			if (arg_info[i].name && strcmp(arg_info[i].name, Z_STRVAL_PP(parameter)) == 0) {
+			if (arg_info[i].name && strcmp(arg_info[i].name, Z_STRVAL_P(parameter)) == 0) {
 				position= i;
 				break;
 			}
@@ -2275,25 +2252,24 @@ ZEND_METHOD(reflection_parameter, __construct)
 		if (position == -1) {
 			if (fptr->common.fn_flags & ZEND_ACC_CALL_VIA_HANDLER) {
 				if (fptr->type != ZEND_OVERLOADED_FUNCTION) {
-					efree((char*)fptr->common.function_name);
+					STR_RELEASE(fptr->common.function_name);
 				}
 				efree(fptr);
 			}
 			if (is_closure) {
-				zval_ptr_dtor(&reference);
+				zval_ptr_dtor(reference);
 			}
 			_DO_THROW("The parameter specified by its name could not be found");
 			/* returns out of this function */
 		}
 	}
 
-	MAKE_STD_ZVAL(name);
 	if (arg_info[position].name) {
-		ZVAL_STRINGL(name, arg_info[position].name, arg_info[position].name_len, 1);
+		ZVAL_STRINGL(&name, arg_info[position].name, arg_info[position].name_len);
 	} else {
-		ZVAL_NULL(name);
+		ZVAL_NULL(&name);
 	}
-	reflection_update_property(object, "name", name);
+	reflection_update_property(object, "name", &name);
 
 	ref = (parameter_reference*) emalloc(sizeof(parameter_reference));
 	ref->arg_info = &arg_info[position];
@@ -2305,7 +2281,7 @@ ZEND_METHOD(reflection_parameter, __construct)
 	intern->ref_type = REF_TYPE_PARAMETER;
 	intern->ce = ce;
 	if (reference && is_closure) {
-		intern->obj = reference;
+		ZVAL_COPY_VALUE(&intern->obj, reference);
 	}
 }
 /* }}} */
@@ -2324,7 +2300,7 @@ ZEND_METHOD(reflection_parameter, __toString)
 	GET_REFLECTION_OBJECT_PTR(param);
 	string_init(&str);
 	_parameter_string(&str, param->fptr, param->arg_info, param->offset, param->required, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -2335,7 +2311,7 @@ ZEND_METHOD(reflection_parameter, getName)
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	_default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
+	_default_get_entry(getThis(), "name", sizeof("name")-1, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -2352,9 +2328,9 @@ ZEND_METHOD(reflection_parameter, getDeclaringFunction)
 	GET_REFLECTION_OBJECT_PTR(param);
 
 	if (!param->fptr->common.scope) {
-		reflection_function_factory(_copy_function(param->fptr TSRMLS_CC), intern->obj, return_value TSRMLS_CC);
+		reflection_function_factory(_copy_function(param->fptr TSRMLS_CC), ZVAL_IS_UNDEF(&intern->obj)? NULL : &intern->obj, return_value TSRMLS_CC);
 	} else {
-		reflection_method_factory(param->fptr->common.scope, _copy_function(param->fptr TSRMLS_CC), intern->obj, return_value TSRMLS_CC);
+		reflection_method_factory(param->fptr->common.scope, _copy_function(param->fptr TSRMLS_CC), ZVAL_IS_UNDEF(&intern->obj)? NULL : &intern->obj, return_value TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -2383,7 +2359,7 @@ ZEND_METHOD(reflection_parameter, getClass)
 {
 	reflection_object *intern;
 	parameter_reference *param;
-	zend_class_entry **pce, *ce;
+	zend_class_entry *ce;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2410,7 +2386,6 @@ ZEND_METHOD(reflection_parameter, getClass)
 					"Parameter uses 'self' as type hint but function is not a class member!");
 				return;
 			}
-			pce= &ce;
 		} else if (0 == zend_binary_strcasecmp(param->arg_info->class_name, param->arg_info->class_name_len, "parent", sizeof("parent")- 1)) {
 			ce = param->fptr->common.scope;
 			if (!ce) {
@@ -2423,13 +2398,18 @@ ZEND_METHOD(reflection_parameter, getClass)
 					"Parameter uses 'parent' as type hint although class does not have a parent!");
 				return;
 			}
-			pce= &ce->parent;
-		} else if (zend_lookup_class(param->arg_info->class_name, param->arg_info->class_name_len, &pce TSRMLS_CC) == FAILURE) {
-			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-				"Class %s does not exist", param->arg_info->class_name);
-			return;
+			ce = ce->parent;
+		} else {
+			zend_string *name = STR_INIT(param->arg_info->class_name, param->arg_info->class_name_len, 0);
+			ce = zend_lookup_class(name TSRMLS_CC);
+			STR_FREE(name);
+			if (!ce) {
+				zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
+					"Class %s does not exist", param->arg_info->class_name);
+				return;
+			}
 		}
-		zend_reflection_class_factory(*pce, return_value TSRMLS_CC);
+		zend_reflection_class_factory(ce, return_value TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -2594,12 +2574,12 @@ ZEND_METHOD(reflection_parameter, getDefaultValue)
 		return;
 	}
 
-	*return_value = *precv->op2.zv;
-	INIT_PZVAL(return_value);
-	if (!IS_CONSTANT_TYPE(Z_TYPE_P(return_value))) {
+	ZVAL_COPY_VALUE(return_value, precv->op2.zv);
+	if (Z_CONSTANT_P(return_value)) {
+		zval_update_constant_ex(return_value, 0, param->fptr->common.scope TSRMLS_CC);
+	} else {
 		zval_copy_ctor(return_value);
 	}
-	zval_update_constant_ex(&return_value, 0, param->fptr->common.scope TSRMLS_CC);
 }
 /* }}} */
 
@@ -2620,7 +2600,7 @@ ZEND_METHOD(reflection_parameter, isDefaultValueConstant)
 	}
 
 	precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param);
-	if (precv && (Z_TYPE_P(precv->op2.zv) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
+	if (precv && Z_TYPE_P(precv->op2.zv) == IS_CONSTANT) {
 		RETURN_TRUE;
 	}
 
@@ -2645,8 +2625,8 @@ ZEND_METHOD(reflection_parameter, getDefaultValueConstantName)
 	}
 
 	precv = _reflection_param_get_default_precv(INTERNAL_FUNCTION_PARAM_PASSTHRU, param);
-	if (precv && (Z_TYPE_P(precv->op2.zv) & IS_CONSTANT_TYPE_MASK) == IS_CONSTANT) {
-		RETURN_STRINGL(Z_STRVAL_P(precv->op2.zv), Z_STRLEN_P(precv->op2.zv), 1);
+	if (precv && Z_TYPE_P(precv->op2.zv) == IS_CONSTANT) {
+		RETURN_STR(STR_COPY(Z_STR_P(precv->op2.zv)));
 	}
 }
 /* }}} */
@@ -2679,11 +2659,10 @@ ZEND_METHOD(reflection_method, export)
    Constructor. Throws an Exception in case the given method does not exist */
 ZEND_METHOD(reflection_method, __construct)
 {
-	zval *name, *classname;
+	zval name, *classname;
 	zval *object, *orig_obj;
 	reflection_object *intern;
 	char *lcname;
-	zend_class_entry **pce;
 	zend_class_entry *ce;
 	zend_function *mptr;
 	char *name_str, *tmp;
@@ -2700,7 +2679,7 @@ ZEND_METHOD(reflection_method, __construct)
 		}
 		classname = &ztmp;
 		tmp_len = tmp - name_str;
-		ZVAL_STRINGL(classname, name_str, tmp_len, 1);
+		ZVAL_STRINGL(classname, name_str, tmp_len);
 		name_len = name_len - (tmp_len + 2);
 		name_str = tmp + 2;
 		orig_obj = NULL;
@@ -2711,7 +2690,7 @@ ZEND_METHOD(reflection_method, __construct)
 	}
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
@@ -2719,7 +2698,7 @@ ZEND_METHOD(reflection_method, __construct)
 	/* Find the class entry */
 	switch (Z_TYPE_P(classname)) {
 		case IS_STRING:
-			if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &pce TSRMLS_CC) == FAILURE) {
+			if ((ce = zend_lookup_class(Z_STR_P(classname) TSRMLS_CC)) == NULL) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 						"Class %s does not exist", Z_STRVAL_P(classname));
 				if (classname == &ztmp) {
@@ -2727,7 +2706,6 @@ ZEND_METHOD(reflection_method, __construct)
 				}
 				return;
 			}
-			ce = *pce;
 			break;
 
 		case IS_OBJECT:
@@ -2750,25 +2728,21 @@ ZEND_METHOD(reflection_method, __construct)
 
 	if (ce == zend_ce_closure && orig_obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
 		&& memcmp(lcname, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
-		&& (mptr = zend_get_closure_invoke_method(orig_obj TSRMLS_CC)) != NULL)
+		&& (mptr = zend_get_closure_invoke_method(Z_OBJ_P(orig_obj) TSRMLS_CC)) != NULL)
 	{
 		/* do nothing, mptr already set */
-	} else if (zend_hash_find(&ce->function_table, lcname, name_len + 1, (void **) &mptr) == FAILURE) {
+	} else if ((mptr = zend_hash_str_find_ptr(&ce->function_table, lcname, name_len)) == NULL) {
 		efree(lcname);
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Method %s::%s() does not exist", ce->name, name_str);
+			"Method %s::%s() does not exist", ce->name->val, name_str);
 		return;
 	}
 	efree(lcname);
 
-	MAKE_STD_ZVAL(classname);
-	ZVAL_STRINGL(classname, mptr->common.scope->name, mptr->common.scope->name_length, 1);
-
-	reflection_update_property(object, "class", classname);
-
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRING(name, mptr->common.function_name, 1);
-	reflection_update_property(object, "name", name);
+	ZVAL_STR(&name, STR_COPY(mptr->common.scope->name));
+	reflection_update_property(object, "class", &name);
+	ZVAL_STR(&name, STR_COPY(mptr->common.function_name));
+	reflection_update_property(object, "name", &name);
 	intern->ptr = mptr;
 	intern->ref_type = REF_TYPE_FUNCTION;
 	intern->ce = ce;
@@ -2789,7 +2763,7 @@ ZEND_METHOD(reflection_method, __toString)
 	GET_REFLECTION_OBJECT_PTR(mptr);
 	string_init(&str);
 	_function_string(&str, mptr, intern->ce, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -2832,9 +2806,9 @@ ZEND_METHOD(reflection_method, getClosure)
    Invokes the method. */
 ZEND_METHOD(reflection_method, invoke)
 {
-	zval *retval_ptr;
-	zval ***params = NULL;
-	zval *object_ptr;
+	zval retval;
+	zval *params = NULL;
+	zend_object *object;
 	reflection_object *intern;
 	zend_function *mptr;
 	int result, num_args = 0;
@@ -2853,13 +2827,13 @@ ZEND_METHOD(reflection_method, invoke)
 		if (mptr->common.fn_flags & ZEND_ACC_ABSTRACT) {
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 				"Trying to invoke abstract method %s::%s()",
-				mptr->common.scope->name, mptr->common.function_name);
+				mptr->common.scope->name->val, mptr->common.function_name->val);
 		} else {
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 				"Trying to invoke %s method %s::%s() from scope %s",
 				mptr->common.fn_flags & ZEND_ACC_PROTECTED ? "protected" : "private",
-				mptr->common.scope->name, mptr->common.function_name,
-				Z_OBJCE_P(getThis())->name);
+				mptr->common.scope->name->val, mptr->common.function_name->val,
+				Z_OBJCE_P(getThis())->name->val);
 		}
 		return;
 	}
@@ -2875,34 +2849,30 @@ ZEND_METHOD(reflection_method, invoke)
 	 * Else, we verify that the given object is an instance of the class.
 	 */
 	if (mptr->common.fn_flags & ZEND_ACC_STATIC) {
-		object_ptr = NULL;
+		object = NULL;
 		obj_ce = mptr->common.scope;
 	} else {
-		if (Z_TYPE_PP(params[0]) != IS_OBJECT) {
-			efree(params);
+		if (Z_TYPE(params[0]) != IS_OBJECT) {
 			_DO_THROW("Non-object passed to Invoke()");
 			/* Returns from this function */
 		}
 
-		obj_ce = Z_OBJCE_PP(params[0]);
+		obj_ce = Z_OBJCE(params[0]);
 
 		if (!instanceof_function(obj_ce, mptr->common.scope TSRMLS_CC)) {
-			if (params) {
-				efree(params);
-			}
 			_DO_THROW("Given object is not an instance of the class this method was declared in");
 			/* Returns from this function */
 		}
 
-		object_ptr = *params[0];
+		object = Z_OBJ(params[0]);
 	}
 
 	fci.size = sizeof(fci);
 	fci.function_table = NULL;
-	fci.function_name = NULL;
+	ZVAL_UNDEF(&fci.function_name);
 	fci.symbol_table = NULL;
-	fci.object_ptr = object_ptr;
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.object = object;
+	fci.retval = &retval;
 	fci.param_count = num_args - 1;
 	fci.params = params + 1;
 	fci.no_separation = 1;
@@ -2911,22 +2881,18 @@ ZEND_METHOD(reflection_method, invoke)
 	fcc.function_handler = mptr;
 	fcc.calling_scope = obj_ce;
 	fcc.called_scope = intern->ce;
-	fcc.object_ptr = object_ptr;
+	fcc.object = object;
 
 	result = zend_call_function(&fci, &fcc TSRMLS_CC);
 
-	if (params) {
-		efree(params);
-	}
-
 	if (result == FAILURE) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Invocation of method %s::%s() failed", mptr->common.scope->name, mptr->common.function_name);
+			"Invocation of method %s::%s() failed", mptr->common.scope->name->val, mptr->common.function_name->val);
 		return;
 	}
 
-	if (retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 }
 /* }}} */
@@ -2935,12 +2901,12 @@ ZEND_METHOD(reflection_method, invoke)
    Invokes the function and pass its arguments as array. */
 ZEND_METHOD(reflection_method, invokeArgs)
 {
-	zval *retval_ptr;
-	zval ***params;
+	zval retval;
+	zval *params;
 	zval *object;
 	reflection_object *intern;
 	zend_function *mptr;
-	int argc;
+	int i, argc;
 	int result;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcc;
@@ -2962,20 +2928,20 @@ ZEND_METHOD(reflection_method, invokeArgs)
 		if (mptr->common.fn_flags & ZEND_ACC_ABSTRACT) {
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 				"Trying to invoke abstract method %s::%s()",
-				mptr->common.scope->name, mptr->common.function_name);
+				mptr->common.scope->name->val, mptr->common.function_name->val);
 		} else {
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 				"Trying to invoke %s method %s::%s() from scope %s",
 				mptr->common.fn_flags & ZEND_ACC_PROTECTED ? "protected" : "private",
-				mptr->common.scope->name, mptr->common.function_name,
-				Z_OBJCE_P(getThis())->name);
+				mptr->common.scope->name->val, mptr->common.function_name->val,
+				Z_OBJCE_P(getThis())->name->val);
 		}
 		return;
 	}
 
 	argc = zend_hash_num_elements(Z_ARRVAL_P(param_array));
 
-	params = safe_emalloc(sizeof(zval **), argc, 0);
+	params = safe_emalloc(sizeof(zval), argc, 0);
 	zend_hash_apply_with_argument(Z_ARRVAL_P(param_array), (apply_func_arg_t)_zval_array_to_c_array, &params TSRMLS_CC);
 	params -= argc;
 
@@ -2993,7 +2959,7 @@ ZEND_METHOD(reflection_method, invokeArgs)
 			efree(params);
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 				"Trying to invoke non static method %s::%s() without an object",
-				mptr->common.scope->name, mptr->common.function_name);
+				mptr->common.scope->name->val, mptr->common.function_name->val);
 			return;
 		}
 
@@ -3008,10 +2974,10 @@ ZEND_METHOD(reflection_method, invokeArgs)
 
 	fci.size = sizeof(fci);
 	fci.function_table = NULL;
-	fci.function_name = NULL;
+	ZVAL_UNDEF(&fci.function_name);
 	fci.symbol_table = NULL;
-	fci.object_ptr = object;
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.object = object ? Z_OBJ_P(object) : NULL;
+	fci.retval = &retval;
 	fci.param_count = argc;
 	fci.params = params;
 	fci.no_separation = 1;
@@ -3020,7 +2986,7 @@ ZEND_METHOD(reflection_method, invokeArgs)
 	fcc.function_handler = mptr;
 	fcc.calling_scope = obj_ce;
 	fcc.called_scope = intern->ce;
-	fcc.object_ptr = object;
+	fcc.object = (object) ? Z_OBJ_P(object) : NULL;
 	
 	/* 
 	 * Copy the zend_function when calling via handler (e.g. Closure::__invoke())
@@ -3032,16 +2998,19 @@ ZEND_METHOD(reflection_method, invokeArgs)
 
 	result = zend_call_function(&fci, &fcc TSRMLS_CC);
 
+	for (i = 0; i < argc; i++) {
+		zval_ptr_dtor(&params[i]);
+	}
 	efree(params);
 
 	if (result == FAILURE) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Invocation of method %s::%s() failed", mptr->common.scope->name, mptr->common.function_name);
+			"Invocation of method %s::%s() failed", mptr->common.scope->name->val, mptr->common.function_name->val);
 		return;
 	}
 
-	if (retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 }
 /* }}} */
@@ -3122,18 +3091,18 @@ ZEND_METHOD(reflection_function, isVariadic)
    Returns whether this function is defined in namespace */
 ZEND_METHOD(reflection_function, inNamespace)
 {
-	zval **name;
+	zval *name;
 	const char *backslash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
+	if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-	if (Z_TYPE_PP(name) == IS_STRING
-		&& (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
-		&& backslash > Z_STRVAL_PP(name))
+	if (Z_TYPE_P(name) == IS_STRING
+		&& (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name)))
+		&& backslash > Z_STRVAL_P(name))
 	{
 		RETURN_TRUE;
 	}
@@ -3145,20 +3114,20 @@ ZEND_METHOD(reflection_function, inNamespace)
    Returns the name of namespace where this function is defined */
 ZEND_METHOD(reflection_function, getNamespaceName)
 {
-	zval **name;
+	zval *name;
 	const char *backslash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
+	if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-	if (Z_TYPE_PP(name) == IS_STRING
-		&& (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
-		&& backslash > Z_STRVAL_PP(name))
+	if (Z_TYPE_P(name) == IS_STRING
+		&& (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name)))
+		&& backslash > Z_STRVAL_P(name))
 	{
-		RETURN_STRINGL(Z_STRVAL_PP(name), backslash - Z_STRVAL_PP(name), 1);
+		RETURN_STRINGL(Z_STRVAL_P(name), backslash - Z_STRVAL_P(name));
 	}
 	RETURN_EMPTY_STRING();
 }
@@ -3168,22 +3137,22 @@ ZEND_METHOD(reflection_function, getNamespaceName)
    Returns the short name of the function (without namespace part) */
 ZEND_METHOD(reflection_function, getShortName)
 {
-	zval **name;
+	zval *name;
 	const char *backslash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
+	if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-	if (Z_TYPE_PP(name) == IS_STRING
-		&& (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
-		&& backslash > Z_STRVAL_PP(name))
+	if (Z_TYPE_P(name) == IS_STRING
+		&& (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name)))
+		&& backslash > Z_STRVAL_P(name))
 	{
-		RETURN_STRINGL(backslash + 1, Z_STRLEN_PP(name) - (backslash - Z_STRVAL_PP(name) + 1), 1);
+		RETURN_STRINGL(backslash + 1, Z_STRLEN_P(name) - (backslash - Z_STRVAL_P(name) + 1));
 	}
-	RETURN_ZVAL(*name, 1, 0);
+	RETURN_ZVAL(name, 1, 0);
 }
 /* }}} */
 
@@ -3270,7 +3239,7 @@ ZEND_METHOD(reflection_method, getPrototype)
 
 	if (!mptr->common.prototype) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Method %s::%s does not have a prototype", intern->ce->name, mptr->common.function_name);
+			"Method %s::%s does not have a prototype", intern->ce->name->val, mptr->common.function_name->val);
 		return;
 	}
 
@@ -3289,7 +3258,7 @@ ZEND_METHOD(reflection_method, setAccessible)
 		return;
 	}
 
-	intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_REFLECTION_P(getThis());
 
 	if (intern == NULL) {
 		return;
@@ -3312,9 +3281,9 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob
 {
 	zval *argument;
 	zval *object;
-	zval *classname;
+	zval classname;
 	reflection_object *intern;
-	zend_class_entry **ce;
+	zend_class_entry *ce;
 
 	if (is_object) {
 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &argument) == FAILURE) {
@@ -3327,34 +3296,32 @@ static void reflection_class_object_ctor(INTERNAL_FUNCTION_PARAMETERS, int is_ob
 	}
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
 
 	if (Z_TYPE_P(argument) == IS_OBJECT) {
-		MAKE_STD_ZVAL(classname);
-		ZVAL_STRINGL(classname, Z_OBJCE_P(argument)->name, Z_OBJCE_P(argument)->name_length, 1);
-		reflection_update_property(object, "name", classname);
+		ZVAL_STR(&classname, STR_COPY(Z_OBJCE_P(argument)->name));
+		reflection_update_property(object, "name", &classname);
 		intern->ptr = Z_OBJCE_P(argument);
 		if (is_object) {
-			intern->obj = argument;
-			zval_add_ref(&argument);
+			ZVAL_COPY_VALUE(&intern->obj, argument);
+			zval_add_ref(argument);
 		}
 	} else {
-		convert_to_string_ex(&argument);
-		if (zend_lookup_class(Z_STRVAL_P(argument), Z_STRLEN_P(argument), &ce TSRMLS_CC) == FAILURE) {
+		convert_to_string_ex(argument);
+		if ((ce = zend_lookup_class(Z_STR_P(argument) TSRMLS_CC)) == NULL) {
 			if (!EG(exception)) {
 				zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Class %s does not exist", Z_STRVAL_P(argument));
 			}
 			return;
 		}
 
-		MAKE_STD_ZVAL(classname);
-		ZVAL_STRINGL(classname, (*ce)->name, (*ce)->name_length, 1);
-		reflection_update_property(object, "name", classname);
+		ZVAL_STR(&classname, STR_COPY(ce->name));
+		reflection_update_property(object, "name", &classname);
 
-		intern->ptr = *ce;
+		intern->ptr = ce;
 	}
 	intern->ref_type = REF_TYPE_OTHER;
 }
@@ -3373,14 +3340,13 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
 {
 	HashPosition pos;
 	zend_property_info *prop_info;
-	zval *prop, *prop_copy;
-	char *key;
-	uint key_len;
+	zval *prop, prop_copy;
+	zend_string *key;
 	ulong num_index;
 
 	zend_hash_internal_pointer_reset_ex(&ce->properties_info, &pos);
-	while (zend_hash_get_current_data_ex(&ce->properties_info, (void **) &prop_info, &pos) == SUCCESS) {
-		zend_hash_get_current_key_ex(&ce->properties_info, &key, &key_len, &num_index, 0, &pos);
+	while ((prop_info = zend_hash_get_current_data_ptr_ex(&ce->properties_info, &pos)) != NULL) {
+		zend_hash_get_current_key_ex(&ce->properties_info, &key, &num_index, 0, &pos);
 		zend_hash_move_forward_ex(&ce->properties_info, &pos);
 		if (((prop_info->flags & ZEND_ACC_SHADOW) &&
 		     prop_info->ce != ce) ||
@@ -3393,9 +3359,9 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
 		prop = NULL;
 		if (prop_info->offset >= 0) {
 			if (statics && (prop_info->flags & ZEND_ACC_STATIC) != 0) {
-				prop = ce->default_static_members_table[prop_info->offset];
+				prop = &ce->default_static_members_table[prop_info->offset];
 			} else if (!statics && (prop_info->flags & ZEND_ACC_STATIC) == 0) {
-				prop = ce->default_properties_table[prop_info->offset];
+				prop = &ce->default_properties_table[prop_info->offset];
 			}
 		}
 		if (!prop) {
@@ -3403,18 +3369,15 @@ static void add_class_vars(zend_class_entry *ce, int statics, zval *return_value
 		}
 
 		/* copy: enforce read only access */
-		ALLOC_ZVAL(prop_copy);
-		*prop_copy = *prop;
-		zval_copy_ctor(prop_copy);
-		INIT_PZVAL(prop_copy);
+		ZVAL_DUP(&prop_copy, prop);
 
 		/* this is necessary to make it able to work with default array
 		* properties, returned to user */
-		if (IS_CONSTANT_TYPE(Z_TYPE_P(prop_copy))) {
+		if (Z_CONSTANT(prop_copy)) {
 			zval_update_constant(&prop_copy, 1 TSRMLS_CC);
 		}
 
-		add_assoc_zval(return_value, key, prop_copy);
+		zend_hash_update(Z_ARRVAL_P(return_value), key, &prop_copy);
 	}
 }
 /* }}} */
@@ -3445,28 +3408,27 @@ ZEND_METHOD(reflection_class, getStaticPropertyValue)
 {
 	reflection_object *intern;
 	zend_class_entry *ce;
-	char *name;
-	int name_len;
-	zval **prop, *def_value = NULL;
+	zend_string *name;
+	zval *prop, *def_value = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &name, &name_len, &def_value) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|z", &name, &def_value) == FAILURE) {
 		return;
 	}
 
 	GET_REFLECTION_OBJECT_PTR(ce);
 
 	zend_update_class_constants(ce TSRMLS_CC);
-	prop = zend_std_get_static_property(ce, name, name_len, 1, NULL TSRMLS_CC);
+	prop = zend_std_get_static_property(ce, name, 1, -1 TSRMLS_CC);
 	if (!prop) {
 		if (def_value) {
 			RETURN_ZVAL(def_value, 1, 0);
 		} else {
 			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-				"Class %s does not have a property named %s", ce->name, name);
+				"Class %s does not have a property named %s", ce->name->val, name->val);
 		}
 		return;
 	} else {
-		RETURN_ZVAL(*prop, 1, 0);
+		RETURN_ZVAL(prop, 1, 0);
 	}
 }
 /* }}} */
@@ -3477,32 +3439,30 @@ ZEND_METHOD(reflection_class, setStaticPropertyValue)
 {
 	reflection_object *intern;
 	zend_class_entry *ce;
-	char *name;
-	int name_len;
-	zval **variable_ptr, *value;
-	int refcount;
-	zend_uchar is_ref;
+	zend_string *name;
+	zval *variable_ptr, *value;
+//???	int refcount;
+//???	zend_uchar is_ref;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &name, &name_len, &value) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz", &name, &value) == FAILURE) {
 		return;
 	}
 
 	GET_REFLECTION_OBJECT_PTR(ce);
 
 	zend_update_class_constants(ce TSRMLS_CC);
-	variable_ptr = zend_std_get_static_property(ce, name, name_len, 1, NULL TSRMLS_CC);
+	variable_ptr = zend_std_get_static_property(ce, name, 1, -1 TSRMLS_CC);
 	if (!variable_ptr) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-				"Class %s does not have a property named %s", ce->name, name);
+				"Class %s does not have a property named %s", ce->name->val, name->val);
 		return;
 	}
-	refcount = Z_REFCOUNT_PP(variable_ptr);
-	is_ref = Z_ISREF_PP(variable_ptr);
-	zval_dtor(*variable_ptr);
-	**variable_ptr = *value;
-	zval_copy_ctor(*variable_ptr);
-	Z_SET_REFCOUNT_PP(variable_ptr, refcount);
-	Z_SET_ISREF_TO_PP(variable_ptr, is_ref);
+//???	refcount = Z_REFCOUNT_PP(variable_ptr);
+//???	is_ref = Z_ISREF_PP(variable_ptr);
+	zval_dtor(variable_ptr);
+	ZVAL_DUP(variable_ptr, value);
+//???	Z_SET_REFCOUNT_PP(variable_ptr, refcount);
+//???	Z_SET_ISREF_TO_PP(variable_ptr, is_ref);
 
 }
 /* }}} */
@@ -3538,8 +3498,8 @@ ZEND_METHOD(reflection_class, __toString)
 	}
 	GET_REFLECTION_OBJECT_PTR(ce);
 	string_init(&str);
-	_class_string(&str, ce, intern->obj, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	_class_string(&str, ce, &intern->obj, "" TSRMLS_CC);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -3550,7 +3510,7 @@ ZEND_METHOD(reflection_class, getName)
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	_default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
+	_default_get_entry(getThis(), "name", sizeof("name")-1, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -3596,7 +3556,8 @@ ZEND_METHOD(reflection_class, getFileName)
 	}
 	GET_REFLECTION_OBJECT_PTR(ce);
 	if (ce->type == ZEND_USER_CLASS) {
-		RETURN_STRING(ce->info.user.filename, 1);
+// TODO: we have to duplicate it, becaise it may be stored in opcache SHM ???
+		RETURN_STR(STR_DUP(ce->info.user.filename, 0));
 	}
 	RETURN_FALSE;
 }
@@ -3650,7 +3611,7 @@ ZEND_METHOD(reflection_class, getDocComment)
 	}
 	GET_REFLECTION_OBJECT_PTR(ce);
 	if (ce->type == ZEND_USER_CLASS && ce->info.user.doc_comment) {
-		RETURN_STRINGL(ce->info.user.doc_comment, ce->info.user.doc_comment_len, 1);
+		RETURN_STR(STR_COPY(ce->info.user.doc_comment));
 	}
 	RETURN_FALSE;
 }
@@ -3694,7 +3655,7 @@ ZEND_METHOD(reflection_class, hasMethod)
 	lc_name = zend_str_tolower_dup(name, name_len);
 	if ((ce == zend_ce_closure && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
 		&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0)
-		|| zend_hash_exists(&ce->function_table, lc_name, name_len + 1)) {
+		|| zend_hash_str_exists(&ce->function_table, lc_name, name_len)) {
 		efree(lc_name);
 		RETURN_TRUE;
 	} else {
@@ -3722,23 +3683,23 @@ ZEND_METHOD(reflection_class, getMethod)
 
 	GET_REFLECTION_OBJECT_PTR(ce);
 	lc_name = zend_str_tolower_dup(name, name_len);
-	if (ce == zend_ce_closure && intern->obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
+	if (ce == zend_ce_closure && !ZVAL_IS_UNDEF(&intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
 		&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
-		&& (mptr = zend_get_closure_invoke_method(intern->obj TSRMLS_CC)) != NULL)
+		&& (mptr = zend_get_closure_invoke_method(Z_OBJ(intern->obj) TSRMLS_CC)) != NULL)
 	{
 		/* don't assign closure_object since we only reflect the invoke handler
 		   method and not the closure definition itself */
 		reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
 		efree(lc_name);
-	} else if (ce == zend_ce_closure && !intern->obj && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
+	} else if (ce == zend_ce_closure && ZVAL_IS_UNDEF(&intern->obj) && (name_len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
 		&& memcmp(lc_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
-		&& object_init_ex(&obj_tmp, ce) == SUCCESS && (mptr = zend_get_closure_invoke_method(&obj_tmp TSRMLS_CC)) != NULL) {
+		&& object_init_ex(&obj_tmp, ce) == SUCCESS && (mptr = zend_get_closure_invoke_method(Z_OBJ(obj_tmp) TSRMLS_CC)) != NULL) {
 		/* don't assign closure_object since we only reflect the invoke handler
 		   method and not the closure definition itself */
 		reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
 		zval_dtor(&obj_tmp);
 		efree(lc_name);
-	} else if (zend_hash_find(&ce->function_table, lc_name, name_len + 1, (void**) &mptr) == SUCCESS) {
+	} else if ((mptr = zend_hash_str_find_ptr(&ce->function_table, lc_name, name_len)) != NULL) {
 		reflection_method_factory(ce, mptr, NULL, return_value TSRMLS_CC);
 		efree(lc_name);
 	} else {
@@ -3753,30 +3714,29 @@ ZEND_METHOD(reflection_class, getMethod)
 /* {{{ _addmethod */
 static void _addmethod(zend_function *mptr, zend_class_entry *ce, zval *retval, long filter, zval *obj TSRMLS_DC)
 {
-	zval *method;
-	uint len = strlen(mptr->common.function_name);
+	zval method;
+	uint len = mptr->common.function_name->len;
 	zend_function *closure;
-
 	if (mptr->common.fn_flags & filter) {
-		ALLOC_ZVAL(method);
 		if (ce == zend_ce_closure && obj && (len == sizeof(ZEND_INVOKE_FUNC_NAME)-1)
-			&& memcmp(mptr->common.function_name, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
-			&& (closure = zend_get_closure_invoke_method(obj TSRMLS_CC)) != NULL)
+			&& memcmp(mptr->common.function_name->val, ZEND_INVOKE_FUNC_NAME, sizeof(ZEND_INVOKE_FUNC_NAME)-1) == 0
+			&& (closure = zend_get_closure_invoke_method(Z_OBJ_P(obj) TSRMLS_CC)) != NULL)
 		{
 			mptr = closure;
 		}
 		/* don't assign closure_object since we only reflect the invoke handler
 		   method and not the closure definition itself, even if we have a
 		   closure */
-		reflection_method_factory(ce, mptr, NULL, method TSRMLS_CC);
-		add_next_index_zval(retval, method);
+		reflection_method_factory(ce, mptr, NULL, &method TSRMLS_CC);
+		add_next_index_zval(retval, &method);
 	}
 }
 /* }}} */
 
 /* {{{ _addmethod */
-static int _addmethod_va(zend_function *mptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int _addmethod_va(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
+	zend_function *mptr = (zend_function*)Z_PTR_P(el);
 	zend_class_entry *ce = *va_arg(args, zend_class_entry**);
 	zval *retval = va_arg(args, zval*);
 	long filter = va_arg(args, long);
@@ -3810,10 +3770,10 @@ ZEND_METHOD(reflection_class, getMethods)
 
 	array_init(return_value);
 	zend_hash_apply_with_arguments(&ce->function_table TSRMLS_CC, (apply_func_args_t) _addmethod_va, 4, &ce, return_value, filter, intern->obj);
-	if (intern->obj && instanceof_function(ce, zend_ce_closure TSRMLS_CC)) {
-		zend_function *closure = zend_get_closure_invoke_method(intern->obj TSRMLS_CC);
+	if (Z_TYPE(intern->obj) != IS_UNDEF && instanceof_function(ce, zend_ce_closure TSRMLS_CC)) {
+		zend_function *closure = zend_get_closure_invoke_method(Z_OBJ(intern->obj) TSRMLS_CC);
 		if (closure) {
-			_addmethod(closure, ce, return_value, filter, intern->obj TSRMLS_CC);
+			_addmethod(closure, ce, return_value, filter, &intern->obj TSRMLS_CC);
 			_free_function(closure TSRMLS_CC);
 		}
 	}
@@ -3827,26 +3787,24 @@ ZEND_METHOD(reflection_class, hasProperty)
 	reflection_object *intern;
 	zend_property_info *property_info;
 	zend_class_entry *ce;
-	char *name;
-	int name_len;
-	zval *property;
+	zend_string *name;
+	zval property;
 
 	METHOD_NOTSTATIC(reflection_class_ptr);
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name) == FAILURE) {
 		return;
 	}
 
 	GET_REFLECTION_OBJECT_PTR(ce);
-	if (zend_hash_find(&ce->properties_info, name, name_len+1, (void **) &property_info) == SUCCESS) {
+	if ((property_info = zend_hash_find_ptr(&ce->properties_info, name)) != NULL) {
 		if (property_info->flags & ZEND_ACC_SHADOW) {
 			RETURN_FALSE;
 		}
 		RETURN_TRUE;
 	} else {
-		if (intern->obj && Z_OBJ_HANDLER_P(intern->obj, has_property)) {
-			MAKE_STD_ZVAL(property);
-			ZVAL_STRINGL(property, name, name_len, 1);
-			if (Z_OBJ_HANDLER_P(intern->obj, has_property)(intern->obj, property, 2, 0 TSRMLS_CC)) {
+		if (Z_TYPE(intern->obj) != IS_UNDEF && Z_OBJ_HANDLER(intern->obj, has_property)) {
+			ZVAL_STR(&property, STR_COPY(name));
+			if (Z_OBJ_HANDLER(intern->obj, has_property)(&intern->obj, &property, 2, -1 TSRMLS_CC)) {
 				zval_ptr_dtor(&property);
 				RETURN_TRUE;
 			}
@@ -3862,75 +3820,79 @@ ZEND_METHOD(reflection_class, hasProperty)
 ZEND_METHOD(reflection_class, getProperty)
 {
 	reflection_object *intern;
-	zend_class_entry *ce, **pce;
+	zend_class_entry *ce, *ce2;
 	zend_property_info *property_info;
-	char *name, *tmp, *classname;
-	int name_len, classname_len;
+	zend_string *name, *classname;
+	char *tmp, *str_name;
+	int classname_len, str_name_len;
 
 	METHOD_NOTSTATIC(reflection_class_ptr);
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name) == FAILURE) {
 		return;
 	}
 
 	GET_REFLECTION_OBJECT_PTR(ce);
-	if (zend_hash_find(&ce->properties_info, name, name_len + 1, (void**) &property_info) == SUCCESS) {
+	if ((property_info = zend_hash_find_ptr(&ce->properties_info, name)) != NULL) {
 		if ((property_info->flags & ZEND_ACC_SHADOW) == 0) {
 			reflection_property_factory(ce, property_info, return_value TSRMLS_CC);
 			return;
 		}
-	} else if (intern->obj) {
+	} else if (Z_TYPE(intern->obj) != IS_UNDEF) {
 		/* Check for dynamic properties */
-		if (zend_hash_exists(Z_OBJ_HT_P(intern->obj)->get_properties(intern->obj TSRMLS_CC), name, name_len+1)) {
+		if (zend_hash_exists(Z_OBJ_HT(intern->obj)->get_properties(&intern->obj TSRMLS_CC), name)) {
 			zend_property_info property_info_tmp;
 			property_info_tmp.flags = ZEND_ACC_IMPLICIT_PUBLIC;
-			property_info_tmp.name = estrndup(name, name_len);
-			property_info_tmp.name_length = name_len;
-			property_info_tmp.h = zend_get_hash_value(name, name_len+1);
+			property_info_tmp.name = STR_COPY(name);
 			property_info_tmp.doc_comment = NULL;
 			property_info_tmp.ce = ce;
 
 			reflection_property_factory(ce, &property_info_tmp, return_value TSRMLS_CC);
-			intern = (reflection_object *) zend_object_store_get_object(return_value TSRMLS_CC);
+			intern = Z_REFLECTION_P(return_value);
 			intern->ref_type = REF_TYPE_DYNAMIC_PROPERTY;
 			return;
 		}
 	}
-	if ((tmp = strstr(name, "::")) != NULL) {
-		classname_len = tmp - name;
-		classname = zend_str_tolower_dup(name, classname_len);
-		classname[classname_len] = '\0';
-		name_len = name_len - (classname_len + 2);
-		name = tmp + 2;
-
-		if (zend_lookup_class(classname, classname_len, &pce TSRMLS_CC) == FAILURE) {
+	str_name = name->val;
+	str_name_len = name->len;
+	if ((tmp = strstr(name->val, "::")) != NULL) {
+		classname_len = tmp - name->val;
+		classname = STR_ALLOC(classname_len, 0);
+		zend_str_tolower_copy(classname->val, name->val, classname_len);
+		classname->val[classname_len] = '\0';
+		str_name_len = name->len - (classname_len + 2);
+		str_name = tmp + 2;
+
+		ce2 = zend_lookup_class(classname TSRMLS_CC);
+		if (!ce2) {
 			if (!EG(exception)) {
-				zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Class %s does not exist", classname);
+				zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Class %s does not exist", classname->val);
 			}
-			efree(classname);
+			STR_FREE(classname);
 			return;
 		}
-		efree(classname);
+		STR_FREE(classname);
 
-		if (!instanceof_function(ce, *pce TSRMLS_CC)) {
-			zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Fully qualified property name %s::%s does not specify a base class of %s", (*pce)->name, name, ce->name);
+		if (!instanceof_function(ce, ce2 TSRMLS_CC)) {
+			zend_throw_exception_ex(reflection_exception_ptr, -1 TSRMLS_CC, "Fully qualified property name %s::%s does not specify a base class of %s", ce2->name->val, str_name, ce->name->val);
 			return;
 		}
-		ce = *pce;
+		ce = ce2;
 
-		if (zend_hash_find(&ce->properties_info, name, name_len + 1, (void**) &property_info) == SUCCESS && (property_info->flags & ZEND_ACC_SHADOW) == 0) {
+		if ((property_info = zend_hash_str_find_ptr(&ce->properties_info, str_name, str_name_len)) != NULL && (property_info->flags & ZEND_ACC_SHADOW) == 0) {
 			reflection_property_factory(ce, property_info, return_value TSRMLS_CC);
 			return;
 		}
 	}
 	zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Property %s does not exist", name);
+			"Property %s does not exist", str_name);
 }
 /* }}} */
 
 /* {{{ _addproperty */
-static int _addproperty(zend_property_info *pptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int _addproperty(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
-	zval *property;
+	zval property;
+	zend_property_info *pptr = (zend_property_info*)Z_PTR_P(el);
 	zend_class_entry *ce = *va_arg(args, zend_class_entry**);
 	zval *retval = va_arg(args, zval*);
 	long filter = va_arg(args, long);
@@ -3940,38 +3902,36 @@ static int _addproperty(zend_property_info *pptr TSRMLS_DC, int num_args, va_lis
 	}
 
 	if (pptr->flags	& filter) {
-		ALLOC_ZVAL(property);
-		reflection_property_factory(ce, pptr, property TSRMLS_CC);
-		add_next_index_zval(retval, property);
+		reflection_property_factory(ce, pptr, &property TSRMLS_CC);
+		add_next_index_zval(retval, &property);
 	}
 	return 0;
 }
 /* }}} */
 
 /* {{{ _adddynproperty */
-static int _adddynproperty(zval **pptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int _adddynproperty(zval *ptr TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
-	zval *property;
+	zval property;
 	zend_class_entry *ce = *va_arg(args, zend_class_entry**);
 	zval *retval = va_arg(args, zval*), member;
 
 	/* under some circumstances, the properties hash table may contain numeric
 	 * properties (e.g. when casting from array). This is a WONT FIX bug, at
 	 * least for the moment. Ignore these */
-	if (hash_key->nKeyLength == 0) {
+	if (hash_key->key == NULL) {
 		return 0;
 	}
 
-	if (hash_key->arKey[0] == '\0') {
+	if (hash_key->key->val[0] == '\0') {
 		return 0; /* non public cannot be dynamic */
 	}
 
-	ZVAL_STRINGL(&member, hash_key->arKey, hash_key->nKeyLength-1, 0);
+	ZVAL_STR(&member, hash_key->key);
 	if (zend_get_property_info(ce, &member, 1 TSRMLS_CC) == &EG(std_property_info)) {
-		MAKE_STD_ZVAL(property);
 		EG(std_property_info).flags = ZEND_ACC_IMPLICIT_PUBLIC;
-		reflection_property_factory(ce, &EG(std_property_info), property TSRMLS_CC);
-		add_next_index_zval(retval, property);
+		reflection_property_factory(ce, &EG(std_property_info), &property TSRMLS_CC);
+		add_next_index_zval(retval, &property);
 	}
 	return 0;
 }
@@ -4001,8 +3961,8 @@ ZEND_METHOD(reflection_class, getProperties)
 	array_init(return_value);
 	zend_hash_apply_with_arguments(&ce->properties_info TSRMLS_CC, (apply_func_args_t) _addproperty, 3, &ce, return_value, filter);
 
-	if (intern->obj && (filter & ZEND_ACC_PUBLIC) != 0 && Z_OBJ_HT_P(intern->obj)->get_properties) {
-		HashTable *properties = Z_OBJ_HT_P(intern->obj)->get_properties(intern->obj TSRMLS_CC);
+	if (Z_TYPE(intern->obj) != IS_UNDEF && (filter & ZEND_ACC_PUBLIC) != 0 && Z_OBJ_HT(intern->obj)->get_properties) {
+		HashTable *properties = Z_OBJ_HT(intern->obj)->get_properties(&intern->obj TSRMLS_CC);
 		zend_hash_apply_with_arguments(properties TSRMLS_CC, (apply_func_args_t) _adddynproperty, 2, &ce, return_value);
 	}
 }
@@ -4014,16 +3974,15 @@ ZEND_METHOD(reflection_class, hasConstant)
 {
 	reflection_object *intern;
 	zend_class_entry *ce;
-	char *name;
-	int name_len;
+	zend_string *name;
 
 	METHOD_NOTSTATIC(reflection_class_ptr);
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name) == FAILURE) {
 		return;
 	}
 
 	GET_REFLECTION_OBJECT_PTR(ce);
-	if (zend_hash_exists(&ce->constants_table, name, name_len + 1)) {
+	if (zend_hash_exists(&ce->constants_table, name)) {
 		RETURN_TRUE;
 	} else {
 		RETURN_FALSE;
@@ -4035,7 +3994,6 @@ ZEND_METHOD(reflection_class, hasConstant)
    Returns an associative array containing this class' constants and their values */
 ZEND_METHOD(reflection_class, getConstants)
 {
-	zval *tmp_copy;
 	reflection_object *intern;
 	zend_class_entry *ce;
 
@@ -4045,7 +4003,7 @@ ZEND_METHOD(reflection_class, getConstants)
 	GET_REFLECTION_OBJECT_PTR(ce);
 	array_init(return_value);
 	zend_hash_apply_with_argument(&ce->constants_table, (apply_func_arg_t)zval_update_constant_inline_change, ce TSRMLS_CC);
-	zend_hash_copy(Z_ARRVAL_P(return_value), &ce->constants_table, (copy_ctor_func_t) zval_add_ref, (void *) &tmp_copy, sizeof(zval *));
+	zend_hash_copy(Z_ARRVAL_P(return_value), &ce->constants_table, zval_add_ref_unref);
 }
 /* }}} */
 
@@ -4055,21 +4013,20 @@ ZEND_METHOD(reflection_class, getConstant)
 {
 	reflection_object *intern;
 	zend_class_entry *ce;
-	zval **value;
-	char *name;
-	int name_len;
+	zval *value;
+	zend_string *name;
 
 	METHOD_NOTSTATIC(reflection_class_ptr);
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &name) == FAILURE) {
 		return;
 	}
 
 	GET_REFLECTION_OBJECT_PTR(ce);
 	zend_hash_apply_with_argument(&ce->constants_table, (apply_func_arg_t)zval_update_constant_inline_change, ce TSRMLS_CC);
-	if (zend_hash_find(&ce->constants_table, name, name_len + 1, (void **) &value) == FAILURE) {
+	if ((value = zend_hash_find(&ce->constants_table, name)) == NULL) {
 		RETURN_FALSE;
 	}
-	MAKE_COPY_ZVAL(value, return_value);
+	ZVAL_DUP(return_value, value);
 }
 /* }}} */
 
@@ -4127,11 +4084,11 @@ ZEND_METHOD(reflection_class, isCloneable)
 	if (ce->ce_flags & (ZEND_ACC_INTERFACE | ZEND_ACC_TRAIT | ZEND_ACC_EXPLICIT_ABSTRACT_CLASS | ZEND_ACC_IMPLICIT_ABSTRACT_CLASS)) {
 		RETURN_FALSE;
 	}
-	if (intern->obj) {
+	if (!ZVAL_IS_UNDEF(&intern->obj)) {
 		if (ce->clone) {
 			RETURN_BOOL(ce->clone->common.fn_flags & ZEND_ACC_PUBLIC);
 		} else {
-			RETURN_BOOL(Z_OBJ_HANDLER_P(intern->obj, clone_obj) != NULL);
+			RETURN_BOOL(Z_OBJ_HANDLER(intern->obj, clone_obj) != NULL);
 		}
 	} else {
 		if (ce->clone) {
@@ -4214,7 +4171,7 @@ ZEND_METHOD(reflection_class, isInstance)
    Returns an instance of this class */
 ZEND_METHOD(reflection_class, newInstance)
 {
-	zval *retval_ptr = NULL;
+	zval retval;
 	reflection_object *intern;
 	zend_class_entry *ce, *old_scope;
 	zend_function *constructor;
@@ -4226,36 +4183,37 @@ ZEND_METHOD(reflection_class, newInstance)
 
 	old_scope = EG(scope);
 	EG(scope) = ce;
-	constructor = Z_OBJ_HT_P(return_value)->get_constructor(return_value TSRMLS_CC);
+	constructor = Z_OBJ_HT_P(return_value)->get_constructor(Z_OBJ_P(return_value) TSRMLS_CC);
 	EG(scope) = old_scope;
 
 	/* Run the constructor if there is one */
 	if (constructor) {
-		zval ***params = NULL;
-		int num_args = 0;
+		zval *params = NULL;
+		int ret, i, num_args = 0;
 		zend_fcall_info fci;
 		zend_fcall_info_cache fcc;
 
 		if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) {
-			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Access to non-public constructor of class %s", ce->name);
+			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Access to non-public constructor of class %s", ce->name->val);
 			zval_dtor(return_value);
 			RETURN_NULL();
 		}
 
 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "*", &params, &num_args) == FAILURE) {
-			if (params) {
-				efree(params);
-			}
 			zval_dtor(return_value);
 			RETURN_FALSE;
 		}
 
+		for (i = 0; i < num_args; i++) {
+			if (Z_REFCOUNTED(params[i])) Z_ADDREF(params[i]);
+		}
+
 		fci.size = sizeof(fci);
 		fci.function_table = EG(function_table);
-		fci.function_name = NULL;
+		ZVAL_UNDEF(&fci.function_name);
 		fci.symbol_table = NULL;
-		fci.object_ptr = return_value;
-		fci.retval_ptr_ptr = &retval_ptr;
+		fci.object = Z_OBJ_P(return_value);
+		fci.retval = &retval;
 		fci.param_count = num_args;
 		fci.params = params;
 		fci.no_separation = 1;
@@ -4264,27 +4222,20 @@ ZEND_METHOD(reflection_class, newInstance)
 		fcc.function_handler = constructor;
 		fcc.calling_scope = EG(scope);
 		fcc.called_scope = Z_OBJCE_P(return_value);
-		fcc.object_ptr = return_value;
+		fcc.object = Z_OBJ_P(return_value);
 
-		if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
-			if (params) {
-				efree(params);
-			}
-			if (retval_ptr) {
-				zval_ptr_dtor(&retval_ptr);
-			}
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invocation of %s's constructor failed", ce->name);
+		ret = zend_call_function(&fci, &fcc TSRMLS_CC);
+		zval_ptr_dtor(&retval);
+		for (i = 0; i < num_args; i++) {
+			zval_ptr_dtor(&params[i]);
+		}
+		if (ret == FAILURE) {
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invocation of %s's constructor failed", ce->name->val);
 			zval_dtor(return_value);
 			RETURN_NULL();
 		}
-		if (retval_ptr) {
-			zval_ptr_dtor(&retval_ptr);
-		}
-		if (params) {
-			efree(params);
-		}
 	} else if (ZEND_NUM_ARGS()) {
-		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name);
+		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name->val);
 	}
 }
 /* }}} */
@@ -4300,7 +4251,7 @@ ZEND_METHOD(reflection_class, newInstanceWithoutConstructor)
 	GET_REFLECTION_OBJECT_PTR(ce);
 
 	if (ce->create_object != NULL) {
-		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s is an internal class that cannot be instantiated without invoking its constructor", ce->name);
+		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s is an internal class that cannot be instantiated without invoking its constructor", ce->name->val);
 	}
 
 	object_init_ex(return_value, ce);
@@ -4311,10 +4262,10 @@ ZEND_METHOD(reflection_class, newInstanceWithoutConstructor)
    Returns an instance of this class */
 ZEND_METHOD(reflection_class, newInstanceArgs)
 {
-	zval *retval_ptr = NULL;
+	zval retval;
 	reflection_object *intern;
 	zend_class_entry *ce, *old_scope;
-	int argc = 0;
+	int ret, i, argc = 0;
 	HashTable *args;
 	zend_function *constructor;
 
@@ -4334,33 +4285,33 @@ ZEND_METHOD(reflection_class, newInstanceArgs)
 
 	old_scope = EG(scope);
 	EG(scope) = ce;
-	constructor = Z_OBJ_HT_P(return_value)->get_constructor(return_value TSRMLS_CC);
+	constructor = Z_OBJ_HT_P(return_value)->get_constructor(Z_OBJ_P(return_value) TSRMLS_CC);
 	EG(scope) = old_scope;
 
 	/* Run the constructor if there is one */
 	if (constructor) {
-		zval ***params = NULL;
+		zval *params = NULL;
 		zend_fcall_info fci;
 		zend_fcall_info_cache fcc;
 
 		if (!(constructor->common.fn_flags & ZEND_ACC_PUBLIC)) {
-			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Access to non-public constructor of class %s", ce->name);
+			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Access to non-public constructor of class %s", ce->name->val);
 			zval_dtor(return_value);
 			RETURN_NULL();
 		}
 
 		if (argc) {
-			params = safe_emalloc(sizeof(zval **), argc, 0);
+			params = safe_emalloc(sizeof(zval), argc, 0);
 			zend_hash_apply_with_argument(args, (apply_func_arg_t)_zval_array_to_c_array, &params TSRMLS_CC);
 			params -= argc;
 		}
 
 		fci.size = sizeof(fci);
 		fci.function_table = EG(function_table);
-		fci.function_name = NULL;
+		ZVAL_UNDEF(&fci.function_name);
 		fci.symbol_table = NULL;
-		fci.object_ptr = return_value;
-		fci.retval_ptr_ptr = &retval_ptr;
+		fci.object = Z_OBJ_P(return_value);
+		fci.retval = &retval;
 		fci.param_count = argc;
 		fci.params = params;
 		fci.no_separation = 1;
@@ -4369,27 +4320,24 @@ ZEND_METHOD(reflection_class, newInstanceArgs)
 		fcc.function_handler = constructor;
 		fcc.calling_scope = EG(scope);
 		fcc.called_scope = Z_OBJCE_P(return_value);
-		fcc.object_ptr = return_value;
+		fcc.object = Z_OBJ_P(return_value);
 
-		if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
-			if (params) {
-				efree(params);
-			}
-			if (retval_ptr) {
-				zval_ptr_dtor(&retval_ptr);
+		ret = zend_call_function(&fci, &fcc TSRMLS_CC);
+		zval_ptr_dtor(&retval);
+		if (params) {
+			for (i = 0; i < argc; i++) {
+				zval_ptr_dtor(&params[i]);
 			}
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invocation of %s's constructor failed", ce->name);
+			efree(params);
+		}
+		if (ret == FAILURE) {
+			zval_ptr_dtor(&retval);
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invocation of %s's constructor failed", ce->name->val);
 			zval_dtor(return_value);
 			RETURN_NULL();
 		}
-		if (retval_ptr) {
-			zval_ptr_dtor(&retval_ptr);
-		}
-		if (params) {
-			efree(params);
-		}
 	} else if (argc) {
-		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name);
+		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Class %s does not have a constructor, so you cannot pass any constructor arguments", ce->name->val);
 	}
 }
 /* }}} */
@@ -4413,10 +4361,9 @@ ZEND_METHOD(reflection_class, getInterfaces)
 		zend_uint i;
 
 		for (i=0; i < ce->num_interfaces; i++) {
-			zval *interface;
-			ALLOC_ZVAL(interface);
-			zend_reflection_class_factory(ce->interfaces[i], interface TSRMLS_CC);
-			add_assoc_zval_ex(return_value, ce->interfaces[i]->name, ce->interfaces[i]->name_length + 1, interface);
+			zval interface;
+			zend_reflection_class_factory(ce->interfaces[i], &interface TSRMLS_CC);
+			zend_hash_update(Z_ARRVAL_P(return_value), ce->interfaces[i]->name, &interface);
 		}
 	}
 }
@@ -4439,7 +4386,7 @@ ZEND_METHOD(reflection_class, getInterfaceNames)
 	array_init(return_value);
 
 	for (i=0; i < ce->num_interfaces; i++) {
-		add_next_index_stringl(return_value, ce->interfaces[i]->name, ce->interfaces[i]->name_length, 1);
+		add_next_index_str(return_value, STR_COPY(ce->interfaces[i]->name));
 	}
 }
 /* }}} */
@@ -4460,10 +4407,9 @@ ZEND_METHOD(reflection_class, getTraits)
 	array_init(return_value);
 
 	for (i=0; i < ce->num_traits; i++) {
-		zval *trait;
-		ALLOC_ZVAL(trait);
-		zend_reflection_class_factory(ce->traits[i], trait TSRMLS_CC);
-		add_assoc_zval_ex(return_value, ce->traits[i]->name, ce->traits[i]->name_length + 1, trait);
+		zval trait;
+		zend_reflection_class_factory(ce->traits[i], &trait TSRMLS_CC);
+		zend_hash_update(Z_ARRVAL_P(return_value), ce->traits[i]->name, &trait);
 	}
 }
 /* }}} */
@@ -4484,7 +4430,7 @@ ZEND_METHOD(reflection_class, getTraitNames)
 	array_init(return_value);
 
 	for (i=0; i < ce->num_traits; i++) {
-		add_next_index_stringl(return_value, ce->traits[i]->name, ce->traits[i]->name_length, 1);
+		add_next_index_str(return_value, STR_COPY(ce->traits[i]->name));
 	}
 }
 /* }}} */
@@ -4506,13 +4452,14 @@ ZEND_METHOD(reflection_class, getTraitAliases)
 	if (ce->trait_aliases) {
 		zend_uint i = 0;
 		while (ce->trait_aliases[i]) {
-			char *method_name;
-			int method_name_len;
+			zend_string *mname;
 			zend_trait_method_reference *cur_ref = ce->trait_aliases[i]->trait_method;
 
 			if (ce->trait_aliases[i]->alias) {
-				method_name_len = spprintf(&method_name, 0, "%s::%s", cur_ref->ce->name, cur_ref->method_name);
-				add_assoc_stringl_ex(return_value, ce->trait_aliases[i]->alias, ce->trait_aliases[i]->alias_len + 1, method_name, method_name_len, 0);
+
+				mname = STR_ALLOC(cur_ref->ce->name->len + cur_ref->method_name->len + 2, 0);
+				snprintf(mname->val, mname->len + 1, "%s::%s", cur_ref->ce->name->val, cur_ref->method_name->val);
+				add_assoc_str_ex(return_value, ce->trait_aliases[i]->alias->val, ce->trait_aliases[i]->alias->len, mname);
 			}
 			i++;
 		}
@@ -4545,7 +4492,7 @@ ZEND_METHOD(reflection_class, getParentClass)
 ZEND_METHOD(reflection_class, isSubclassOf)
 {
 	reflection_object *intern, *argument;
-	zend_class_entry *ce, **pce, *class_ce;
+	zend_class_entry *ce, *class_ce;
 	zval *class_name;
 
 	METHOD_NOTSTATIC(reflection_class_ptr);
@@ -4555,18 +4502,17 @@ ZEND_METHOD(reflection_class, isSubclassOf)
 		return;
 	}
 
-	switch(class_name->type) {
+	switch (Z_TYPE_P(class_name)) {
 		case IS_STRING:
-			if (zend_lookup_class(Z_STRVAL_P(class_name), Z_STRLEN_P(class_name), &pce TSRMLS_CC) == FAILURE) {
+			if ((class_ce = zend_lookup_class(Z_STR_P(class_name) TSRMLS_CC)) == NULL) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 						"Class %s does not exist", Z_STRVAL_P(class_name));
 				return;
 			}
-			class_ce = *pce;
 			break;
 		case IS_OBJECT:
 			if (instanceof_function(Z_OBJCE_P(class_name), reflection_class_ptr TSRMLS_CC)) {
-				argument = (reflection_object *) zend_object_store_get_object(class_name TSRMLS_CC);
+				argument = Z_REFLECTION_P(class_name);
 				if (argument == NULL || argument->ptr == NULL) {
 					php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the argument's reflection object");
 					/* Bails out */
@@ -4590,7 +4536,7 @@ ZEND_METHOD(reflection_class, isSubclassOf)
 ZEND_METHOD(reflection_class, implementsInterface)
 {
 	reflection_object *intern, *argument;
-	zend_class_entry *ce, *interface_ce, **pce;
+	zend_class_entry *ce, *interface_ce;
 	zval *interface;
 
 	METHOD_NOTSTATIC(reflection_class_ptr);
@@ -4600,18 +4546,17 @@ ZEND_METHOD(reflection_class, implementsInterface)
 		return;
 	}
 
-	switch(interface->type) {
+	switch (Z_TYPE_P(interface)) {
 		case IS_STRING:
-			if (zend_lookup_class(Z_STRVAL_P(interface), Z_STRLEN_P(interface), &pce TSRMLS_CC) == FAILURE) {
+			if ((interface_ce = zend_lookup_class(Z_STR_P(interface) TSRMLS_CC)) == NULL) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 						"Interface %s does not exist", Z_STRVAL_P(interface));
 				return;
 			}
-			interface_ce = *pce;
 			break;
 		case IS_OBJECT:
 			if (instanceof_function(Z_OBJCE_P(interface), reflection_class_ptr TSRMLS_CC)) {
-				argument = (reflection_object *) zend_object_store_get_object(interface TSRMLS_CC);
+				argument = Z_REFLECTION_P(interface);
 				if (argument == NULL || argument->ptr == NULL) {
 					php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Failed to retrieve the argument's reflection object");
 					/* Bails out */
@@ -4628,7 +4573,7 @@ ZEND_METHOD(reflection_class, implementsInterface)
 
 	if (!(interface_ce->ce_flags & ZEND_ACC_INTERFACE)) {
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-				"Interface %s is a Class", interface_ce->name);
+				"Interface %s is a Class", interface_ce->name->val);
 		return;
 	}
 	RETURN_BOOL(instanceof_function(ce, interface_ce TSRMLS_CC));
@@ -4688,7 +4633,7 @@ ZEND_METHOD(reflection_class, getExtensionName)
 	GET_REFLECTION_OBJECT_PTR(ce);
 
 	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module) {
-		RETURN_STRING(ce->info.internal.module->name, 1);
+		RETURN_STRING(ce->info.internal.module->name);
 	} else {
 		RETURN_FALSE;
 	}
@@ -4699,18 +4644,18 @@ ZEND_METHOD(reflection_class, getExtensionName)
    Returns whether this class is defined in namespace */
 ZEND_METHOD(reflection_class, inNamespace)
 {
-	zval **name;
+	zval *name;
 	const char *backslash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
+	if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-	if (Z_TYPE_PP(name) == IS_STRING
-		&& (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
-		&& backslash > Z_STRVAL_PP(name))
+	if (Z_TYPE_P(name) == IS_STRING
+		&& (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name)))
+		&& backslash > Z_STRVAL_P(name))
 	{
 		RETURN_TRUE;
 	}
@@ -4722,20 +4667,20 @@ ZEND_METHOD(reflection_class, inNamespace)
    Returns the name of namespace where this class is defined */
 ZEND_METHOD(reflection_class, getNamespaceName)
 {
-	zval **name;
+	zval *name;
 	const char *backslash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
+	if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-	if (Z_TYPE_PP(name) == IS_STRING
-		&& (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
-		&& backslash > Z_STRVAL_PP(name))
+	if (Z_TYPE_P(name) == IS_STRING
+		&& (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name)))
+		&& backslash > Z_STRVAL_P(name))
 	{
-		RETURN_STRINGL(Z_STRVAL_PP(name), backslash - Z_STRVAL_PP(name), 1);
+		RETURN_STRINGL(Z_STRVAL_P(name), backslash - Z_STRVAL_P(name));
 	}
 	RETURN_EMPTY_STRING();
 }
@@ -4745,22 +4690,22 @@ ZEND_METHOD(reflection_class, getNamespaceName)
    Returns the short name of the class (without namespace part) */
 ZEND_METHOD(reflection_class, getShortName)
 {
-	zval **name;
+	zval *name;
 	const char *backslash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	if (zend_hash_find(Z_OBJPROP_P(getThis()), "name", sizeof("name"), (void **) &name) == FAILURE) {
+	if ((name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC)) == NULL) {
 		RETURN_FALSE;
 	}
-	if (Z_TYPE_PP(name) == IS_STRING
-		&& (backslash = zend_memrchr(Z_STRVAL_PP(name), '\\', Z_STRLEN_PP(name)))
-		&& backslash > Z_STRVAL_PP(name))
+	if (Z_TYPE_P(name) == IS_STRING
+		&& (backslash = zend_memrchr(Z_STRVAL_P(name), '\\', Z_STRLEN_P(name)))
+		&& backslash > Z_STRVAL_P(name))
 	{
-		RETURN_STRINGL(backslash + 1, Z_STRLEN_PP(name) - (backslash - Z_STRVAL_PP(name) + 1), 1);
+		RETURN_STRINGL(backslash + 1, Z_STRLEN_P(name) - (backslash - Z_STRVAL_P(name) + 1));
 	}
-	RETURN_ZVAL(*name, 1, 0);
+	RETURN_ZVAL(name, 1, 0);
 }
 /* }}} */
 
@@ -4792,13 +4737,12 @@ ZEND_METHOD(reflection_property, export)
    Constructor. Throws an Exception in case the given property does not exist */
 ZEND_METHOD(reflection_property, __construct)
 {
-	zval *propname, *classname;
+	zval propname, cname, *classname;
 	char *name_str;
 	const char *class_name, *prop_name;
 	int name_len, dynam_prop = 0;
 	zval *object;
 	reflection_object *intern;
-	zend_class_entry **pce;
 	zend_class_entry *ce;
 	zend_property_info *property_info = NULL;
 	property_reference *reference;
@@ -4808,7 +4752,7 @@ ZEND_METHOD(reflection_property, __construct)
 	}
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
@@ -4816,12 +4760,11 @@ ZEND_METHOD(reflection_property, __construct)
 	/* Find the class entry */
 	switch (Z_TYPE_P(classname)) {
 		case IS_STRING:
-			if (zend_lookup_class(Z_STRVAL_P(classname), Z_STRLEN_P(classname), &pce TSRMLS_CC) == FAILURE) {
+			if ((ce = zend_lookup_class(Z_STR_P(classname) TSRMLS_CC)) == NULL) {
 				zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 						"Class %s does not exist", Z_STRVAL_P(classname));
 				return;
 			}
-			ce = *pce;
 			break;
 
 		case IS_OBJECT:
@@ -4833,15 +4776,15 @@ ZEND_METHOD(reflection_property, __construct)
 			/* returns out of this function */
 	}
 
-	if (zend_hash_find(&ce->properties_info, name_str, name_len + 1, (void **) &property_info) == FAILURE || (property_info->flags & ZEND_ACC_SHADOW)) {
+	if ((property_info = zend_hash_str_find_ptr(&ce->properties_info, name_str, name_len)) == NULL || (property_info->flags & ZEND_ACC_SHADOW)) {
 		/* Check for dynamic properties */
 		if (property_info == NULL && Z_TYPE_P(classname) == IS_OBJECT && Z_OBJ_HT_P(classname)->get_properties) {
-			if (zend_hash_exists(Z_OBJ_HT_P(classname)->get_properties(classname TSRMLS_CC), name_str, name_len+1)) {
+			if (zend_hash_str_exists(Z_OBJ_HT_P(classname)->get_properties(classname TSRMLS_CC), name_str, name_len)) {
 				dynam_prop = 1;
 			}
 		}
 		if (dynam_prop == 0) {
-			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Property %s::$%s does not exist", ce->name, name_str);
+			zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC, "Property %s::$%s does not exist", ce->name->val, name_str);
 			return;
 		}
 	}
@@ -4851,33 +4794,28 @@ ZEND_METHOD(reflection_property, __construct)
 		zend_class_entry *tmp_ce = ce;
 		zend_property_info *tmp_info;
 
-		while (tmp_ce && zend_hash_find(&tmp_ce->properties_info, name_str, name_len + 1, (void **) &tmp_info) != SUCCESS) {
+		while (tmp_ce && (tmp_info = zend_hash_str_find_ptr(&tmp_ce->properties_info, name_str, name_len)) == NULL) {
 			ce = tmp_ce;
 			property_info = tmp_info;
 			tmp_ce = tmp_ce->parent;
 		}
 	}
 
-	MAKE_STD_ZVAL(classname);
-	MAKE_STD_ZVAL(propname);
-
 	if (dynam_prop == 0) {
-		zend_unmangle_property_name(property_info->name, property_info->name_length, &class_name, &prop_name);
-		ZVAL_STRINGL(classname, property_info->ce->name, property_info->ce->name_length, 1);
-		ZVAL_STRING(propname, prop_name, 1);
+		zend_unmangle_property_name(property_info->name->val, property_info->name->len, &class_name, &prop_name);
+		ZVAL_STR(&cname, STR_COPY(property_info->ce->name));
+		ZVAL_STRING(&propname, prop_name);
 	} else {
-		ZVAL_STRINGL(classname, ce->name, ce->name_length, 1);
-		ZVAL_STRINGL(propname, name_str, name_len, 1);
+		ZVAL_STR(&cname, STR_COPY(ce->name));
+		ZVAL_STRINGL(&propname, name_str, name_len);
 	}
-	reflection_update_property(object, "class", classname);
-	reflection_update_property(object, "name", propname);
+	reflection_update_property(object, "class", &cname);
+	reflection_update_property(object, "name", &propname);
 
 	reference = (property_reference*) emalloc(sizeof(property_reference));
 	if (dynam_prop) {
 		reference->prop.flags = ZEND_ACC_IMPLICIT_PUBLIC;
-		reference->prop.name = Z_STRVAL_P(propname);
-		reference->prop.name_length = Z_STRLEN_P(propname);
-		reference->prop.h = zend_get_hash_value(name_str, name_len+1);
+		reference->prop.name = Z_STR(propname);
 		reference->prop.doc_comment = NULL;
 		reference->prop.ce = ce;
 	} else {
@@ -4905,7 +4843,7 @@ ZEND_METHOD(reflection_property, __toString)
 	GET_REFLECTION_OBJECT_PTR(ref);
 	string_init(&str);
 	_property_string(&str, &ref->prop, NULL, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -4916,7 +4854,7 @@ ZEND_METHOD(reflection_property, getName)
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	_default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
+	_default_get_entry(getThis(), "name", sizeof("name")-1, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -4995,42 +4933,35 @@ ZEND_METHOD(reflection_property, getValue)
 {
 	reflection_object *intern;
 	property_reference *ref;
-	zval *object, name;
+	zval *object, *name;
 	zval *member_p = NULL;
 
 	METHOD_NOTSTATIC(reflection_property_ptr);
 	GET_REFLECTION_OBJECT_PTR(ref);
 
 	if (!(ref->prop.flags & (ZEND_ACC_PUBLIC | ZEND_ACC_IMPLICIT_PUBLIC)) && intern->ignore_visibility == 0) {
-		_default_get_entry(getThis(), "name", sizeof("name"), &name TSRMLS_CC);
+		name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC);
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Cannot access non-public member %s::%s", intern->ce->name, Z_STRVAL(name));
-		zval_dtor(&name);
+			"Cannot access non-public member %s::%s", intern->ce->name->val, Z_STRVAL_P(name));
 		return;
 	}
 
 	if ((ref->prop.flags & ZEND_ACC_STATIC)) {
 		zend_update_class_constants(intern->ce TSRMLS_CC);
-		if (!CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]) {
-			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Could not find the property %s::%s", intern->ce->name, ref->prop.name);
+		if (Z_TYPE(CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]) == IS_UNDEF) {
+			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Could not find the property %s::%s", intern->ce->name->val, ref->prop.name->val);
 			/* Bails out */
 		}
-		*return_value= *CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset];
-		zval_copy_ctor(return_value);
- 		INIT_PZVAL(return_value);
+		ZVAL_DUP(return_value, &CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]);
 	} else {
 		const char *class_name, *prop_name;
 
 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &object) == FAILURE) {
 			return;
 		}
-		zend_unmangle_property_name(ref->prop.name, ref->prop.name_length, &class_name, &prop_name);
+		zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name);
 		member_p = zend_read_property(ref->ce, object, prop_name, strlen(prop_name), 1 TSRMLS_CC);
-		MAKE_COPY_ZVAL(&member_p, return_value);
-		if (member_p != EG(uninitialized_zval_ptr)) {
-			zval_add_ref(&member_p);
-			zval_ptr_dtor(&member_p);
-		}
+		ZVAL_DUP(return_value, member_p);
 	}
 }
 /* }}} */
@@ -5041,8 +4972,8 @@ ZEND_METHOD(reflection_property, setValue)
 {
 	reflection_object *intern;
 	property_reference *ref;
-	zval **variable_ptr;
-	zval *object, name;
+	zval *variable_ptr;
+	zval *object, *name;
 	zval *value;
 	zval *tmp;
 
@@ -5050,10 +4981,9 @@ ZEND_METHOD(reflection_property, setValue)
 	GET_REFLECTION_OBJECT_PTR(ref);
 
 	if (!(ref->prop.flags & ZEND_ACC_PUBLIC) && intern->ignore_visibility == 0) {
-		_default_get_entry(getThis(), "name", sizeof("name"), &name TSRMLS_CC);
+		name = _default_load_entry(getThis(), "name", sizeof("name")-1 TSRMLS_CC);
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Cannot access non-public member %s::%s", intern->ce->name, Z_STRVAL(name));
-		zval_dtor(&name);
+			"Cannot access non-public member %s::%s", intern->ce->name->val, Z_STRVAL_P(name));
 		return;
 	}
 
@@ -5065,31 +4995,35 @@ ZEND_METHOD(reflection_property, setValue)
 		}
 		zend_update_class_constants(intern->ce TSRMLS_CC);
 
-		if (!CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]) {
-			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Could not find the property %s::%s", intern->ce->name, ref->prop.name);
+		if (Z_TYPE(CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset]) == IS_UNDEF) {
+			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Internal error: Could not find the property %s::%s", intern->ce->name->val, ref->prop.name->val);
 			/* Bails out */
 		}
 		variable_ptr = &CE_STATIC_MEMBERS(intern->ce)[ref->prop.offset];
-		if (*variable_ptr != value) {
-			if (PZVAL_IS_REF(*variable_ptr)) {
-				zval garbage = **variable_ptr; /* old value should be destroyed */
+		if (variable_ptr != value) {
+			if (Z_ISREF_P(variable_ptr)) {
+				zval garbage;
+				
+				ZVAL_COPY_VALUE(&garbage, variable_ptr); /* old value should be destroyed */
 
 				/* To check: can't *variable_ptr be some system variable like error_zval here? */
-				Z_TYPE_PP(variable_ptr) = Z_TYPE_P(value);
-				(*variable_ptr)->value = value->value;
-				if (Z_REFCOUNT_P(value) > 0) {
-					zval_copy_ctor(*variable_ptr);
+				ZVAL_COPY_VALUE(variable_ptr, value);
+				if (Z_REFCOUNTED_P(value) && Z_REFCOUNT_P(value) > 0) {
+					zval_copy_ctor(variable_ptr);
 				}
 				zval_dtor(&garbage);
 			} else {
-				zval *garbage = *variable_ptr;
-
+				zval garbage;
+				
+				ZVAL_COPY_VALUE(&garbage, variable_ptr);
 				/* if we assign referenced variable, we should separate it */
-				Z_ADDREF_P(value);
-				if (PZVAL_IS_REF(value)) {
-					SEPARATE_ZVAL(&value);
+				if (Z_REFCOUNTED_P(value)) {
+					Z_ADDREF_P(value);
 				}
-				*variable_ptr = value;
+				if (Z_ISREF_P(value)) {
+					SEPARATE_ZVAL(value);
+				}
+				ZVAL_COPY_VALUE(variable_ptr, value);
 				zval_ptr_dtor(&garbage);
 			}
 		}
@@ -5099,7 +5033,7 @@ ZEND_METHOD(reflection_property, setValue)
 		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "oz", &object, &value) == FAILURE) {
 			return;
 		}
-		zend_unmangle_property_name(ref->prop.name, ref->prop.name_length, &class_name, &prop_name);
+		zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name);
 		zend_update_property(ref->ce, object, prop_name, strlen(prop_name), value TSRMLS_CC);
 	}
 }
@@ -5121,13 +5055,13 @@ ZEND_METHOD(reflection_property, getDeclaringClass)
 	}
 	GET_REFLECTION_OBJECT_PTR(ref);
 
-	if (zend_unmangle_property_name(ref->prop.name, ref->prop.name_length, &class_name, &prop_name) != SUCCESS) {
+	if (zend_unmangle_property_name(ref->prop.name->val, ref->prop.name->len, &class_name, &prop_name) != SUCCESS) {
 		RETURN_FALSE;
 	}
 
 	prop_name_len = strlen(prop_name);
 	ce = tmp_ce = ref->ce;
-	while (tmp_ce && zend_hash_find(&tmp_ce->properties_info, prop_name, prop_name_len + 1, (void **) &tmp_info) == SUCCESS) {
+	while (tmp_ce && (tmp_info = zend_hash_str_find_ptr(&tmp_ce->properties_info, prop_name, prop_name_len)) != NULL) {
 		if (tmp_info->flags & ZEND_ACC_PRIVATE || tmp_info->flags & ZEND_ACC_SHADOW) {
 			/* it's a private property, so it can't be inherited */
 			break;
@@ -5156,7 +5090,7 @@ ZEND_METHOD(reflection_property, getDocComment)
 	}
 	GET_REFLECTION_OBJECT_PTR(ref);
 	if (ref->prop.doc_comment) {
-		RETURN_STRINGL(ref->prop.doc_comment, ref->prop.doc_comment_len, 1);
+		RETURN_STR(STR_COPY(ref->prop.doc_comment));
 	}
 	RETURN_FALSE;
 }
@@ -5173,7 +5107,7 @@ ZEND_METHOD(reflection_property, setAccessible)
 		return;
 	}
 
-	intern = (reflection_object *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_REFLECTION_P(getThis());
 
 	if (intern == NULL) {
 		return;
@@ -5195,7 +5129,7 @@ ZEND_METHOD(reflection_extension, export)
    Constructor. Throws an Exception in case the given extension does not exist */
 ZEND_METHOD(reflection_extension, __construct)
 {
-	zval *name;
+	zval name;
 	zval *object;
 	char *lcname;
 	reflection_object *intern;
@@ -5209,22 +5143,21 @@ ZEND_METHOD(reflection_extension, __construct)
 	}
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
 	lcname = do_alloca(name_len + 1, use_heap);
 	zend_str_tolower_copy(lcname, name_str, name_len);
-	if (zend_hash_find(&module_registry, lcname, name_len + 1, (void **)&module) == FAILURE) {
+	if ((module = zend_hash_str_find_ptr(&module_registry, lcname, name_len)) == NULL) {
 		free_alloca(lcname, use_heap);
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
 			"Extension %s does not exist", name_str);
 		return;
 	}
 	free_alloca(lcname, use_heap);
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRING(name, module->name, 1);
-	reflection_update_property( object, "name", name);
+	ZVAL_STRING(&name, module->name);
+	reflection_update_property(object, "name", &name);
 	intern->ptr = module;
 	intern->ref_type = REF_TYPE_OTHER;
 	intern->ce = NULL;
@@ -5245,7 +5178,7 @@ ZEND_METHOD(reflection_extension, __toString)
 	GET_REFLECTION_OBJECT_PTR(module);
 	string_init(&str);
 	_extension_string(&str, module, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -5256,7 +5189,7 @@ ZEND_METHOD(reflection_extension, getName)
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	_default_get_entry(getThis(), "name", sizeof("name"), return_value TSRMLS_CC);
+	_default_get_entry(getThis(), "name", sizeof("name")-1, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -5276,7 +5209,7 @@ ZEND_METHOD(reflection_extension, getVersion)
 	if (module->version == NO_VERSION_YET) {
 		RETURN_NULL();
 	} else {
-		RETURN_STRING(module->version, 1);
+		RETURN_STRING(module->version);
 	}
 }
 /* }}} */
@@ -5288,7 +5221,7 @@ ZEND_METHOD(reflection_extension, getFunctions)
 	reflection_object *intern;
 	zend_module_entry *module;
 	HashPosition iterator;
-	zval *function;
+	zval function;
 	zend_function *fptr;
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -5298,30 +5231,27 @@ ZEND_METHOD(reflection_extension, getFunctions)
 
 	array_init(return_value);
 	zend_hash_internal_pointer_reset_ex(CG(function_table), &iterator);
-	while (zend_hash_get_current_data_ex(CG(function_table), (void **) &fptr, &iterator) == SUCCESS) {
+	while ((fptr = zend_hash_get_current_data_ptr_ex(CG(function_table), &iterator)) != NULL) {
 		if (fptr->common.type==ZEND_INTERNAL_FUNCTION
 			&& fptr->internal_function.module == module) {
-			ALLOC_ZVAL(function);
-			reflection_function_factory(fptr, NULL, function TSRMLS_CC);
-			add_assoc_zval(return_value, fptr->common.function_name, function);
+			reflection_function_factory(fptr, NULL, &function TSRMLS_CC);
+			zend_hash_update(Z_ARRVAL_P(return_value), fptr->common.function_name, &function);
 		}
 		zend_hash_move_forward_ex(CG(function_table), &iterator);
 	}
 }
 /* }}} */
 
-static int _addconstant(zend_constant *constant TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int _addconstant(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
-	zval *const_val;
+	zval const_val;
+	zend_constant *constant = (zend_constant*)Z_PTR_P(el);
 	zval *retval = va_arg(args, zval*);
 	int number = va_arg(args, int);
 
 	if (number == constant->module_number) {
-		ALLOC_ZVAL(const_val);
-		*const_val = constant->value;
-		zval_copy_ctor(const_val);
-		INIT_PZVAL(const_val);
-		add_assoc_zval_ex(retval, constant->name, constant->name_len, const_val);
+		ZVAL_DUP(&const_val, &constant->value);
+		zend_hash_update(Z_ARRVAL_P(retval), constant->name, &const_val);
 	}
 	return 0;
 }
@@ -5345,14 +5275,15 @@ ZEND_METHOD(reflection_extension, getConstants)
 /* }}} */
 
 /* {{{ _addinientry */
-static int _addinientry(zend_ini_entry *ini_entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int _addinientry(zval *el TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
+	zend_ini_entry *ini_entry = (zend_ini_entry*)Z_PTR_P(el);
 	zval *retval = va_arg(args, zval*);
 	int number = va_arg(args, int);
 
 	if (number == ini_entry->module_number) {
 		if (ini_entry->value) {
-			add_assoc_stringl(retval, ini_entry->name, ini_entry->value, ini_entry->value_length, 1);
+			add_assoc_stringl(retval, ini_entry->name, ini_entry->value, ini_entry->value_length);
 		} else {
 			add_assoc_null(retval, ini_entry->name);
 		}
@@ -5379,19 +5310,19 @@ ZEND_METHOD(reflection_extension, getINIEntries)
 /* }}} */
 
 /* {{{ add_extension_class */
-static int add_extension_class(zend_class_entry **pce TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
+static int add_extension_class(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
-	zval *class_array = va_arg(args, zval*), *zclass;
+	zend_class_entry *ce = Z_PTR_P(zv);
+	zval *class_array = va_arg(args, zval*), zclass;
 	struct _zend_module_entry *module = va_arg(args, struct _zend_module_entry*);
 	int add_reflection_class = va_arg(args, int);
 
-	if (((*pce)->type == ZEND_INTERNAL_CLASS) && (*pce)->info.internal.module && !strcasecmp((*pce)->info.internal.module->name, module->name)) {
+	if ((ce->type == ZEND_INTERNAL_CLASS) && ce->info.internal.module && !strcasecmp(ce->info.internal.module->name, module->name)) {
 		if (add_reflection_class) {
-			ALLOC_ZVAL(zclass);
-			zend_reflection_class_factory(*pce, zclass TSRMLS_CC);
-			add_assoc_zval_ex(class_array, (*pce)->name, (*pce)->name_length + 1, zclass);
+			zend_reflection_class_factory(ce, &zclass TSRMLS_CC);
+			zend_hash_update(Z_ARRVAL_P(class_array), ce->name, &zclass);
 		} else {
-			add_next_index_stringl(class_array, (*pce)->name, (*pce)->name_length, 1);
+			add_next_index_str(class_array, STR_COPY(ce->name));
 		}
 	}
 	return ZEND_HASH_APPLY_KEEP;
@@ -5455,32 +5386,45 @@ ZEND_METHOD(reflection_extension, getDependencies)
 	}
 
 	while(dep->name) {
-		char *relation;
+		zend_string *relation;
 		char *rel_type;
-		int len;
+		int len = 0;
 
 		switch(dep->type) {
-		case MODULE_DEP_REQUIRED:
-			rel_type = "Required";
-			break;
-		case MODULE_DEP_CONFLICTS:
-			rel_type = "Conflicts";
-			break;
-		case MODULE_DEP_OPTIONAL:
-			rel_type = "Optional";
-			break;
-		default:
-			rel_type = "Error"; /* shouldn't happen */
-			break;
+			case MODULE_DEP_REQUIRED:
+				rel_type = "Required";
+				len += sizeof("Required") - 1;
+				break;
+			case MODULE_DEP_CONFLICTS:
+				rel_type = "Conflicts";
+				len += sizeof("Conflicts") - 1;
+				break;
+			case MODULE_DEP_OPTIONAL:
+				rel_type = "Optional";
+				len += sizeof("Optional") - 1;
+				break;
+			default:
+				rel_type = "Error"; /* shouldn't happen */
+				len += sizeof("Error") - 1;
+				break;
+		}
+
+		if (dep->rel) {
+			len += strlen(dep->rel) + 1;
 		}
 
-		len = spprintf(&relation, 0, "%s%s%s%s%s",
+		if (dep->version) {
+			len += strlen(dep->version) + 1;
+		}
+
+		relation = STR_ALLOC(len, 0);
+		snprintf(relation->val, relation->len + 1, "%s%s%s%s%s",
 						rel_type,
 						dep->rel ? " " : "",
 						dep->rel ? dep->rel : "",
 						dep->version ? " " : "",
 						dep->version ? dep->version : "");
-		add_assoc_stringl(return_value, dep->name, relation, len, 0);
+		add_assoc_str(return_value, dep->name, relation);
 		dep++;
 	}
 }
@@ -5546,7 +5490,7 @@ ZEND_METHOD(reflection_zend_extension, export)
        Constructor. Throws an Exception in case the given Zend extension does not exist */
 ZEND_METHOD(reflection_zend_extension, __construct)
 {
-	zval *name;
+	zval name;
 	zval *object;
 	reflection_object *intern;
 	zend_extension *extension;
@@ -5558,7 +5502,7 @@ ZEND_METHOD(reflection_zend_extension, __construct)
 	}
 
 	object = getThis();
-	intern = (reflection_object *) zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_REFLECTION_P(object);
 	if (intern == NULL) {
 		return;
 	}
@@ -5569,9 +5513,8 @@ ZEND_METHOD(reflection_zend_extension, __construct)
 				"Zend Extension %s does not exist", name_str);
 		return;
 	}
-	MAKE_STD_ZVAL(name);
-	ZVAL_STRING(name, extension->name, 1);
-	reflection_update_property(object, "name", name);
+	ZVAL_STRING(&name, extension->name);
+	reflection_update_property(object, "name", &name);
 	intern->ptr = extension;
 	intern->ref_type = REF_TYPE_OTHER;
 	intern->ce = NULL;
@@ -5592,7 +5535,7 @@ ZEND_METHOD(reflection_zend_extension, __toString)
 	GET_REFLECTION_OBJECT_PTR(extension);
 	string_init(&str);
 	_zend_extension_string(&str, extension, "" TSRMLS_CC);
-	RETURN_STRINGL(str.string, str.len - 1, 0);
+	RETURN_STR(str.buf);
 }
 /* }}} */
 
@@ -5608,7 +5551,7 @@ ZEND_METHOD(reflection_zend_extension, getName)
 	}
 	GET_REFLECTION_OBJECT_PTR(extension);
 
-	RETURN_STRING(extension->name, 1);
+	RETURN_STRING(extension->name);
 }
 /* }}} */
 
@@ -5624,7 +5567,11 @@ ZEND_METHOD(reflection_zend_extension, getVersion)
 	}
 	GET_REFLECTION_OBJECT_PTR(extension);
 
-	RETURN_STRING(extension->version ? extension->version : "", 1);
+	if (extension->version) {
+		RETURN_STRING(extension->version);
+	} else {
+		RETURN_EMPTY_STRING();
+	}
 }
 /* }}} */
 
@@ -5640,7 +5587,11 @@ ZEND_METHOD(reflection_zend_extension, getAuthor)
 	}
 	GET_REFLECTION_OBJECT_PTR(extension);
 
-	RETURN_STRING(extension->author ? extension->author : "", 1);
+	if (extension->author) {
+		RETURN_STRING(extension->author);
+	} else {
+		RETURN_EMPTY_STRING();
+	}
 }
 /* }}} */
 
@@ -5656,7 +5607,11 @@ ZEND_METHOD(reflection_zend_extension, getURL)
 	}
 	GET_REFLECTION_OBJECT_PTR(extension);
 
-	RETURN_STRING(extension->URL ? extension->URL : "", 1);
+	if (extension->URL) {
+		RETURN_STRING(extension->URL);
+	} else {
+		RETURN_EMPTY_STRING();
+	}
 }
 /* }}} */
 
@@ -5672,7 +5627,11 @@ ZEND_METHOD(reflection_zend_extension, getCopyright)
 	}
 	GET_REFLECTION_OBJECT_PTR(extension);
 
-	RETURN_STRING(extension->copyright ? extension->copyright : "", 1);
+	if (extension->copyright) {
+		RETURN_STRING(extension->copyright);
+	} else {
+		RETURN_EMPTY_STRING();
+	}
 }
 /* }}} */
 
@@ -6092,19 +6051,19 @@ const zend_function_entry reflection_ext_functions[] = { /* {{{ */
 static zend_object_handlers *zend_std_obj_handlers;
 
 /* {{{ _reflection_write_property */
-static void _reflection_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void _reflection_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
 	if ((Z_TYPE_P(member) == IS_STRING)
-		&& zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STRVAL_P(member), Z_STRLEN_P(member)+1)
+		&& zend_hash_exists(&Z_OBJCE_P(object)->properties_info, Z_STR_P(member))
 		&& ((Z_STRLEN_P(member) == sizeof("name") - 1  && !memcmp(Z_STRVAL_P(member), "name",  sizeof("name")))
 			|| (Z_STRLEN_P(member) == sizeof("class") - 1 && !memcmp(Z_STRVAL_P(member), "class", sizeof("class")))))
 	{
 		zend_throw_exception_ex(reflection_exception_ptr, 0 TSRMLS_CC,
-			"Cannot set read-only property %s::$%s", Z_OBJCE_P(object)->name, Z_STRVAL_P(member));
+			"Cannot set read-only property %s::$%s", Z_OBJCE_P(object)->name->val, Z_STRVAL_P(member));
 	}
 	else
 	{
-		zend_std_obj_handlers->write_property(object, member, value, key TSRMLS_CC);
+		zend_std_obj_handlers->write_property(object, member, value, cache_slot TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -6115,11 +6074,13 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */
 
 	zend_std_obj_handlers = zend_get_std_object_handlers();
 	memcpy(&reflection_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	reflection_object_handlers.offset = XtOffsetOf(reflection_object, zo);
+	reflection_object_handlers.free_obj = reflection_free_objects_storage;
 	reflection_object_handlers.clone_obj = NULL;
 	reflection_object_handlers.write_property = _reflection_write_property;
 
 	INIT_CLASS_ENTRY(_reflection_entry, "ReflectionException", reflection_exception_functions);
-	reflection_exception_ptr = zend_register_internal_class_ex(&_reflection_entry, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
+	reflection_exception_ptr = zend_register_internal_class_ex(&_reflection_entry, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
 
 	INIT_CLASS_ENTRY(_reflection_entry, "Reflection", reflection_functions);
 	reflection_ptr = zend_register_internal_class(&_reflection_entry TSRMLS_CC);
@@ -6135,7 +6096,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */
 
 	INIT_CLASS_ENTRY(_reflection_entry, "ReflectionFunction", reflection_function_functions);
 	_reflection_entry.create_object = reflection_objects_new;
-	reflection_function_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr, NULL TSRMLS_CC);
+	reflection_function_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr TSRMLS_CC);
 	zend_declare_property_string(reflection_function_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
 
 	REGISTER_REFLECTION_CLASS_CONST_LONG(function, "IS_DEPRECATED", ZEND_ACC_DEPRECATED);
@@ -6148,7 +6109,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */
 
 	INIT_CLASS_ENTRY(_reflection_entry, "ReflectionMethod", reflection_method_functions);
 	_reflection_entry.create_object = reflection_objects_new;
-	reflection_method_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr, NULL TSRMLS_CC);
+	reflection_method_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_function_abstract_ptr TSRMLS_CC);
 	zend_declare_property_string(reflection_method_ptr, "name", sizeof("name")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
 	zend_declare_property_string(reflection_method_ptr, "class", sizeof("class")-1, "", ZEND_ACC_PUBLIC TSRMLS_CC);
 
@@ -6171,7 +6132,7 @@ PHP_MINIT_FUNCTION(reflection) /* {{{ */
 
 	INIT_CLASS_ENTRY(_reflection_entry, "ReflectionObject", reflection_object_functions);
 	_reflection_entry.create_object = reflection_objects_new;
-	reflection_object_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_class_ptr, NULL TSRMLS_CC);
+	reflection_object_ptr = zend_register_internal_class_ex(&_reflection_entry, reflection_class_ptr TSRMLS_CC);
 
 	INIT_CLASS_ENTRY(_reflection_entry, "ReflectionProperty", reflection_property_functions);
 	_reflection_entry.create_object = reflection_objects_new;
diff --git a/ext/reflection/tests/009.phpt b/ext/reflection/tests/009.phpt
index b54e89e5bf..8cc0f98166 100644
--- a/ext/reflection/tests/009.phpt
+++ b/ext/reflection/tests/009.phpt
@@ -93,17 +93,17 @@ bool(false)
 --getParameters--
 array(3) {
   [0]=>
-  &object(ReflectionParameter)#2 (1) {
+  object(ReflectionParameter)#2 (1) {
     ["name"]=>
     string(1) "a"
   }
   [1]=>
-  &object(ReflectionParameter)#3 (1) {
+  object(ReflectionParameter)#3 (1) {
     ["name"]=>
     string(1) "b"
   }
   [2]=>
-  &object(ReflectionParameter)#4 (1) {
+  object(ReflectionParameter)#4 (1) {
     ["name"]=>
     string(1) "c"
   }
diff --git a/ext/reflection/tests/025.phpt b/ext/reflection/tests/025.phpt
index 92002007b6..e49fa998e7 100644
--- a/ext/reflection/tests/025.phpt
+++ b/ext/reflection/tests/025.phpt
@@ -95,17 +95,17 @@ bool(false)
 --getParameters--
 array(3) {
   [0]=>
-  &object(ReflectionParameter)#2 (1) {
+  object(ReflectionParameter)#2 (1) {
     ["name"]=>
     string(1) "a"
   }
   [1]=>
-  &object(ReflectionParameter)#3 (1) {
+  object(ReflectionParameter)#3 (1) {
     ["name"]=>
     string(1) "b"
   }
   [2]=>
-  &object(ReflectionParameter)#4 (1) {
+  object(ReflectionParameter)#4 (1) {
     ["name"]=>
     string(1) "c"
   }
diff --git a/ext/reflection/tests/ReflectionClass_getInterfaces_003.phpt b/ext/reflection/tests/ReflectionClass_getInterfaces_003.phpt
index 74044f7531..f1cac44e95 100644
--- a/ext/reflection/tests/ReflectionClass_getInterfaces_003.phpt
+++ b/ext/reflection/tests/ReflectionClass_getInterfaces_003.phpt
@@ -52,7 +52,7 @@ The result is an array in which each element is an object (an instance of Reflec
 Var_dumping this array shows that the elements are referenced. By what?
 array(1) {
   ["I"]=>
-  &object(ReflectionClass)#%d (1) {
+  object(ReflectionClass)#%d (1) {
     ["name"]=>
     string(1) "I"
   }
@@ -66,4 +66,4 @@ array(1) {
     ["x"]=>
     int(1)
   }
-}
\ No newline at end of file
+}
diff --git a/ext/reflection/tests/ReflectionClass_getMethods_001.phpt b/ext/reflection/tests/ReflectionClass_getMethods_001.phpt
index ce5c980c60..1e11dee2f3 100644
--- a/ext/reflection/tests/ReflectionClass_getMethods_001.phpt
+++ b/ext/reflection/tests/ReflectionClass_getMethods_001.phpt
@@ -39,14 +39,14 @@ foreach($classes as $class) {
 Reflecting on class pubf: 
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "f"
     [%u|b%"class"]=>
     %unicode|string%(4) "pubf"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -56,14 +56,14 @@ array(2) {
 Reflecting on class subpubf: 
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "f"
     [%u|b%"class"]=>
     %unicode|string%(4) "pubf"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -73,14 +73,14 @@ array(2) {
 Reflecting on class protf: 
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "f"
     [%u|b%"class"]=>
     %unicode|string%(5) "protf"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -90,14 +90,14 @@ array(2) {
 Reflecting on class subprotf: 
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "f"
     [%u|b%"class"]=>
     %unicode|string%(5) "protf"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -107,14 +107,14 @@ array(2) {
 Reflecting on class privf: 
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "f"
     [%u|b%"class"]=>
     %unicode|string%(5) "privf"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -124,14 +124,14 @@ array(2) {
 Reflecting on class subprivf: 
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "f"
     [%u|b%"class"]=>
     %unicode|string%(5) "privf"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
diff --git a/ext/reflection/tests/ReflectionClass_getMethods_003.phpt b/ext/reflection/tests/ReflectionClass_getMethods_003.phpt
index 435f5d2d8d..885bd908f1 100644
--- a/ext/reflection/tests/ReflectionClass_getMethods_003.phpt
+++ b/ext/reflection/tests/ReflectionClass_getMethods_003.phpt
@@ -43,28 +43,28 @@ No methods:array(0) {
 }
 Public methods:array(4) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(5) "pubf1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(5) "pubf2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "pubsf1"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "pubsf2"
     ["class"]=>
@@ -73,28 +73,28 @@ Public methods:array(4) {
 }
 Private methods:array(4) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "privf1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "privf2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "privsf1"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "privsf2"
     ["class"]=>
@@ -103,42 +103,42 @@ Private methods:array(4) {
 }
 Public or static methods:array(6) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(5) "pubf1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(5) "pubf2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "pubsf1"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "pubsf2"
     ["class"]=>
     string(1) "C"
   }
   [4]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "privsf1"
     ["class"]=>
     string(1) "C"
   }
   [5]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "privsf2"
     ["class"]=>
@@ -147,42 +147,42 @@ Public or static methods:array(6) {
 }
 Private or static methods:array(6) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "privf1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "privf2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "pubsf1"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(6) "pubsf2"
     ["class"]=>
     string(1) "C"
   }
   [4]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "privsf1"
     ["class"]=>
     string(1) "C"
   }
   [5]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(7) "privsf2"
     ["class"]=>
diff --git a/ext/reflection/tests/ReflectionClass_getProperties_001.phpt b/ext/reflection/tests/ReflectionClass_getProperties_001.phpt
index b4f99ca68f..cd4a29d450 100644
--- a/ext/reflection/tests/ReflectionClass_getProperties_001.phpt
+++ b/ext/reflection/tests/ReflectionClass_getProperties_001.phpt
@@ -39,14 +39,14 @@ foreach($classes as $class) {
 Reflecting on class pubf: 
 array(2) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "a"
     [%u|b%"class"]=>
     %unicode|string%(4) "pubf"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -56,14 +56,14 @@ array(2) {
 Reflecting on class subpubf: 
 array(2) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "a"
     [%u|b%"class"]=>
     %unicode|string%(4) "pubf"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -73,14 +73,14 @@ array(2) {
 Reflecting on class protf: 
 array(2) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "a"
     [%u|b%"class"]=>
     %unicode|string%(5) "protf"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -90,14 +90,14 @@ array(2) {
 Reflecting on class subprotf: 
 array(2) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "a"
     [%u|b%"class"]=>
     %unicode|string%(5) "protf"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
@@ -107,14 +107,14 @@ array(2) {
 Reflecting on class privf: 
 array(2) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "a"
     [%u|b%"class"]=>
     %unicode|string%(5) "privf"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     [%u|b%"name"]=>
     %unicode|string%(1) "s"
     [%u|b%"class"]=>
diff --git a/ext/reflection/tests/ReflectionClass_getProperties_003.phpt b/ext/reflection/tests/ReflectionClass_getProperties_003.phpt
index b4f9a774db..ac16a68349 100644
--- a/ext/reflection/tests/ReflectionClass_getProperties_003.phpt
+++ b/ext/reflection/tests/ReflectionClass_getProperties_003.phpt
@@ -41,28 +41,28 @@ No properties:array(0) {
 }
 Public properties:array(4) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pub1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pub2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pubs"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "pubs2"
     ["class"]=>
@@ -71,28 +71,28 @@ Public properties:array(4) {
 }
 Private properties:array(4) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "priv1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "priv2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(6) "privs1"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(6) "privs2"
     ["class"]=>
@@ -101,42 +101,42 @@ Private properties:array(4) {
 }
 Public or static properties:array(6) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pub1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pub2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pubs"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "pubs2"
     ["class"]=>
     string(1) "C"
   }
   [4]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(6) "privs1"
     ["class"]=>
     string(1) "C"
   }
   [5]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(6) "privs2"
     ["class"]=>
@@ -145,42 +145,42 @@ Public or static properties:array(6) {
 }
 Private or static properties:array(6) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "priv1"
     ["class"]=>
     string(1) "C"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "priv2"
     ["class"]=>
     string(1) "C"
   }
   [2]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(4) "pubs"
     ["class"]=>
     string(1) "C"
   }
   [3]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "pubs2"
     ["class"]=>
     string(1) "C"
   }
   [4]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(6) "privs1"
     ["class"]=>
     string(1) "C"
   }
   [5]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(6) "privs2"
     ["class"]=>
diff --git a/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt b/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt
index 5df9e08c69..876109001c 100644
--- a/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt
+++ b/ext/reflection/tests/ReflectionExtension_getClasses_basic.phpt
@@ -11,62 +11,62 @@ var_dump($ext->getClasses());
 --EXPECT--
 array(12) {
   ["ReflectionException"]=>
-  &object(ReflectionClass)#2 (1) {
+  object(ReflectionClass)#2 (1) {
     ["name"]=>
     string(19) "ReflectionException"
   }
   ["Reflection"]=>
-  &object(ReflectionClass)#3 (1) {
+  object(ReflectionClass)#3 (1) {
     ["name"]=>
     string(10) "Reflection"
   }
   ["Reflector"]=>
-  &object(ReflectionClass)#4 (1) {
+  object(ReflectionClass)#4 (1) {
     ["name"]=>
     string(9) "Reflector"
   }
   ["ReflectionFunctionAbstract"]=>
-  &object(ReflectionClass)#5 (1) {
+  object(ReflectionClass)#5 (1) {
     ["name"]=>
     string(26) "ReflectionFunctionAbstract"
   }
   ["ReflectionFunction"]=>
-  &object(ReflectionClass)#6 (1) {
+  object(ReflectionClass)#6 (1) {
     ["name"]=>
     string(18) "ReflectionFunction"
   }
   ["ReflectionParameter"]=>
-  &object(ReflectionClass)#7 (1) {
+  object(ReflectionClass)#7 (1) {
     ["name"]=>
     string(19) "ReflectionParameter"
   }
   ["ReflectionMethod"]=>
-  &object(ReflectionClass)#8 (1) {
+  object(ReflectionClass)#8 (1) {
     ["name"]=>
     string(16) "ReflectionMethod"
   }
   ["ReflectionClass"]=>
-  &object(ReflectionClass)#9 (1) {
+  object(ReflectionClass)#9 (1) {
     ["name"]=>
     string(15) "ReflectionClass"
   }
   ["ReflectionObject"]=>
-  &object(ReflectionClass)#10 (1) {
+  object(ReflectionClass)#10 (1) {
     ["name"]=>
     string(16) "ReflectionObject"
   }
   ["ReflectionProperty"]=>
-  &object(ReflectionClass)#11 (1) {
+  object(ReflectionClass)#11 (1) {
     ["name"]=>
     string(18) "ReflectionProperty"
   }
   ["ReflectionExtension"]=>
-  &object(ReflectionClass)#12 (1) {
+  object(ReflectionClass)#12 (1) {
     ["name"]=>
     string(19) "ReflectionExtension"
   }
   ["ReflectionZendExtension"]=>
-  &object(ReflectionClass)#13 (1) {
+  object(ReflectionClass)#13 (1) {
     ["name"]=>
     string(23) "ReflectionZendExtension"
   }
diff --git a/ext/reflection/tests/ReflectionProperty_setAccessible.phpt b/ext/reflection/tests/ReflectionProperty_setAccessible.phpt
index cc184c1920..1e829b3a6c 100644
--- a/ext/reflection/tests/ReflectionProperty_setAccessible.phpt
+++ b/ext/reflection/tests/ReflectionProperty_setAccessible.phpt
@@ -132,7 +132,7 @@ string(44) "Cannot access non-public member B::protected"
 string(50) "Cannot access non-public member B::protectedStatic"
 string(42) "Cannot access non-public member A::private"
 string(1) "a"
-string(1) "f"
+string(1) "b"
 string(1) "c"
 string(1) "e"
 string(1) "f"
diff --git a/ext/reflection/tests/bug40431.phpt b/ext/reflection/tests/bug40431.phpt
index 863df7a78f..0c96e70faf 100644
--- a/ext/reflection/tests/bug40431.phpt
+++ b/ext/reflection/tests/bug40431.phpt
@@ -80,7 +80,7 @@ echo "Done\n";
 === 1st test ===
 array(1) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "value"
     ["class"]=>
@@ -94,7 +94,7 @@ bool(false)
 === 2nd test ===
 array(1) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "value"
     ["class"]=>
@@ -108,7 +108,7 @@ bool(false)
 === 3rd test ===
 array(1) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "value"
     ["class"]=>
@@ -122,7 +122,7 @@ bool(false)
 === 4th test ===
 array(1) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(5) "value"
     ["class"]=>
diff --git a/ext/reflection/tests/bug46064_2.phpt b/ext/reflection/tests/bug46064_2.phpt
index da14148a7a..0b74708dff 100644
--- a/ext/reflection/tests/bug46064_2.phpt
+++ b/ext/reflection/tests/bug46064_2.phpt
@@ -57,14 +57,14 @@ bool(true)
 bool(false)
 array(2) {
   [0]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(1) "b"
     ["class"]=>
     string(4) "test"
   }
   [1]=>
-  &object(ReflectionProperty)#%d (2) {
+  object(ReflectionProperty)#%d (2) {
     ["name"]=>
     string(1) "a"
     ["class"]=>
diff --git a/ext/reflection/tests/traits004.phpt b/ext/reflection/tests/traits004.phpt
index c9367c1f48..ca0314d0df 100644
--- a/ext/reflection/tests/traits004.phpt
+++ b/ext/reflection/tests/traits004.phpt
@@ -30,7 +30,7 @@ array(1) {
 }
 array(1) {
   ["T1"]=>
-  &object(ReflectionClass)#1 (1) {
+  object(ReflectionClass)#1 (1) {
     ["name"]=>
     string(2) "T1"
   }
@@ -45,12 +45,12 @@ array(2) {
 }
 array(2) {
   ["T1"]=>
-  &object(ReflectionClass)#2 (1) {
+  object(ReflectionClass)#2 (1) {
     ["name"]=>
     string(2) "T1"
   }
   ["T2"]=>
-  &object(ReflectionClass)#3 (1) {
+  object(ReflectionClass)#3 (1) {
     ["name"]=>
     string(2) "T2"
   }
diff --git a/ext/session/mod_files.c b/ext/session/mod_files.c
index 33e177c5df..3e577bc28a 100644
--- a/ext/session/mod_files.c
+++ b/ext/session/mod_files.c
@@ -339,13 +339,13 @@ PS_READ_FUNC(files)
 
 	/* If strict mode, check session id existence */
 	if (PS(use_strict_mode) &&
-		ps_files_key_exists(data, key TSRMLS_CC) == FAILURE) {
+		ps_files_key_exists(data, key? key->val : NULL TSRMLS_CC) == FAILURE) {
 		/* key points to PS(id), but cannot change here. */
 		if (key) {
-			efree(PS(id));
+			STR_RELEASE(PS(id));
 			PS(id) = NULL;
 		}
-		PS(id) = PS(mod)->s_create_sid((void **)&data, NULL TSRMLS_CC);
+		PS(id) = PS(mod)->s_create_sid((void **)&data TSRMLS_CC);
 		if (!PS(id)) {
 			return FAILURE;
 		}
@@ -356,7 +356,7 @@ PS_READ_FUNC(files)
 		PS(session_status) = php_session_active;
 	}
 
-	ps_files_open(data, PS(id) TSRMLS_CC);
+	ps_files_open(data, PS(id)->val TSRMLS_CC);
 	if (data->fd < 0) {
 		return FAILURE;
 	}
@@ -365,20 +365,20 @@ PS_READ_FUNC(files)
 		return FAILURE;
 	}
 
-	data->st_size = *vallen = sbuf.st_size;
+	data->st_size = sbuf.st_size;
 
 	if (sbuf.st_size == 0) {
 		*val = STR_EMPTY_ALLOC();
 		return SUCCESS;
 	}
 
-	*val = emalloc(sbuf.st_size);
+	*val = STR_ALLOC(sbuf.st_size, 0);
 
 #if defined(HAVE_PREAD)
-	n = pread(data->fd, *val, sbuf.st_size, 0);
+	n = pread(data->fd, (*val)->val, (*val)->len, 0);
 #else
 	lseek(data->fd, 0, SEEK_SET);
-	n = read(data->fd, *val, sbuf.st_size);
+	n = read(data->fd, (*val)->val, (*val)->len);
 #endif
 
 	if (n != sbuf.st_size) {
@@ -387,7 +387,7 @@ PS_READ_FUNC(files)
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "read returned less bytes than requested");
 		}
-		efree(*val);
+		STR_RELEASE(*val);
 		return FAILURE;
 	}
 
@@ -399,25 +399,25 @@ PS_WRITE_FUNC(files)
 	long n;
 	PS_FILES_DATA;
 
-	ps_files_open(data, key TSRMLS_CC);
+	ps_files_open(data, key->val TSRMLS_CC);
 	if (data->fd < 0) {
 		return FAILURE;
 	}
 
 	/* Truncate file if the amount of new data is smaller than the existing data set. */
 
-	if (vallen < (int)data->st_size) {
+	if (val->len < (int)data->st_size) {
 		php_ignore_value(ftruncate(data->fd, 0));
 	}
 
 #if defined(HAVE_PWRITE)
-	n = pwrite(data->fd, val, vallen, 0);
+	n = pwrite(data->fd, val->val, val->len, 0);
 #else
 	lseek(data->fd, 0, SEEK_SET);
-	n = write(data->fd, val, vallen);
+	n = write(data->fd, val->val, val->len);
 #endif
 
-	if (n != vallen) {
+	if (n != val->len) {
 		if (n == -1) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "write failed: %s (%d)", strerror(errno), errno);
 		} else {
@@ -434,7 +434,7 @@ PS_DESTROY_FUNC(files)
 	char buf[MAXPATHLEN];
 	PS_FILES_DATA;
 
-	if (!ps_files_path_create(buf, sizeof(buf), data, key)) {
+	if (!ps_files_path_create(buf, sizeof(buf), data, key->val)) {
 		return FAILURE;
 	}
 
@@ -470,16 +470,16 @@ PS_GC_FUNC(files)
 
 PS_CREATE_SID_FUNC(files)
 {
-	char *sid;
+	zend_string *sid;
 	int maxfail = 3;
 	PS_FILES_DATA;
 
 	do {
-		sid = php_session_create_id((void **)&data, newlen TSRMLS_CC);
+		sid = php_session_create_id((void**)&data TSRMLS_C);
 		/* Check collision */
-		if (data && ps_files_key_exists(data, sid TSRMLS_CC) == SUCCESS) {
+		if (data && ps_files_key_exists(data, sid? sid->val : NULL TSRMLS_CC) == SUCCESS) {
 			if (sid) {
-				efree(sid);
+				STR_RELEASE(sid);
 				sid = NULL;
 			}
 			if (!(maxfail--)) {
diff --git a/ext/session/mod_user.c b/ext/session/mod_user.c
index 5573d4cdfd..2b4e79996f 100644
--- a/ext/session/mod_user.c
+++ b/ext/session/mod_user.c
@@ -28,7 +28,6 @@ ps_module ps_mod_user = {
 
 #define SESS_ZVAL_LONG(val, a)						\
 {													\
-	MAKE_STD_ZVAL(a);								\
 	ZVAL_LONG(a, val);								\
 }
 
@@ -40,58 +39,58 @@ ps_module ps_mod_user = {
 
 #define SESS_ZVAL_STRINGN(vl, ln, a)				\
 {													\
-	MAKE_STD_ZVAL(a);								\
-	ZVAL_STRINGL(a, vl, ln, 1);						\
+	ZVAL_STRINGL(a, vl, ln);						\
 }
 
-static zval *ps_call_handler(zval *func, int argc, zval **argv TSRMLS_DC)
+#define SESS_ZVAL_STR(vl, a)						\
+{													\
+	ZVAL_STR(a, STR_COPY(vl));						\
+}
+
+static void ps_call_handler(zval *func, int argc, zval *argv, zval *retval TSRMLS_DC)
 {
 	int i;
-	zval *retval = NULL;
-
-	MAKE_STD_ZVAL(retval);
 	if (call_user_function(EG(function_table), NULL, func, retval, argc, argv TSRMLS_CC) == FAILURE) {
-		zval_ptr_dtor(&retval);
-		retval = NULL;
+		zval_ptr_dtor(retval);
+		ZVAL_UNDEF(retval);
+	} else if (ZVAL_IS_UNDEF(retval)) {
+		ZVAL_NULL(retval);
 	}
-
 	for (i = 0; i < argc; i++) {
 		zval_ptr_dtor(&argv[i]);
 	}
-
-	return retval;
 }
 
 #define STDVARS								\
-	zval *retval = NULL;					\
+	zval retval;							\
 	int ret = FAILURE
 
 #define PSF(a) PS(mod_user_names).name.ps_##a
 
 #define FINISH								\
-	if (retval) {							\
-		convert_to_long(retval);			\
-		ret = Z_LVAL_P(retval);				\
+	if (!ZVAL_IS_UNDEF(&retval)) {			\
+		convert_to_long(&retval);			\
+		ret = Z_LVAL(retval);				\
 		zval_ptr_dtor(&retval);				\
 	}										\
 	return ret
 
 PS_OPEN_FUNC(user)
 {
-	zval *args[2];
+	zval args[2];
 	STDVARS;
 	
-	if (PSF(open) == NULL) {
+	if (ZVAL_IS_UNDEF(&PSF(open))) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING,
 			"user session functions not defined");
 			
 		return FAILURE;
 	}
 
-	SESS_ZVAL_STRING((char*)save_path, args[0]);
-	SESS_ZVAL_STRING((char*)session_name, args[1]);
+	SESS_ZVAL_STRING((char*)save_path, &args[0]);
+	SESS_ZVAL_STRING((char*)session_name, &args[1]);
 
-	retval = ps_call_handler(PSF(open), 2, args TSRMLS_CC);
+	ps_call_handler(&PSF(open), 2, args, &retval TSRMLS_CC);
 	PS(mod_user_implemented) = 1;
 
 	FINISH;
@@ -108,7 +107,7 @@ PS_CLOSE_FUNC(user)
 	}
 
 	zend_try {
-		retval = ps_call_handler(PSF(close), 0, NULL TSRMLS_CC);
+		ps_call_handler(&PSF(close), 0, NULL, &retval TSRMLS_CC);
 	} zend_catch {
 		bailout = 1;
 	} zend_end_try();
@@ -116,7 +115,7 @@ PS_CLOSE_FUNC(user)
 	PS(mod_user_implemented) = 0;
 
 	if (bailout) {
-		if (retval) {
+		if (!ZVAL_IS_UNDEF(&retval)) {
 			zval_ptr_dtor(&retval);
 		}
 		zend_bailout();
@@ -127,17 +126,16 @@ PS_CLOSE_FUNC(user)
 
 PS_READ_FUNC(user)
 {
-	zval *args[1];
+	zval args[1];
 	STDVARS;
 
-	SESS_ZVAL_STRING((char*)key, args[0]);
+	SESS_ZVAL_STR(key, &args[0]);
 
-	retval = ps_call_handler(PSF(read), 1, args TSRMLS_CC);
+	ps_call_handler(&PSF(read), 1, args, &retval TSRMLS_CC);
 
-	if (retval) {
-		if (Z_TYPE_P(retval) == IS_STRING) {
-			*val = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
-			*vallen = Z_STRLEN_P(retval);
+	if (!ZVAL_IS_UNDEF(&retval)) {
+		if (Z_TYPE(retval) == IS_STRING) {
+			*val = STR_COPY(Z_STR(retval));
 			ret = SUCCESS;
 		}
 		zval_ptr_dtor(&retval);
@@ -148,37 +146,37 @@ PS_READ_FUNC(user)
 
 PS_WRITE_FUNC(user)
 {
-	zval *args[2];
+	zval args[2];
 	STDVARS;
 
-	SESS_ZVAL_STRING((char*)key, args[0]);
-	SESS_ZVAL_STRINGN((char*)val, vallen, args[1]);
+	SESS_ZVAL_STR(key, &args[0]);
+	SESS_ZVAL_STR(val, &args[1]);
 
-	retval = ps_call_handler(PSF(write), 2, args TSRMLS_CC);
+	ps_call_handler(&PSF(write), 2, args, &retval TSRMLS_CC);
 
 	FINISH;
 }
 
 PS_DESTROY_FUNC(user)
 {
-	zval *args[1];
+	zval args[1];
 	STDVARS;
 
-	SESS_ZVAL_STRING((char*)key, args[0]);
+	SESS_ZVAL_STR(key, &args[0]);
 
-	retval = ps_call_handler(PSF(destroy), 1, args TSRMLS_CC);
+	ps_call_handler(&PSF(destroy), 1, args, &retval TSRMLS_CC);
 
 	FINISH;
 }
 
 PS_GC_FUNC(user)
 {
-	zval *args[1];
+	zval args[1];
 	STDVARS;
 
-	SESS_ZVAL_LONG(maxlifetime, args[0]);
+	SESS_ZVAL_LONG(maxlifetime, &args[0]);
 
-	retval = ps_call_handler(PSF(gc), 1, args TSRMLS_CC);
+	ps_call_handler(&PSF(gc), 1, args, &retval TSRMLS_CC);
 
 	FINISH;
 }
@@ -186,19 +184,18 @@ PS_GC_FUNC(user)
 PS_CREATE_SID_FUNC(user)
 {
 	/* maintain backwards compatibility */
-	if (PSF(create_sid) != NULL) {
-		char *id = NULL;
-		zval *retval = NULL;
+	if (!ZVAL_IS_UNDEF(&PSF(create_sid))) {
+		zend_string *id = NULL;
+		zval retval;
 
-		retval = ps_call_handler(PSF(create_sid), 0, NULL TSRMLS_CC);
+		ps_call_handler(&PSF(create_sid), 0, NULL, &retval TSRMLS_CC);
 
-		if (retval) {
-			if (Z_TYPE_P(retval) == IS_STRING) {
-				id = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			if (Z_TYPE(retval) == IS_STRING) {
+				id = STR_COPY(Z_STR(retval));
 			}
 			zval_ptr_dtor(&retval);
-		}
-		else {
+		} else {
 			php_error_docref(NULL TSRMLS_CC, E_ERROR, "No session id returned by function");
 			return NULL;
 		}
@@ -212,7 +209,7 @@ PS_CREATE_SID_FUNC(user)
 	}
 
 	/* function as defined by PS_MOD */
-	return php_session_create_id(mod_data, newlen TSRMLS_CC);
+	return php_session_create_id(mod_data TSRMLS_CC);
 }
 
 /*
diff --git a/ext/session/mod_user_class.c b/ext/session/mod_user_class.c
index 5b1480bf8c..78b90f49fa 100644
--- a/ext/session/mod_user_class.c
+++ b/ext/session/mod_user_class.c
@@ -71,23 +71,21 @@ PHP_METHOD(SessionHandler, close)
    Wraps the old read handler */
 PHP_METHOD(SessionHandler, read)
 {
-	char *key, *val;
-	int key_len, val_len;
+	zend_string *val;
+	zend_string *key;
 
 	PS_SANITY_CHECK_IS_OPEN;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &key) == FAILURE) {
 		return;
 	}
 
-	if (PS(default_mod)->s_read(&PS(mod_data), key, &val, &val_len TSRMLS_CC) == FAILURE) {
+	if (PS(default_mod)->s_read(&PS(mod_data), key, &val TSRMLS_CC) == FAILURE) {
 		RETVAL_FALSE;
 		return;
 	}
 
-	RETVAL_STRINGL(val, val_len, 1);
-	str_efree(val);
-	return;
+	RETURN_STR(val);
 }
 /* }}} */
 
@@ -95,16 +93,15 @@ PHP_METHOD(SessionHandler, read)
    Wraps the old write handler */
 PHP_METHOD(SessionHandler, write)
 {
-	char *key, *val;
-	int key_len, val_len;
+	zend_string *key, *val;
 
 	PS_SANITY_CHECK_IS_OPEN;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &key, &key_len, &val, &val_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &key, &val) == FAILURE) {
 		return;
 	}
 
-	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val, val_len TSRMLS_CC));
+	RETURN_BOOL(SUCCESS == PS(default_mod)->s_write(&PS(mod_data), key, val TSRMLS_CC));
 }
 /* }}} */
 
@@ -112,16 +109,15 @@ PHP_METHOD(SessionHandler, write)
    Wraps the old destroy handler */
 PHP_METHOD(SessionHandler, destroy)
 {
-	char *key;
-	int key_len;
+	zend_string *key;
 
 	PS_SANITY_CHECK_IS_OPEN;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &key, &key_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &key) == FAILURE) {
 		return;
 	}
 	
-	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_destroy(&PS(mod_data), key TSRMLS_CC));
+	RETURN_BOOL(SUCCESS == PS(default_mod)->s_destroy(&PS(mod_data), key TSRMLS_CC));
 }
 /* }}} */
 
@@ -138,7 +134,7 @@ PHP_METHOD(SessionHandler, gc)
 		return;
 	}
 	
-	RETVAL_BOOL(SUCCESS == PS(default_mod)->s_gc(&PS(mod_data), maxlifetime, &nrdels TSRMLS_CC));
+	RETURN_BOOL(SUCCESS == PS(default_mod)->s_gc(&PS(mod_data), maxlifetime, &nrdels TSRMLS_CC));
 }
 /* }}} */
 
@@ -146,14 +142,14 @@ PHP_METHOD(SessionHandler, gc)
    Wraps the old create_sid handler */
 PHP_METHOD(SessionHandler, create_sid)
 {
-	char *id;
+	zend_string *id;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 	    return;
 	}
 
-	id = PS(default_mod)->s_create_sid(&PS(mod_data), NULL TSRMLS_CC);
+	id = PS(default_mod)->s_create_sid(&PS(mod_data) TSRMLS_CC);
 
-	RETURN_STRING(id, 0);
+	RETURN_STR(id);
 }
 /* }}} */
diff --git a/ext/session/php_session.h b/ext/session/php_session.h
index b2866ad037..2bf0d858f7 100644
--- a/ext/session/php_session.h
+++ b/ext/session/php_session.h
@@ -34,14 +34,14 @@
 
 #define PS_OPEN_ARGS void **mod_data, const char *save_path, const char *session_name TSRMLS_DC
 #define PS_CLOSE_ARGS void **mod_data TSRMLS_DC
-#define PS_READ_ARGS void **mod_data, const char *key, char **val, int *vallen TSRMLS_DC
-#define PS_WRITE_ARGS void **mod_data, const char *key, const char *val, const int vallen TSRMLS_DC
-#define PS_DESTROY_ARGS void **mod_data, const char *key TSRMLS_DC
+#define PS_READ_ARGS void **mod_data, zend_string *key, zend_string **val TSRMLS_DC
+#define PS_WRITE_ARGS void **mod_data, zend_string *key, zend_string *val TSRMLS_DC
+#define PS_DESTROY_ARGS void **mod_data, zend_string *key TSRMLS_DC
 #define PS_GC_ARGS void **mod_data, int maxlifetime, int *nrdels TSRMLS_DC
-#define PS_CREATE_SID_ARGS void **mod_data, int *newlen TSRMLS_DC
+#define PS_CREATE_SID_ARGS void **mod_data TSRMLS_DC
 
 /* default create id function */
-PHPAPI char *php_session_create_id(PS_CREATE_SID_ARGS);
+PHPAPI zend_string *php_session_create_id(PS_CREATE_SID_ARGS);
 
 typedef struct ps_module_struct {
 	const char *s_name;
@@ -51,7 +51,7 @@ typedef struct ps_module_struct {
 	int (*s_write)(PS_WRITE_ARGS);
 	int (*s_destroy)(PS_DESTROY_ARGS);
 	int (*s_gc)(PS_GC_ARGS);
-	char *(*s_create_sid)(PS_CREATE_SID_ARGS);
+	zend_string *(*s_create_sid)(PS_CREATE_SID_ARGS);
 } ps_module;
 
 #define PS_GET_MOD_DATA() *mod_data
@@ -63,7 +63,7 @@ typedef struct ps_module_struct {
 #define PS_WRITE_FUNC(x) 	int ps_write_##x(PS_WRITE_ARGS)
 #define PS_DESTROY_FUNC(x) 	int ps_delete_##x(PS_DESTROY_ARGS)
 #define PS_GC_FUNC(x) 		int ps_gc_##x(PS_GC_ARGS)
-#define PS_CREATE_SID_FUNC(x)	char *ps_create_sid_##x(PS_CREATE_SID_ARGS)
+#define PS_CREATE_SID_FUNC(x)	zend_string *ps_create_sid_##x(PS_CREATE_SID_ARGS)
 
 #define PS_FUNCS(x) \
 	PS_OPEN_FUNC(x); \
@@ -111,17 +111,17 @@ typedef struct _php_session_rfc1867_progress {
 	zend_bool apply_trans_sid;
 	size_t    content_length;
 
-	zval      *data;                 /* the array exported to session data */
-	zval      *post_bytes_processed; /* data["bytes_processed"] */
-	zval      *files;                /* data["files"] array */
-	zval      *current_file;         /* array of currently uploading file */
-	zval      *current_file_bytes_processed;
+	zval      data;                 /* the array exported to session data */
+	zval	 *post_bytes_processed; /* data["bytes_processed"] */
+	zval      files;                /* data["files"] array */
+	zval      current_file;         /* array of currently uploading file */
+	zval	 *current_file_bytes_processed;
 } php_session_rfc1867_progress;
 
 typedef struct _php_ps_globals {
 	char *save_path;
 	char *session_name;
-	char *id;
+	zend_string *id;
 	char *extern_referer_chk;
 	char *entropy_file;
 	char *cache_limiter;
@@ -141,21 +141,21 @@ typedef struct _php_ps_globals {
 	int module_number;
 	long cache_expire;
 	union {
-		zval *names[7];
+		zval names[7];
 		struct {
-			zval *ps_open;
-			zval *ps_close;
-			zval *ps_read;
-			zval *ps_write;
-			zval *ps_destroy;
-			zval *ps_gc;
-			zval *ps_create_sid;
+			zval ps_open;
+			zval ps_close;
+			zval ps_read;
+			zval ps_write;
+			zval ps_destroy;
+			zval ps_gc;
+			zval ps_create_sid;
 		} name;
 	} mod_user_names;
 	int mod_user_implemented;
 	int mod_user_is_open;
 	const struct ps_serializer_struct *serializer;
-	zval *http_session_vars;
+	zval http_session_vars;
 	zend_bool auto_start;
 	zend_bool use_cookies;
 	zend_bool use_only_cookies;
@@ -174,8 +174,8 @@ typedef struct _php_ps_globals {
 	php_session_rfc1867_progress *rfc1867_progress;
 	zend_bool rfc1867_enabled; /* session.upload_progress.enabled */
 	zend_bool rfc1867_cleanup; /* session.upload_progress.cleanup */
-	smart_str rfc1867_prefix;  /* session.upload_progress.prefix */
-	smart_str rfc1867_name;    /* session.upload_progress.name */
+	char *rfc1867_prefix;  /* session.upload_progress.prefix */
+	char *rfc1867_name;    /* session.upload_progress.name */
 	long rfc1867_freq;         /* session.upload_progress.freq */
 	double rfc1867_min_freq;   /* session.upload_progress.min_freq */
 
@@ -194,12 +194,12 @@ extern zend_module_entry session_module_entry;
 #define PS(v) (ps_globals.v)
 #endif
 
-#define PS_SERIALIZER_ENCODE_ARGS char **newstr, int *newlen TSRMLS_DC
+#define PS_SERIALIZER_ENCODE_ARGS TSRMLS_D
 #define PS_SERIALIZER_DECODE_ARGS const char *val, int vallen TSRMLS_DC
 
 typedef struct ps_serializer_struct {
 	const char *name;
-	int (*encode)(PS_SERIALIZER_ENCODE_ARGS);
+	zend_string *(*encode)(PS_SERIALIZER_ENCODE_ARGS);
 	int (*decode)(PS_SERIALIZER_DECODE_ARGS);
 } ps_serializer;
 
@@ -207,7 +207,7 @@ typedef struct ps_serializer_struct {
 #define PS_SERIALIZER_DECODE_NAME(x) ps_srlzr_decode_##x
 
 #define PS_SERIALIZER_ENCODE_FUNC(x) \
-	int PS_SERIALIZER_ENCODE_NAME(x)(PS_SERIALIZER_ENCODE_ARGS)
+	zend_string *PS_SERIALIZER_ENCODE_NAME(x)(PS_SERIALIZER_ENCODE_ARGS)
 #define PS_SERIALIZER_DECODE_FUNC(x) \
 	int PS_SERIALIZER_DECODE_NAME(x)(PS_SERIALIZER_DECODE_ARGS)
 
@@ -220,14 +220,14 @@ typedef struct ps_serializer_struct {
 
 PHPAPI void session_adapt_url(const char *, size_t, char **, size_t * TSRMLS_DC);
 
-PHPAPI void php_add_session_var(char *name, size_t namelen TSRMLS_DC);
-PHPAPI void php_set_session_var(char *name, size_t namelen, zval *state_val, php_unserialize_data_t *var_hash TSRMLS_DC);
-PHPAPI int php_get_session_var(char *name, size_t namelen, zval ***state_var TSRMLS_DC);
+PHPAPI void php_add_session_var(zend_string *name TSRMLS_DC);
+PHPAPI zval *php_set_session_var(zend_string *name, zval *state_val, php_unserialize_data_t *var_hash TSRMLS_DC);
+PHPAPI zval *php_get_session_var(zend_string *name TSRMLS_DC);
 
 PHPAPI int php_session_register_module(ps_module *);
 
 PHPAPI int php_session_register_serializer(const char *name,
-	        int (*encode)(PS_SERIALIZER_ENCODE_ARGS),
+	        zend_string *(*encode)(PS_SERIALIZER_ENCODE_ARGS),
 	        int (*decode)(PS_SERIALIZER_DECODE_ARGS));
 
 PHPAPI void php_session_set_id(char *id TSRMLS_DC);
@@ -239,41 +239,41 @@ PHPAPI const ps_serializer *_php_find_ps_serializer(char *name TSRMLS_DC);
 PHPAPI int php_session_valid_key(const char *key);
 PHPAPI void php_session_reset_id(TSRMLS_D);
 
-#define PS_ADD_VARL(name,namelen) do {										\
-	php_add_session_var(name, namelen TSRMLS_CC);							\
+#define PS_ADD_VARL(name) do {										\
+	php_add_session_var(name TSRMLS_CC);							\
 } while (0)
 
-#define PS_ADD_VAR(name) PS_ADD_VARL(name, strlen(name))
+#define PS_ADD_VAR(name) PS_ADD_VARL(name)
 
-#define PS_DEL_VARL(name,namelen) do {										\
-	if (PS(http_session_vars)) {											\
-		zend_hash_del(Z_ARRVAL_P(PS(http_session_vars)), name, namelen+1);	\
-	}																		\
+#define PS_DEL_VARL(name) do {										\
+	if (!ZVAL_IS_NULL(&PS(http_session_vars))) {					\
+		zend_hash_del(Z_ARRVAL(PS(http_session_vars)), name);		\
+	}																\
 } while (0)
 
 
-#define PS_ENCODE_VARS 											\
-	char *key;													\
-	uint key_length;											\
-	ulong num_key;												\
-	zval **struc;
-
-#define PS_ENCODE_LOOP(code) do {									\
-		HashTable *_ht = Z_ARRVAL_P(PS(http_session_vars));			\
-		int key_type;												\
-																	\
-		for (zend_hash_internal_pointer_reset(_ht);					\
-				(key_type = zend_hash_get_current_key_ex(_ht, &key, &key_length, &num_key, 0, NULL)) != HASH_KEY_NON_EXISTENT; \
-					zend_hash_move_forward(_ht)) {					\
-			if (key_type == HASH_KEY_IS_LONG) {						\
-				php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Skipping numeric key %ld", num_key);	\
-				continue;											\
-			}														\
-			key_length--;											\
-			if (php_get_session_var(key, key_length, &struc TSRMLS_CC) == SUCCESS) {	\
-				code;		 										\
-			} 														\
-		}															\
+#define PS_ENCODE_VARS 												\
+	zend_string *key;												\
+	ulong num_key;													\
+	zval *struc;
+
+#define PS_ENCODE_LOOP(code) do {										\
+		HashTable *_ht = Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars)));	\
+		int key_type;													\
+																		\
+		for (zend_hash_internal_pointer_reset(_ht);						\
+				(key_type = zend_hash_get_current_key(_ht, &key,		\
+						&num_key, 0)) != HASH_KEY_NON_EXISTENT; 	\
+					zend_hash_move_forward(_ht)) {						\
+			if (key_type == HASH_KEY_IS_LONG) {							\
+				php_error_docref(NULL TSRMLS_CC, E_NOTICE,				\
+						"Skipping numeric key %ld", num_key);			\
+				continue;												\
+			}															\
+			if ((struc = php_get_session_var(key TSRMLS_CC))) {			\
+				code;		 											\
+			} 															\
+		}																\
 	} while(0)
 
 PHPAPI ZEND_EXTERN_MODULE_GLOBALS(ps)
diff --git a/ext/session/session.c b/ext/session/session.c
index 1d60c40188..8784016db6 100644
--- a/ext/session/session.c
+++ b/ext/session/session.c
@@ -78,7 +78,7 @@ zend_class_entry *php_session_id_iface_entry;
    *********** */
 
 #define IF_SESSION_VARS() \
-	if (PS(http_session_vars) && PS(http_session_vars)->type == IS_ARRAY)
+	if (Z_ISREF_P(&PS(http_session_vars)) && Z_TYPE_P(Z_REFVAL(PS(http_session_vars))) == IS_ARRAY)
 
 #define SESSION_CHECK_ACTIVE_STATE	\
 	if (PS(session_status) == php_session_active) {	\
@@ -96,16 +96,16 @@ static inline void php_rinit_session_globals(TSRMLS_D) /* {{{ */
 	PS(mod_data) = NULL;
 	PS(mod_user_is_open) = 0;
 	/* Do NOT init PS(mod_user_names) here! */
-	PS(http_session_vars) = NULL;
+	ZVAL_UNDEF(&PS(http_session_vars));
 }
 /* }}} */
 
 /* Dispatched by RSHUTDOWN and by php_session_destroy */
 static inline void php_rshutdown_session_globals(TSRMLS_D) /* {{{ */
 {
-	if (PS(http_session_vars)) {
+	if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
 		zval_ptr_dtor(&PS(http_session_vars));
-		PS(http_session_vars) = NULL;
+		ZVAL_UNDEF(&PS(http_session_vars));
 	}
 	/* Do NOT destroy PS(mod_user_names) here! */
 	if (PS(mod_data) || PS(mod_user_implemented)) {
@@ -114,7 +114,7 @@ static inline void php_rshutdown_session_globals(TSRMLS_D) /* {{{ */
 		} zend_end_try();
 	}
 	if (PS(id)) {
-		efree(PS(id));
+		STR_RELEASE(PS(id));
 	}
 }
 /* }}} */
@@ -140,78 +140,74 @@ static int php_session_destroy(TSRMLS_D) /* {{{ */
 }
 /* }}} */
 
-PHPAPI void php_add_session_var(char *name, size_t namelen TSRMLS_DC) /* {{{ */
+PHPAPI void php_add_session_var(zend_string *name TSRMLS_DC) /* {{{ */
 {
-	zval **sym_track = NULL;
+	zval *sym_track = NULL;
 
 	IF_SESSION_VARS() {
-		zend_hash_find(Z_ARRVAL_P(PS(http_session_vars)), name, namelen + 1, (void *) &sym_track);
+		sym_track = zend_hash_find(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name);
 	} else {
 		return;
 	}
 
 	if (sym_track == NULL) {
-		zval *empty_var;
+		zval empty_var;
 
-		ALLOC_INIT_ZVAL(empty_var);
-		ZEND_SET_SYMBOL_WITH_LENGTH(Z_ARRVAL_P(PS(http_session_vars)), name, namelen+1, empty_var, 1, 0);
+		ZVAL_NULL(&empty_var);
+		zend_hash_update(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name, &empty_var);
 	}
 }
 /* }}} */
 
-PHPAPI void php_set_session_var(char *name, size_t namelen, zval *state_val, php_unserialize_data_t *var_hash TSRMLS_DC) /* {{{ */
+PHPAPI zval* php_set_session_var(zend_string *name, zval *state_val, php_unserialize_data_t *var_hash TSRMLS_DC) /* {{{ */
 {
 	IF_SESSION_VARS() {
-		zend_set_hash_symbol(state_val, name, namelen, PZVAL_IS_REF(state_val), 1, Z_ARRVAL_P(PS(http_session_vars)));
+		return zend_hash_update(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name, state_val);
 	}
+	return NULL;
 }
 /* }}} */
 
-PHPAPI int php_get_session_var(char *name, size_t namelen, zval ***state_var TSRMLS_DC) /* {{{ */
+PHPAPI zval* php_get_session_var(zend_string *name TSRMLS_DC) /* {{{ */
 {
-	int ret = FAILURE;
-
 	IF_SESSION_VARS() {
-		ret = zend_hash_find(Z_ARRVAL_P(PS(http_session_vars)), name, namelen + 1, (void **) state_var);
+		return zend_hash_find(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), name);
 	}
-	return ret;
+	return NULL;
 }
 /* }}} */
 
 static void php_session_track_init(TSRMLS_D) /* {{{ */
 {
-	zval *session_vars = NULL;
-
+	zval session_vars;
+	zend_string *var_name = STR_INIT("_SESSION", sizeof("_SESSION") - 1, 0);
 	/* Unconditionally destroy existing array -- possible dirty data */
-	zend_delete_global_variable("_SESSION", sizeof("_SESSION")-1 TSRMLS_CC);
+	zend_delete_global_variable(var_name TSRMLS_CC);
 
-	if (PS(http_session_vars)) {
+	if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
 		zval_ptr_dtor(&PS(http_session_vars));
 	}
 
-	MAKE_STD_ZVAL(session_vars);
-	array_init(session_vars);
-	PS(http_session_vars) = session_vars;
-
-	ZEND_SET_GLOBAL_VAR_WITH_LENGTH("_SESSION", sizeof("_SESSION"), PS(http_session_vars), 2, 1);
+	array_init(&session_vars);
+	ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);
+	Z_ADDREF_P(&PS(http_session_vars));
+	zend_hash_update_ind(&EG(symbol_table).ht, var_name, &PS(http_session_vars));
+	STR_RELEASE(var_name);
 }
 /* }}} */
 
-static char *php_session_encode(int *newlen TSRMLS_DC) /* {{{ */
+static zend_string *php_session_encode(TSRMLS_D) /* {{{ */
 {
-	char *ret = NULL;
-
 	IF_SESSION_VARS() {
 		if (!PS(serializer)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown session.serialize_handler. Failed to encode session object");
-			ret = NULL;
-		} else if (PS(serializer)->encode(&ret, newlen TSRMLS_CC) == FAILURE) {
-			ret = NULL;
-		}
+			return NULL;
+		} 
+		return PS(serializer)->encode(TSRMLS_C);
 	} else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot encode non-existent session");
 	}
-	return ret;
+	return NULL;
 }
 /* }}} */
 
@@ -250,7 +246,7 @@ static char *bin_to_readable(char *in, size_t inlen, char *out, char nbits) /* {
 	int mask;
 	int have;
 
-	p = (unsigned char *) in;
+	p = (unsigned char *)in;
 	q = (unsigned char *)in + inlen;
 
 	w = 0;
@@ -281,7 +277,7 @@ static char *bin_to_readable(char *in, size_t inlen, char *out, char nbits) /* {
 }
 /* }}} */
 
-PHPAPI char *php_session_create_id(PS_CREATE_SID_ARGS) /* {{{ */
+PHPAPI zend_string *php_session_create_id(PS_CREATE_SID_ARGS) /* {{{ */
 {
 	PHP_MD5_CTX md5_context;
 	PHP_SHA1_CTX sha1_context;
@@ -290,20 +286,20 @@ PHPAPI char *php_session_create_id(PS_CREATE_SID_ARGS) /* {{{ */
 #endif
 	unsigned char *digest;
 	int digest_len;
-	int j;
-	char *buf, *outid;
+	char *buf;
 	struct timeval tv;
-	zval **array;
-	zval **token;
+	zval *array;
+	zval *token;
+	zend_string *outid;
 	char *remote_addr = NULL;
 
 	gettimeofday(&tv, NULL);
 
-	if (zend_hash_find(&EG(symbol_table), "_SERVER", sizeof("_SERVER"), (void **) &array) == SUCCESS &&
-		Z_TYPE_PP(array) == IS_ARRAY &&
-		zend_hash_find(Z_ARRVAL_PP(array), "REMOTE_ADDR", sizeof("REMOTE_ADDR"), (void **) &token) == SUCCESS
+	if ((array = zend_hash_str_find(&EG(symbol_table).ht, "_SERVER", sizeof("_SERVER") - 1)) &&
+		Z_TYPE_P(array) == IS_ARRAY &&
+		(token = zend_hash_str_find(Z_ARRVAL_P(array), "REMOTE_ADDR", sizeof("REMOTE_ADDR") - 1))
 	) {
-		remote_addr = Z_STRVAL_PP(token);
+		remote_addr = Z_STRVAL_P(token);
 	}
 
 	/* maximum 15+19+19+10 bytes */
@@ -418,14 +414,10 @@ PHPAPI char *php_session_create_id(PS_CREATE_SID_ARGS) /* {{{ */
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "The ini setting hash_bits_per_character is out of range (should be 4, 5, or 6) - using 4 for now");
 	}
 	
-	outid = emalloc((size_t)((digest_len + 2) * ((8.0f / PS(hash_bits_per_character)) + 0.5)));
-	j = (int) (bin_to_readable((char *)digest, digest_len, outid, (char)PS(hash_bits_per_character)) - outid);
+	outid = STR_ALLOC((digest_len + 2) * ((8.0f / PS(hash_bits_per_character) + 0.5)), 0);
+	outid->len = (int)(bin_to_readable((char *)digest, digest_len, outid->val, (char)PS(hash_bits_per_character)) - (char *)&outid->val);
 	efree(digest);
 
-	if (newlen) {
-		*newlen = j;
-	}
-
 	return outid;
 }
 /* }}} */
@@ -466,8 +458,7 @@ PHPAPI int php_session_valid_key(const char *key) /* {{{ */
 
 static void php_session_initialize(TSRMLS_D) /* {{{ */
 {
-	char *val = NULL;
-	int vallen;
+	zend_string *val = NULL;
 
 	if (!PS(mod)) {
 		php_error_docref(NULL TSRMLS_CC, E_ERROR, "No storage module chosen - failed to initialize session");
@@ -482,7 +473,7 @@ static void php_session_initialize(TSRMLS_D) /* {{{ */
 
 	/* If there is no ID, use session module to create one */
 	if (!PS(id)) {
-		PS(id) = PS(mod)->s_create_sid(&PS(mod_data), NULL TSRMLS_CC);
+		PS(id) = PS(mod)->s_create_sid(&PS(mod_data) TSRMLS_CC);
 		if (!PS(id)) {
 			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Failed to create session ID: %s (path: %s)", PS(mod)->s_name, PS(save_path));
 			return;
@@ -500,7 +491,7 @@ static void php_session_initialize(TSRMLS_D) /* {{{ */
 
 	/* Read data */
 	php_session_track_init(TSRMLS_C);
-	if (PS(mod)->s_read(&PS(mod_data), PS(id), &val, &vallen TSRMLS_CC) == FAILURE) {
+	if (PS(mod)->s_read(&PS(mod_data), PS(id), &val TSRMLS_CC) == FAILURE) {
 		/* Some broken save handler implementation returns FAILURE for non-existent session ID */
 		/* It's better to raise error for this, but disabled error for better compatibility */
 		/*
@@ -517,11 +508,11 @@ static void php_session_initialize(TSRMLS_D) /* {{{ */
 
 		/* Store read data's MD5 hash */
 		PHP_MD5Init(&context);
-		PHP_MD5Update(&context, val, vallen);
+		PHP_MD5Update(&context, val->val, val->len);
 		PHP_MD5Final(PS(session_data_hash), &context);
 
-		php_session_decode(val, vallen TSRMLS_CC);
-		str_efree(val);
+		php_session_decode(val->val, val->len TSRMLS_CC);
+		STR_RELEASE(val);
 	} else {
 		memset(PS(session_data_hash),'\0', 16);
 	}
@@ -541,27 +532,26 @@ static void php_session_save_current_state(TSRMLS_D) /* {{{ */
 
 	IF_SESSION_VARS() {
  		if (PS(mod_data) || PS(mod_user_implemented)) {
-			char *val;
-			int vallen;
+			zend_string *val;
 
-			val = php_session_encode(&vallen TSRMLS_CC);
+			val = php_session_encode(TSRMLS_C);
 			if (val) {
 				PHP_MD5_CTX context;
 				unsigned char digest[16];
 
 				/* Generate data's MD5 hash */
 				PHP_MD5Init(&context);
-				PHP_MD5Update(&context, val, vallen);
+				PHP_MD5Update(&context, val->val, val->len);
 				PHP_MD5Final(digest, &context);
 				/* Write only when save is required */
 				if (memcmp(digest, PS(session_data_hash), 16)) {
-					ret = PS(mod)->s_write(&PS(mod_data), PS(id), val, vallen TSRMLS_CC);
+					ret = PS(mod)->s_write(&PS(mod_data), PS(id), val TSRMLS_CC);
 				} else {
 					ret = SUCCESS;
 				}
-				efree(val);
+				STR_RELEASE(val);
 			} else {
-				ret = PS(mod)->s_write(&PS(mod_data), PS(id), "", 0 TSRMLS_CC);
+				ret = PS(mod)->s_write(&PS(mod_data), PS(id), STR_EMPTY_ALLOC() TSRMLS_CC);
 			}
 		}
 
@@ -780,25 +770,6 @@ static PHP_INI_MH(OnUpdateRfc1867Freq) /* {{{ */
 	return SUCCESS;
 } /* }}} */
 
-static ZEND_INI_MH(OnUpdateSmartStr) /* {{{ */
-{
-	smart_str *p;
-#ifndef ZTS
-	char *base = (char *) mh_arg2;
-#else
-	char *base;
-
-	base = (char *) ts_resource(*((int *) mh_arg2));
-#endif
-
-	p = (smart_str *) (base+(size_t) mh_arg1);
-
-	smart_str_sets(p, new_value);
-
-	return SUCCESS;
-}
-/* }}} */
-
 /* {{{ PHP_INI
  */
 PHP_INI_BEGIN()
@@ -841,9 +812,9 @@ PHP_INI_BEGIN()
 	STD_PHP_INI_BOOLEAN("session.upload_progress.cleanup",
 	                                                "1",     ZEND_INI_PERDIR, OnUpdateBool,        rfc1867_cleanup, php_ps_globals, ps_globals)
 	STD_PHP_INI_ENTRY("session.upload_progress.prefix",
-	                                     "upload_progress_", ZEND_INI_PERDIR, OnUpdateSmartStr,      rfc1867_prefix,  php_ps_globals, ps_globals)
+	                                     "upload_progress_", ZEND_INI_PERDIR, OnUpdateString,      rfc1867_prefix,  php_ps_globals, ps_globals)
 	STD_PHP_INI_ENTRY("session.upload_progress.name",
-	                          "PHP_SESSION_UPLOAD_PROGRESS", ZEND_INI_PERDIR, OnUpdateSmartStr,      rfc1867_name,    php_ps_globals, ps_globals)
+	                          "PHP_SESSION_UPLOAD_PROGRESS", ZEND_INI_PERDIR, OnUpdateString,      rfc1867_name,    php_ps_globals, ps_globals)
 	STD_PHP_INI_ENTRY("session.upload_progress.freq",  "1%", ZEND_INI_PERDIR, OnUpdateRfc1867Freq, rfc1867_freq,    php_ps_globals, ps_globals)
 	STD_PHP_INI_ENTRY("session.upload_progress.min_freq",
 	                                                   "1",  ZEND_INI_PERDIR, OnUpdateReal,        rfc1867_min_freq,php_ps_globals, ps_globals)
@@ -862,35 +833,33 @@ PS_SERIALIZER_ENCODE_FUNC(php_serialize) /* {{{ */
 	php_serialize_data_t var_hash;
 
 	PHP_VAR_SERIALIZE_INIT(var_hash);
-	php_var_serialize(&buf, &PS(http_session_vars), &var_hash TSRMLS_CC);
+	php_var_serialize(&buf, Z_REFVAL(PS(http_session_vars)), &var_hash TSRMLS_CC);
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
-	if (newlen) {
-		*newlen = buf.len;
-	}
-	smart_str_0(&buf);
-	*newstr = buf.c;
-	return SUCCESS;
+	return buf.s;
 }
 /* }}} */
 
 PS_SERIALIZER_DECODE_FUNC(php_serialize) /* {{{ */
 {
 	const char *endptr = val + vallen;
-	zval *session_vars;
+	zval session_vars;
 	php_unserialize_data_t var_hash;
+	zend_string *var_name = STR_INIT("_SESSION", sizeof("_SESSION") - 1, 0);
 
+	ZVAL_NULL(&session_vars);
 	PHP_VAR_UNSERIALIZE_INIT(var_hash);
-	ALLOC_INIT_ZVAL(session_vars);
-	php_var_unserialize(&session_vars, &val, endptr, &var_hash TSRMLS_CC);
+	php_var_unserialize(&session_vars, (const unsigned char**)&val, endptr, &var_hash TSRMLS_CC);
 	PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
-	if (PS(http_session_vars)) {
+	if (!ZVAL_IS_UNDEF(&PS(http_session_vars))) {
 		zval_ptr_dtor(&PS(http_session_vars));
 	}
-	if (Z_TYPE_P(session_vars) == IS_NULL) {
-		array_init(session_vars);
-	}
-	PS(http_session_vars) = session_vars;
-	ZEND_SET_GLOBAL_VAR_WITH_LENGTH("_SESSION", sizeof("_SESSION"), PS(http_session_vars), 2, 1);
+	if (Z_TYPE(session_vars) == IS_NULL) {
+		array_init(&session_vars);
+	} 
+	ZVAL_NEW_REF(&PS(http_session_vars), &session_vars);
+	Z_ADDREF_P(&PS(http_session_vars));
+	zend_hash_update_ind(&EG(symbol_table).ht, var_name, &PS(http_session_vars));
+	STR_RELEASE(var_name);
 	return SUCCESS;
 }
 /* }}} */
@@ -908,41 +877,37 @@ PS_SERIALIZER_ENCODE_FUNC(php_binary) /* {{{ */
 	PHP_VAR_SERIALIZE_INIT(var_hash);
 
 	PS_ENCODE_LOOP(
-			if (key_length > PS_BIN_MAX) continue;
-			smart_str_appendc(&buf, (unsigned char) key_length);
-			smart_str_appendl(&buf, key, key_length);
+			if (key->len > PS_BIN_MAX) continue;
+			smart_str_appendc(&buf, (unsigned char)key->len);
+			smart_str_appendl(&buf, key->val, key->len);
 			php_var_serialize(&buf, struc, &var_hash TSRMLS_CC);
 		} else {
-			if (key_length > PS_BIN_MAX) continue;
-			smart_str_appendc(&buf, (unsigned char) (key_length & PS_BIN_UNDEF));
-			smart_str_appendl(&buf, key, key_length);
+			if (key->len > PS_BIN_MAX) continue;
+			smart_str_appendc(&buf, (unsigned char) (key->len & PS_BIN_UNDEF));
+			smart_str_appendl(&buf, key->val, key->len);
 	);
 
-	if (newlen) {
-		*newlen = buf.len;
-	}
 	smart_str_0(&buf);
-	*newstr = buf.c;
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
 
-	return SUCCESS;
+	return buf.s;
 }
 /* }}} */
 
 PS_SERIALIZER_DECODE_FUNC(php_binary) /* {{{ */
 {
 	const char *p;
-	char *name;
 	const char *endptr = val + vallen;
-	zval *current;
-	int namelen;
+	zval current;
 	int has_value;
+	int namelen;
+	zend_string *name;
 	php_unserialize_data_t var_hash;
 
 	PHP_VAR_UNSERIALIZE_INIT(var_hash);
 
 	for (p = val; p < endptr; ) {
-		zval **tmp;
+		zval *tmp;
 		namelen = ((unsigned char)(*p)) & (~PS_BIN_UNDEF);
 
 		if (namelen < 0 || namelen > PS_BIN_MAX || (p + namelen) >= endptr) {
@@ -951,26 +916,28 @@ PS_SERIALIZER_DECODE_FUNC(php_binary) /* {{{ */
 
 		has_value = *p & PS_BIN_UNDEF ? 0 : 1;
 
-		name = estrndup(p + 1, namelen);
+		name = STR_INIT(p + 1, namelen, 0);
 
 		p += namelen + 1;
 
-		if (zend_hash_find(&EG(symbol_table), name, namelen + 1, (void **) &tmp) == SUCCESS) {
-			if ((Z_TYPE_PP(tmp) == IS_ARRAY && Z_ARRVAL_PP(tmp) == &EG(symbol_table)) || *tmp == PS(http_session_vars)) {
+		if ((tmp = zend_hash_find(&EG(symbol_table).ht, name))) {
+			if ((Z_TYPE_P(tmp) == IS_ARRAY && Z_ARRVAL_P(tmp) == &EG(symbol_table).ht) || tmp == &PS(http_session_vars)) {
 				efree(name);
 				continue;
 			}
 		}
 
 		if (has_value) {
-			ALLOC_INIT_ZVAL(current);
+			ZVAL_UNDEF(&current);
 			if (php_var_unserialize(&current, (const unsigned char **) &p, (const unsigned char *) endptr, &var_hash TSRMLS_CC)) {
-				php_set_session_var(name, namelen, current, &var_hash  TSRMLS_CC);
+				zval *zv = php_set_session_var(name, &current, &var_hash  TSRMLS_CC);
+				var_replace(&var_hash, &current, zv);
+			} else {
+				zval_ptr_dtor(&current);
 			}
-			zval_ptr_dtor(&current);
 		}
-		PS_ADD_VARL(name, namelen);
-		efree(name);
+		PS_ADD_VARL(name);
+		STR_RELEASE(name);
 	}
 
 	PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
@@ -991,40 +958,36 @@ PS_SERIALIZER_ENCODE_FUNC(php) /* {{{ */
 	PHP_VAR_SERIALIZE_INIT(var_hash);
 
 	PS_ENCODE_LOOP(
-			smart_str_appendl(&buf, key, key_length);
-			if (memchr(key, PS_DELIMITER, key_length) || memchr(key, PS_UNDEF_MARKER, key_length)) {
+			smart_str_appendl(&buf, key->val, key->len);
+			if (memchr(key->val, PS_DELIMITER, key->len) || memchr(key->val, PS_UNDEF_MARKER, key->len)) {
 				PHP_VAR_SERIALIZE_DESTROY(var_hash);
 				smart_str_free(&buf);
-				return FAILURE;
+				return NULL;
 			}
 			smart_str_appendc(&buf, PS_DELIMITER);
 
 			php_var_serialize(&buf, struc, &var_hash TSRMLS_CC);
 		} else {
 			smart_str_appendc(&buf, PS_UNDEF_MARKER);
-			smart_str_appendl(&buf, key, key_length);
+			smart_str_appendl(&buf, key->val, key->len);
 			smart_str_appendc(&buf, PS_DELIMITER);
 	);
 
-	if (newlen) {
-		*newlen = buf.len;
-	}
 	smart_str_0(&buf);
-	*newstr = buf.c;
 
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
-	return SUCCESS;
+	return buf.s;
 }
 /* }}} */
 
 PS_SERIALIZER_DECODE_FUNC(php) /* {{{ */
 {
 	const char *p, *q;
-	char *name;
 	const char *endptr = val + vallen;
-	zval *current;
-	int namelen;
+	zval current;
 	int has_value;
+	int namelen;
+	zend_string *name;
 	php_unserialize_data_t var_hash;
 
 	PHP_VAR_UNSERIALIZE_INIT(var_hash);
@@ -1032,7 +995,7 @@ PS_SERIALIZER_DECODE_FUNC(php) /* {{{ */
 	p = val;
 
 	while (p < endptr) {
-		zval **tmp;
+		zval *tmp;
 		q = p;
 		while (*q != PS_DELIMITER) {
 			if (++q >= endptr) goto break_outer_loop;
@@ -1045,25 +1008,27 @@ PS_SERIALIZER_DECODE_FUNC(php) /* {{{ */
 		}
 
 		namelen = q - p;
-		name = estrndup(p, namelen);
+		name = STR_INIT(p, namelen, 0);
 		q++;
 
-		if (zend_hash_find(&EG(symbol_table), name, namelen + 1, (void **) &tmp) == SUCCESS) {
-			if ((Z_TYPE_PP(tmp) == IS_ARRAY && Z_ARRVAL_PP(tmp) == &EG(symbol_table)) || *tmp == PS(http_session_vars)) {
+		if ((tmp = zend_hash_find(&EG(symbol_table).ht, name))) {
+			if ((Z_TYPE_P(tmp) == IS_ARRAY && Z_ARRVAL_P(tmp) == &EG(symbol_table).ht) || tmp == &PS(http_session_vars)) {
 				goto skip;
 			}
 		}
 
 		if (has_value) {
-			ALLOC_INIT_ZVAL(current);
+			ZVAL_UNDEF(&current);
 			if (php_var_unserialize(&current, (const unsigned char **) &q, (const unsigned char *) endptr, &var_hash TSRMLS_CC)) {
-				php_set_session_var(name, namelen, current, &var_hash  TSRMLS_CC);
+				zval *zv = php_set_session_var(name, &current, &var_hash TSRMLS_CC);
+				var_replace(&var_hash, &current, zv);
+			} else {
+				zval_ptr_dtor(&current);
 			}
-			zval_ptr_dtor(&current);
 		}
-		PS_ADD_VARL(name, namelen);
+		PS_ADD_VARL(name);
 skip:
-		efree(name);
+		STR_RELEASE(name);
 
 		p = q;
 	}
@@ -1084,7 +1049,7 @@ static ps_serializer ps_serializers[MAX_SERIALIZERS + 1] = {
 	PS_SERIALIZER_ENTRY(php_binary)
 };
 
-PHPAPI int php_session_register_serializer(const char *name, int (*encode)(PS_SERIALIZER_ENCODE_ARGS), int (*decode)(PS_SERIALIZER_DECODE_ARGS)) /* {{{ */
+PHPAPI int php_session_register_serializer(const char *name, zend_string *(*encode)(PS_SERIALIZER_ENCODE_ARGS), int (*decode)(PS_SERIALIZER_DECODE_ARGS)) /* {{{ */
 {
 	int ret = -1;
 	int i;
@@ -1310,7 +1275,7 @@ static void php_session_remove_cookie(TSRMLS_D) {
 	char *session_cookie, *e_session_name;
 	int session_cookie_len, len = sizeof("Set-Cookie")-1;
 
-	e_session_name = php_url_encode(PS(session_name), strlen(PS(session_name)), NULL);
+	e_session_name = php_url_encode(PS(session_name), strlen(PS(session_name)));
 	spprintf(&session_cookie, 0, "Set-Cookie: %s=", e_session_name);
 	efree(e_session_name);
 
@@ -1343,8 +1308,8 @@ static void php_session_remove_cookie(TSRMLS_D) {
 static void php_session_send_cookie(TSRMLS_D) /* {{{ */
 {
 	smart_str ncookie = {0};
-	char *date_fmt = NULL;
-	char *e_session_name, *e_id;
+	zend_string *date_fmt = NULL;
+	zend_string *e_session_name, *e_id;
 
 	if (SG(headers_sent)) {
 		const char *output_start_filename = php_output_get_start_filename(TSRMLS_C);
@@ -1359,16 +1324,16 @@ static void php_session_send_cookie(TSRMLS_D) /* {{{ */
 	}
 
 	/* URL encode session_name and id because they might be user supplied */
-	e_session_name = php_url_encode(PS(session_name), strlen(PS(session_name)), NULL);
-	e_id = php_url_encode(PS(id), strlen(PS(id)), NULL);
+	e_session_name = php_url_encode(PS(session_name), strlen(PS(session_name)));
+	e_id = php_url_encode(PS(id)->val, PS(id)->len);
 
 	smart_str_appends(&ncookie, COOKIE_SET_COOKIE);
-	smart_str_appends(&ncookie, e_session_name);
+	smart_str_appendl(&ncookie, e_session_name->val, e_session_name->len);
 	smart_str_appendc(&ncookie, '=');
-	smart_str_appends(&ncookie, e_id);
+	smart_str_appendl(&ncookie, e_id->val, e_id->len);
 
-	efree(e_session_name);
-	efree(e_id);
+	STR_RELEASE(e_session_name);
+	STR_RELEASE(e_id);
 
 	if (PS(cookie_lifetime) > 0) {
 		struct timeval tv;
@@ -1380,8 +1345,8 @@ static void php_session_send_cookie(TSRMLS_D) /* {{{ */
 		if (t > 0) {
 			date_fmt = php_format_date("D, d-M-Y H:i:s T", sizeof("D, d-M-Y H:i:s T")-1, t, 0 TSRMLS_CC);
 			smart_str_appends(&ncookie, COOKIE_EXPIRES);
-			smart_str_appends(&ncookie, date_fmt);
-			efree(date_fmt);
+			smart_str_appendl(&ncookie, date_fmt->val, date_fmt->len);
+			STR_RELEASE(date_fmt);
 
 			smart_str_appends(&ncookie, COOKIE_MAX_AGE);
 			smart_str_append_long(&ncookie, PS(cookie_lifetime));
@@ -1409,7 +1374,10 @@ static void php_session_send_cookie(TSRMLS_D) /* {{{ */
 	smart_str_0(&ncookie);
 
 	php_session_remove_cookie(TSRMLS_C); /* remove already sent session ID cookie */
-	sapi_add_header_ex(ncookie.c, ncookie.len, 0, 0 TSRMLS_CC);
+	/*	'replace' must be 0 here, else a previous Set-Cookie
+		header, probably sent with setcookie() will be replaced! */
+	sapi_add_header_ex(estrndup(ncookie.s->val, ncookie.s->len), ncookie.s->len, 0, 0 TSRMLS_CC);
+	smart_str_free(&ncookie);
 }
 /* }}} */
 
@@ -1445,8 +1413,8 @@ PHPAPI const ps_serializer *_php_find_ps_serializer(char *name TSRMLS_DC) /* {{{
 /* }}} */
 
 #define PPID2SID \
-		convert_to_string((*ppid)); \
-		PS(id) = estrndup(Z_STRVAL_PP(ppid), Z_STRLEN_PP(ppid))
+		convert_to_string((ppid)); \
+		PS(id) = STR_INIT(Z_STRVAL_P(ppid), Z_STRLEN_P(ppid), 0)
 
 PHPAPI void php_session_reset_id(TSRMLS_D) /* {{{ */
 {
@@ -1463,31 +1431,32 @@ PHPAPI void php_session_reset_id(TSRMLS_D) /* {{{ */
 	}
 
 	/* if the SID constant exists, destroy it. */
-	zend_hash_del(EG(zend_constants), "sid", sizeof("sid"));
+	zend_hash_str_del(EG(zend_constants), "sid", sizeof("sid") - 1);
 
 	if (PS(define_sid)) {
 		smart_str var = {0};
 
 		smart_str_appends(&var, PS(session_name));
 		smart_str_appendc(&var, '=');
-		smart_str_appends(&var, PS(id));
+		smart_str_appends(&var, PS(id)->val);
 		smart_str_0(&var);
-		REGISTER_STRINGL_CONSTANT("SID", var.c, var.len, 0);
+		REGISTER_STRINGL_CONSTANT("SID", var.s->val, var.s->len, 0);
+		smart_str_free(&var);
 	} else {
-		REGISTER_STRINGL_CONSTANT("SID", STR_EMPTY_ALLOC(), 0, 0);
+		REGISTER_STRINGL_CONSTANT("SID", "", 0, 0);
 	}
 
 	if (PS(apply_trans_sid)) {
 		php_url_scanner_reset_vars(TSRMLS_C);
-		php_url_scanner_add_var(PS(session_name), strlen(PS(session_name)), PS(id), strlen(PS(id)), 1 TSRMLS_CC);
+		php_url_scanner_add_var(PS(session_name), strlen(PS(session_name)), PS(id)->val, PS(id)->len, 1 TSRMLS_CC);
 	}
 }
 /* }}} */
 
 PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 {
-	zval **ppid;
-	zval **data;
+	zval *ppid;
+	zval *data;
 	char *p, *value;
 	int nrand;
 	int lensess;
@@ -1505,7 +1474,7 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 			break;
 
 		case php_session_disabled:
-			value = zend_ini_string("session.save_handler", sizeof("session.save_handler"), 0);
+			value = zend_ini_string("session.save_handler", sizeof("session.save_handler") - 1, 0);
 			if (!PS(mod) && value) {
 				PS(mod) = _php_find_ps_module(value TSRMLS_CC);
 				if (!PS(mod)) {
@@ -1513,7 +1482,7 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 					return;
 				}
 			}
-			value = zend_ini_string("session.serialize_handler", sizeof("session.serialize_handler"), 0);
+			value = zend_ini_string("session.serialize_handler", sizeof("session.serialize_handler") - 1, 0);
 			if (!PS(serializer) && value) {
 				PS(serializer) = _php_find_ps_serializer(value TSRMLS_CC);
 				if (!PS(serializer)) {
@@ -1536,9 +1505,9 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 	 * cookie and get variables will be available. */
 
 	if (!PS(id)) {
-		if (PS(use_cookies) && zend_hash_find(&EG(symbol_table), "_COOKIE", sizeof("_COOKIE"), (void **) &data) == SUCCESS &&
-				Z_TYPE_PP(data) == IS_ARRAY &&
-				zend_hash_find(Z_ARRVAL_PP(data), PS(session_name), lensess + 1, (void **) &ppid) == SUCCESS
+		if (PS(use_cookies) && (data = zend_hash_str_find(&EG(symbol_table).ht, "_COOKIE", sizeof("_COOKIE") - 1)) &&
+				Z_TYPE_P(data) == IS_ARRAY &&
+				(ppid = zend_hash_str_find(Z_ARRVAL_P(data), PS(session_name), lensess))
 		) {
 			PPID2SID;
 			PS(apply_trans_sid) = 0;
@@ -1547,18 +1516,18 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 		}
 
 		if (!PS(use_only_cookies) && !PS(id) &&
-				zend_hash_find(&EG(symbol_table), "_GET", sizeof("_GET"), (void **) &data) == SUCCESS &&
-				Z_TYPE_PP(data) == IS_ARRAY &&
-				zend_hash_find(Z_ARRVAL_PP(data), PS(session_name), lensess + 1, (void **) &ppid) == SUCCESS
+				(data = zend_hash_str_find(&EG(symbol_table).ht, "_GET", sizeof("_GET") - 1)) &&
+				Z_TYPE_P(data) == IS_ARRAY &&
+				(ppid = zend_hash_str_find(Z_ARRVAL_P(data), PS(session_name), lensess))
 		) {
 			PPID2SID;
 			PS(send_cookie) = 0;
 		}
 
 		if (!PS(use_only_cookies) && !PS(id) &&
-				zend_hash_find(&EG(symbol_table), "_POST", sizeof("_POST"), (void **) &data) == SUCCESS &&
-				Z_TYPE_PP(data) == IS_ARRAY &&
-				zend_hash_find(Z_ARRVAL_PP(data), PS(session_name), lensess + 1, (void **) &ppid) == SUCCESS
+				(data = zend_hash_str_find(&EG(symbol_table).ht, "_POST", sizeof("_POST") - 1)) &&
+				Z_TYPE_P(data) == IS_ARRAY &&
+				(ppid = zend_hash_str_find(Z_ARRVAL_P(data), PS(session_name), lensess))
 		) {
 			PPID2SID;
 			PS(send_cookie) = 0;
@@ -1569,17 +1538,17 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 	 * '<session-name>=<session-id>' to allow URLs of the form
 	 * http://yoursite/<session-name>=<session-id>/script.php */
 
-	if (!PS(use_only_cookies) && !PS(id) && PG(http_globals)[TRACK_VARS_SERVER] &&
-			zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "REQUEST_URI", sizeof("REQUEST_URI"), (void **) &data) == SUCCESS &&
-			Z_TYPE_PP(data) == IS_STRING &&
-			(p = strstr(Z_STRVAL_PP(data), PS(session_name))) &&
+	if (!PS(use_only_cookies) && !PS(id) && !ZVAL_IS_UNDEF(&PG(http_globals)[TRACK_VARS_SERVER]) &&
+			(data = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "REQUEST_URI", sizeof("REQUEST_URI") - 1)) &&
+			Z_TYPE_P(data) == IS_STRING &&
+			(p = strstr(Z_STRVAL_P(data), PS(session_name))) &&
 			p[lensess] == '='
 	) {
 		char *q;
 
 		p += lensess + 1;
 		if ((q = strpbrk(p, "/?\\"))) {
-			PS(id) = estrndup(p, q - p);
+			PS(id) = STR_INIT(p, q - p, 0);
 			PS(send_cookie) = 0;
 		}
 	}
@@ -1589,13 +1558,13 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 
 	if (PS(id) &&
 			PS(extern_referer_chk)[0] != '\0' &&
-			PG(http_globals)[TRACK_VARS_SERVER] &&
-			zend_hash_find(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_REFERER", sizeof("HTTP_REFERER"), (void **) &data) == SUCCESS &&
-			Z_TYPE_PP(data) == IS_STRING &&
-			Z_STRLEN_PP(data) != 0 &&
-			strstr(Z_STRVAL_PP(data), PS(extern_referer_chk)) == NULL
+			!ZVAL_IS_UNDEF(&PG(http_globals)[TRACK_VARS_SERVER]) &&
+			(data = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_REFERER", sizeof("HTTP_REFERER") - 1)) &&
+			Z_TYPE_P(data) == IS_STRING &&
+			Z_STRLEN_P(data) != 0 &&
+			strstr(Z_STRVAL_P(data), PS(extern_referer_chk)) == NULL
 	) {
-		efree(PS(id));
+		STR_RELEASE(PS(id));
 		PS(id) = NULL;
 		PS(send_cookie) = 1;
 		if (PS(use_trans_sid) && !PS(use_only_cookies)) {
@@ -1605,8 +1574,8 @@ PHPAPI void php_session_start(TSRMLS_D) /* {{{ */
 
 	/* Finally check session id for dangarous characters
 	 * Security note: session id may be embedded in HTML pages.*/
-	if (PS(id) && strpbrk(PS(id), "\r\n\t <>'\"\\")) {
-		efree(PS(id));
+	if (PS(id) && strpbrk(PS(id)->val, "\r\n\t <>'\"\\")) {
+		STR_RELEASE(PS(id));
 		PS(id) = NULL;
 	}
 
@@ -1661,7 +1630,7 @@ static void php_session_reset(TSRMLS_D) /* {{{ */
 PHPAPI void session_adapt_url(const char *url, size_t urllen, char **new, size_t *newlen TSRMLS_DC) /* {{{ */
 {
 	if (PS(apply_trans_sid) && (PS(session_status) == php_session_active)) {
-		*new = php_url_scanner_adapt_single_url(url, urllen, PS(session_name), PS(id), newlen TSRMLS_CC);
+		*new = php_url_scanner_adapt_single_url(url, urllen, PS(session_name), PS(id)->val, newlen TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -1674,32 +1643,43 @@ PHPAPI void session_adapt_url(const char *url, size_t urllen, char **new, size_t
    Set session cookie parameters */
 static PHP_FUNCTION(session_set_cookie_params)
 {
-	zval **lifetime = NULL;
+	zval *lifetime;
 	char *path = NULL, *domain = NULL;
 	int path_len, domain_len, argc = ZEND_NUM_ARGS();
 	zend_bool secure = 0, httponly = 0;
+	zend_string *ini_name;
 
 	if (!PS(use_cookies) ||
-		zend_parse_parameters(argc TSRMLS_CC, "Z|ssbb", &lifetime, &path, &path_len, &domain, &domain_len, &secure, &httponly) == FAILURE) {
+		zend_parse_parameters(argc TSRMLS_CC, "z|ssbb", &lifetime, &path, &path_len, &domain, &domain_len, &secure, &httponly) == FAILURE) {
 		return;
 	}
 
 	convert_to_string_ex(lifetime);
 
-	zend_alter_ini_entry("session.cookie_lifetime", sizeof("session.cookie_lifetime"), Z_STRVAL_PP(lifetime), Z_STRLEN_PP(lifetime), PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+	ini_name = STR_INIT("session.cookie_lifetime", sizeof("session.cookie_lifetime") - 1, 0);
+	zend_alter_ini_entry(ini_name,  Z_STRVAL_P(lifetime), Z_STRLEN_P(lifetime), PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+	STR_RELEASE(ini_name);
 
 	if (path) {
-		zend_alter_ini_entry("session.cookie_path", sizeof("session.cookie_path"), path, path_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.cookie_path", sizeof("session.cookie_path") - 1, 0);
+		zend_alter_ini_entry(ini_name, path, path_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 	if (domain) {
-		zend_alter_ini_entry("session.cookie_domain", sizeof("session.cookie_domain"), domain, domain_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.cookie_domain", sizeof("session.cookie_domain") - 1, 0);
+		zend_alter_ini_entry(ini_name, domain, domain_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 
 	if (argc > 3) {
-		zend_alter_ini_entry("session.cookie_secure", sizeof("session.cookie_secure"), secure ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.cookie_secure", sizeof("session.cookie_secure") - 1, 0);
+		zend_alter_ini_entry(ini_name, secure ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 	if (argc > 4) {
-		zend_alter_ini_entry("session.cookie_httponly", sizeof("session.cookie_httponly"), httponly ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.cookie_httponly", sizeof("session.cookie_httponly") - 1, 0);
+		zend_alter_ini_entry(ini_name, httponly ? "1" : "0", 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -1715,8 +1695,8 @@ static PHP_FUNCTION(session_get_cookie_params)
 	array_init(return_value);
 
 	add_assoc_long(return_value, "lifetime", PS(cookie_lifetime));
-	add_assoc_string(return_value, "path", PS(cookie_path), 1);
-	add_assoc_string(return_value, "domain", PS(cookie_domain), 1);
+	add_assoc_string(return_value, "path", PS(cookie_path));
+	add_assoc_string(return_value, "domain", PS(cookie_domain));
 	add_assoc_bool(return_value, "secure", PS(cookie_secure));
 	add_assoc_bool(return_value, "httponly", PS(cookie_httponly));
 }
@@ -1728,15 +1708,18 @@ static PHP_FUNCTION(session_name)
 {
 	char *name = NULL;
 	int name_len;
+	zend_string *ini_name;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &name, &name_len) == FAILURE) {
 		return;
 	}
 
-	RETVAL_STRING(PS(session_name), 1);
+	RETVAL_STRING(PS(session_name));
 
 	if (name) {
-		zend_alter_ini_entry("session.name", sizeof("session.name"), name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.name", sizeof("session.name") - 1, 0);
+		zend_alter_ini_entry(ini_name, name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -1747,6 +1730,7 @@ static PHP_FUNCTION(session_module_name)
 {
 	char *name = NULL;
 	int name_len;
+	zend_string *ini_name;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &name, &name_len) == FAILURE) {
 		return;
@@ -1754,7 +1738,7 @@ static PHP_FUNCTION(session_module_name)
 
 	/* Set return_value to current module name */
 	if (PS(mod) && PS(mod)->s_name) {
-		RETVAL_STRING(safe_estrdup(PS(mod)->s_name), 0);
+		RETVAL_STRING(PS(mod)->s_name);
 	} else {
 		RETVAL_EMPTY_STRING();
 	}
@@ -1771,7 +1755,9 @@ static PHP_FUNCTION(session_module_name)
 		}
 		PS(mod_data) = NULL;
 
-		zend_alter_ini_entry("session.save_handler", sizeof("session.save_handler"), name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.save_handler", sizeof("session.save_handler") - 1, 0);
+		zend_alter_ini_entry(ini_name, name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -1780,18 +1766,18 @@ static PHP_FUNCTION(session_module_name)
    Sets user-level functions */
 static PHP_FUNCTION(session_set_save_handler)
 {
-	zval ***args = NULL;
+	zval *args = NULL;
 	int i, num_args, argc = ZEND_NUM_ARGS();
-	char *name;
+	zend_string *name;
+	zend_string *ini_name;
 
 	if (PS(session_status) != php_session_none) {
 		RETURN_FALSE;
 	}
 
 	if (argc > 0 && argc <= 2) {
-		zval *obj = NULL, *callback = NULL;
-		zend_uint func_name_len;
-		char *func_name;
+		zval *obj = NULL;
+		zend_string *func_name;
 		HashPosition pos;
 		zend_function *default_mptr, *current_mptr;
 		ulong func_index;
@@ -1805,20 +1791,18 @@ static PHP_FUNCTION(session_set_save_handler)
 		/* Find implemented methods - SessionHandlerInterface */
 		zend_hash_internal_pointer_reset_ex(&php_session_iface_entry->function_table, &pos);
 		i = 0;
-		while (zend_hash_get_current_data_ex(&php_session_iface_entry->function_table, (void **) &default_mptr, &pos) == SUCCESS) {
-			zend_hash_get_current_key_ex(&php_session_iface_entry->function_table, &func_name, &func_name_len, &func_index, 0, &pos);
+		while ((default_mptr = zend_hash_get_current_data_ptr_ex(&php_session_iface_entry->function_table, &pos))) {
+			zend_hash_get_current_key_ex(&php_session_iface_entry->function_table, &func_name, &func_index, 0, &pos);
 
-			if (zend_hash_find(&Z_OBJCE_P(obj)->function_table, func_name, func_name_len, (void **)&current_mptr) == SUCCESS) {
-				if (PS(mod_user_names).names[i] != NULL) {
+			if ((current_mptr = zend_hash_find_ptr(&Z_OBJCE_P(obj)->function_table, func_name))) {
+				if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
 					zval_ptr_dtor(&PS(mod_user_names).names[i]);
 				}
 
-				MAKE_STD_ZVAL(callback);
-				array_init_size(callback, 2);
+				array_init_size(&PS(mod_user_names).names[i], 2);
 				Z_ADDREF_P(obj);
-				add_next_index_zval(callback, obj);
-				add_next_index_stringl(callback, func_name, func_name_len - 1, 1);
-				PS(mod_user_names).names[i] = callback;
+				add_next_index_zval(&PS(mod_user_names).names[i], obj);
+				add_next_index_str(&PS(mod_user_names).names[i], func_name);
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_ERROR, "Session handler's function table is corrupt");
 				RETURN_FALSE;
@@ -1830,20 +1814,18 @@ static PHP_FUNCTION(session_set_save_handler)
 
 		/* Find implemented methods - SessionIdInterface (optional) */
 		zend_hash_internal_pointer_reset_ex(&php_session_id_iface_entry->function_table, &pos);
-		while (zend_hash_get_current_data_ex(&php_session_id_iface_entry->function_table, (void **) &default_mptr, &pos) == SUCCESS) {
-			zend_hash_get_current_key_ex(&php_session_id_iface_entry->function_table, &func_name, &func_name_len, &func_index, 0, &pos);
+		while ((default_mptr = zend_hash_get_current_data_ptr_ex(&php_session_id_iface_entry->function_table, &pos))) {
+			zend_hash_get_current_key_ex(&php_session_id_iface_entry->function_table, &func_name, &func_index, 0, &pos);
 
-			if (zend_hash_find(&Z_OBJCE_P(obj)->function_table, func_name, func_name_len, (void **)&current_mptr) == SUCCESS) {
-				if (PS(mod_user_names).names[i] != NULL) {
+			if ((current_mptr = zend_hash_find_ptr(&Z_OBJCE_P(obj)->function_table, func_name))) {
+				if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
 					zval_ptr_dtor(&PS(mod_user_names).names[i]);
 				}
 
-				MAKE_STD_ZVAL(callback);
-				array_init_size(callback, 2);
+				array_init_size(&PS(mod_user_names).names[i], 2);
 				Z_ADDREF_P(obj);
-				add_next_index_zval(callback, obj);
-				add_next_index_stringl(callback, func_name, func_name_len - 1, 1);
-				PS(mod_user_names).names[i] = callback;
+				add_next_index_zval(&PS(mod_user_names).names[i], obj);
+				add_next_index_str(&PS(mod_user_names).names[i], func_name);
 			}
 
 			zend_hash_move_forward_ex(&php_session_id_iface_entry->function_table, &pos);
@@ -1853,26 +1835,26 @@ static PHP_FUNCTION(session_set_save_handler)
 		if (register_shutdown) {
 			/* create shutdown function */
 			shutdown_function_entry.arg_count = 1;
-			shutdown_function_entry.arguments = (zval **) safe_emalloc(sizeof(zval *), 1, 0);
+			shutdown_function_entry.arguments = (zval *) safe_emalloc(sizeof(zval), 1, 0);
 
-			MAKE_STD_ZVAL(callback);
-			ZVAL_STRING(callback, "session_register_shutdown", 1);
-			shutdown_function_entry.arguments[0] = callback;
+			ZVAL_STRING(&shutdown_function_entry.arguments[0], "session_register_shutdown");
 
 			/* add shutdown function, removing the old one if it exists */
-			if (!register_user_shutdown_function("session_shutdown", sizeof("session_shutdown"), &shutdown_function_entry TSRMLS_CC)) {
-				zval_ptr_dtor(&callback);
+			if (!register_user_shutdown_function("session_shutdown", sizeof("session_shutdown") - 1, &shutdown_function_entry TSRMLS_CC)) {
+				zval_ptr_dtor(&shutdown_function_entry.arguments[0]);
 				efree(shutdown_function_entry.arguments);
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to register session shutdown function");
 				RETURN_FALSE;
 			}
 		} else {
 			/* remove shutdown function */
-			remove_user_shutdown_function("session_shutdown", sizeof("session_shutdown") TSRMLS_CC);
+			remove_user_shutdown_function("session_shutdown", sizeof("session_shutdown") - 1 TSRMLS_CC);
 		}
 
 		if (PS(mod) && PS(session_status) == php_session_none && PS(mod) != &ps_mod_user) {
-			zend_alter_ini_entry("session.save_handler", sizeof("session.save_handler"), "user", sizeof("user")-1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+			ini_name = STR_INIT("session.save_handler", sizeof("session.save_handler") - 1, 0);
+			zend_alter_ini_entry(ini_name, "user", sizeof("user") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+			STR_RELEASE(ini_name);
 		}
 
 		RETURN_TRUE;
@@ -1887,32 +1869,31 @@ static PHP_FUNCTION(session_set_save_handler)
 	}
 
 	/* remove shutdown function */
-	remove_user_shutdown_function("session_shutdown", sizeof("session_shutdown") TSRMLS_CC);
+	remove_user_shutdown_function("session_shutdown", sizeof("session_shutdown") - 1 TSRMLS_CC);
 
 	/* at this point argc can only be 6 or 7 */
 	for (i = 0; i < argc; i++) {
-		if (!zend_is_callable(*args[i], 0, &name TSRMLS_CC)) {
-			efree(args);
+		if (!zend_is_callable(&args[i], 0, &name TSRMLS_CC)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument %d is not a valid callback", i+1);
-			efree(name);
+			STR_RELEASE(name);
 			RETURN_FALSE;
 		}
-		efree(name);
+		STR_RELEASE(name);
 	}
 	
 	if (PS(mod) && PS(mod) != &ps_mod_user) {
-		zend_alter_ini_entry("session.save_handler", sizeof("session.save_handler"), "user", sizeof("user")-1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.save_handler", sizeof("session.save_handler") - 1, 0);
+		zend_alter_ini_entry(ini_name, "user", sizeof("user")-1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 
 	for (i = 0; i < argc; i++) {
-		if (PS(mod_user_names).names[i] != NULL) {
+		if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
 			zval_ptr_dtor(&PS(mod_user_names).names[i]);
 		}
-		Z_ADDREF_PP(args[i]);
-		PS(mod_user_names).names[i] = *args[i];
+		ZVAL_COPY(&PS(mod_user_names).names[i], &args[i]);
 	}
 
-	efree(args);
 	RETURN_TRUE;
 }
 /* }}} */
@@ -1923,12 +1904,13 @@ static PHP_FUNCTION(session_save_path)
 {
 	char *name = NULL;
 	int name_len;
+	zend_string *ini_name;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &name, &name_len) == FAILURE) {
 		return;
 	}
 
-	RETVAL_STRING(PS(save_path), 1);
+	RETVAL_STRING(PS(save_path));
 
 	if (name) {
 		if (memchr(name, '\0', name_len) != NULL) {
@@ -1936,7 +1918,9 @@ static PHP_FUNCTION(session_save_path)
 			zval_dtor(return_value);
 			RETURN_FALSE;
 		}
-		zend_alter_ini_entry("session.save_path", sizeof("session.save_path"), name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.save_path", sizeof("session.save_path") - 1, 0);
+		zend_alter_ini_entry(ini_name, name, name_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -1945,24 +1929,31 @@ static PHP_FUNCTION(session_save_path)
    Return the current session id. If newid is given, the session id is replaced with newid */
 static PHP_FUNCTION(session_id)
 {
-	char *name = NULL;
-	int name_len, argc = ZEND_NUM_ARGS();
+	zend_string *name = NULL;
+	int argc = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(argc TSRMLS_CC, "|s", &name, &name_len) == FAILURE) {
+	if (zend_parse_parameters(argc TSRMLS_CC, "|S", &name) == FAILURE) {
 		return;
 	}
 
 	if (PS(id)) {
-		RETVAL_STRING(PS(id), 1);
+		//??? keep compatibility for "\0" characters
+		//??? see: ext/session/tests/session_id_error3.phpt
+		int len = strlen(PS(id)->val);
+		if (UNEXPECTED(len != PS(id)->len)) {
+			RETVAL_STR(STR_INIT(PS(id)->val, len, 0));
+		} else {
+			RETVAL_STR(STR_COPY(PS(id)));
+		}
 	} else {
 		RETVAL_EMPTY_STRING();
 	}
 
 	if (name) {
 		if (PS(id)) {
-			efree(PS(id));
+			STR_RELEASE(PS(id));
 		}
-		PS(id) = estrndup(name, name_len);
+		PS(id) = STR_COPY(name);
 	}
 }
 /* }}} */
@@ -1988,11 +1979,11 @@ static PHP_FUNCTION(session_regenerate_id)
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Session object destruction failed");
 				RETURN_FALSE;
 			}
-			efree(PS(id));
+			STR_RELEASE(PS(id));
 			PS(id) = NULL;
 		}
 
-		PS(id) = PS(mod)->s_create_sid(&PS(mod_data), NULL TSRMLS_CC);
+		PS(id) = PS(mod)->s_create_sid(&PS(mod_data) TSRMLS_CC);
 		if (PS(id)) {
 			PS(send_cookie) = 1;
 			php_session_reset_id(TSRMLS_C);
@@ -2011,15 +2002,18 @@ static PHP_FUNCTION(session_cache_limiter)
 {
 	char *limiter = NULL;
 	int limiter_len;
+	zend_string *ini_name;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &limiter, &limiter_len) == FAILURE) {
 		return;
 	}
 
-	RETVAL_STRING(PS(cache_limiter), 1);
+	RETVAL_STRING(PS(cache_limiter));
 
 	if (limiter) {
-		zend_alter_ini_entry("session.cache_limiter", sizeof("session.cache_limiter"), limiter, limiter_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.cache_limiter", sizeof("session.cache_limiter") - 1, 0);
+		zend_alter_ini_entry(ini_name, limiter, limiter_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -2028,18 +2022,20 @@ static PHP_FUNCTION(session_cache_limiter)
    Return the current cache expire. If new_cache_expire is given, the current cache_expire is replaced with new_cache_expire */
 static PHP_FUNCTION(session_cache_expire)
 {
-	zval **expires = NULL;
-	int argc = ZEND_NUM_ARGS();
+	zval *expires = NULL;
+	zend_string *ini_name;
 
-	if (zend_parse_parameters(argc TSRMLS_CC, "|Z", &expires) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|z", &expires) == FAILURE) {
 		return;
 	}
 
 	RETVAL_LONG(PS(cache_expire));
 
-	if (argc == 1) {
+	if (expires) {
 		convert_to_string_ex(expires);
-		zend_alter_ini_entry("session.cache_expire", sizeof("session.cache_expire"), Z_STRVAL_PP(expires), Z_STRLEN_PP(expires), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+		ini_name = STR_INIT("session.cache_expire", sizeof("session.cache_expire") - 1, 0);
+		zend_alter_ini_entry(ini_name, Z_STRVAL_P(expires), Z_STRLEN_P(expires), ZEND_INI_USER, ZEND_INI_STAGE_RUNTIME);
+		STR_RELEASE(ini_name);
 	}
 }
 /* }}} */
@@ -2048,19 +2044,18 @@ static PHP_FUNCTION(session_cache_expire)
    Serializes the current setup and returns the serialized representation */
 static PHP_FUNCTION(session_encode)
 {
-	int len;
-	char *enc;
+	zend_string *enc;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	enc = php_session_encode(&len TSRMLS_CC);
+	enc = php_session_encode(TSRMLS_C);
 	if (enc == NULL) {
 		RETURN_FALSE;
 	}
 
-	RETVAL_STRINGL(enc, len, 0);
+	RETURN_STR(enc);
 }
 /* }}} */
 
@@ -2123,7 +2118,7 @@ static PHP_FUNCTION(session_unset)
 		HashTable *ht_sess_var;
 
 		SEPARATE_ZVAL_IF_NOT_REF(&PS(http_session_vars));
-		ht_sess_var = Z_ARRVAL_P(PS(http_session_vars));
+		ht_sess_var = Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars)));
 
 		/* Clean $_SESSION. */
 		zend_hash_clean(ht_sess_var);
@@ -2172,7 +2167,6 @@ static PHP_FUNCTION(session_status)
 static PHP_FUNCTION(session_register_shutdown)
 {
 	php_shutdown_function_entry shutdown_function_entry;
-	zval *callback;
 
 	/* This function is registered itself as a shutdown function by
 	 * session_set_save_handler($obj). The reason we now register another
@@ -2182,14 +2176,12 @@ static PHP_FUNCTION(session_register_shutdown)
 	 */
 
 	shutdown_function_entry.arg_count = 1;
-	shutdown_function_entry.arguments = (zval **) safe_emalloc(sizeof(zval *), 1, 0);
+	shutdown_function_entry.arguments = (zval *) safe_emalloc(sizeof(zval), 1, 0);
 
-	MAKE_STD_ZVAL(callback);
-	ZVAL_STRING(callback, "session_write_close", 1);
-	shutdown_function_entry.arguments[0] = callback;
+	ZVAL_STRING(&shutdown_function_entry.arguments[0], "session_write_close");
 
 	if (!append_user_shutdown_function(shutdown_function_entry TSRMLS_CC)) {
-		zval_ptr_dtor(&callback);
+		zval_ptr_dtor(&shutdown_function_entry.arguments[0]);
 		efree(shutdown_function_entry.arguments);
 
 		/* Unable to register shutdown function, presumably because of lack
@@ -2361,7 +2353,7 @@ static int php_rinit_session(zend_bool auto_start TSRMLS_DC) /* {{{ */
 	if (PS(mod) == NULL) {
 		char *value;
 
-		value = zend_ini_string("session.save_handler", sizeof("session.save_handler"), 0);
+		value = zend_ini_string("session.save_handler", sizeof("session.save_handler") - 1, 0);
 		if (value) {
 			PS(mod) = _php_find_ps_module(value TSRMLS_CC);
 		}
@@ -2370,7 +2362,7 @@ static int php_rinit_session(zend_bool auto_start TSRMLS_DC) /* {{{ */
 	if (PS(serializer) == NULL) {
 		char *value;
 
-		value = zend_ini_string("session.serialize_handler", sizeof("session.serialize_handler"), 0);
+		value = zend_ini_string("session.serialize_handler", sizeof("session.serialize_handler") - 1, 0);
 		if (value) {
 			PS(serializer) = _php_find_ps_serializer(value TSRMLS_CC);
 		}
@@ -2406,9 +2398,9 @@ static PHP_RSHUTDOWN_FUNCTION(session) /* {{{ */
 
 	/* this should NOT be done in php_rshutdown_session_globals() */
 	for (i = 0; i < 7; i++) {
-		if (PS(mod_user_names).names[i] != NULL) {
+		if (!ZVAL_IS_UNDEF(&PS(mod_user_names).names[i])) {
 			zval_ptr_dtor(&PS(mod_user_names).names[i]);
-			PS(mod_user_names).names[i] = NULL;
+			ZVAL_UNDEF(&PS(mod_user_names).names[i]);
 		}
 	}
 
@@ -2431,9 +2423,9 @@ static PHP_GINIT_FUNCTION(ps) /* {{{ */
 	ps_globals->mod_user_implemented = 0;
 	ps_globals->mod_user_is_open = 0;
 	for (i = 0; i < 7; i++) {
-		ps_globals->mod_user_names.names[i] = NULL;
+		ZVAL_UNDEF(&ps_globals->mod_user_names.names[i]);
 	}
-	ps_globals->http_session_vars = NULL;
+	ZVAL_UNDEF(&ps_globals->http_session_vars);
 }
 /* }}} */
 
@@ -2441,7 +2433,7 @@ static PHP_MINIT_FUNCTION(session) /* {{{ */
 {
 	zend_class_entry ce;
 
-	zend_register_auto_global("_SESSION", sizeof("_SESSION")-1, 0, NULL TSRMLS_CC);
+	zend_register_auto_global(STR_INIT("_SESSION", sizeof("_SESSION") - 1, 1), 0, NULL TSRMLS_CC);
 
 	PS(module_number) = module_number; /* if we really need this var we need to init it in zts mode as well! */
 
@@ -2525,17 +2517,17 @@ static PHP_MINFO_FUNCTION(session) /* {{{ */
 	php_info_print_table_start();
 	php_info_print_table_row(2, "Session Support", "enabled" );
 
-	if (save_handlers.c) {
+	if (save_handlers.s) {
 		smart_str_0(&save_handlers);
-		php_info_print_table_row(2, "Registered save handlers", save_handlers.c);
+		php_info_print_table_row(2, "Registered save handlers", save_handlers.s->val);
 		smart_str_free(&save_handlers);
 	} else {
 		php_info_print_table_row(2, "Registered save handlers", "none");
 	}
 
-	if (ser_handlers.c) {
+	if (ser_handlers.s) {
 		smart_str_0(&ser_handlers);
-		php_info_print_table_row(2, "Registered serializer handlers", ser_handlers.c);
+		php_info_print_table_row(2, "Registered serializer handlers", ser_handlers.s->val);
 		smart_str_free(&ser_handlers);
 	} else {
 		php_info_print_table_row(2, "Registered serializer handlers", "none");
@@ -2560,16 +2552,16 @@ static const zend_module_dep session_deps[] = { /* {{{ */
 
 static zend_bool early_find_sid_in(zval *dest, int where, php_session_rfc1867_progress *progress TSRMLS_DC) /* {{{ */
 {
-	zval **ppid;
+	zval *ppid;
 
-	if (!PG(http_globals)[where]) {
+	if (ZVAL_IS_UNDEF(&PG(http_globals)[where])) {
 		return 0;
 	}
 
-	if (zend_hash_find(Z_ARRVAL_P(PG(http_globals)[where]), PS(session_name), progress->sname_len+1, (void **)&ppid) == SUCCESS
-			&& Z_TYPE_PP(ppid) == IS_STRING) {
+	if ((ppid = zend_hash_str_find(Z_ARRVAL(PG(http_globals)[where]), PS(session_name), progress->sname_len))
+			&& Z_TYPE_P(ppid) == IS_STRING) {
 		zval_dtor(dest);
-		ZVAL_ZVAL(dest, *ppid, 1, 0);
+		ZVAL_ZVAL(dest, ppid, 1, 0);
 		return 1;
 	}
 
@@ -2595,18 +2587,18 @@ static void php_session_rfc1867_early_find_sid(php_session_rfc1867_progress *pro
 
 static zend_bool php_check_cancel_upload(php_session_rfc1867_progress *progress TSRMLS_DC) /* {{{ */
 {
-	zval **progress_ary, **cancel_upload;
+	zval *progress_ary, *cancel_upload;
 
-	if (zend_symtable_find(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1, (void**)&progress_ary) != SUCCESS) {
+	if ((progress_ary = zend_symtable_find(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s)) == NULL) {
 		return 0;
 	}
-	if (Z_TYPE_PP(progress_ary) != IS_ARRAY) {
+	if (Z_TYPE_P(progress_ary) != IS_ARRAY) {
 		return 0;
 	}
-	if (zend_hash_find(Z_ARRVAL_PP(progress_ary), "cancel_upload", sizeof("cancel_upload"), (void**)&cancel_upload) != SUCCESS) {
+	if ((cancel_upload = zend_hash_str_find(Z_ARRVAL_P(progress_ary), "cancel_upload", sizeof("cancel_upload") - 1)) == NULL) {
 		return 0;
 	}
-	return Z_TYPE_PP(cancel_upload) == IS_BOOL && Z_LVAL_PP(cancel_upload);
+	return Z_TYPE_P(cancel_upload) == IS_BOOL && Z_LVAL_P(cancel_upload);
 } /* }}} */
 
 static void php_session_rfc1867_update(php_session_rfc1867_progress *progress, int force_update TSRMLS_DC) /* {{{ */
@@ -2634,7 +2626,8 @@ static void php_session_rfc1867_update(php_session_rfc1867_progress *progress, i
 	PS(session_status) = php_session_active;
 	IF_SESSION_VARS() {
 		progress->cancel_upload |= php_check_cancel_upload(progress TSRMLS_CC);
-		ZEND_SET_SYMBOL_WITH_LENGTH(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1, progress->data, 2, 0);
+		if (Z_REFCOUNTED(progress->data)) Z_ADDREF(progress->data);
+		zend_hash_update(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s, &progress->data);
 	}
 	php_session_flush(TSRMLS_C);
 } /* }}} */
@@ -2644,7 +2637,7 @@ static void php_session_rfc1867_cleanup(php_session_rfc1867_progress *progress T
 	php_session_initialize(TSRMLS_C);
 	PS(session_status) = php_session_active;
 	IF_SESSION_VARS() {
-		zend_hash_del(Z_ARRVAL_P(PS(http_session_vars)), progress->key.c, progress->key.len+1);
+		zend_hash_del(Z_ARRVAL_P(Z_REFVAL(PS(http_session_vars))), progress->key.s);
 	}
 	php_session_flush(TSRMLS_C);
 } /* }}} */
@@ -2676,7 +2669,7 @@ static int php_session_rfc1867_callback(unsigned int event, void *event_data, vo
 			multipart_event_formdata *data = (multipart_event_formdata *) event_data;
 			size_t value_len;
 
-			if (Z_TYPE(progress->sid) && progress->key.c) {
+			if (Z_TYPE(progress->sid) && progress->key.s) {
 				break;
 			}
 
@@ -2692,11 +2685,10 @@ static int php_session_rfc1867_callback(unsigned int event, void *event_data, vo
 
 				if (name_len == progress->sname_len && memcmp(data->name, PS(session_name), name_len) == 0) {
 					zval_dtor(&progress->sid);
-					ZVAL_STRINGL(&progress->sid, (*data->value), value_len, 1);
-
-				} else if (name_len == PS(rfc1867_name).len && memcmp(data->name, PS(rfc1867_name).c, name_len) == 0) {
+					ZVAL_STRINGL(&progress->sid, (*data->value), value_len);
+				} else if (memcmp(data->name, PS(rfc1867_name), name_len + 1) == 0) {
 					smart_str_free(&progress->key);
-					smart_str_appendl(&progress->key, PS(rfc1867_prefix).c, PS(rfc1867_prefix).len);
+					smart_str_appends(&progress->key, PS(rfc1867_prefix));
 					smart_str_appendl(&progress->key, *data->value, value_len);
 					smart_str_0(&progress->key);
 
@@ -2711,12 +2703,12 @@ static int php_session_rfc1867_callback(unsigned int event, void *event_data, vo
 
 			/* Do nothing when $_POST["PHP_SESSION_UPLOAD_PROGRESS"] is not set 
 			 * or when we have no session id */
-			if (!Z_TYPE(progress->sid) || !progress->key.c) {
+			if (!Z_TYPE(progress->sid) || !progress->key.s) {
 				break;
 			}
 			
 			/* First FILE_START event, initializing data */
-			if (!progress->data) {
+			if (ZVAL_IS_UNDEF(&progress->data)) {
 
 				if (PS(rfc1867_freq) >= 0) {
 					progress->update_step = PS(rfc1867_freq);
@@ -2726,54 +2718,47 @@ static int php_session_rfc1867_callback(unsigned int event, void *event_data, vo
 				progress->next_update = 0;
 				progress->next_update_time = 0.0;
 
-				ALLOC_INIT_ZVAL(progress->data);
-				array_init(progress->data);
-
-				ALLOC_INIT_ZVAL(progress->post_bytes_processed);
-				ZVAL_LONG(progress->post_bytes_processed, data->post_bytes_processed);
+				array_init(&progress->data);
+				array_init(&progress->files);
 
-				ALLOC_INIT_ZVAL(progress->files);
-				array_init(progress->files);
+				add_assoc_long_ex(&progress->data, "start_time", sizeof("start_time") - 1, (long)sapi_get_request_time(TSRMLS_C));
+				add_assoc_long_ex(&progress->data, "content_length",  sizeof("content_length") - 1, progress->content_length);
+				add_assoc_long_ex(&progress->data, "bytes_processed", sizeof("bytes_processed") - 1, data->post_bytes_processed);
+				add_assoc_bool_ex(&progress->data, "done", sizeof("done") - 1, 0);
+				add_assoc_zval_ex(&progress->data, "files", sizeof("files") - 1, &progress->files);
 
-				add_assoc_long_ex(progress->data, "start_time",      sizeof("start_time"),      (long)sapi_get_request_time(TSRMLS_C));
-				add_assoc_long_ex(progress->data, "content_length",  sizeof("content_length"),  progress->content_length);
-				add_assoc_zval_ex(progress->data, "bytes_processed", sizeof("bytes_processed"), progress->post_bytes_processed);
-				add_assoc_bool_ex(progress->data, "done",            sizeof("done"),            0);
-				add_assoc_zval_ex(progress->data, "files",           sizeof("files"),           progress->files);
+				progress->post_bytes_processed = zend_hash_str_find(Z_ARRVAL(progress->data), "bytes_processed", sizeof("bytes_processed") - 1);
 
 				php_rinit_session(0 TSRMLS_CC);
-				PS(id) = estrndup(Z_STRVAL(progress->sid), Z_STRLEN(progress->sid));
+				PS(id) = STR_INIT(Z_STRVAL(progress->sid), Z_STRLEN(progress->sid), 0);
 				PS(apply_trans_sid) = progress->apply_trans_sid;
 				PS(send_cookie) = 0;
 			}
 
-			ALLOC_INIT_ZVAL(progress->current_file);
-			array_init(progress->current_file);
-
-			ALLOC_INIT_ZVAL(progress->current_file_bytes_processed);
-			ZVAL_LONG(progress->current_file_bytes_processed, 0);
+			array_init(&progress->current_file);
 
 			/* Each uploaded file has its own array. Trying to make it close to $_FILES entries. */
-			add_assoc_string_ex(progress->current_file, "field_name",    sizeof("field_name"),      data->name, 1);
-			add_assoc_string_ex(progress->current_file, "name",          sizeof("name"),            *data->filename, 1);
-			add_assoc_null_ex(progress->current_file, "tmp_name",        sizeof("tmp_name"));
-			add_assoc_long_ex(progress->current_file, "error",           sizeof("error"),           0);
+			add_assoc_string_ex(&progress->current_file, "field_name", sizeof("field_name") - 1, data->name);
+			add_assoc_string_ex(&progress->current_file, "name", sizeof("name") - 1, *data->filename);
+			add_assoc_null_ex(&progress->current_file, "tmp_name", sizeof("tmp_name") - 1);
+			add_assoc_long_ex(&progress->current_file, "error", sizeof("error") - 1, 0);
 
-			add_assoc_bool_ex(progress->current_file, "done",            sizeof("done"),            0);
-			add_assoc_long_ex(progress->current_file, "start_time",      sizeof("start_time"),      (long)time(NULL));
-			add_assoc_zval_ex(progress->current_file, "bytes_processed", sizeof("bytes_processed"), progress->current_file_bytes_processed);
+			add_assoc_bool_ex(&progress->current_file, "done", sizeof("done") - 1, 0);
+			add_assoc_long_ex(&progress->current_file, "start_time", sizeof("start_time") - 1, (long)time(NULL));
+			add_assoc_long_ex(&progress->current_file, "bytes_processed", sizeof("bytes_processed") - 1, 0);
 
-			add_next_index_zval(progress->files, progress->current_file);
+			add_next_index_zval(&progress->files, &progress->current_file);
 			
-			Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
+			progress->current_file_bytes_processed = zend_hash_str_find(Z_ARRVAL(progress->current_file), "bytes_processed", sizeof("bytes_processed") - 1);
 
+			Z_LVAL_P(progress->current_file_bytes_processed) =  data->post_bytes_processed;
 			php_session_rfc1867_update(progress, 0 TSRMLS_CC);
 		}
 		break;
 		case MULTIPART_EVENT_FILE_DATA: {
 			multipart_event_file_data *data = (multipart_event_file_data *) event_data;
 
-			if (!Z_TYPE(progress->sid) || !progress->key.c) {
+			if (!Z_TYPE(progress->sid) || !progress->key.s) {
 				break;
 			}
 			
@@ -2786,15 +2771,16 @@ static int php_session_rfc1867_callback(unsigned int event, void *event_data, vo
 		case MULTIPART_EVENT_FILE_END: {
 			multipart_event_file_end *data = (multipart_event_file_end *) event_data;
 
-			if (!Z_TYPE(progress->sid) || !progress->key.c) {
+			if (!Z_TYPE(progress->sid) || !progress->key.s) {
 				break;
 			}
 			
 			if (data->temp_filename) {
-				add_assoc_string_ex(progress->current_file, "tmp_name",  sizeof("tmp_name"), data->temp_filename, 1);
+				add_assoc_string_ex(&progress->current_file, "tmp_name",  sizeof("tmp_name") - 1, data->temp_filename);
 			}
-			add_assoc_long_ex(progress->current_file, "error", sizeof("error"), data->cancel_upload);
-			add_assoc_bool_ex(progress->current_file, "done",  sizeof("done"),  1);
+
+			add_assoc_long_ex(&progress->current_file, "error", sizeof("error") - 1, data->cancel_upload);
+			add_assoc_bool_ex(&progress->current_file, "done", sizeof("done") - 1,  1);
 
 			Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
 
@@ -2804,21 +2790,21 @@ static int php_session_rfc1867_callback(unsigned int event, void *event_data, vo
 		case MULTIPART_EVENT_END: {
 			multipart_event_end *data = (multipart_event_end *) event_data;
 
-			if (Z_TYPE(progress->sid) && progress->key.c) {
+			if (Z_TYPE(progress->sid) && progress->key.s) {
 				if (PS(rfc1867_cleanup)) {
 					php_session_rfc1867_cleanup(progress TSRMLS_CC);
 				} else {
-					add_assoc_bool_ex(progress->data, "done", sizeof("done"), 1);
+					add_assoc_bool_ex(&progress->data, "done", sizeof("done") - 1, 1);
 					Z_LVAL_P(progress->post_bytes_processed) = data->post_bytes_processed;
 					php_session_rfc1867_update(progress, 1 TSRMLS_CC);
 				}
 				php_rshutdown_session_globals(TSRMLS_C);
 			}
 
-			if (progress->data) {
+			if (!ZVAL_IS_UNDEF(&progress->data)) {
 				zval_ptr_dtor(&progress->data);
 			}
-			zval_dtor(&progress->sid);
+			zval_ptr_dtor(&progress->sid);
 			smart_str_free(&progress->key);
 			efree(progress);
 			progress = NULL;
diff --git a/ext/session/tests/006.phpt b/ext/session/tests/006.phpt
index dba6894c7e..c9a11d3337 100644
--- a/ext/session/tests/006.phpt
+++ b/ext/session/tests/006.phpt
@@ -42,6 +42,8 @@ session_start();
 
 echo "values after session:\n";
 var_dump($a,$b);
+
+session_destroy();
 ?>
 --EXPECTF--
 original values:
diff --git a/ext/session/tests/026.phpt b/ext/session/tests/026.phpt
index 44f0ae0ec0..f797286bf6 100644
--- a/ext/session/tests/026.phpt
+++ b/ext/session/tests/026.phpt
@@ -44,6 +44,7 @@ $a = $_SESSION['a'];
 $b = $_SESSION['b'];
 echo "values after session:\n";
 var_dump($a,$b);
+session_destroy();
 ?>
 --EXPECTF--
 original values:
diff --git a/ext/session/tests/031.phpt b/ext/session/tests/031.phpt
index e8deb3dac5..7486c4b866 100644
--- a/ext/session/tests/031.phpt
+++ b/ext/session/tests/031.phpt
@@ -2,6 +2,7 @@
 setting hash_function to sha512 and hash_bits_per_character > 4 should not crash
 --SKIPIF--
 <?php include('skipif.inc'); ?>
+<?php if (!extension_loaded('hash')) die('skip hash extension not available'); ?>
 --INI--
 session.use_cookies=0
 session.cache_limiter=
diff --git a/ext/session/tests/session_set_save_handler_class_005.phpt b/ext/session/tests/session_set_save_handler_class_005.phpt
index a996eb8d26..c74c81de1d 100644
--- a/ext/session/tests/session_set_save_handler_class_005.phpt
+++ b/ext/session/tests/session_set_save_handler_class_005.phpt
@@ -3,6 +3,7 @@ Test session_set_save_handler() : incomplete implementation
 --INI--
 session.save_handler=files
 session.name=PHPSESSID
+session.gc_probability=0
 --SKIPIF--
 <?php include('skipif.inc'); ?>
 --FILE--
diff --git a/ext/session/tests/session_set_save_handler_class_012.phpt b/ext/session/tests/session_set_save_handler_class_012.phpt
index 706ef793ef..3899d28816 100644
--- a/ext/session/tests/session_set_save_handler_class_012.phpt
+++ b/ext/session/tests/session_set_save_handler_class_012.phpt
@@ -3,6 +3,7 @@ Test session_set_save_handler() : incorrect arguments for existing handler open
 --INI--
 session.save_handler=files
 session.name=PHPSESSID
+session.gc_probability=0
 --SKIPIF--
 <?php include('skipif.inc'); ?>
 --FILE--
diff --git a/ext/simplexml/php_simplexml.h b/ext/simplexml/php_simplexml.h
index 7314d8c825..b908e4c722 100644
--- a/ext/simplexml/php_simplexml.h
+++ b/ext/simplexml/php_simplexml.h
@@ -55,7 +55,6 @@ typedef enum {
 } SXE_ITER;
 
 typedef struct {
-	zend_object zo;
 	php_libxml_node_ptr *node;
 	php_libxml_ref_obj *document;
 	HashTable *properties;
@@ -65,10 +64,11 @@ typedef struct {
 		xmlChar               *nsprefix;
 		int                   isprefix;
 		SXE_ITER              type;
-		zval                  *data;
+		zval                  data;
 	} iter;
-	zval *tmp;
+	zval tmp;
 	zend_function *fptr_count;
+	zend_object zo;
 } php_sxe_object;
 
 #ifdef ZTS
diff --git a/ext/simplexml/php_simplexml_exports.h b/ext/simplexml/php_simplexml_exports.h
index 2c858566b9..6cdda1be4a 100644
--- a/ext/simplexml/php_simplexml_exports.h
+++ b/ext/simplexml/php_simplexml_exports.h
@@ -39,16 +39,15 @@
 	} \
 }
 
-PHP_SXE_API zend_object_value sxe_object_new(zend_class_entry *ce TSRMLS_DC);
-/* {{{ php_sxe_fetch_object()
- */
-static inline php_sxe_object *
-php_sxe_fetch_object(zval *object TSRMLS_DC)
-{
-	return (php_sxe_object *) zend_object_store_get_object(object TSRMLS_CC);
+PHP_SXE_API zend_object *sxe_object_new(zend_class_entry *ce TSRMLS_DC);
+
+static inline php_sxe_object *php_sxe_fetch_object(zend_object *obj) /* {{{ */ {
+	return (php_sxe_object *)((char*)(obj) - XtOffsetOf(php_sxe_object, zo));
 }
 /* }}} */
 
+#define Z_SXEOBJ_P(zv) php_sxe_fetch_object(Z_OBJ_P((zv)))
+
 typedef struct {
 	zend_object_iterator  intern;
 	php_sxe_object        *sxe;
diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c
index f84e1e014d..31beb1a9f0 100644
--- a/ext/simplexml/simplexml.c
+++ b/ext/simplexml/simplexml.c
@@ -52,13 +52,12 @@ PHP_SXE_API zend_class_entry *sxe_get_element_class_entry() /* {{{ */
 #define SXE_METHOD(func) PHP_METHOD(simplexml_element, func)
 
 static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC);
-static zend_object_value php_sxe_register_object(php_sxe_object * TSRMLS_DC);
 static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data TSRMLS_DC);
 static xmlNodePtr php_sxe_iterator_fetch(php_sxe_object *sxe, xmlNodePtr node, int use_data TSRMLS_DC);
-static zval *sxe_get_value(zval *z TSRMLS_DC);
+static zval *sxe_get_value(zval *z, zval *rv TSRMLS_DC);
 static void php_sxe_iterator_dtor(zend_object_iterator *iter TSRMLS_DC);
 static int php_sxe_iterator_valid(zend_object_iterator *iter TSRMLS_DC);
-static void php_sxe_iterator_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC);
+static zval *php_sxe_iterator_current_data(zend_object_iterator *iter TSRMLS_DC);
 static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC);
 static void php_sxe_iterator_move_forward(zend_object_iterator *iter TSRMLS_DC);
 static void php_sxe_iterator_rewind(zend_object_iterator *iter TSRMLS_DC);
@@ -83,8 +82,7 @@ static void _node_as_zval(php_sxe_object *sxe, xmlNodePtr node, zval *value, SXE
 
 	php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL TSRMLS_CC);
 
-	value->type = IS_OBJECT;
-	value->value.obj = php_sxe_register_object(subnode TSRMLS_CC);
+	ZVAL_OBJ(value, &subnode->zo);
 }
 /* }}} */
 
@@ -115,8 +113,8 @@ static xmlNodePtr php_sxe_get_first_node(php_sxe_object *sxe, xmlNodePtr node TS
 
 	if (sxe && sxe->iter.type != SXE_ITER_NONE) {
 		php_sxe_reset_iterator(sxe, 1 TSRMLS_CC);
-		if (sxe->iter.data) {
-			intern = (php_sxe_object *)zend_object_store_get_object(sxe->iter.data TSRMLS_CC);
+		if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+			intern = Z_SXEOBJ_P(&sxe->iter.data);
 			GET_NODE(intern, retnode)
 		}
 		return retnode;
@@ -245,9 +243,8 @@ next_iter:
 
 /* {{{ sxe_prop_dim_read()
  */
-static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type TSRMLS_DC)
+static zval *sxe_prop_dim_read(zval *object, zval *member, zend_bool elements, zend_bool attribs, int type, zval *rv TSRMLS_DC)
 {
-	zval           *return_value;
 	php_sxe_object *sxe;
 	char           *name;
 	xmlNodePtr      node;
@@ -256,7 +253,7 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
 	int             nodendx = 0;
 	int             test = 0;
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 
 	if (!member || Z_TYPE_P(member) == IS_LONG) {
 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
@@ -298,8 +295,7 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
 		}
 	}
 
-	MAKE_STD_ZVAL(return_value);
-	ZVAL_NULL(return_value);
+	ZVAL_UNDEF(rv);
 
 	if (node) {
 		if (attribs) {
@@ -308,7 +304,7 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
 					while (attr && nodendx <= Z_LVAL_P(member)) {
 						if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
 							if (nodendx == Z_LVAL_P(member)) {
-								_node_as_zval(sxe, (xmlNodePtr) attr, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+								_node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 								break;
 							}
 							nodendx++;
@@ -318,7 +314,7 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
 				} else {
 					while (attr) {
 						if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && !xmlStrcmp(attr->name, (xmlChar *)name) && match_ns(sxe, (xmlNodePtr) attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
-							_node_as_zval(sxe, (xmlNodePtr) attr, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+							_node_as_zval(sxe, (xmlNodePtr) attr, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 							break;
 						}
 						attr = attr->next;
@@ -348,13 +344,13 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
 					node = NULL;
 				}
 				if (node) {
-					_node_as_zval(sxe, node, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+					_node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 				} else if (type == BP_VAR_W || type == BP_VAR_RW) {
 					if (member && cnt < Z_LVAL_P(member)) {
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element %s number %ld when only %ld such elements exist", mynode->name, Z_LVAL_P(member), cnt);
 					}
 					node = xmlNewTextChild(mynode->parent, mynode->ns, mynode->name, NULL);
-					_node_as_zval(sxe, node, return_value, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+					_node_as_zval(sxe, node, rv, SXE_ITER_NONE, NULL, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 				}
 			} else {
 #if SXE_ELEMENT_BY_NAME
@@ -363,43 +359,40 @@ static zval * sxe_prop_dim_read(zval *object, zval *member, zend_bool elements,
 				GET_NODE(sxe, node);
 				node = sxe_get_element_by_name(sxe, node, &name, &newtype TSRMLS_CC);
 				if (node) {
-					_node_as_zval(sxe, node, return_value, newtype, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+					_node_as_zval(sxe, node, rv, newtype, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 				}
 #else
-				_node_as_zval(sxe, node, return_value, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+				_node_as_zval(sxe, node, rv, SXE_ITER_ELEMENT, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 #endif
 			}
 		}
 	}
 
-	Z_SET_REFCOUNT_P(return_value, 0);
-	Z_UNSET_ISREF_P(return_value);
-
 	if (member == &tmp_zv) {
 		zval_dtor(&tmp_zv);
 	}
-	if (Z_TYPE_P(return_value) == IS_NULL) {
-		FREE_ZVAL(return_value);
-		return_value = &EG(uninitialized_zval);
+
+	if (ZVAL_IS_UNDEF(rv)) {
+		ZVAL_COPY_VALUE(rv, &EG(uninitialized_zval));
 	}
 
-	return return_value;
+	return rv;
 }
 /* }}} */
 
 /* {{{ sxe_property_read()
  */
-static zval * sxe_property_read(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC)
+static zval *sxe_property_read(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC)
 {
-	return sxe_prop_dim_read(object, member, 1, 0, type TSRMLS_CC);
+	return sxe_prop_dim_read(object, member, 1, 0, type, rv TSRMLS_CC);
 }
 /* }}} */
 
 /* {{{ sxe_dimension_read()
  */
-static zval * sxe_dimension_read(zval *object, zval *offset, int type TSRMLS_DC)
+static zval *sxe_dimension_read(zval *object, zval *offset, int type, zval *rv TSRMLS_DC)
 {
-	return sxe_prop_dim_read(object, offset, 0, 1, type TSRMLS_CC);
+	return sxe_prop_dim_read(object, offset, 0, 1, type, rv TSRMLS_CC);
 }
 /* }}} */
 
@@ -464,9 +457,9 @@ static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool
 	int				new_value = 0;
 	long            cnt = 0;
 	int				retval = SUCCESS;
-	zval            tmp_zv, trim_zv, value_copy;
+	zval            tmp_zv, trim_zv, zval_copy;
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 
 	if (!member || Z_TYPE_P(member) == IS_LONG) {
 		if (sxe->iter.type != SXE_ITER_ATTRLIST) {
@@ -535,19 +528,15 @@ static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool
 			case IS_BOOL:
 			case IS_DOUBLE:
 			case IS_NULL:
-				if (Z_REFCOUNT_P(value) > 1) {
-					value_copy = *value;
-					zval_copy_ctor(&value_copy);
-					value = &value_copy;
-				}
 				convert_to_string(value);
 				break;
 			case IS_STRING:
 				break;
 			case IS_OBJECT:
 				if (Z_OBJCE_P(value) == sxe_class_entry) {
-					value = sxe_get_value(value TSRMLS_CC);
-					INIT_PZVAL(value);
+					//???
+					value = sxe_get_value(value, &zval_copy TSRMLS_CC);
+					//INIT_PZVAL(value);
 					new_value = 1;
 					break;
 				}
@@ -668,11 +657,8 @@ next_iter:
 	if (pnewnode) {
 		*pnewnode = newnode;
 	}
-	if (value && value == &value_copy) {
-		zval_dtor(value);
-	}
 	if (new_value) {
-		zval_ptr_dtor(&value);
+		zval_ptr_dtor(value);
 	}
 	return retval;
 }
@@ -680,7 +666,7 @@ next_iter:
 
 /* {{{ sxe_property_write()
  */
-static void sxe_property_write(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC)
+static void sxe_property_write(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC)
 {
 	sxe_prop_dim_write(object, member, value, 1, 0, NULL TSRMLS_CC);
 }
@@ -694,15 +680,15 @@ static void sxe_dimension_write(zval *object, zval *offset, zval *value TSRMLS_D
 }
 /* }}} */
 
-static zval** sxe_property_get_adr(zval *object, zval *member, int fetch_type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *sxe_property_get_adr(zval *object, zval *member, int fetch_type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	php_sxe_object *sxe;
 	xmlNodePtr      node;
-	zval           *return_value;
+	zval            ret;
 	char           *name;
 	SXE_ITER        type;
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 
 	GET_NODE(sxe, node);
 	convert_to_string(member);
@@ -717,15 +703,15 @@ static zval** sxe_property_get_adr(zval *object, zval *member, int fetch_type, c
 	type = SXE_ITER_NONE;
 	name = NULL;
 
-	MAKE_STD_ZVAL(return_value);
-	_node_as_zval(sxe, node, return_value, type, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
+	_node_as_zval(sxe, node, &ret, type, name, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 
-	sxe = php_sxe_fetch_object(return_value TSRMLS_CC);
-	if (sxe->tmp) {
+	sxe = Z_SXEOBJ_P(&ret);
+	if (!ZVAL_IS_UNDEF(&sxe->tmp)) {
 		zval_ptr_dtor(&sxe->tmp);
 	}
-	sxe->tmp = return_value;
-	Z_SET_ISREF_P(return_value);
+
+	ZVAL_COPY_VALUE(&sxe->tmp, &ret);
+	//???? Z_SET_ISREF_P(return_value);
 
 	return &sxe->tmp;
 }
@@ -749,7 +735,7 @@ static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend
 		convert_to_string(member);
 	}
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 
 	GET_NODE(sxe, node);
 
@@ -827,9 +813,9 @@ static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend
 			}
 			if (node) {
 				exists = 1;
-                                if (check_empty == 1 &&
+				if (check_empty == 1 &&
 					(!node->children || (node->children->type == XML_TEXT_NODE && !node->children->next &&
-						(!node->children->content || !node->children->content[0] || !xmlStrcmp(node->children->content, "0")))) ) {
+					 (!node->children->content || !node->children->content[0] || !xmlStrcmp(node->children->content, "0")))) ) {
 					exists = 0;
 				}
 			}
@@ -846,7 +832,7 @@ static int sxe_prop_dim_exists(zval *object, zval *member, int check_empty, zend
 
 /* {{{ sxe_property_exists()
  */
-static int sxe_property_exists(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC)
+static int sxe_property_exists(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC)
 {
 	return sxe_prop_dim_exists(object, member, check_empty, 1, 0 TSRMLS_CC);
 }
@@ -879,7 +865,7 @@ static void sxe_prop_dim_delete(zval *object, zval *member, zend_bool elements,
 		convert_to_string(member);
 	}
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 
 	GET_NODE(sxe, node);
 
@@ -971,7 +957,7 @@ next_iter:
 
 /* {{{ sxe_property_delete()
  */
-static void sxe_property_delete(zval *object, zval *member, const zend_literal *key TSRMLS_DC)
+static void sxe_property_delete(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC)
 {
 	sxe_prop_dim_delete(object, member, 1, 0 TSRMLS_CC);
 }
@@ -985,13 +971,13 @@ static void sxe_dimension_delete(zval *object, zval *offset TSRMLS_DC)
 }
 /* }}} */
 
-static inline char * sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine) /* {{{ */
+static inline zend_string *sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, int inLine TSRMLS_DC) /* {{{ */
 {
 	xmlChar *tmp = xmlNodeListGetString(doc, list, inLine);
-	char    *res;
+	zend_string *res;
 	
 	if (tmp) {
-		res = estrdup((char*)tmp);
+		res = STR_INIT((char*)tmp, strlen((char *)tmp), 0);
 		xmlFree(tmp);
 	} else {
 		res = STR_EMPTY_ALLOC();
@@ -1003,17 +989,15 @@ static inline char * sxe_xmlNodeListGetString(xmlDocPtr doc, xmlNodePtr list, in
 
 /* {{{ _get_base_node_value()
  */
-static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval **value, xmlChar *nsprefix, int isprefix TSRMLS_DC)
+static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval *value, xmlChar *nsprefix, int isprefix TSRMLS_DC)
 {
 	php_sxe_object *subnode;
 	xmlChar        *contents;
 
-	MAKE_STD_ZVAL(*value);
-
 	if (node->children && node->children->type == XML_TEXT_NODE && !xmlIsBlankNode(node->children)) {
 		contents = xmlNodeListGetString(node->doc, node->children, 1);
 		if (contents) {
-			ZVAL_STRING(*value, (char *)contents, 1);
+			ZVAL_STRING(value, (char *)contents);
 			xmlFree(contents);
 		}
 	} else {
@@ -1026,8 +1010,7 @@ static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval
 		}
 		php_libxml_increment_node_ptr((php_libxml_node_object *)subnode, node, NULL TSRMLS_CC);
 
-		(*value)->type = IS_OBJECT;
-		(*value)->value.obj = php_sxe_register_object(subnode TSRMLS_CC);
+		ZVAL_OBJ(value, &subnode->zo);
 		/*zval_add_ref(value);*/
 	}
 }
@@ -1035,33 +1018,33 @@ static void _get_base_node_value(php_sxe_object *sxe_ref, xmlNodePtr node, zval
 
 static void sxe_properties_add(HashTable *rv, char *name, int namelen, zval *value TSRMLS_DC) /* {{{ */
 {
-	zval  **data_ptr;
-	zval  *newptr;
-	ulong h = zend_hash_func(name, namelen);
+	zval  *data_ptr;
+	zval  newptr;
 
-	if (zend_hash_quick_find(rv, name, namelen, h, (void **) &data_ptr) == SUCCESS) {
-		if (Z_TYPE_PP(data_ptr) == IS_ARRAY) {
-			zend_hash_next_index_insert(Z_ARRVAL_PP(data_ptr), &value, sizeof(zval *), NULL);
+	if ((data_ptr = zend_hash_str_find(rv, name, namelen)) != NULL) {
+		if (Z_TYPE_P(data_ptr) == IS_ARRAY) {
+			zend_hash_next_index_insert(Z_ARRVAL_P(data_ptr), value);
 		} else {
-			MAKE_STD_ZVAL(newptr);
-			array_init(newptr);
+			array_init(&newptr);
 
-			zval_add_ref(data_ptr);
-			zend_hash_next_index_insert(Z_ARRVAL_P(newptr), data_ptr, sizeof(zval *), NULL);
-			zend_hash_next_index_insert(Z_ARRVAL_P(newptr), &value, sizeof(zval *), NULL);
+			if (Z_REFCOUNTED_P(data_ptr)) {
+				Z_ADDREF_P(data_ptr);
+			}
+			zend_hash_next_index_insert(Z_ARRVAL(newptr), data_ptr);
+			zend_hash_next_index_insert(Z_ARRVAL(newptr), value);
 
-			zend_hash_quick_update(rv, name, namelen, h, &newptr, sizeof(zval *), NULL);
+			zend_hash_str_update(rv, name, namelen, &newptr);
 		}
 	} else {
-		zend_hash_quick_update(rv, name, namelen, h, &value, sizeof(zval *), NULL);
+		zend_hash_str_update(rv, name, namelen, value);
 	}
 }
 /* }}} */
 
-static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{{ */
+static HashTable *sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{{ */
 {
-	zval            *value;
-	zval            *zattr;
+	zval            value;
+	zval            zattr;
 	HashTable       *rv;
 	php_sxe_object  *sxe;
 	char            *name;
@@ -1069,18 +1052,17 @@ static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{
 	xmlAttrPtr       attr;
 	int              namelen;
 	int              test;
-	char 		 use_iter;
-	zval            *iter_data = NULL;
+	char 		 	 use_iter;
+	zval             iter_data;
 
 	use_iter = 0;
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 
 	if (is_debug) {
 		ALLOC_HASHTABLE(rv);
 		zend_hash_init(rv, 0, NULL, ZVAL_PTR_DTOR, 0);
-	}
-	else if (sxe->properties) {
+	} else if (sxe->properties) {
 		zend_hash_clean(sxe->properties);
 		rv = sxe->properties;
 	} else {
@@ -1099,19 +1081,17 @@ static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{
 		}
 		if (!node || node->type != XML_ENTITY_DECL) {
 			attr = node ? (xmlAttrPtr)node->properties : NULL;
-			zattr = NULL;
+			ZVAL_UNDEF(&zattr);
 			test = sxe->iter.name && sxe->iter.type == SXE_ITER_ATTRLIST;
 			while (attr) {
 				if ((!test || !xmlStrcmp(attr->name, sxe->iter.name)) && match_ns(sxe, (xmlNodePtr)attr, sxe->iter.nsprefix, sxe->iter.isprefix)) {
-					MAKE_STD_ZVAL(value);
-					ZVAL_STRING(value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1), 0);
-					namelen = xmlStrlen(attr->name) + 1;
-					if (!zattr) {
-						MAKE_STD_ZVAL(zattr);
-						array_init(zattr);
-						sxe_properties_add(rv, "@attributes", sizeof("@attributes"), zattr TSRMLS_CC);
+					ZVAL_STR(&value, sxe_xmlNodeListGetString((xmlDocPtr) sxe->document->ptr, attr->children, 1 TSRMLS_CC));
+					namelen = xmlStrlen(attr->name);
+					if (ZVAL_IS_UNDEF(&zattr)) {
+						array_init(&zattr);
+						sxe_properties_add(rv, "@attributes", sizeof("@attributes") - 1, &zattr TSRMLS_CC);
 					}
-					add_assoc_zval_ex(zattr, (char*)attr->name, namelen, value);
+					add_assoc_zval_ex(&zattr, (char*)attr->name, namelen, &value);
 				}
 				attr = attr->next;
 			}
@@ -1123,17 +1103,16 @@ static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{
 
 	if (node && sxe->iter.type != SXE_ITER_ATTRLIST) {
 		if (node->type == XML_ATTRIBUTE_NODE) {
-			MAKE_STD_ZVAL(value);
-			ZVAL_STRING(value, sxe_xmlNodeListGetString(node->doc, node->children, 1), 0);
-			zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
+			ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node->children, 1 TSRMLS_CC));
+			zend_hash_next_index_insert(rv, &value);
 			node = NULL;
 		} else if (sxe->iter.type != SXE_ITER_CHILD) {
 
 			if ( !node->children || !node->parent || !node->next || node->children->next || node->children->children || node->parent->children == node->parent->last ) {
 				node = node->children;
 			} else {
-				iter_data = sxe->iter.data;
-				sxe->iter.data = NULL;
+				ZVAL_COPY_VALUE(&iter_data, &sxe->iter.data);
+				ZVAL_UNDEF(&sxe->iter.data);
 
 				node = php_sxe_reset_iterator(sxe, 0 TSRMLS_CC);
 
@@ -1149,9 +1128,8 @@ static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{
 					const xmlChar *cur = node->content;
 					
 					if (*cur != 0) {
-						MAKE_STD_ZVAL(value);
-						ZVAL_STRING(value, sxe_xmlNodeListGetString(node->doc, node, 1), 0);
-						zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
+						ZVAL_STR(&value, sxe_xmlNodeListGetString(node->doc, node, 1 TSRMLS_CC));
+						zend_hash_next_index_insert(rv, &value);
 					}
 					goto next_iter;
 				}
@@ -1165,18 +1143,18 @@ static HashTable * sxe_get_prop_hash(zval *object, int is_debug TSRMLS_DC) /* {{
 			if (!name) {
 				goto next_iter;
 			} else {
-				namelen = xmlStrlen(node->name) + 1;
+				namelen = xmlStrlen(node->name);
 			}
 
 			_get_base_node_value(sxe, node, &value, sxe->iter.nsprefix, sxe->iter.isprefix TSRMLS_CC);
 
 			if ( use_iter ) {
-				zend_hash_next_index_insert(rv, &value, sizeof(zval *), NULL);
+				zend_hash_next_index_insert(rv, &value);
 			} else {
-				sxe_properties_add(rv, name, namelen, value TSRMLS_CC);
+				sxe_properties_add(rv, name, namelen, &value TSRMLS_CC);
 			}
 next_iter:
-			if ( use_iter ) {
+			if (use_iter) {
 				node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
 			} else {
 				node = node->next;
@@ -1184,20 +1162,20 @@ next_iter:
 		}
 	}
 
-	if ( use_iter ) {
-		if (sxe->iter.data) {
+	if (use_iter) {
+		if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
 			zval_ptr_dtor(&sxe->iter.data);
 		}
-		sxe->iter.data = iter_data;
+		ZVAL_COPY_VALUE(&sxe->iter.data, &iter_data);
 	}
 
 	return rv;
 }
 /* }}} */
 
-static HashTable * sxe_get_gc(zval *object, zval ***table, int *n TSRMLS_DC) /* {{{ */ {
-	php_sxe_object  *sxe;
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+static HashTable *sxe_get_gc(zval *object, zval **table, int *n TSRMLS_DC) /* {{{ */ {
+	php_sxe_object *sxe;
+	sxe = Z_SXEOBJ_P(object);
 	
 	*table = NULL;
 	*n = 0;
@@ -1205,7 +1183,7 @@ static HashTable * sxe_get_gc(zval *object, zval ***table, int *n TSRMLS_DC) /*
 }
 /* }}} */
 
-static HashTable * sxe_get_properties(zval *object TSRMLS_DC) /* {{{ */
+static HashTable *sxe_get_properties(zval *object TSRMLS_DC) /* {{{ */
 {
 	return sxe_get_prop_hash(object, 0 TSRMLS_CC);
 }
@@ -1223,8 +1201,8 @@ static int sxe_objects_compare(zval *object1, zval *object2 TSRMLS_DC) /* {{{ */
 	php_sxe_object *sxe1;
 	php_sxe_object *sxe2;
 
-	sxe1 = php_sxe_fetch_object(object1 TSRMLS_CC);
-	sxe2 = php_sxe_fetch_object(object2 TSRMLS_CC);
+	sxe1 = Z_SXEOBJ_P(object1);
+	sxe2 = Z_SXEOBJ_P(object2);
 
 	if (sxe1->node == NULL) {
 		if (sxe2->node) {
@@ -1244,7 +1222,7 @@ static int sxe_objects_compare(zval *object1, zval *object2 TSRMLS_DC) /* {{{ */
 SXE_METHOD(xpath)
 {
 	php_sxe_object    *sxe;
-	zval              *value;
+	zval               value;
 	char              *query;
 	int                query_len;
 	int                i;
@@ -1258,7 +1236,7 @@ SXE_METHOD(xpath)
 		return;
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 
 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
 		return; /* attributes don't have attributes */
@@ -1304,21 +1282,20 @@ SXE_METHOD(xpath)
 		for (i = 0; i < result->nodeNr; ++i) {
 			nodeptr = result->nodeTab[i];
 			if (nodeptr->type == XML_TEXT_NODE || nodeptr->type == XML_ELEMENT_NODE || nodeptr->type == XML_ATTRIBUTE_NODE) {
-				MAKE_STD_ZVAL(value);
 				/**
 				 * Detect the case where the last selector is text(), simplexml
 				 * always accesses the text() child by default, therefore we assign
 				 * to the parent node.
 				 */
 				if (nodeptr->type == XML_TEXT_NODE) {
-					_node_as_zval(sxe, nodeptr->parent, value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
+					_node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
 				} else if (nodeptr->type == XML_ATTRIBUTE_NODE) {
-					_node_as_zval(sxe, nodeptr->parent, value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0 TSRMLS_CC);
+					_node_as_zval(sxe, nodeptr->parent, &value, SXE_ITER_ATTRLIST, (char*)nodeptr->name, nodeptr->ns ? (xmlChar *)nodeptr->ns->href : NULL, 0 TSRMLS_CC);
 				} else {
-					_node_as_zval(sxe, nodeptr, value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
+					_node_as_zval(sxe, nodeptr, &value, SXE_ITER_NONE, NULL, NULL, 0 TSRMLS_CC);
 				}
 
-				add_next_index_zval(return_value, value);
+				add_next_index_zval(return_value, &value);
 			}
 		}
 	}
@@ -1339,7 +1316,7 @@ SXE_METHOD(registerXPathNamespace)
 		return;
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	if (!sxe->xpath) {
 		sxe->xpath = xmlXPathNewContext((xmlDocPtr) sxe->document->ptr);
 	}
@@ -1373,7 +1350,7 @@ SXE_METHOD(asXML)
 			RETURN_FALSE;
 		}
 
-		sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+		sxe = Z_SXEOBJ_P(getThis());
 		GET_NODE(sxe, node);
 		node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
 
@@ -1402,14 +1379,14 @@ SXE_METHOD(asXML)
 		}
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	GET_NODE(sxe, node);
 	node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
 
 	if (node) {
 		if (node->parent && (XML_DOCUMENT_NODE == node->parent->type)) {
 			xmlDocDumpMemoryEnc((xmlDocPtr) sxe->document->ptr, &strval, &strval_len, ((xmlDocPtr) sxe->document->ptr)->encoding);
-			RETVAL_STRINGL((char *)strval, strval_len, 1);
+			RETVAL_STRINGL((char *)strval, strval_len);
 			xmlFree(strval);
 		} else {
 			/* Should we be passing encoding information instead of NULL? */
@@ -1422,9 +1399,9 @@ SXE_METHOD(asXML)
 			xmlNodeDumpOutput(outbuf, (xmlDocPtr) sxe->document->ptr, node, 0, 0, ((xmlDocPtr) sxe->document->ptr)->encoding);
 			xmlOutputBufferFlush(outbuf);
 #ifdef LIBXML2_NEW_BUFFER
-			RETVAL_STRINGL((char *)xmlOutputBufferGetContent(outbuf), xmlOutputBufferGetSize(outbuf), 1);
+			RETVAL_STRINGL((char *)xmlOutputBufferGetContent(outbuf), xmlOutputBufferGetSize(outbuf));
 #else
-			RETVAL_STRINGL((char *)outbuf->buffer->content, outbuf->buffer->use, 1);
+			RETVAL_STRINGL((char *)outbuf->buffer->content, outbuf->buffer->use);
 #endif
 			xmlOutputBufferClose(outbuf);
 		}
@@ -1439,8 +1416,8 @@ SXE_METHOD(asXML)
 static inline void sxe_add_namespace_name(zval *return_value, xmlNsPtr ns) /* {{{ */
 {
 	char *prefix = SXE_NS_PREFIX(ns);
-	if (zend_hash_exists(Z_ARRVAL_P(return_value), prefix, strlen(prefix) + 1) == 0) {
-		add_assoc_string(return_value, prefix, (char*)ns->href, 1);
+	if (zend_hash_str_exists(Z_ARRVAL_P(return_value), prefix, strlen(prefix)) == 0) {
+		add_assoc_string(return_value, prefix, (char*)ns->href);
 	}
 }
 /* }}} */
@@ -1486,7 +1463,7 @@ SXE_METHOD(getNamespaces)
 
 	array_init(return_value);
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	GET_NODE(sxe, node);
 	node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
 
@@ -1535,7 +1512,7 @@ SXE_METHOD(getDocNamespaces)
 
 	array_init(return_value);
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	if(from_root){
 		node = xmlDocGetRootElement((xmlDocPtr)sxe->document->ptr);
 	}else{
@@ -1560,7 +1537,7 @@ SXE_METHOD(children)
 		return;
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 
 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
 		return; /* attributes don't have attributes */
@@ -1582,13 +1559,13 @@ SXE_METHOD(getName)
 	xmlNodePtr      node;
 	int             namelen;
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 
 	GET_NODE(sxe, node);
 	node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
 	if (node) {
 		namelen = xmlStrlen(node->name);
-		RETURN_STRINGL((char*)node->name, namelen, 1);
+		RETURN_STRINGL((char*)node->name, namelen);
 	} else {
 		RETURN_EMPTY_STRING();
 	}
@@ -1609,7 +1586,7 @@ SXE_METHOD(attributes)
 		return;
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	GET_NODE(sxe, node);
 
 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
@@ -1643,7 +1620,7 @@ SXE_METHOD(addChild)
 		return;
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	GET_NODE(sxe, node);
 
 	if (sxe->iter.type == SXE_ITER_ATTRLIST) {
@@ -1709,7 +1686,7 @@ SXE_METHOD(addAttribute)
 		return;
 	}
 
-	sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(getThis());
 	GET_NODE(sxe, node);
 
 	node = php_sxe_get_first_node(sxe, node TSRMLS_CC);
@@ -1766,12 +1743,12 @@ SXE_METHOD(addAttribute)
 static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
 {
 	if (contents) {
-		ZVAL_STRINGL(object, contents, strlen(contents), 1);
+		ZVAL_STRINGL(object, contents, strlen(contents));
 	} else {
 		ZVAL_NULL(object);
 	}
-	Z_SET_REFCOUNT_P(object, 1);
-	Z_UNSET_ISREF_P(object);
+	//???? Z_SET_REFCOUNT_P(object, 1);
+	//Z_UNSET_ISREF_P(object);
 
 	switch (type) {
 		case IS_STRING:
@@ -1798,17 +1775,16 @@ static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
 static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 {
 	php_sxe_object *sxe;
-	xmlChar           *contents = NULL;
+	xmlChar        *contents = NULL;
 	xmlNodePtr	    node;
 	int rv;
 	HashTable      *prop_hash;
 
-	sxe = php_sxe_fetch_object(readobj TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(readobj);
 
 	if (type == IS_BOOL) {
 		node = php_sxe_get_first_node(sxe, NULL TSRMLS_CC);
 		prop_hash = sxe_get_prop_hash(readobj, 1 TSRMLS_CC);
-		INIT_PZVAL(writeobj);
 		ZVAL_BOOL(writeobj, node != NULL || zend_hash_num_elements(prop_hash) > 0);
 		zend_hash_destroy(prop_hash);
 		efree(prop_hash);
@@ -1835,8 +1811,7 @@ static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 	}
 
 	if (readobj == writeobj) {
-		INIT_PZVAL(writeobj);
-		zval_dtor(readobj);
+		zval_ptr_dtor(readobj);
 	}
 
 	rv = cast_object(writeobj, type, (char *)contents TSRMLS_CC);
@@ -1844,6 +1819,7 @@ static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 	if (contents) {
 		xmlFree(contents);
 	}
+
 	return rv;
 }
 /* }}} */
@@ -1852,12 +1828,10 @@ static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
    Returns the string content */
 SXE_METHOD(__toString)
 {
-	zval           *result;
-
-	ALLOC_INIT_ZVAL(result);
+	zval           result;
 
-	if (sxe_object_cast(getThis(), result, IS_STRING TSRMLS_CC) == SUCCESS) {
-		RETURN_ZVAL(result, 1, 1);
+	if (sxe_object_cast(getThis(), &result, IS_STRING TSRMLS_CC) == SUCCESS) {
+		RETURN_ZVAL(&result, 0, 0);
 	} else {
 		zval_ptr_dtor(&result);
 		RETURN_EMPTY_STRING();
@@ -1867,13 +1841,13 @@ SXE_METHOD(__toString)
 
 static int php_sxe_count_elements_helper(php_sxe_object *sxe, long *count TSRMLS_DC) /* {{{ */
 {
-	xmlNodePtr       node;
-	zval            *data;
+	xmlNodePtr      node;
+	zval            data;
 
 	*count = 0;
 
-	data = sxe->iter.data;
-	sxe->iter.data = NULL;
+	ZVAL_COPY_VALUE(&data, &sxe->iter.data);
+	ZVAL_UNDEF(&sxe->iter.data);
 
 	node = php_sxe_reset_iterator(sxe, 0 TSRMLS_CC);
 
@@ -1883,10 +1857,10 @@ static int php_sxe_count_elements_helper(php_sxe_object *sxe, long *count TSRMLS
 		node = php_sxe_iterator_fetch(sxe, node->next, 0 TSRMLS_CC);
 	}
 
-	if (sxe->iter.data) {
+	if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
 		zval_ptr_dtor(&sxe->iter.data);
 	}
-	sxe->iter.data = data;
+	ZVAL_COPY_VALUE(&sxe->iter.data, &data);
 
 	return SUCCESS;
 }
@@ -1895,18 +1869,17 @@ static int php_sxe_count_elements_helper(php_sxe_object *sxe, long *count TSRMLS
 static int sxe_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
 {
 	php_sxe_object  *intern;
-	intern = php_sxe_fetch_object(object TSRMLS_CC);
+	intern = Z_SXEOBJ_P(object);
 	if (intern->fptr_count) {
-		zval *rv;
-		zend_call_method_with_0_params(&object, intern->zo.ce, &intern->fptr_count, "count", &rv);
-		if (rv) {
-			if (intern->tmp) {
+		zval rv;
+		zend_call_method_with_0_params(object, intern->zo.ce, &intern->fptr_count, "count", &rv);
+		if (!ZVAL_IS_UNDEF(&rv)) {
+			if (!ZVAL_IS_UNDEF(&intern->tmp)) {
 				zval_ptr_dtor(&intern->tmp);
 			}
-			MAKE_STD_ZVAL(intern->tmp);
-			ZVAL_ZVAL(intern->tmp, rv, 1, 1);
-			convert_to_long(intern->tmp);
-			*count = (long) Z_LVAL_P(intern->tmp);
+			ZVAL_ZVAL(&intern->tmp, &rv, 0, 0);
+			convert_to_long(&intern->tmp);
+			*count = (long)Z_LVAL(intern->tmp);
 			return SUCCESS;
 		}
 		return FAILURE;
@@ -1920,7 +1893,7 @@ static int sxe_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
 SXE_METHOD(count)
 {
 	long count = 0;
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1932,19 +1905,14 @@ SXE_METHOD(count)
 }
 /* }}} */
 
-static zval *sxe_get_value(zval *z TSRMLS_DC) /* {{{ */
+static zval *sxe_get_value(zval *z, zval *rv TSRMLS_DC) /* {{{ */
 {
-	zval *retval;
-
-	MAKE_STD_ZVAL(retval);
-
-	if (sxe_object_cast(z, retval, IS_STRING TSRMLS_CC)==FAILURE) {
+	if (sxe_object_cast(z, rv, IS_STRING TSRMLS_CC) == FAILURE) {
 		zend_error(E_ERROR, "Unable to cast node to string");
 		/* FIXME: Should not be fatal */
 	}
 
-	Z_SET_REFCOUNT_P(retval, 0);
-	return retval;
+	return rv;
 }
 /* }}} */
 
@@ -1978,10 +1946,10 @@ static zend_object_handlers sxe_object_handlers = { /* {{{ */
 
 /* {{{ sxe_object_clone()
  */
-static void
-sxe_object_clone(void *object, void **clone_ptr TSRMLS_DC)
+static zend_object *
+sxe_object_clone(zval *object TSRMLS_DC)
 {
-	php_sxe_object *sxe = (php_sxe_object *) object;
+	php_sxe_object *sxe = Z_SXEOBJ_P(object);
 	php_sxe_object *clone;
 	xmlNodePtr nodep = NULL;
 	xmlDocPtr docp = NULL;
@@ -2008,23 +1976,22 @@ sxe_object_clone(void *object, void **clone_ptr TSRMLS_DC)
 
 	php_libxml_increment_node_ptr((php_libxml_node_object *)clone, nodep, NULL TSRMLS_CC);
 
-	*clone_ptr = (void *) clone;
+	return &clone->zo;
 }
 /* }}} */
 
 /* {{{ sxe_object_dtor()
  */
-static void sxe_object_dtor(void *object, zend_object_handle handle TSRMLS_DC)
+static void sxe_object_dtor(zend_object *object TSRMLS_DC)
 {
 	/* dtor required to cleanup iterator related data properly */
-
 	php_sxe_object *sxe;
 
-	sxe = (php_sxe_object *) object;
+	sxe = php_sxe_fetch_object(object);
 
-	if (sxe->iter.data) {
+	if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
 		zval_ptr_dtor(&sxe->iter.data);
-		sxe->iter.data = NULL;
+		ZVAL_UNDEF(&sxe->iter.data);
 	}
 
 	if (sxe->iter.name) {
@@ -2035,34 +2002,22 @@ static void sxe_object_dtor(void *object, zend_object_handle handle TSRMLS_DC)
 		xmlFree(sxe->iter.nsprefix);
 		sxe->iter.nsprefix = NULL;
 	}
-	if (sxe->tmp) {
+	if (!ZVAL_IS_UNDEF(&sxe->tmp)) {
 		zval_ptr_dtor(&sxe->tmp);
-		sxe->tmp = NULL;
+		ZVAL_UNDEF(&sxe->tmp);
 	}
 }
 /* }}} */
 
 /* {{{ sxe_object_free_storage()
  */
-static void sxe_object_free_storage(void *object TSRMLS_DC)
+static void sxe_object_free_storage(zend_object *object TSRMLS_DC)
 {
 	php_sxe_object *sxe;
 
-	sxe = (php_sxe_object *) object;
+	sxe = php_sxe_fetch_object(object);
 
-#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 && PHP_RELEASE_VERSION > 2) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 1) || (PHP_MAJOR_VERSION > 5)
 	zend_object_std_dtor(&sxe->zo TSRMLS_CC);
-#else
-	if (sxe->zo.guards) {
-		zend_hash_destroy(sxe->zo.guards);
-		FREE_HASHTABLE(sxe->zo.guards);
-	}
-
-	if (sxe->zo.properties) {
-		zend_hash_destroy(sxe->zo.properties);
-		FREE_HASHTABLE(sxe->zo.properties);
-	}
-#endif
 
 	php_libxml_node_decrement_resource((php_libxml_node_object *)sxe TSRMLS_CC);
 
@@ -2074,8 +2029,6 @@ static void sxe_object_free_storage(void *object TSRMLS_DC)
 		zend_hash_destroy(sxe->properties);
 		FREE_HASHTABLE(sxe->properties);
 	}
-
-	efree(object);
 }
 /* }}} */
 
@@ -2084,25 +2037,19 @@ static void sxe_object_free_storage(void *object TSRMLS_DC)
 static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC)
 {
 	php_sxe_object *intern;
-	zend_class_entry     *parent = ce;
+	zend_class_entry *parent = ce;
 	int inherited = 0;
 
-	intern = ecalloc(1, sizeof(php_sxe_object));
+	intern = ecalloc(1, sizeof(php_sxe_object) + sizeof(zval) * (parent->default_properties_count - 1));
 
 	intern->iter.type = SXE_ITER_NONE;
 	intern->iter.nsprefix = NULL;
 	intern->iter.name = NULL;
 	intern->fptr_count = NULL;
 
-#if (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION == 1 && PHP_RELEASE_VERSION > 2) || (PHP_MAJOR_VERSION == 5 && PHP_MINOR_VERSION > 1) || (PHP_MAJOR_VERSION > 5)
 	zend_object_std_init(&intern->zo, ce TSRMLS_CC);
-#else
-	ALLOC_HASHTABLE(intern->zo.properties);
-	zend_hash_init(intern->zo.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
-
-	intern->zo.ce = ce;
-	intern->zo.guards = NULL;
-#endif
+	object_properties_init(&intern->zo, ce);
+	intern->zo.handlers = &sxe_object_handlers;
 
 	while (parent) {
 		if (parent == sxe_class_entry) {
@@ -2112,9 +2059,9 @@ static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC)
 		parent = parent->parent;
 		inherited = 1;
 	}
-
+	
 	if (inherited) {
-		zend_hash_find(&ce->function_table, "count", sizeof("count"),(void **) &intern->fptr_count);
+		intern->fptr_count = zend_hash_str_find_ptr(&ce->function_table, "count", sizeof("count") - 1);
 		if (intern->fptr_count->common.scope == parent) {
 			intern->fptr_count = NULL;
 		}
@@ -2124,29 +2071,15 @@ static php_sxe_object* php_sxe_object_new(zend_class_entry *ce TSRMLS_DC)
 }
 /* }}} */
 
-/* {{{ php_sxe_register_object
- */
-static zend_object_value
-php_sxe_register_object(php_sxe_object *intern TSRMLS_DC)
-{
-	zend_object_value rv;
-
-	rv.handle = zend_objects_store_put(intern, sxe_object_dtor, (zend_objects_free_object_storage_t)sxe_object_free_storage, sxe_object_clone TSRMLS_CC);
-	rv.handlers = (zend_object_handlers *) &sxe_object_handlers;
-
-	return rv;
-}
-/* }}} */
-
 /* {{{ sxe_object_new()
  */
-PHP_SXE_API zend_object_value
+PHP_SXE_API zend_object *
 sxe_object_new(zend_class_entry *ce TSRMLS_DC)
 {
 	php_sxe_object    *intern;
 
 	intern = php_sxe_object_new(ce TSRMLS_CC);
-	return php_sxe_register_object(intern TSRMLS_CC);
+	return &intern->zo;
 }
 /* }}} */
 
@@ -2170,7 +2103,7 @@ PHP_FUNCTION(simplexml_load_file)
 
 	docp = xmlReadFile(filename, NULL, options);
 
-	if (! docp) {
+	if (!docp) {
 		RETURN_FALSE;
 	}
 
@@ -2183,8 +2116,7 @@ PHP_FUNCTION(simplexml_load_file)
 	php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
 	php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
 
-	return_value->type = IS_OBJECT;
-	return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
+	ZVAL_OBJ(return_value, &sxe->zo);
 }
 /* }}} */
 
@@ -2208,7 +2140,7 @@ PHP_FUNCTION(simplexml_load_string)
 
 	docp = xmlReadMemory(data, data_len, NULL, NULL, options);
 
-	if (! docp) {
+	if (!docp) {
 		RETURN_FALSE;
 	}
 
@@ -2221,8 +2153,7 @@ PHP_FUNCTION(simplexml_load_string)
 	php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, docp TSRMLS_CC);
 	php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, xmlDocGetRootElement(docp), NULL TSRMLS_CC);
 
-	return_value->type = IS_OBJECT;
-	return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
+	ZVAL_OBJ(return_value, &sxe->zo);
 }
 /* }}} */
 
@@ -2230,7 +2161,7 @@ PHP_FUNCTION(simplexml_load_string)
    SimpleXMLElement constructor */
 SXE_METHOD(__construct)
 {
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 	char           *data, *ns = NULL;
 	int             data_len, ns_len = 0;
 	xmlDocPtr       docp;
@@ -2294,8 +2225,7 @@ next_iter:
 	}
 
 	if (node && use_data) {
-		ALLOC_INIT_ZVAL(sxe->iter.data);
-		_node_as_zval(sxe, node, sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix TSRMLS_CC);
+		_node_as_zval(sxe, node, &sxe->iter.data, SXE_ITER_NONE, NULL, prefix, isprefix TSRMLS_CC);
 	}
 
 	return node;
@@ -2306,9 +2236,9 @@ static xmlNodePtr php_sxe_reset_iterator(php_sxe_object *sxe, int use_data TSRML
 {
 	xmlNodePtr node;
 
-	if (sxe->iter.data) {
+	if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
 		zval_ptr_dtor(&sxe->iter.data);
-		sxe->iter.data = NULL;
+		ZVAL_UNDEF(&sxe->iter.data);
 	}
 
 	GET_NODE(sxe, node)
@@ -2337,11 +2267,11 @@ zend_object_iterator *php_sxe_get_iterator(zend_class_entry *ce, zval *object, i
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
 	iterator = emalloc(sizeof(php_sxe_iterator));
+	zend_iterator_init(&iterator->intern TSRMLS_CC);
 
-	Z_ADDREF_P(object);
-	iterator->intern.data = (void*)object;
+	ZVAL_COPY(&iterator->intern.data, object);
 	iterator->intern.funcs = &php_sxe_iterator_funcs;
-	iterator->sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	iterator->sxe = Z_SXEOBJ_P(object);
 
 	return (zend_object_iterator*)iterator;
 }
@@ -2352,11 +2282,9 @@ static void php_sxe_iterator_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ *
 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
 
 	/* cleanup handled in sxe_object_dtor as we dont always have an iterator wrapper */
-	if (iterator->intern.data) {
-		zval_ptr_dtor((zval**)&iterator->intern.data);
+	if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+		zval_ptr_dtor(&iterator->intern.data);
 	}
-
-	efree(iterator);
 }
 /* }}} */
 
@@ -2364,23 +2292,23 @@ static int php_sxe_iterator_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ *
 {
 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
 
-	return iterator->sxe->iter.data ? SUCCESS : FAILURE;
+	return ZVAL_IS_UNDEF(&iterator->sxe->iter.data) ? FAILURE : SUCCESS;
 }
 /* }}} */
 
-static void php_sxe_iterator_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *php_sxe_iterator_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
 
-	*data = &iterator->sxe->iter.data;
+	return &iterator->sxe->iter.data;
 }
 /* }}} */
 
 static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
 {
 	php_sxe_iterator *iterator = (php_sxe_iterator *)iter;
-	zval *curobj = iterator->sxe->iter.data;
-	php_sxe_object *intern = (php_sxe_object *)zend_object_store_get_object(curobj TSRMLS_CC);
+	zval *curobj = &iterator->sxe->iter.data;
+	php_sxe_object *intern = Z_SXEOBJ_P(curobj);
 
 	xmlNodePtr curnode = NULL;
 	if (intern != NULL && intern->node != NULL) {
@@ -2388,7 +2316,7 @@ static void php_sxe_iterator_current_key(zend_object_iterator *iter, zval *key T
 	}
 
 	if (curnode) {
-		ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name), 1);
+		ZVAL_STRINGL(key, (char *) curnode->name, xmlStrlen(curnode->name));
 	} else {
 		ZVAL_NULL(key);
 	}
@@ -2400,11 +2328,11 @@ PHP_SXE_API void php_sxe_move_forward_iterator(php_sxe_object *sxe TSRMLS_DC) /*
 	xmlNodePtr      node = NULL;
 	php_sxe_object  *intern;
 
-	if (sxe->iter.data) {
-		intern = (php_sxe_object *)zend_object_store_get_object(sxe->iter.data TSRMLS_CC);
+	if (!ZVAL_IS_UNDEF(&sxe->iter.data)) {
+		intern = Z_SXEOBJ_P(&sxe->iter.data);
 		GET_NODE(intern, node)
 		zval_ptr_dtor(&sxe->iter.data);
-		sxe->iter.data = NULL;
+		ZVAL_UNDEF(&sxe->iter.data);
 	}
 
 	if (node) {
@@ -2436,7 +2364,7 @@ void *simplexml_export_node(zval *object TSRMLS_DC) /* {{{ */
 	php_sxe_object *sxe;
 	xmlNodePtr node;
 
-	sxe = php_sxe_fetch_object(object TSRMLS_CC);
+	sxe = Z_SXEOBJ_P(object);
 	GET_NODE(sxe, node);
 	return php_sxe_get_first_node(sxe, node TSRMLS_CC);
 }
@@ -2450,13 +2378,13 @@ PHP_FUNCTION(simplexml_import_dom)
 	zval *node;
 	php_libxml_node_object *object;
 	xmlNodePtr		nodep = NULL;
-	zend_class_entry *ce= sxe_class_entry;
+	zend_class_entry *ce = sxe_class_entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|C!", &node, &ce) == FAILURE) {
 		return;
 	}
 
-	object = (php_libxml_node_object *)zend_object_store_get_object(node TSRMLS_CC);
+	object = (php_libxml_node_object *) ((char *) Z_OBJ_P(node) - Z_OBJ_HT_P(node)->offset);
 
 	nodep = php_libxml_import_node(node TSRMLS_CC);
 
@@ -2479,8 +2407,7 @@ PHP_FUNCTION(simplexml_import_dom)
 		php_libxml_increment_doc_ref((php_libxml_node_object *)sxe, nodep->doc TSRMLS_CC);
 		php_libxml_increment_node_ptr((php_libxml_node_object *)sxe, nodep, NULL TSRMLS_CC);
 
-		return_value->type = IS_OBJECT;
-		return_value->value.obj = php_sxe_register_object(sxe TSRMLS_CC);
+		ZVAL_OBJ(return_value, &sxe->zo);
 	} else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid Nodetype to import");
 		RETVAL_NULL();
@@ -2622,6 +2549,10 @@ PHP_MINIT_FUNCTION(simplexml)
 	sxe_class_entry->get_iterator = php_sxe_get_iterator;
 	sxe_class_entry->iterator_funcs.funcs = &php_sxe_iterator_funcs;
 	zend_class_implements(sxe_class_entry TSRMLS_CC, 1, zend_ce_traversable);
+	sxe_object_handlers.offset = XtOffsetOf(php_sxe_object, zo);
+	sxe_object_handlers.dtor_obj = sxe_object_dtor;
+	sxe_object_handlers.free_obj = sxe_object_free_storage;
+	sxe_object_handlers.clone_obj = sxe_object_clone;
 	sxe_object_handlers.get_method = zend_get_std_object_handlers()->get_method;
 	sxe_object_handlers.get_constructor = zend_get_std_object_handlers()->get_constructor;
 	sxe_object_handlers.get_class_entry = zend_get_std_object_handlers()->get_class_entry;
diff --git a/ext/simplexml/sxe.c b/ext/simplexml/sxe.c
index 9a513e946f..c88cbfbe93 100644
--- a/ext/simplexml/sxe.c
+++ b/ext/simplexml/sxe.c
@@ -46,7 +46,7 @@ PHP_METHOD(ce_SimpleXMLIterator, rewind)
 		return;
 	}
 
-	iter.sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	iter.sxe = Z_SXEOBJ_P(getThis());
 	ce_SimpleXMLElement->iterator_funcs.funcs->rewind((zend_object_iterator*)&iter TSRMLS_CC);
 }
 /* }}} */
@@ -55,13 +55,13 @@ PHP_METHOD(ce_SimpleXMLIterator, rewind)
  Check whether iteration is valid */
 PHP_METHOD(ce_SimpleXMLIterator, valid)
 {
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	RETURN_BOOL(sxe->iter.data);
+	RETURN_BOOL(!ZVAL_IS_UNDEF(&sxe->iter.data));
 }
 /* }}} */
 
@@ -69,17 +69,17 @@ PHP_METHOD(ce_SimpleXMLIterator, valid)
  Get current element */
 PHP_METHOD(ce_SimpleXMLIterator, current)
 {
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (!sxe->iter.data) {
+	if (ZVAL_IS_UNDEF(&sxe->iter.data)) {
 		return; /* return NULL */
 	}
 
-	RETURN_ZVAL(sxe->iter.data, 1, 0);
+	RETURN_ZVAL(&sxe->iter.data, 1, 0);
 }
 /* }}} */
 
@@ -89,20 +89,20 @@ PHP_METHOD(ce_SimpleXMLIterator, key)
 {
 	xmlNodePtr curnode;
 	php_sxe_object *intern;
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (!sxe->iter.data) {
+	if (ZVAL_IS_UNDEF(&sxe->iter.data)) {
 		RETURN_FALSE;
 	}
 
-	intern = (php_sxe_object *)zend_object_store_get_object(sxe->iter.data TSRMLS_CC);
+	intern = Z_SXEOBJ_P(&sxe->iter.data);
 	if (intern != NULL && intern->node != NULL) {
 		curnode = (xmlNodePtr)((php_libxml_node_ptr *)intern->node)->node;
-		RETURN_STRINGL((char*)curnode->name, xmlStrlen(curnode->name), 1);
+		RETURN_STRINGL((char*)curnode->name, xmlStrlen(curnode->name));
 	}
     
 	RETURN_FALSE;
@@ -119,7 +119,7 @@ PHP_METHOD(ce_SimpleXMLIterator, next)
 		return;
 	}
 
-	iter.sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	iter.sxe = Z_SXEOBJ_P(getThis());
 	ce_SimpleXMLElement->iterator_funcs.funcs->move_forward((zend_object_iterator*)&iter TSRMLS_CC);
 }
 /* }}} */
@@ -128,7 +128,7 @@ PHP_METHOD(ce_SimpleXMLIterator, next)
  Check whether element has children (elements) */ 
 PHP_METHOD(ce_SimpleXMLIterator, hasChildren)
 {
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 	php_sxe_object *child;
 	xmlNodePtr      node;
 	
@@ -136,10 +136,10 @@ PHP_METHOD(ce_SimpleXMLIterator, hasChildren)
 		return;
 	}
 
-	if (!sxe->iter.data || sxe->iter.type == SXE_ITER_ATTRLIST) {
+	if (ZVAL_IS_UNDEF(&sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
 		RETURN_FALSE;
 	}
-	child = php_sxe_fetch_object(sxe->iter.data TSRMLS_CC);
+	child = Z_SXEOBJ_P(&sxe->iter.data);
 
 	GET_NODE(child, node);
 	if (node) {
@@ -156,16 +156,16 @@ PHP_METHOD(ce_SimpleXMLIterator, hasChildren)
  Get child element iterator */ 
 PHP_METHOD(ce_SimpleXMLIterator, getChildren)
 {
-	php_sxe_object *sxe = php_sxe_fetch_object(getThis() TSRMLS_CC);
+	php_sxe_object *sxe = Z_SXEOBJ_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (!sxe->iter.data || sxe->iter.type == SXE_ITER_ATTRLIST) {
+	if (ZVAL_IS_UNDEF(&sxe->iter.data) || sxe->iter.type == SXE_ITER_ATTRLIST) {
 		return; /* return NULL */
 	}
-	RETURN_ZVAL(sxe->iter.data, 1, 0);
+	RETURN_ZVAL(&sxe->iter.data, 1, 0);
 }
 
 /* {{{ arginfo */
@@ -187,19 +187,19 @@ static const zend_function_entry funcs_SimpleXMLIterator[] = {
 
 PHP_MINIT_FUNCTION(sxe) /* {{{ */
 {
-	zend_class_entry **pce;
+	zend_class_entry *pce;
 	zend_class_entry sxi;
 
-	if (zend_hash_find(CG(class_table), "simplexmlelement", sizeof("SimpleXMLElement"), (void **) &pce) == FAILURE) {
+	if ((pce = zend_hash_str_find_ptr(CG(class_table), "simplexmlelement", sizeof("SimpleXMLElement") - 1)) == NULL) {
 		ce_SimpleXMLElement  = NULL;
 		ce_SimpleXMLIterator = NULL;
 		return SUCCESS; /* SimpleXML must be initialized before */
 	}
 
-	ce_SimpleXMLElement = *pce;
+	ce_SimpleXMLElement = pce;
 
-	INIT_CLASS_ENTRY_EX(sxi, "SimpleXMLIterator", strlen("SimpleXMLIterator"), funcs_SimpleXMLIterator);
-	ce_SimpleXMLIterator = zend_register_internal_class_ex(&sxi, ce_SimpleXMLElement, NULL TSRMLS_CC);
+	INIT_CLASS_ENTRY_EX(sxi, "SimpleXMLIterator", sizeof("SimpleXMLIterator") - 1, funcs_SimpleXMLIterator);
+	ce_SimpleXMLIterator = zend_register_internal_class_ex(&sxi, ce_SimpleXMLElement TSRMLS_CC);
 	ce_SimpleXMLIterator->create_object = ce_SimpleXMLElement->create_object;
 
 	zend_class_implements(ce_SimpleXMLIterator TSRMLS_CC, 1, spl_ce_RecursiveIterator);
diff --git a/ext/snmp/snmp.c b/ext/snmp/snmp.c
index 4dd4badcd2..8b6afdee3a 100644
--- a/ext/snmp/snmp.c
+++ b/ext/snmp/snmp.c
@@ -2453,9 +2453,9 @@ PHP_MINIT_FUNCTION(snmp)
 	/* Register SNMPException class */
 	INIT_CLASS_ENTRY(cex, "SNMPException", NULL);
 #ifdef HAVE_SPL
-	php_snmp_exception_ce = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException, NULL TSRMLS_CC);
+	php_snmp_exception_ce = zend_register_internal_class_ex(&cex, spl_ce_RuntimeException TSRMLS_CC);
 #else
-	php_snmp_exception_ce = zend_register_internal_class_ex(&cex, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
+	php_snmp_exception_ce = zend_register_internal_class_ex(&cex, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
 #endif
 
 	return SUCCESS;
diff --git a/ext/soap/php_encoding.c b/ext/soap/php_encoding.c
index 720f212475..c4ce4476bc 100644
--- a/ext/soap/php_encoding.c
+++ b/ext/soap/php_encoding.c
@@ -2271,8 +2271,11 @@ static void add_xml_array_elements(xmlNodePtr xmlParam,
 
 static inline int array_num_elements(HashTable* ht)
 {
-	if (ht->pListTail && ht->pListTail->nKeyLength == 0) {
-		return ht->pListTail->h-1;
+	if (ht->nNumUsed &&
+	    ht->arData[ht->nNumUsed-1].xData &&
+	    ht->arData[ht->nNumUsed-1].nKeyLength == 0) {
+
+	    return ht->arData[ht->nNumUsed-1].h - 1;
 	}
 	return 0;
 }
@@ -2957,9 +2960,9 @@ static zval *guess_zval_convert(encodeTypePtr type, xmlNodePtr data TSRMLS_DC)
 		add_property_zval(soapvar, "enc_value", ret);
 		parse_namespace(type_name, &cptype, &ns);
 		nsptr = xmlSearchNs(data->doc, data, BAD_CAST(ns));
-		add_property_string(soapvar, "enc_stype", cptype, 1);
+		add_property_string(soapvar, "enc_stype", cptype);
 		if (nsptr) {
-			add_property_string(soapvar, "enc_ns", (char*)nsptr->href, 1);
+			add_property_string(soapvar, "enc_ns", (char*)nsptr->href);
 		}
 		efree(cptype);
 		if (ns) {efree(ns);}
diff --git a/ext/soap/php_http.c b/ext/soap/php_http.c
index 2a5679a439..f3abe680c9 100644
--- a/ext/soap/php_http.c
+++ b/ext/soap/php_http.c
@@ -849,7 +849,7 @@ try_again:
 		smart_str_0(&soap_headers);
 		if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
 		    Z_LVAL_PP(trace) > 0) {
-			add_property_stringl(this_ptr, "__last_request_headers", soap_headers.c, soap_headers.len, 1);
+			add_property_stringl(this_ptr, "__last_request_headers", soap_headers.c, soap_headers.len);
 		}
 		smart_str_appendl(&soap_headers, request, request_size);
 		smart_str_0(&soap_headers);
@@ -894,7 +894,7 @@ try_again:
 
 		if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
 		    Z_LVAL_PP(trace) > 0) {
-			add_property_stringl(this_ptr, "__last_response_headers", http_headers, http_header_size, 1);
+			add_property_stringl(this_ptr, "__last_response_headers", http_headers, http_header_size);
 		}
 
 		/* Check to see what HTTP status was sent */
@@ -970,7 +970,7 @@ try_again:
 
 			ALLOC_INIT_ZVAL(zcookie);
 			array_init(zcookie);
-			add_index_stringl(zcookie, 0, eqpos + 1, cookie_len, 1);
+			add_index_stringl(zcookie, 0, eqpos + 1, cookie_len);
 
 			if (sempos != NULL) {
 				char *options = cookie + cookie_len+1;
@@ -979,10 +979,10 @@ try_again:
 					sempos = strstr(options, ";");
 					if (strstr(options,"path=") == options) {
 						eqpos = options + sizeof("path=")-1;
-						add_index_stringl(zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos), 1);
+						add_index_stringl(zcookie, 1, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
 					} else if (strstr(options,"domain=") == options) {
 						eqpos = options + sizeof("domain=")-1;
-						add_index_stringl(zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos), 1);
+						add_index_stringl(zcookie, 2, eqpos, sempos?(sempos-eqpos):strlen(eqpos));
 					} else if (strstr(options,"secure") == options) {
 						add_index_bool(zcookie, 3, 1);
 					}
@@ -997,11 +997,11 @@ try_again:
 				char *t = phpurl->path?phpurl->path:"/";
 				char *c = strrchr(t, '/');
 				if (c) {
-					add_index_stringl(zcookie, 1, t, c-t, 1);
+					add_index_stringl(zcookie, 1, t, c-t);
 				}
 			}
 			if (!zend_hash_index_exists(Z_ARRVAL_P(zcookie), 2)) {
-				add_index_string(zcookie, 2, phpurl->host, 1);
+				add_index_string(zcookie, 2, phpurl->host);
 			}
 
 			add_assoc_zval_ex(*cookies, name.c, name.len+1, zcookie);
@@ -1173,7 +1173,7 @@ try_again:
 						ALLOC_INIT_ZVAL(digest);
 						array_init(digest);
 					}
-					add_assoc_string(digest, name, val ,1);
+					add_assoc_string(digest, name, val);
 				}
 			}
 
diff --git a/ext/soap/soap.c b/ext/soap/soap.c
index a8c6cb9369..9f3b5e14bf 100644
--- a/ext/soap/soap.c
+++ b/ext/soap/soap.c
@@ -532,6 +532,7 @@ static void php_soap_prepare_globals()
 	zend_hash_init(&defEnc, 0, NULL, NULL, 1);
 	zend_hash_init(&defEncIndex, 0, NULL, NULL, 1);
 	zend_hash_init(&defEncNs, 0, NULL, NULL, 1);
+	defEncNs.flags |= HASH_FLAG_BIG_DATA;	
 
 	i = 0;
 	do {
@@ -647,7 +648,7 @@ PHP_MINIT_FUNCTION(soap)
 
 	/* Register SoapFault class */
 	INIT_CLASS_ENTRY(ce, PHP_SOAP_FAULT_CLASSNAME, soap_fault_functions);
-	soap_fault_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C), NULL TSRMLS_CC);
+	soap_fault_class_entry = zend_register_internal_class_ex(&ce, zend_exception_get_default(TSRMLS_C) TSRMLS_CC);
 
 	/* Register SoapParam class */
 	INIT_CLASS_ENTRY(ce, PHP_SOAP_PARAM_CLASSNAME, soap_param_functions);
@@ -791,7 +792,7 @@ PHP_METHOD(SoapParam, SoapParam)
 		return;
 	}
 
-	add_property_stringl(this_ptr, "param_name", name, name_length, 1);
+	add_property_stringl(this_ptr, "param_name", name, name_length);
 	add_property_zval(this_ptr, "param_data", data);
 }
 /* }}} */
@@ -818,8 +819,8 @@ PHP_METHOD(SoapHeader, SoapHeader)
 		return;
 	}
 
-	add_property_stringl(this_ptr, "namespace", ns, ns_len, 1);
-	add_property_stringl(this_ptr, "name", name, name_len, 1);
+	add_property_stringl(this_ptr, "namespace", ns, ns_len);
+	add_property_stringl(this_ptr, "name", name, name_len);
 	if (data) {
 		add_property_zval(this_ptr, "data", data);
 	}
@@ -831,7 +832,7 @@ PHP_METHOD(SoapHeader, SoapHeader)
 	   Z_LVAL_P(actor) == SOAP_ACTOR_UNLIMATERECEIVER)) {
 		add_property_long(this_ptr, "actor", Z_LVAL_P(actor));
 	} else if (Z_TYPE_P(actor) == IS_STRING && Z_STRLEN_P(actor) > 0) {
-		add_property_stringl(this_ptr, "actor", Z_STRVAL_P(actor), Z_STRLEN_P(actor), 1);
+		add_property_stringl(this_ptr, "actor", Z_STRVAL_P(actor), Z_STRLEN_P(actor));
 	} else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid actor");
 	}
@@ -963,16 +964,16 @@ PHP_METHOD(SoapVar, SoapVar)
 	}
 
 	if (stype && stype_len > 0) {
-		add_property_stringl(this_ptr, "enc_stype", stype, stype_len, 1);
+		add_property_stringl(this_ptr, "enc_stype", stype, stype_len);
 	}
 	if (ns && ns_len > 0) {
-		add_property_stringl(this_ptr, "enc_ns", ns, ns_len, 1);
+		add_property_stringl(this_ptr, "enc_ns", ns, ns_len);
 	}
 	if (name && name_len > 0) {
-		add_property_stringl(this_ptr, "enc_name", name, name_len, 1);
+		add_property_stringl(this_ptr, "enc_name", name, name_len);
 	}
 	if (namens && namens_len > 0) {
-		add_property_stringl(this_ptr, "enc_namens", namens, namens_len, 1);
+		add_property_stringl(this_ptr, "enc_namens", namens, namens_len);
 	}
 }
 /* }}} */
@@ -1356,7 +1357,7 @@ PHP_METHOD(SoapServer, getFunctions)
 
 		zend_hash_internal_pointer_reset_ex(service->soap_functions.ft, &pos);
 		while (zend_hash_get_current_data_ex(service->soap_functions.ft, (void **)&name, &pos) != FAILURE) {
-			add_next_index_string(return_value, Z_STRVAL_PP(name), 1);
+			add_next_index_string(return_value, Z_STRVAL_PP(name));
 			zend_hash_move_forward_ex(service->soap_functions.ft, &pos);
 		}
 	}
@@ -1366,7 +1367,7 @@ PHP_METHOD(SoapServer, getFunctions)
 		zend_hash_internal_pointer_reset_ex(ft, &pos);
 		while (zend_hash_get_current_data_ex(ft, (void **)&f, &pos) != FAILURE) {
 			if ((service->type != SOAP_OBJECT && service->type != SOAP_CLASS) || (f->common.fn_flags & ZEND_ACC_PUBLIC)) {
-				add_next_index_string(return_value, f->common.function_name, 1);
+				add_next_index_string(return_value, f->common.function_name);
 			}
 			zend_hash_move_forward_ex(ft, &pos);
 		}
@@ -2343,7 +2344,7 @@ PHP_METHOD(SoapClient, SoapClient)
 			/* Fetching non-WSDL mode options */
 			if (zend_hash_find(ht, "uri", sizeof("uri"), (void**)&tmp) == SUCCESS &&
 			    Z_TYPE_PP(tmp) == IS_STRING) {
-				add_property_stringl(this_ptr, "uri", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+				add_property_stringl(this_ptr, "uri", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_ERROR, "'uri' option is required in nonWSDL mode");
 			}
@@ -2369,7 +2370,7 @@ PHP_METHOD(SoapClient, SoapClient)
 
 		if (zend_hash_find(ht, "location", sizeof("location"), (void**)&tmp) == SUCCESS &&
 		    Z_TYPE_PP(tmp) == IS_STRING) {
-			add_property_stringl(this_ptr, "location", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+			add_property_stringl(this_ptr, "location", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 		} else if (Z_TYPE_P(wsdl) == IS_NULL) {
 			php_error_docref(NULL TSRMLS_CC, E_ERROR, "'location' option is required in nonWSDL mode");
 		}
@@ -2382,10 +2383,10 @@ PHP_METHOD(SoapClient, SoapClient)
 		}
 		if (zend_hash_find(ht, "login", sizeof("login"), (void**)&tmp) == SUCCESS &&
 		    Z_TYPE_PP(tmp) == IS_STRING) {
-			add_property_stringl(this_ptr, "_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+			add_property_stringl(this_ptr, "_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 			if (zend_hash_find(ht, "password", sizeof("password"), (void**)&tmp) == SUCCESS &&
 			    Z_TYPE_PP(tmp) == IS_STRING) {
-				add_property_stringl(this_ptr, "_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+				add_property_stringl(this_ptr, "_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 			}
 			if (zend_hash_find(ht, "authentication", sizeof("authentication"), (void**)&tmp) == SUCCESS &&
 			    Z_TYPE_PP(tmp) == IS_LONG &&
@@ -2395,17 +2396,17 @@ PHP_METHOD(SoapClient, SoapClient)
 		}
 		if (zend_hash_find(ht, "proxy_host", sizeof("proxy_host"), (void**)&tmp) == SUCCESS &&
 		    Z_TYPE_PP(tmp) == IS_STRING) {
-			add_property_stringl(this_ptr, "_proxy_host", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+			add_property_stringl(this_ptr, "_proxy_host", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 			if (zend_hash_find(ht, "proxy_port", sizeof("proxy_port"), (void**)&tmp) == SUCCESS) {
 				convert_to_long(*tmp);
 				add_property_long(this_ptr, "_proxy_port", Z_LVAL_PP(tmp));
 			}
 			if (zend_hash_find(ht, "proxy_login", sizeof("proxy_login"), (void**)&tmp) == SUCCESS &&
 			    Z_TYPE_PP(tmp) == IS_STRING) {
-				add_property_stringl(this_ptr, "_proxy_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+				add_property_stringl(this_ptr, "_proxy_login", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 				if (zend_hash_find(ht, "proxy_password", sizeof("proxy_password"), (void**)&tmp) == SUCCESS &&
 				    Z_TYPE_PP(tmp) == IS_STRING) {
-					add_property_stringl(this_ptr, "_proxy_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+					add_property_stringl(this_ptr, "_proxy_password", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 				}
 			}
 		}
@@ -2450,7 +2451,7 @@ PHP_METHOD(SoapClient, SoapClient)
 				php_error_docref(NULL TSRMLS_CC, E_ERROR, "Invalid 'encoding' option - '%s'", Z_STRVAL_PP(tmp));
 			} else {
 				xmlCharEncCloseFunc(encoding);
-				add_property_stringl(this_ptr, "_encoding", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);			
+				add_property_stringl(this_ptr, "_encoding", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 			}
 		}
 		if (zend_hash_find(ht, "classmap", sizeof("classmap"), (void**)&tmp) == SUCCESS &&
@@ -2493,7 +2494,7 @@ PHP_METHOD(SoapClient, SoapClient)
 
 		if (zend_hash_find(ht, "user_agent", sizeof("user_agent"), (void**)&tmp) == SUCCESS &&
 		    Z_TYPE_PP(tmp) == IS_STRING) {
-			add_property_stringl(this_ptr, "_user_agent", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp), 1);
+			add_property_stringl(this_ptr, "_user_agent", Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
 		}
 		
 		if (zend_hash_find(ht, "keep_alive", sizeof("keep_alive"), (void**)&tmp) == SUCCESS &&
@@ -2558,7 +2559,7 @@ static int do_request(zval *this_ptr, xmlDoc *request, char *location, char *act
 
 	if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
 	    Z_LVAL_PP(trace) > 0) {
-		add_property_stringl(this_ptr, "__last_request", buf, buf_size, 1);
+		add_property_stringl(this_ptr, "__last_request", buf, buf_size);
 	}
 
 	INIT_ZVAL(func);
@@ -2593,7 +2594,7 @@ static int do_request(zval *this_ptr, xmlDoc *request, char *location, char *act
 		ret = FALSE;
 	} else if (zend_hash_find(Z_OBJPROP_P(this_ptr), "trace", sizeof("trace"), (void **) &trace) == SUCCESS &&
 	    Z_LVAL_PP(trace) > 0) {
-		add_property_stringl(this_ptr, "__last_response", Z_STRVAL_P(response), Z_STRLEN_P(response), 1);
+		add_property_stringl(this_ptr, "__last_response", Z_STRVAL_P(response), Z_STRLEN_P(response));
 	}
 	zval_ptr_dtor(&params[4]);
 	zval_ptr_dtor(&params[3]);
@@ -2967,7 +2968,7 @@ PHP_METHOD(SoapClient, __getFunctions)
  		zend_hash_internal_pointer_reset_ex(&sdl->functions, &pos);
 		while (zend_hash_get_current_data_ex(&sdl->functions, (void **)&function, &pos) != FAILURE) {
 			function_to_string((*function), &buf);
-			add_next_index_stringl(return_value, buf.c, buf.len, 1);
+			add_next_index_stringl(return_value, buf.c, buf.len);
 			smart_str_free(&buf);
 			zend_hash_move_forward_ex(&sdl->functions, &pos);
 		}
@@ -2998,7 +2999,7 @@ PHP_METHOD(SoapClient, __getTypes)
 			zend_hash_internal_pointer_reset_ex(sdl->types, &pos);
 			while (zend_hash_get_current_data_ex(sdl->types, (void **)&type, &pos) != FAILURE) {
 				type_to_string((*type), &buf, 0);
-				add_next_index_stringl(return_value, buf.c, buf.len, 1);
+				add_next_index_stringl(return_value, buf.c, buf.len);
 				smart_str_free(&buf);
 				zend_hash_move_forward_ex(sdl->types, &pos);
 			}
@@ -3144,7 +3145,7 @@ PHP_METHOD(SoapClient, __setCookie)
 
 		ALLOC_INIT_ZVAL(zcookie);
 		array_init(zcookie);
-		add_index_stringl(zcookie, 0, val, val_len, 1);
+		add_index_stringl(zcookie, 0, val, val_len);
 		add_assoc_zval_ex(*cookies, name, name_len+1, zcookie);
 	}
 }
@@ -3212,7 +3213,7 @@ PHP_METHOD(SoapClient, __setLocation)
 	}
 
 	if (location && location_len) {
-		add_property_stringl(this_ptr, "location", location, location_len, 1);
+		add_property_stringl(this_ptr, "location", location, location_len);
 	} else {
 		zend_hash_del(Z_OBJPROP_P(this_ptr), "location", sizeof("location"));
 	}
@@ -3243,50 +3244,50 @@ static void set_soap_fault(zval *obj, char *fault_code_ns, char *fault_code, cha
 		object_init_ex(obj, soap_fault_class_entry);
 	}
 	
-	add_property_string(obj, "faultstring", fault_string ? fault_string : "", 1);
+	add_property_string(obj, "faultstring", fault_string ? fault_string : "");
 	zend_update_property_string(zend_exception_get_default(TSRMLS_C), obj, "message", sizeof("message")-1, (fault_string ? fault_string : "") TSRMLS_CC);
 	
 	if (fault_code != NULL) {
 		int soap_version = SOAP_GLOBAL(soap_version);
 
 		if (fault_code_ns) {
-			add_property_string(obj, "faultcode", fault_code, 1);
-			add_property_string(obj, "faultcodens", fault_code_ns, 1);
+			add_property_string(obj, "faultcode", fault_code);
+			add_property_string(obj, "faultcodens", fault_code_ns);
 		} else {
 			if (soap_version == SOAP_1_1) {
-				add_property_string(obj, "faultcode", fault_code, 1);
+				add_property_string(obj, "faultcode", fault_code);
 				if (strcmp(fault_code,"Client") == 0 ||
 				    strcmp(fault_code,"Server") == 0 ||
 				    strcmp(fault_code,"VersionMismatch") == 0 ||
 			  	  strcmp(fault_code,"MustUnderstand") == 0) {
-					add_property_string(obj, "faultcodens", SOAP_1_1_ENV_NAMESPACE, 1);
+					add_property_string(obj, "faultcodens", SOAP_1_1_ENV_NAMESPACE);
 				}
 			} else if (soap_version == SOAP_1_2) {
 				if (strcmp(fault_code,"Client") == 0) {
-					add_property_string(obj, "faultcode", "Sender", 1);
-					add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE, 1);
+					add_property_string(obj, "faultcode", "Sender");
+					add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE);
 				} else if (strcmp(fault_code,"Server") == 0) {
-					add_property_string(obj, "faultcode", "Receiver", 1);
-					add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE, 1);
+					add_property_string(obj, "faultcode", "Receiver");
+					add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE);
 				} else if (strcmp(fault_code,"VersionMismatch") == 0 ||
 				           strcmp(fault_code,"MustUnderstand") == 0 ||
 				           strcmp(fault_code,"DataEncodingUnknown") == 0) {
-					add_property_string(obj, "faultcode", fault_code, 1);
-					add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE, 1);
+					add_property_string(obj, "faultcode", fault_code);
+					add_property_string(obj, "faultcodens", SOAP_1_2_ENV_NAMESPACE);
 				} else {
-					add_property_string(obj, "faultcode", fault_code, 1);
+					add_property_string(obj, "faultcode", fault_code);
 				}
 			}
 		}
 	}
 	if (fault_actor != NULL) {
-		add_property_string(obj, "faultactor", fault_actor, 1);
+		add_property_string(obj, "faultactor", fault_actor);
 	}
 	if (fault_detail != NULL) {
 		add_property_zval(obj, "detail", fault_detail);
 	}
 	if (name != NULL) {
-		add_property_string(obj, "_name", name, 1);
+		add_property_string(obj, "_name", name);
 	}
 }
 
diff --git a/ext/spl/php_spl.c b/ext/spl/php_spl.c
index 5927e05562..30ecf67824 100644
--- a/ext/spl/php_spl.c
+++ b/ext/spl/php_spl.c
@@ -56,35 +56,30 @@ ZEND_DECLARE_MODULE_GLOBALS(spl)
 static PHP_GINIT_FUNCTION(spl)
 {
 	spl_globals->autoload_extensions     = NULL;
-	spl_globals->autoload_extensions_len = 0;
 	spl_globals->autoload_functions      = NULL;
 	spl_globals->autoload_running        = 0;
 }
 /* }}} */
 
-static zend_class_entry * spl_find_ce_by_name(char *name, int len, zend_bool autoload TSRMLS_DC)
+static zend_class_entry * spl_find_ce_by_name(zend_string *name, zend_bool autoload TSRMLS_DC)
 {
-	zend_class_entry **ce;
-	int found;
+	zend_class_entry *ce;
 
 	if (!autoload) {
-		char *lc_name;
-		ALLOCA_FLAG(use_heap)
-
-		lc_name = do_alloca(len + 1, use_heap);
-		zend_str_tolower_copy(lc_name, name, len);
+		zend_string *lc_name = STR_ALLOC(name->len, 0);
+		zend_str_tolower_copy(lc_name->val, name->val, name->len);
 
-		found = zend_hash_find(EG(class_table), lc_name, len +1, (void **) &ce);
-		free_alloca(lc_name, use_heap);
+		ce = zend_hash_find_ptr(EG(class_table), lc_name);
+		STR_FREE(lc_name);
 	} else {
- 		found = zend_lookup_class(name, len, &ce TSRMLS_CC);
+ 		ce = zend_lookup_class(name TSRMLS_CC);
  	}
- 	if (found != SUCCESS) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class %s does not exist%s", name, autoload ? " and could not be loaded" : "");
+ 	if (ce == NULL) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class %s does not exist%s", name->val, autoload ? " and could not be loaded" : "");
 		return NULL;
 	}
 	
-	return *ce;
+	return ce;
 }
 
 /* {{{ proto array class_parents(object instance [, boolean autoload = true])
@@ -105,7 +100,7 @@ PHP_FUNCTION(class_parents)
 	}
 	
 	if (Z_TYPE_P(obj) == IS_STRING) {
-		if (NULL == (ce = spl_find_ce_by_name(Z_STRVAL_P(obj), Z_STRLEN_P(obj), autoload TSRMLS_CC))) {
+		if (NULL == (ce = spl_find_ce_by_name(Z_STR_P(obj), autoload TSRMLS_CC))) {
 			RETURN_FALSE;
 		}
 	} else {
@@ -138,7 +133,7 @@ PHP_FUNCTION(class_implements)
 	}
 	
 	if (Z_TYPE_P(obj) == IS_STRING) {
-		if (NULL == (ce = spl_find_ce_by_name(Z_STRVAL_P(obj), Z_STRLEN_P(obj), autoload TSRMLS_CC))) {
+		if (NULL == (ce = spl_find_ce_by_name(Z_STR_P(obj), autoload TSRMLS_CC))) {
 			RETURN_FALSE;
 		}
 	} else {
@@ -167,7 +162,7 @@ PHP_FUNCTION(class_uses)
 	}
 	
 	if (Z_TYPE_P(obj) == IS_STRING) {
-		if (NULL == (ce = spl_find_ce_by_name(Z_STRVAL_P(obj), Z_STRLEN_P(obj), autoload TSRMLS_CC))) {
+		if (NULL == (ce = spl_find_ce_by_name(Z_STR_P(obj), autoload TSRMLS_CC))) {
 			RETURN_FALSE;
 		}
 	} else {
@@ -250,17 +245,17 @@ PHP_FUNCTION(spl_classes)
 }
 /* }}} */
 
-static int spl_autoload(const char *class_name, const char * lc_name, int class_name_len, const char * file_extension TSRMLS_DC) /* {{{ */
+static int spl_autoload(zend_string *class_name, zend_string *lc_name, const char *ext, int ext_len TSRMLS_DC) /* {{{ */
 {
 	char *class_file;
 	int class_file_len;
-	int dummy = 1;
+	zval dummy;
 	zend_file_handle file_handle;
 	zend_op_array *new_op_array;
-	zval *result = NULL;
+	zval result;
 	int ret;
 
-	class_file_len = spprintf(&class_file, 0, "%s%s", lc_name, file_extension);
+	class_file_len = spprintf(&class_file, 0, "%s%.*s", lc_name->val, ext_len, ext);
 
 #if DEFAULT_SLASH != '\\'
 	{
@@ -276,35 +271,37 @@ static int spl_autoload(const char *class_name, const char * lc_name, int class_
 	ret = php_stream_open_for_zend_ex(class_file, &file_handle, USE_PATH|STREAM_OPEN_FOR_INCLUDE TSRMLS_CC);
 
 	if (ret == SUCCESS) {
+		zend_string *opened_path;
 		if (!file_handle.opened_path) {
 			file_handle.opened_path = estrndup(class_file, class_file_len);
 		}
-		if (zend_hash_add(&EG(included_files), file_handle.opened_path, strlen(file_handle.opened_path)+1, (void *)&dummy, sizeof(int), NULL)==SUCCESS) {
+		opened_path = STR_INIT(file_handle.opened_path, strlen(file_handle.opened_path), 0);
+		ZVAL_NULL(&dummy);
+		if (zend_hash_add(&EG(included_files), opened_path, &dummy)) {
 			new_op_array = zend_compile_file(&file_handle, ZEND_REQUIRE TSRMLS_CC);
 			zend_destroy_file_handle(&file_handle TSRMLS_CC);
 		} else {
 			new_op_array = NULL;
 			zend_file_handle_dtor(&file_handle TSRMLS_CC);
 		}
+		STR_RELEASE(opened_path);
 		if (new_op_array) {
-			EG(return_value_ptr_ptr) = &result;
 			EG(active_op_array) = new_op_array;
 			if (!EG(active_symbol_table)) {
 				zend_rebuild_symbol_table(TSRMLS_C);
 			}
 
-			zend_execute(new_op_array TSRMLS_CC);
+			ZVAL_UNDEF(&result);
+			zend_execute(new_op_array, &result TSRMLS_CC);
 	
 			destroy_op_array(new_op_array TSRMLS_CC);
 			efree(new_op_array);
 			if (!EG(exception)) {
-				if (EG(return_value_ptr_ptr)) {
-					zval_ptr_dtor(EG(return_value_ptr_ptr));
-				}
+				zval_ptr_dtor(&result);
 			}
 
 			efree(class_file);
-			return zend_hash_exists(EG(class_table), (char*)lc_name, class_name_len+1);
+			return zend_hash_exists(EG(class_table), lc_name);
 		}
 	}
 	efree(class_file);
@@ -315,41 +312,44 @@ static int spl_autoload(const char *class_name, const char * lc_name, int class_
  Default implementation for __autoload() */
 PHP_FUNCTION(spl_autoload)
 {
-	char *class_name, *lc_name, *file_exts = SPL_G(autoload_extensions);
-	int class_name_len, file_exts_len = SPL_G(autoload_extensions_len), found = 0;
-	char *copy, *pos1, *pos2;
-	zval **original_return_value = EG(return_value_ptr_ptr);
+	int found = 0, pos_len, pos1_len;
+	char *pos, *pos1;
+	zend_string *class_name, *lc_name, *file_exts = SPL_G(autoload_extensions);
 	zend_op **original_opline_ptr = EG(opline_ptr);
 	zend_op_array *original_active_op_array = EG(active_op_array);
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &class_name, &class_name_len, &file_exts, &file_exts_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S|S", &class_name, &file_exts) == FAILURE) {
 		RETURN_FALSE;
 	}
 
 	if (file_exts == NULL) { /* autoload_extensions is not intialzed, set to defaults */
-		copy = pos1 = estrndup(SPL_DEFAULT_FILE_EXTENSIONS, sizeof(SPL_DEFAULT_FILE_EXTENSIONS)-1);
+		pos = SPL_DEFAULT_FILE_EXTENSIONS;
+		pos_len = sizeof(SPL_DEFAULT_FILE_EXTENSIONS) - 1;
 	} else {
-		copy = pos1 = estrndup(file_exts, file_exts_len);
+		pos = file_exts->val;
+		pos_len = file_exts->len;
 	}
-	lc_name = zend_str_tolower_dup(class_name, class_name_len);
-	while(pos1 && *pos1 && !EG(exception)) {
-		EG(return_value_ptr_ptr) = original_return_value;
+
+	lc_name = STR_ALLOC(class_name->len, 0);
+	zend_str_tolower_copy(lc_name->val, class_name->val, class_name->len);
+	while (pos && *pos && !EG(exception)) {
 		EG(opline_ptr) = original_opline_ptr;
 		EG(active_op_array) = original_active_op_array;
-		pos2 = strchr(pos1, ',');
-		if (pos2) *pos2 = '\0';
-		if (spl_autoload(class_name, lc_name, class_name_len, pos1 TSRMLS_CC)) {
+		pos1 = strchr(pos, ',');
+		if (pos1) { 
+			pos1_len = pos1 - pos;
+		} else {
+			pos1_len = pos_len;
+		}
+		if (spl_autoload(class_name, lc_name, pos, pos1_len TSRMLS_CC)) {
 			found = 1;
 			break; /* loaded */
 		}
-		pos1 = pos2 ? pos2 + 1 : NULL;
-	}
-	efree(lc_name);
-	if (copy) {
-		efree(copy);
+		pos = pos1 ? pos1 + 1 : NULL;
+		pos_len = pos1? pos_len - pos1_len - 1 : 0;
 	}
+	STR_FREE(lc_name);
 
-	EG(return_value_ptr_ptr) = original_return_value;
 	EG(opline_ptr) = original_opline_ptr;
 	EG(active_op_array) = original_active_op_array;
 
@@ -359,9 +359,9 @@ PHP_FUNCTION(spl_autoload)
 		 * the Zend engine.
 		 */
 		if (active_opline->opcode != ZEND_FETCH_CLASS) {
-			zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Class %s could not be loaded", class_name);
+			zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Class %s could not be loaded", class_name->val);
 		} else {
-			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be loaded", class_name);
+			php_error_docref(NULL TSRMLS_CC, E_ERROR, "Class %s could not be loaded", class_name->val);
 		}
 	}
 } /* }}} */
@@ -370,53 +370,52 @@ PHP_FUNCTION(spl_autoload)
  Register and return default file extensions for spl_autoload */
 PHP_FUNCTION(spl_autoload_extensions)
 {
-	char *file_exts = NULL;
-	int file_exts_len;
+	zend_string *file_exts = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &file_exts, &file_exts_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|S", &file_exts) == FAILURE) {
 		return;
 	}
 	if (file_exts) {
 		if (SPL_G(autoload_extensions)) {
-			efree(SPL_G(autoload_extensions));
+			STR_RELEASE(SPL_G(autoload_extensions));
 		}
-		SPL_G(autoload_extensions) = estrndup(file_exts, file_exts_len);
-		SPL_G(autoload_extensions_len) = file_exts_len;
+		SPL_G(autoload_extensions) = STR_COPY(file_exts);
 	}
 
 	if (SPL_G(autoload_extensions) == NULL) {
-		RETURN_STRINGL(SPL_DEFAULT_FILE_EXTENSIONS, sizeof(SPL_DEFAULT_FILE_EXTENSIONS) - 1, 1);
+		RETURN_STRINGL(SPL_DEFAULT_FILE_EXTENSIONS, sizeof(SPL_DEFAULT_FILE_EXTENSIONS) - 1);
 	} else {
-		RETURN_STRINGL(SPL_G(autoload_extensions), SPL_G(autoload_extensions_len), 1);
+		STR_ADDREF(SPL_G(autoload_extensions));
+		RETURN_STR(SPL_G(autoload_extensions));
 	}
 } /* }}} */
 
 typedef struct {
 	zend_function *func_ptr;
-	zval *obj;
-	zval *closure;
+	zval obj;
+	zval closure;
 	zend_class_entry *ce;
 } autoload_func_info;
 
-static void autoload_func_info_dtor(autoload_func_info *alfi)
+static void autoload_func_info_dtor(zval *element)
 {
-	if (alfi->obj) {
+	autoload_func_info *alfi = (autoload_func_info*)Z_PTR_P(element);
+	if (!ZVAL_IS_UNDEF(&alfi->obj)) {
 		zval_ptr_dtor(&alfi->obj);
 	}
-	if (alfi->closure) {
+	if (!ZVAL_IS_UNDEF(&alfi->closure)) {
 		zval_ptr_dtor(&alfi->closure);
 	}
+	efree(alfi);
 }
 
 /* {{{ proto void spl_autoload_call(string class_name)
  Try all registerd autoload function to load the requested class */
 PHP_FUNCTION(spl_autoload_call)
 {
-	zval *class_name, *retval = NULL;
-	int class_name_len;
-	char *func_name, *lc_name;
-	uint func_name_len;
 	ulong dummy;
+	zval *class_name, *retval = NULL;
+	zend_string *lc_name, *func_name;
 	HashPosition function_pos;
 	autoload_func_info *alfi;
 
@@ -427,25 +426,25 @@ PHP_FUNCTION(spl_autoload_call)
 	if (SPL_G(autoload_functions)) {
 		int l_autoload_running = SPL_G(autoload_running);
 		SPL_G(autoload_running) = 1;
-		class_name_len = Z_STRLEN_P(class_name);
-		lc_name = zend_str_tolower_dup(Z_STRVAL_P(class_name), class_name_len);
+		lc_name = STR_ALLOC(Z_STRLEN_P(class_name), 0);
+		zend_str_tolower_copy(lc_name->val, Z_STRVAL_P(class_name), Z_STRLEN_P(class_name));
 		zend_hash_internal_pointer_reset_ex(SPL_G(autoload_functions), &function_pos);
-		while(zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
-			zend_hash_get_current_key_ex(SPL_G(autoload_functions), &func_name, &func_name_len, &dummy, 0, &function_pos);
-			zend_hash_get_current_data_ex(SPL_G(autoload_functions), (void **) &alfi, &function_pos);
-			zend_call_method(alfi->obj ? &alfi->obj : NULL, alfi->ce, &alfi->func_ptr, func_name, func_name_len, &retval, 1, class_name, NULL TSRMLS_CC);
+		while (zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
+			zend_hash_get_current_key_ex(SPL_G(autoload_functions), &func_name, &dummy, 0, &function_pos);
+			alfi = zend_hash_get_current_data_ptr_ex(SPL_G(autoload_functions), &function_pos);
+			zend_call_method(ZVAL_IS_UNDEF(&alfi->obj)? NULL : &alfi->obj, alfi->ce, &alfi->func_ptr, func_name->val, func_name->len, retval, 1, class_name, NULL TSRMLS_CC);
 			zend_exception_save(TSRMLS_C);
 			if (retval) {
-				zval_ptr_dtor(&retval);
+				zval_ptr_dtor(retval);
 				retval = NULL;
 			}
-			if (zend_hash_exists(EG(class_table), lc_name, class_name_len + 1)) {
+			if (zend_hash_exists(EG(class_table), lc_name)) {
 				break;
 			}
 			zend_hash_move_forward_ex(SPL_G(autoload_functions), &function_pos);
 		}
 		zend_exception_restore(TSRMLS_C);
-		efree(lc_name);
+		STR_FREE(lc_name);
 		SPL_G(autoload_running) = l_autoload_running;
 	} else {
 		/* do not use or overwrite &EG(autoload_func) here */
@@ -453,27 +452,41 @@ PHP_FUNCTION(spl_autoload_call)
 	}
 } /* }}} */
 
-#define HT_MOVE_TAIL_TO_HEAD(ht)							\
-	(ht)->pListTail->pListNext = (ht)->pListHead;			\
-	(ht)->pListHead = (ht)->pListTail;						\
-	(ht)->pListTail = (ht)->pListHead->pListLast;			\
-	(ht)->pListHead->pListNext->pListLast = (ht)->pListHead;\
-	(ht)->pListTail->pListNext = NULL;						\
-	(ht)->pListHead->pListLast = NULL;
+#define HT_MOVE_TAIL_TO_HEAD(ht)						        \
+	do {												        \
+		uint first = 0;									        \
+		uint last = (ht)->nNumUsed;						        \
+		while (first < last) {							        \
+			if (Z_TYPE((ht)->arData[first].val) != IS_UNDEF)    \
+				break;			                                \
+			first++;									        \
+		}												        \
+		while (last > first) {							        \
+			last--;										        \
+			if (Z_TYPE((ht)->arData[last].val) != IS_UNDEF)     \
+				break;			                                \
+		}												        \
+		if (first != last) {							        \
+			Bucket tmp = (ht)->arData[first];                   \
+			(ht)->arData[first] = (ht)->arData[last];           \
+			(ht)->arData[last] = tmp;                           \
+			zend_hash_rehash(ht);						        \
+		}												        \
+	} while (0)
 
 /* {{{ proto bool spl_autoload_register([mixed autoload_function = "spl_autoload" [, throw = true [, prepend]]])
  Register given function as __autoload() implementation */
 PHP_FUNCTION(spl_autoload_register)
 {
-	char *func_name, *error = NULL;
-	int  func_name_len;
-	char *lc_name = NULL;
+	zend_string *func_name;
+	char *error = NULL;
+	zend_string *lc_name;
 	zval *zcallable = NULL;
 	zend_bool do_throw = 1;
 	zend_bool prepend  = 0;
 	zend_function *spl_func_ptr;
 	autoload_func_info alfi;
-	zval *obj_ptr;
+	zend_object *obj_ptr;
 	zend_fcall_info_cache fcc;
 
 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|zbb", &zcallable, &do_throw, &prepend) == FAILURE) {
@@ -481,21 +494,10 @@ PHP_FUNCTION(spl_autoload_register)
 	}
 
 	if (ZEND_NUM_ARGS()) {
-		if (Z_TYPE_P(zcallable) == IS_STRING) {
-			if (Z_STRLEN_P(zcallable) == sizeof("spl_autoload_call") - 1) {
-				if (!zend_binary_strcasecmp(Z_STRVAL_P(zcallable), sizeof("spl_autoload_call"), "spl_autoload_call", sizeof("spl_autoload_call"))) {
-					if (do_throw) {
-						zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Function spl_autoload_call() cannot be registered");
-					}
-					RETURN_FALSE;
-				}
-			}
-		}
-	
-		if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_STRICT, &func_name, &func_name_len, &fcc, &error TSRMLS_CC)) {
+		if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_STRICT, &func_name, &fcc, &error TSRMLS_CC)) {
 			alfi.ce = fcc.calling_scope;
 			alfi.func_ptr = fcc.function_handler;
-			obj_ptr = fcc.object_ptr;
+			obj_ptr = fcc.object;
 			if (Z_TYPE_P(zcallable) == IS_ARRAY) {
 				if (!obj_ptr && alfi.func_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
 					if (do_throw) {
@@ -504,25 +506,24 @@ PHP_FUNCTION(spl_autoload_register)
 					if (error) {
 						efree(error);
 					}
-					efree(func_name);
+					STR_RELEASE(func_name);
 					RETURN_FALSE;
-				}
-				else if (do_throw) {
+				} else if (do_throw) {
 					zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Passed array does not specify %s %smethod (%s)", alfi.func_ptr ? "a callable" : "an existing", !obj_ptr ? "static " : "", error);
 				}
 				if (error) {
 					efree(error);
 				}
-				efree(func_name);
+				STR_RELEASE(func_name);
 				RETURN_FALSE;
 			} else if (Z_TYPE_P(zcallable) == IS_STRING) {
 				if (do_throw) {
-					zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Function '%s' not %s (%s)", func_name, alfi.func_ptr ? "callable" : "found", error);
+					zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Function '%s' not %s (%s)", func_name->val, alfi.func_ptr ? "callable" : "found", error);
 				}
 				if (error) {
 					efree(error);
 				}
-				efree(func_name);
+				STR_RELEASE(func_name);
 				RETURN_FALSE;
 			} else {
 				if (do_throw) {
@@ -531,79 +532,87 @@ PHP_FUNCTION(spl_autoload_register)
 				if (error) {
 					efree(error);
 				}
-				efree(func_name);
+				STR_RELEASE(func_name);
 				RETURN_FALSE;
 			}
+		} else if (fcc.function_handler->type == ZEND_INTERNAL_FUNCTION &&
+				   fcc.function_handler->internal_function.handler == zif_spl_autoload_call) {
+			if (do_throw) {
+				zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Function spl_autoload_call() cannot be registered");
+			}
+			if (error) {
+				efree(error);
+			}
+			STR_RELEASE(func_name);
+			RETURN_FALSE;
 		}
-		alfi.closure = NULL;
 		alfi.ce = fcc.calling_scope;
 		alfi.func_ptr = fcc.function_handler;
-		obj_ptr = fcc.object_ptr;
+		obj_ptr = fcc.object;
 		if (error) {
 			efree(error);
 		}
-	
-		lc_name = safe_emalloc(func_name_len, 1, sizeof(long) + 1);
-		zend_str_tolower_copy(lc_name, func_name, func_name_len);
-		efree(func_name);
 
 		if (Z_TYPE_P(zcallable) == IS_OBJECT) {
-			alfi.closure = zcallable;
-			Z_ADDREF_P(zcallable);
-
-			lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
-			memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(zcallable),
-				sizeof(zend_object_handle));
-			func_name_len += sizeof(zend_object_handle);
-			lc_name[func_name_len] = '\0';
+			ZVAL_COPY(&alfi.closure, zcallable);
+
+			lc_name = STR_ALLOC(func_name->len + sizeof(zend_uint), 0);
+			zend_str_tolower_copy(lc_name->val, func_name->val, func_name->len);
+			memcpy(lc_name->val + func_name->len, &Z_OBJ_HANDLE_P(zcallable), sizeof(zend_uint));
+			lc_name->val[lc_name->len] = '\0';
+		} else {
+			ZVAL_UNDEF(&alfi.closure);
+			lc_name = STR_ALLOC(func_name->len, 0);
+			zend_str_tolower_copy(lc_name->val, func_name->val, func_name->len);
 		}
+		STR_RELEASE(func_name);
 
-		if (SPL_G(autoload_functions) && zend_hash_exists(SPL_G(autoload_functions), (char*)lc_name, func_name_len+1)) {
-			if (alfi.closure) {
-				Z_DELREF_P(zcallable);
+		if (SPL_G(autoload_functions) && zend_hash_exists(SPL_G(autoload_functions), lc_name)) {
+			if (!ZVAL_IS_UNDEF(&alfi.closure)) {
+				Z_DELREF_P(&alfi.closure);
 			}
 			goto skip;
 		}
 
 		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 */
-			lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
-			memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_object_handle));
-			func_name_len += sizeof(zend_object_handle);
-			lc_name[func_name_len] = '\0';
-			alfi.obj = obj_ptr;
-			Z_ADDREF_P(alfi.obj);
+			lc_name = STR_REALLOC(lc_name, lc_name->len + sizeof(zend_uint), 0);
+			memcpy(lc_name->val + lc_name->len - sizeof(zend_uint), &obj_ptr->handle, sizeof(zend_uint));
+			lc_name->val[lc_name->len] = '\0';
+			ZVAL_OBJ(&alfi.obj, obj_ptr);
+			Z_ADDREF(alfi.obj);
 		} else {
-			alfi.obj = NULL;
+			ZVAL_UNDEF(&alfi.obj);
 		}
 
 		if (!SPL_G(autoload_functions)) {
 			ALLOC_HASHTABLE(SPL_G(autoload_functions));
-			zend_hash_init(SPL_G(autoload_functions), 1, NULL, (dtor_func_t) autoload_func_info_dtor, 0);
+			zend_hash_init(SPL_G(autoload_functions), 1, NULL, autoload_func_info_dtor, 0);
 		}
 
-		zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &spl_func_ptr);
+		spl_func_ptr = zend_hash_str_find_ptr(EG(function_table), "spl_autoload", sizeof("spl_autoload") - 1);
 
 		if (EG(autoload_func) == spl_func_ptr) { /* registered already, so we insert that first */
 			autoload_func_info spl_alfi;
 
 			spl_alfi.func_ptr = spl_func_ptr;
-			spl_alfi.obj = NULL;
+			ZVAL_UNDEF(&spl_alfi.obj);
+			ZVAL_UNDEF(&spl_alfi.closure);
 			spl_alfi.ce = NULL;
-			spl_alfi.closure = NULL;
-			zend_hash_add(SPL_G(autoload_functions), "spl_autoload", sizeof("spl_autoload"), &spl_alfi, sizeof(autoload_func_info), NULL);
+			zend_hash_str_add_mem(SPL_G(autoload_functions), "spl_autoload", sizeof("spl_autoload") - 1,
+					&spl_alfi, sizeof(autoload_func_info));
 			if (prepend && SPL_G(autoload_functions)->nNumOfElements > 1) {
 				/* Move the newly created element to the head of the hashtable */
 				HT_MOVE_TAIL_TO_HEAD(SPL_G(autoload_functions));
 			}
 		}
 
-		if (zend_hash_add(SPL_G(autoload_functions), lc_name, func_name_len+1, &alfi.func_ptr, sizeof(autoload_func_info), NULL) == FAILURE) {
+		if (zend_hash_add_mem(SPL_G(autoload_functions), lc_name, &alfi, sizeof(autoload_func_info)) == NULL) {
 			if (obj_ptr && !(alfi.func_ptr->common.fn_flags & ZEND_ACC_STATIC)) {
-				Z_DELREF_P(alfi.obj);
+				Z_DELREF(alfi.obj);
 			}				
-			if (alfi.closure) {
-				Z_DELREF_P(alfi.closure);
+			if (!ZVAL_IS_UNDEF(&alfi.closure)) {
+				Z_DELREF(alfi.closure);
 			}
 		}
 		if (prepend && SPL_G(autoload_functions)->nNumOfElements > 1) {
@@ -611,14 +620,15 @@ PHP_FUNCTION(spl_autoload_register)
 			HT_MOVE_TAIL_TO_HEAD(SPL_G(autoload_functions));
 		}
 skip:
-		efree(lc_name);
+		STR_RELEASE(lc_name);
 	}
 
 	if (SPL_G(autoload_functions)) {
-		zend_hash_find(EG(function_table), "spl_autoload_call", sizeof("spl_autoload_call"), (void **) &EG(autoload_func));
+		EG(autoload_func) = zend_hash_str_find_ptr(EG(function_table), "spl_autoload_call", sizeof("spl_autoload_call") - 1);
 	} else {
-		zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &EG(autoload_func));
+		EG(autoload_func) =	zend_hash_str_find_ptr(EG(function_table), "spl_autoload", sizeof("spl_autoload") - 1);
 	}
+
 	RETURN_TRUE;
 } /* }}} */
 
@@ -626,48 +636,47 @@ skip:
  Unregister given function as __autoload() implementation */
 PHP_FUNCTION(spl_autoload_unregister)
 {
-	char *func_name, *error = NULL;
-	int func_name_len;
-	char *lc_name = NULL;
+	zend_string *func_name = NULL;
+	char *error = NULL;
+	zend_string *lc_name;
 	zval *zcallable;
 	int success = FAILURE;
 	zend_function *spl_func_ptr;
-	zval *obj_ptr;
+	zend_object *obj_ptr;
 	zend_fcall_info_cache fcc;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zcallable) == FAILURE) {
 		return;
 	}
 
-	if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_CHECK_SYNTAX_ONLY, &func_name, &func_name_len, &fcc, &error TSRMLS_CC)) {
+	if (!zend_is_callable_ex(zcallable, NULL, IS_CALLABLE_CHECK_SYNTAX_ONLY, &func_name, &fcc, &error TSRMLS_CC)) {
 		zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Unable to unregister invalid function (%s)", error);
 		if (error) {
 			efree(error);
 		}
 		if (func_name) {
-			efree(func_name);
+			STR_RELEASE(func_name);
 		}
 		RETURN_FALSE;
 	}
-	obj_ptr = fcc.object_ptr;
+	obj_ptr = fcc.object;
 	if (error) {
 		efree(error);
 	}
 
-	lc_name = safe_emalloc(func_name_len, 1, sizeof(long) + 1);
-	zend_str_tolower_copy(lc_name, func_name, func_name_len);
-	efree(func_name);
-
 	if (Z_TYPE_P(zcallable) == IS_OBJECT) {
-		lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
-		memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(zcallable),
-			sizeof(zend_object_handle));
-		func_name_len += sizeof(zend_object_handle);
-		lc_name[func_name_len] = '\0';
+		lc_name = STR_ALLOC(func_name->len + sizeof(zend_uint), 0);
+		zend_str_tolower_copy(lc_name->val, func_name->val, func_name->len);
+		memcpy(lc_name->val + func_name->len, &Z_OBJ_HANDLE_P(zcallable), sizeof(zend_uint));
+		lc_name->val[lc_name->len] = '\0';
+	} else {
+		lc_name = STR_ALLOC(func_name->len, 0);
+		zend_str_tolower_copy(lc_name->val, func_name->val, func_name->len);
 	}
+	STR_RELEASE(func_name);
 
 	if (SPL_G(autoload_functions)) {
-		if (func_name_len == sizeof("spl_autoload_call")-1 && !strcmp(lc_name, "spl_autoload_call")) {
+		if (lc_name->len == sizeof("spl_autoload_call") - 1 && !strcmp(lc_name->val, "spl_autoload_call")) {
 			/* remove all */
 			zend_hash_destroy(SPL_G(autoload_functions));
 			FREE_HASHTABLE(SPL_G(autoload_functions));
@@ -676,18 +685,17 @@ PHP_FUNCTION(spl_autoload_unregister)
 			success = SUCCESS;
 		} else {
 			/* remove specific */
-			success = zend_hash_del(SPL_G(autoload_functions), lc_name, func_name_len+1);
+			success = zend_hash_del(SPL_G(autoload_functions), lc_name);
 			if (success != SUCCESS && obj_ptr) {
-				lc_name = erealloc(lc_name, func_name_len + 2 + sizeof(zend_object_handle));
-				memcpy(lc_name + func_name_len, &Z_OBJ_HANDLE_P(obj_ptr), sizeof(zend_object_handle));
-				func_name_len += sizeof(zend_object_handle);
-				lc_name[func_name_len] = '\0';
-				success = zend_hash_del(SPL_G(autoload_functions), lc_name, func_name_len+1);
+				lc_name = STR_REALLOC(lc_name, lc_name->len + sizeof(zend_uint), 0);
+				memcpy(lc_name->val + lc_name->len - sizeof(zend_uint), &obj_ptr->handle, sizeof(zend_uint));
+				lc_name->val[lc_name->len] = '\0';
+				success = zend_hash_del(SPL_G(autoload_functions), lc_name);
 			}
 		}
-	} else if (func_name_len == sizeof("spl_autoload")-1 && !strcmp(lc_name, "spl_autoload")) {
+	} else if (lc_name->len == sizeof("spl_autoload")-1 && !strcmp(lc_name->val, "spl_autoload")) {
 		/* register single spl_autoload() */
-		zend_hash_find(EG(function_table), "spl_autoload", sizeof("spl_autoload"), (void **) &spl_func_ptr);
+		spl_func_ptr = zend_hash_str_find_ptr(EG(function_table), "spl_autoload", sizeof("spl_autoload") - 1);
 
 		if (EG(autoload_func) == spl_func_ptr) {
 			success = SUCCESS;
@@ -695,7 +703,7 @@ PHP_FUNCTION(spl_autoload_unregister)
 		}
 	}
 
-	efree(lc_name);
+	STR_RELEASE(lc_name);
 	RETURN_BOOL(success == SUCCESS);
 } /* }}} */
 
@@ -712,46 +720,44 @@ PHP_FUNCTION(spl_autoload_functions)
 	}
 	
 	if (!EG(autoload_func)) {
-		if (zend_hash_find(EG(function_table), ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME), (void **) &fptr) == SUCCESS) {
+		if ((fptr = zend_hash_str_find_ptr(EG(function_table), ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME) - 1))) {
 			array_init(return_value);
-			add_next_index_stringl(return_value, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1, 1);
+			add_next_index_stringl(return_value, ZEND_AUTOLOAD_FUNC_NAME, sizeof(ZEND_AUTOLOAD_FUNC_NAME)-1);
 			return;
 		}
 		RETURN_FALSE;
 	}
 
-	zend_hash_find(EG(function_table), "spl_autoload_call", sizeof("spl_autoload_call"), (void **) &fptr);
+	fptr = zend_hash_str_find_ptr(EG(function_table), "spl_autoload_call", sizeof("spl_autoload_call") - 1);
 
 	if (EG(autoload_func) == fptr) {
 		array_init(return_value);
 		zend_hash_internal_pointer_reset_ex(SPL_G(autoload_functions), &function_pos);
-		while(zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
-			zend_hash_get_current_data_ex(SPL_G(autoload_functions), (void **) &alfi, &function_pos);
-			if (alfi->closure) {
-				Z_ADDREF_P(alfi->closure);
-				add_next_index_zval(return_value, alfi->closure);
+		while (zend_hash_has_more_elements_ex(SPL_G(autoload_functions), &function_pos) == SUCCESS) {
+			alfi = zend_hash_get_current_data_ptr_ex(SPL_G(autoload_functions), &function_pos);
+			if (!ZVAL_IS_UNDEF(&alfi->closure)) {
+				Z_ADDREF(alfi->closure);
+				add_next_index_zval(return_value, &alfi->closure);
 			} else if (alfi->func_ptr->common.scope) {
-				zval *tmp;
-				MAKE_STD_ZVAL(tmp);
-				array_init(tmp);
+				zval tmp;
 
-				if (alfi->obj) {
-					Z_ADDREF_P(alfi->obj);
-					add_next_index_zval(tmp, alfi->obj);
+				array_init(&tmp);
+				if (!ZVAL_IS_UNDEF(&alfi->obj)) {
+					Z_ADDREF(alfi->obj);
+					add_next_index_zval(&tmp, &alfi->obj);
 				} else {
-					add_next_index_string(tmp, alfi->ce->name, 1);
+					add_next_index_str(&tmp, STR_COPY(alfi->ce->name));
 				}
-				add_next_index_string(tmp, alfi->func_ptr->common.function_name, 1);
-				add_next_index_zval(return_value, tmp);
+				add_next_index_str(&tmp, STR_COPY(alfi->func_ptr->common.function_name));
+				add_next_index_zval(return_value, &tmp);
 			} else {
-				if (strncmp(alfi->func_ptr->common.function_name, "__lambda_func", sizeof("__lambda_func") - 1)) {
-					add_next_index_string(return_value, alfi->func_ptr->common.function_name, 1);
+				if (strncmp(alfi->func_ptr->common.function_name->val, "__lambda_func", sizeof("__lambda_func") - 1)) {
+					add_next_index_str(return_value, STR_COPY(alfi->func_ptr->common.function_name));
 				} else {
-				   char *key;
-				   uint len;
-				   long dummy;
-				   zend_hash_get_current_key_ex(SPL_G(autoload_functions), &key, &len, &dummy, 0, &function_pos); 
-				   add_next_index_stringl(return_value, key, len - 1, 1);
+					zend_string *key;
+					ulong dummy;
+					zend_hash_get_current_key_ex(SPL_G(autoload_functions), &key, &dummy, 0, &function_pos); 
+					add_next_index_str(return_value, STR_COPY(key));
 				}
 			}
 
@@ -761,7 +767,7 @@ PHP_FUNCTION(spl_autoload_functions)
 	}
 
 	array_init(return_value);
-	add_next_index_string(return_value, EG(autoload_func)->common.function_name, 1);
+	add_next_index_str(return_value, STR_COPY(EG(autoload_func)->common.function_name));
 } /* }}} */
 
 /* {{{ proto string spl_object_hash(object obj)
@@ -769,16 +775,15 @@ PHP_FUNCTION(spl_autoload_functions)
 PHP_FUNCTION(spl_object_hash)
 {
 	zval *obj;
-	char* hash;
+	char hash[33];
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
 		return;
 	}
 	
-	hash = emalloc(33);
 	php_spl_object_hash(obj, hash TSRMLS_CC);
 	
-	RETVAL_STRING(hash, 0);
+	RETURN_STRING(hash);
 }
 /* }}} */
 
@@ -807,11 +812,11 @@ PHPAPI void php_spl_object_hash(zval *obj, char *result TSRMLS_DC) /* {{{*/
 }
 /* }}} */
 
-int spl_build_class_list_string(zval **entry, char **list TSRMLS_DC) /* {{{ */
+int spl_build_class_list_string(zval *entry, char **list TSRMLS_DC) /* {{{ */
 {
 	char *res;
 	
-	spprintf(&res, 0, "%s, %s", *list, Z_STRVAL_PP(entry));
+	spprintf(&res, 0, "%s, %s", *list, Z_STRVAL_P(entry));
 	efree(*list);
 	*list = res;
 	return ZEND_HASH_APPLY_KEEP;
@@ -827,7 +832,6 @@ PHP_MINFO_FUNCTION(spl)
 	php_info_print_table_start();
 	php_info_print_table_header(2, "SPL support",        "enabled");
 
-	INIT_PZVAL(&list);
 	array_init(&list);
 	SPL_LIST_CLASSES(&list, 0, 1, ZEND_ACC_INTERFACE)
 	strg = estrdup("");
@@ -836,7 +840,6 @@ PHP_MINFO_FUNCTION(spl)
 	php_info_print_table_row(2, "Interfaces", strg + 2);
 	efree(strg);
 
-	INIT_PZVAL(&list);
 	array_init(&list);
 	SPL_LIST_CLASSES(&list, 0, -1, ZEND_ACC_INTERFACE)
 	strg = estrdup("");
@@ -956,7 +959,6 @@ PHP_MINIT_FUNCTION(spl)
 PHP_RINIT_FUNCTION(spl) /* {{{ */
 {
 	SPL_G(autoload_extensions) = NULL;
-	SPL_G(autoload_extensions_len) = 0;
 	SPL_G(autoload_functions) = NULL;
 	SPL_G(hash_mask_init) = 0;
 	return SUCCESS;
@@ -965,9 +967,8 @@ PHP_RINIT_FUNCTION(spl) /* {{{ */
 PHP_RSHUTDOWN_FUNCTION(spl) /* {{{ */
 {
 	if (SPL_G(autoload_extensions)) {
-		efree(SPL_G(autoload_extensions));
+		STR_RELEASE(SPL_G(autoload_extensions));
 		SPL_G(autoload_extensions) = NULL;
-		SPL_G(autoload_extensions_len) = 0;
 	}
 	if (SPL_G(autoload_functions)) {
 		zend_hash_destroy(SPL_G(autoload_functions));
diff --git a/ext/spl/php_spl.h b/ext/spl/php_spl.h
index 425e56cb1a..b186255f57 100644
--- a/ext/spl/php_spl.h
+++ b/ext/spl/php_spl.h
@@ -58,10 +58,9 @@ PHP_MINFO_FUNCTION(spl);
 
 
 ZEND_BEGIN_MODULE_GLOBALS(spl)
-	char *       autoload_extensions;
-	HashTable *  autoload_functions;
+	zend_string *autoload_extensions;
+	HashTable   *autoload_functions;
 	int          autoload_running;
-	int          autoload_extensions_len;
 	intptr_t     hash_mask_handle;
 	intptr_t     hash_mask_handlers;
 	int          hash_mask_init;
diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c
index 3e97e9448d..0baba586ce 100644
--- a/ext/spl/spl_array.c
+++ b/ext/spl/spl_array.c
@@ -63,9 +63,8 @@ PHPAPI zend_class_entry  *spl_ce_RecursiveArrayIterator;
 #define SPL_ARRAY_METHOD_MAY_USER_ARG 		2
 
 typedef struct _spl_array_object {
-	zend_object       std;
-	zval              *array;
-	zval              *retval;
+	zval              array;
+	zval              retval;
 	HashPosition      pos;
 	ulong             pos_h;
 	int               ar_flags;
@@ -76,18 +75,26 @@ typedef struct _spl_array_object {
 	zend_function     *fptr_offset_del;
 	zend_function     *fptr_count;
 	zend_class_entry* ce_get_iterator;
-	HashTable              *debug_info;
-	unsigned char		   nApplyCount;
+	HashTable         *debug_info;
+	unsigned char	  nApplyCount;
+	zend_object       std;
 } spl_array_object;
 
+static inline spl_array_object *spl_array_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_array_object*)((char*)(obj) - XtOffsetOf(spl_array_object, std));
+}
+/* }}} */
+
+#define Z_SPLARRAY_P(zv)  spl_array_from_obj(Z_OBJ_P((zv)))
+
 static inline HashTable *spl_array_get_hash_table(spl_array_object* intern, int check_std_props TSRMLS_DC) { /* {{{ */
 	if ((intern->ar_flags & SPL_ARRAY_IS_SELF) != 0) {
 		if (!intern->std.properties) {
 			rebuild_object_properties(&intern->std);
 		}
 		return intern->std.properties;
-	} else if ((intern->ar_flags & SPL_ARRAY_USE_OTHER) && (check_std_props == 0 || (intern->ar_flags & SPL_ARRAY_STD_PROP_LIST) == 0) && Z_TYPE_P(intern->array) == IS_OBJECT) {
-		spl_array_object *other  = (spl_array_object*)zend_object_store_get_object(intern->array TSRMLS_CC);
+	} else if ((intern->ar_flags & SPL_ARRAY_USE_OTHER) && (check_std_props == 0 || (intern->ar_flags & SPL_ARRAY_STD_PROP_LIST) == 0) && Z_TYPE(intern->array) == IS_OBJECT) {
+		spl_array_object *other = Z_SPLARRAY_P(&intern->array);
 		return spl_array_get_hash_table(other, check_std_props TSRMLS_CC);
 	} else if ((intern->ar_flags & ((check_std_props ? SPL_ARRAY_STD_PROP_LIST : 0) | SPL_ARRAY_IS_SELF)) != 0) {
 		if (!intern->std.properties) {
@@ -95,39 +102,45 @@ static inline HashTable *spl_array_get_hash_table(spl_array_object* intern, int
 		}
 		return intern->std.properties;
 	} else {
-		return HASH_OF(intern->array);
+		return HASH_OF(&intern->array);
 	}
 } /* }}} */
 
 static void spl_array_rewind(spl_array_object *intern TSRMLS_DC);
 
-static void spl_array_update_pos(spl_array_object* intern) /* {{{ */
+static void spl_array_update_pos(HashTable *ht, spl_array_object* intern) /* {{{ */
 {
-	Bucket *pos = intern->pos;
-	if (pos != NULL) {
-		intern->pos_h = pos->h;
+	uint pos = intern->pos;
+	if (pos != INVALID_IDX) {
+		intern->pos_h = ht->arData[pos].h;
 	}
 } /* }}} */
 
-static void spl_array_set_pos(spl_array_object* intern, HashPosition pos) /* {{{ */
+static void spl_array_set_pos(spl_array_object* intern, HashTable *ht, HashPosition pos) /* {{{ */
 {
 	intern->pos = pos;
-	spl_array_update_pos(intern);
+	spl_array_update_pos(ht, intern);
 } /* }}} */
 
 SPL_API int spl_hash_verify_pos_ex(spl_array_object * intern, HashTable * ht TSRMLS_DC) /* {{{ */
 {
-	Bucket *p;
+	uint idx;
 
 /*	IS_CONSISTENT(ht);*/
 
 /*	HASH_PROTECT_RECURSION(ht);*/
-	p = ht->arBuckets[intern->pos_h & ht->nTableMask];
-	while (p != NULL) {
-		if (p == intern->pos) {
+	if (ht->u.flags & HASH_FLAG_PACKED) {
+		if (intern->pos_h == intern->pos && Z_TYPE(ht->arData[intern->pos_h].val) != IS_UNDEF) {
 			return SUCCESS;
 		}
-		p = p->pNext;
+	} else {
+		idx = ht->arHash[intern->pos_h & ht->nTableMask];
+		while (idx != INVALID_IDX) {		
+			if (idx == intern->pos) {
+				return SUCCESS;
+			}
+			idx = Z_NEXT(ht->arData[idx].val);
+		}
 	}
 /*	HASH_UNPROTECT_RECURSION(ht); */
 	spl_array_rewind(intern TSRMLS_CC);
@@ -143,9 +156,9 @@ SPL_API int spl_hash_verify_pos(spl_array_object * intern TSRMLS_DC) /* {{{ */
 /* }}} */
 
 /* {{{ spl_array_object_free_storage */
-static void spl_array_object_free_storage(void *object TSRMLS_DC)
+static void spl_array_object_free_storage(zend_object *object TSRMLS_DC)
 {
-	spl_array_object *intern = (spl_array_object *)object;
+	spl_array_object *intern = spl_array_from_obj(object);
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 
@@ -156,26 +169,19 @@ static void spl_array_object_free_storage(void *object TSRMLS_DC)
 		zend_hash_destroy(intern->debug_info);
 		efree(intern->debug_info);
 	}
-
-	efree(object);
 }
 /* }}} */
 
 zend_object_iterator *spl_array_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 
 /* {{{ spl_array_object_new_ex */
-static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, spl_array_object **obj, zval *orig, int clone_orig TSRMLS_DC)
+static zend_object *spl_array_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig TSRMLS_DC)
 {
-	zend_object_value retval = {0};
 	spl_array_object *intern;
-	zval *tmp;
-	zend_class_entry * parent = class_type;
+	zend_class_entry *parent = class_type;
 	int inherited = 0;
 
-	intern = emalloc(sizeof(spl_array_object));
-	memset(intern, 0, sizeof(spl_array_object));
-	*obj = intern;
-	ALLOC_INIT_ZVAL(intern->retval);
+	intern = ecalloc(1, sizeof(spl_array_object) + sizeof(zval) * (parent->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
@@ -184,7 +190,7 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s
 	intern->debug_info       = NULL;
 	intern->ce_get_iterator = spl_ce_ArrayIterator;
 	if (orig) {
-		spl_array_object *other = (spl_array_object*)zend_object_store_get_object(orig TSRMLS_CC);
+		spl_array_object *other = Z_SPLARRAY_P(orig);
 
 		intern->ar_flags &= ~ SPL_ARRAY_CLONE_MASK;
 		intern->ar_flags |= (other->ar_flags & SPL_ARRAY_CLONE_MASK);
@@ -192,32 +198,29 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s
 		if (clone_orig) {
 			intern->array = other->array;
 			if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayObject) {
-				MAKE_STD_ZVAL(intern->array);
-				array_init(intern->array);
-				zend_hash_copy(HASH_OF(intern->array), HASH_OF(other->array), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
+				array_init(&intern->array);
+				zend_hash_copy(HASH_OF(&intern->array), HASH_OF(&other->array), (copy_ctor_func_t) zval_add_ref);
 			}
 			if (Z_OBJ_HT_P(orig) == &spl_handler_ArrayIterator) {
-				Z_ADDREF_P(other->array);
+				Z_ADDREF_P(&other->array);
 			}
 		} else {
-			intern->array = orig;
-			Z_ADDREF_P(intern->array);
+			intern->array = *orig;
+			Z_ADDREF_P(&intern->array);
 			intern->ar_flags |= SPL_ARRAY_IS_REF | SPL_ARRAY_USE_OTHER;
 		}
 	} else {
-		MAKE_STD_ZVAL(intern->array);
-		array_init(intern->array);
+		array_init(&intern->array);
 		intern->ar_flags &= ~SPL_ARRAY_IS_REF;
 	}
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) spl_array_object_free_storage, NULL TSRMLS_CC);
 	while (parent) {
 		if (parent == spl_ce_ArrayIterator || parent == spl_ce_RecursiveArrayIterator) {
-			retval.handlers = &spl_handler_ArrayIterator;
+			intern->std.handlers = &spl_handler_ArrayIterator;
 			class_type->get_iterator = spl_array_get_iterator;
 			break;
 		} else if (parent == spl_ce_ArrayObject) {
-			retval.handlers = &spl_handler_ArrayObject;
+			intern->std.handlers = &spl_handler_ArrayObject;
 			break;
 		}
 		parent = parent->parent;
@@ -227,36 +230,36 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s
 		php_error_docref(NULL TSRMLS_CC, E_COMPILE_ERROR, "Internal compiler error, Class is not child of ArrayObject or ArrayIterator");
 	}
 	if (inherited) {
-		zend_hash_find(&class_type->function_table, "offsetget",    sizeof("offsetget"),    (void **) &intern->fptr_offset_get);
+		intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1);
 		if (intern->fptr_offset_get->common.scope == parent) {
 			intern->fptr_offset_get = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetset",    sizeof("offsetset"),    (void **) &intern->fptr_offset_set);
+		intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1);
 		if (intern->fptr_offset_set->common.scope == parent) {
 			intern->fptr_offset_set = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetexists", sizeof("offsetexists"), (void **) &intern->fptr_offset_has);
+		intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1);
 		if (intern->fptr_offset_has->common.scope == parent) {
 			intern->fptr_offset_has = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetunset",  sizeof("offsetunset"),  (void **) &intern->fptr_offset_del);
+		intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset",  sizeof("offsetunset") - 1);
 		if (intern->fptr_offset_del->common.scope == parent) {
 			intern->fptr_offset_del = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "count",        sizeof("count"),        (void **) &intern->fptr_count);
+		intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
 		if (intern->fptr_count->common.scope == parent) {
 			intern->fptr_count = NULL;
 		}
 	}
 	/* Cache iterator functions if ArrayIterator or derived. Check current's */
 	/* cache since only current is always required */
-	if (retval.handlers == &spl_handler_ArrayIterator) {
+	if (intern->std.handlers == &spl_handler_ArrayIterator) {
 		if (!class_type->iterator_funcs.zf_current) {
-			zend_hash_find(&class_type->function_table, "rewind",  sizeof("rewind"),  (void **) &class_type->iterator_funcs.zf_rewind);
-			zend_hash_find(&class_type->function_table, "valid",   sizeof("valid"),   (void **) &class_type->iterator_funcs.zf_valid);
-			zend_hash_find(&class_type->function_table, "key",     sizeof("key"),     (void **) &class_type->iterator_funcs.zf_key);
-			zend_hash_find(&class_type->function_table, "current", sizeof("current"), (void **) &class_type->iterator_funcs.zf_current);
-			zend_hash_find(&class_type->function_table, "next",    sizeof("next"),    (void **) &class_type->iterator_funcs.zf_next);
+			class_type->iterator_funcs.zf_rewind = zend_hash_str_find_ptr(&class_type->function_table, "rewind", sizeof("rewind") - 1);
+			class_type->iterator_funcs.zf_valid = zend_hash_str_find_ptr(&class_type->function_table, "valid", sizeof("valid") - 1);
+			class_type->iterator_funcs.zf_key = zend_hash_str_find_ptr(&class_type->function_table, "key", sizeof("key") - 1);
+			class_type->iterator_funcs.zf_current = zend_hash_str_find_ptr(&class_type->function_table, "current", sizeof("current") - 1);
+			class_type->iterator_funcs.zf_next = zend_hash_str_find_ptr(&class_type->function_table, "next", sizeof("next") - 1);
 		}
 		if (inherited) {
 			if (class_type->iterator_funcs.zf_rewind->common.scope  != parent) intern->ar_flags |= SPL_ARRAY_OVERLOADED_REWIND;
@@ -268,100 +271,119 @@ static zend_object_value spl_array_object_new_ex(zend_class_entry *class_type, s
 	}
 
 	spl_array_rewind(intern TSRMLS_CC);
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
 /* {{{ spl_array_object_new */
-static zend_object_value spl_array_object_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_array_object_new(zend_class_entry *class_type TSRMLS_DC)
 {
-	spl_array_object *tmp;
-	return spl_array_object_new_ex(class_type, &tmp, NULL, 0 TSRMLS_CC);
+	return spl_array_object_new_ex(class_type, NULL, 0 TSRMLS_CC);
 }
 /* }}} */
 
 /* {{{ spl_array_object_clone */
-static zend_object_value spl_array_object_clone(zval *zobject TSRMLS_DC)
+static zend_object *spl_array_object_clone(zval *zobject TSRMLS_DC)
 {
-	zend_object_value new_obj_val;
 	zend_object *old_object;
 	zend_object *new_object;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-	spl_array_object *intern;
 
-	old_object = zend_objects_get_address(zobject TSRMLS_CC);
-	new_obj_val = spl_array_object_new_ex(old_object->ce, &intern, zobject, 1 TSRMLS_CC);
-	new_object = &intern->std;
+	old_object = Z_OBJ_P(zobject);
+	new_object = spl_array_object_new_ex(old_object->ce, zobject, 1 TSRMLS_CC);
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
-	return new_obj_val;
+	return new_object;
 }
 /* }}} */
 
-static zval **spl_array_get_dimension_ptr_ptr(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
+static zval *spl_array_get_dimension_ptr(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
-	zval **retval;
+	zval *retval;
 	long index;
+	zend_string *offset_key;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
-	if (!offset) {
-		return &EG(uninitialized_zval_ptr);
+	if (!offset || ZVAL_IS_UNDEF(offset)) {
+		return &EG(uninitialized_zval);
 	}
 
-	if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->nApplyCount > 0)) {
+	if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->u.v.nApplyCount > 0)) {
 		zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
-		return &EG(error_zval_ptr);;
+		return &EG(error_zval);;
 	}
 
-	switch(Z_TYPE_P(offset)) {
+	switch (Z_TYPE_P(offset)) {
 	case IS_NULL:
-		Z_STRVAL_P(offset) = "";
-		Z_STRLEN_P(offset) = 0;
+	   offset_key = STR_EMPTY_ALLOC();
+	   goto fetch_dim_string;
 	case IS_STRING:
-		if (zend_symtable_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **) &retval) == FAILURE) {
+	   offset_key = Z_STR_P(offset);
+fetch_dim_string:
+		retval = zend_symtable_find(ht, offset_key);
+		if (retval) {
+			if (Z_TYPE_P(retval) == IS_INDIRECT) {
+				retval = Z_INDIRECT_P(retval);
+				if (Z_TYPE_P(retval) == IS_UNDEF) {
+					switch (type) {
+						case BP_VAR_R:
+							zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
+						case BP_VAR_UNSET:
+						case BP_VAR_IS:
+							retval = &EG(uninitialized_zval);
+							break;
+						case BP_VAR_RW:
+							zend_error(E_NOTICE,"Undefined index: %s", offset_key->val);
+						case BP_VAR_W: {
+							ZVAL_NULL(retval);
+						}
+					}
+				}
+			}
+		} else {
 			switch (type) {
 				case BP_VAR_R:
-					zend_error(E_NOTICE, "Undefined index: %s", Z_STRVAL_P(offset));
+					zend_error(E_NOTICE, "Undefined index: %s", offset_key->val);
 				case BP_VAR_UNSET:
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = &EG(uninitialized_zval);
 					break;
 				case BP_VAR_RW:
-					zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
+					zend_error(E_NOTICE,"Undefined index: %s", offset_key->val);
 				case BP_VAR_W: {
-				    zval *value;
-				    ALLOC_INIT_ZVAL(value);
-				    zend_symtable_update(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), (void **)&retval);
+				    zval value;
+					ZVAL_NULL(&value);
+				    retval = zend_symtable_update(ht, offset_key, &value);
 				}
 			}
 		}
 		return retval;
 	case IS_RESOURCE:
-		zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(offset), Z_LVAL_P(offset));
+		zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_P(offset)->handle, Z_RES_P(offset)->handle);
+		index = Z_RES_P(offset)->handle;
+		goto num_index;
 	case IS_DOUBLE:
+		index = (long)Z_DVAL_P(offset);
+		goto num_index;
 	case IS_BOOL:
 	case IS_LONG:
-		if (offset->type == IS_DOUBLE) {
-			index = (long)Z_DVAL_P(offset);
-		} else {
-			index = Z_LVAL_P(offset);
-		}
-		if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) {
+		index = Z_LVAL_P(offset);
+num_index:
+		if ((retval = zend_hash_index_find(ht, index)) == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 					zend_error(E_NOTICE, "Undefined offset: %ld", index);
 				case BP_VAR_UNSET:
 				case BP_VAR_IS:
-					retval = &EG(uninitialized_zval_ptr);
+					retval = &EG(uninitialized_zval);
 					break;
 				case BP_VAR_RW:
 					zend_error(E_NOTICE, "Undefined offset: %ld", index);
 				case BP_VAR_W: {
-				    zval *value;
-				    ALLOC_INIT_ZVAL(value);
-					zend_hash_index_update(ht, index, (void**)&value, sizeof(void*), (void **)&retval);
+				    zval value;
+					ZVAL_UNDEF(&value);
+					retval = zend_hash_index_update(ht, index, &value);
 			   }
 			}
 		}
@@ -369,131 +391,129 @@ static zval **spl_array_get_dimension_ptr_ptr(int check_inherited, zval *object,
 	default:
 		zend_error(E_WARNING, "Illegal offset type");
 		return (type == BP_VAR_W || type == BP_VAR_RW) ?
-			&EG(error_zval_ptr) : &EG(uninitialized_zval_ptr);
+			&EG(error_zval) : &EG(uninitialized_zval);
 	}
 } /* }}} */
 
-static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
+static zval *spl_array_read_dimension_ex(int check_inherited, zval *object, zval *offset, int type, zval *zv TSRMLS_DC) /* {{{ */
 {
-	zval **ret;
+	zval *ret;
 
 	if (check_inherited) {
-		spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+		spl_array_object *intern = Z_SPLARRAY_P(object);
 		if (intern->fptr_offset_get) {
-			zval *rv;
+			zval rv, tmp;
 			if (!offset) {
-				ALLOC_INIT_ZVAL(offset);
+				ZVAL_UNDEF(&tmp);
+				offset = &tmp;
 			} else {
 				SEPARATE_ARG_IF_REF(offset);
 			}
-			zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_get, "offsetGet", &rv, offset);
-			zval_ptr_dtor(&offset);
-			if (rv) {
+			zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_get, "offsetGet", &rv, offset);
+			zval_ptr_dtor(offset);
+			if (!ZVAL_IS_UNDEF(&rv)) {
 				zval_ptr_dtor(&intern->retval);
-				MAKE_STD_ZVAL(intern->retval);
-				ZVAL_ZVAL(intern->retval, rv, 1, 1);
-				return intern->retval;
+				ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+				return &intern->retval;
 			}
-			return EG(uninitialized_zval_ptr);
+			return &EG(uninitialized_zval);
 		}
 	}
-	ret = spl_array_get_dimension_ptr_ptr(check_inherited, object, offset, type TSRMLS_CC);
+	ret = spl_array_get_dimension_ptr(check_inherited, object, offset, type TSRMLS_CC);
+	//!!! FIXME?
+	//	ZVAL_COPY(result, ret);
 
 	/* When in a write context,
 	 * ZE has to be fooled into thinking this is in a reference set
-	 * by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1) */
-	if ((type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) && !Z_ISREF_PP(ret)) {
-		if (Z_REFCOUNT_PP(ret) > 1) {
-			zval *newval;
-
-			/* Separate */
-			MAKE_STD_ZVAL(newval);
-			*newval = **ret;
-			zval_copy_ctor(newval);
-			Z_SET_REFCOUNT_P(newval, 1);
-
-			/* Replace */
-			Z_DELREF_PP(ret);
-			*ret = newval;
-		}
-
-		Z_SET_ISREF_PP(ret);
+	 * by separating (if necessary) and returning as an is_ref=1 zval (even if refcount == 1) 
+	 */
+	
+	if ((type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) &&
+	    !Z_ISREF_P(ret) &&
+	    EXPECTED(ret != &EG(uninitialized_zval))) {
+		ZVAL_NEW_REF(ret, ret);
 	}
 
-	return *ret;
+	return ret;
 } /* }}} */
 
-static zval *spl_array_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
+static zval *spl_array_read_dimension(zval *object, zval *offset, int type, zval *rv TSRMLS_DC) /* {{{ */
 {
-	return spl_array_read_dimension_ex(1, object, offset, type TSRMLS_CC);
+	return spl_array_read_dimension_ex(1, object, offset, type, rv TSRMLS_CC);
 } /* }}} */
 
 static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval *offset, zval *value TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	long index;
 	HashTable *ht;
 
 	if (check_inherited && intern->fptr_offset_set) {
+		zval tmp;
+
 		if (!offset) {
-			ALLOC_INIT_ZVAL(offset);
+			ZVAL_NULL(&tmp);
+			offset = &tmp;
 		} else {
 			SEPARATE_ARG_IF_REF(offset);
 		}
-		zend_call_method_with_2_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_set, "offsetSet", NULL, offset, value);
-		zval_ptr_dtor(&offset);
+		zend_call_method_with_2_params(object, Z_OBJCE_P(object), &intern->fptr_offset_set, "offsetSet", NULL, offset, value);
+		zval_ptr_dtor(offset);
 		return;
 	}
 
 	if (!offset) {
 		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-		if (ht->nApplyCount > 0) {
+		if (ht->u.v.nApplyCount > 0) {
 			zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
 			return;
 		}
-		Z_ADDREF_P(value);
-		zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);
+		if (Z_REFCOUNTED_P(value)) {
+			Z_ADDREF_P(value);
+		}
+		zend_hash_next_index_insert(ht, value);
 		return;
 	}
-	switch(Z_TYPE_P(offset)) {
-	case IS_STRING:
-		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-		if (ht->nApplyCount > 0) {
-			zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
-			return;
-		}
+
+	if (Z_REFCOUNTED_P(value)) {
 		Z_ADDREF_P(value);
-		zend_symtable_update(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), NULL);
-		return;
-	case IS_DOUBLE:
-	case IS_RESOURCE:
-	case IS_BOOL:
-	case IS_LONG:
-		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-		if (ht->nApplyCount > 0) {
-			zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
+	}
+	switch (Z_TYPE_P(offset)) {
+		case IS_STRING:
+			ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
+			if (ht->u.v.nApplyCount > 0) {
+				zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
+				return;
+			}
+			zend_symtable_update_ind(ht, Z_STR_P(offset), value);
 			return;
-		}
-		if (offset->type == IS_DOUBLE) {
-			index = (long)Z_DVAL_P(offset);
-		} else {
-			index = Z_LVAL_P(offset);
-		}
-		Z_ADDREF_P(value);
-		zend_hash_index_update(ht, index, (void**)&value, sizeof(void*), NULL);
-		return;
-	case IS_NULL:
-		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-		if (ht->nApplyCount > 0) {
-			zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
+		case IS_DOUBLE:
+		case IS_RESOURCE:
+		case IS_BOOL:
+		case IS_LONG:
+			ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
+			if (ht->u.v.nApplyCount > 0) {
+				zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
+				return;
+			}
+			if (Z_TYPE_P(offset) == IS_DOUBLE) {
+				index = (long)Z_DVAL_P(offset);
+			} else {
+				index = Z_LVAL_P(offset);
+			}
+			zend_hash_index_update(ht, index, value);
+			return;
+		case IS_NULL:
+			ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
+			if (ht->u.v.nApplyCount > 0) {
+				zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
+				return;
+			}
+			zend_hash_next_index_insert(ht, value);
+			return;
+		default:
+			zend_error(E_WARNING, "Illegal offset type");
 			return;
-		}
-		Z_ADDREF_P(value);
-		zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);
-		return;
-	default:
-		zend_error(E_WARNING, "Illegal offset type");
-		return;
 	}
 } /* }}} */
 
@@ -504,58 +524,52 @@ static void spl_array_write_dimension(zval *object, zval *offset, zval *value TS
 
 static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval *offset TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
 	long index;
 	HashTable *ht;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if (check_inherited && intern->fptr_offset_del) {
 		SEPARATE_ARG_IF_REF(offset);
-		zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_del, "offsetUnset", NULL, offset);
-		zval_ptr_dtor(&offset);
+		zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_del, "offsetUnset", NULL, offset);
+		zval_ptr_dtor(offset);
 		return;
 	}
 
 	switch(Z_TYPE_P(offset)) {
 	case IS_STRING:
 		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-		if (ht->nApplyCount > 0) {
+		if (ht->u.v.nApplyCount > 0) {
 			zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
 			return;
 		}
-		if (ht == &EG(symbol_table)) {
-			if (zend_delete_global_variable(Z_STRVAL_P(offset), Z_STRLEN_P(offset) TSRMLS_CC)) {
+		if (ht == &EG(symbol_table).ht) {
+			if (zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC)) {
 				zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
 			}
 		} else {
-			if (zend_symtable_del(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1) == FAILURE) {
-				zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
-			} else {
-				spl_array_object *obj = intern;
-
-				while (1) {
-					if ((obj->ar_flags & SPL_ARRAY_IS_SELF) != 0) {
-						break;
-					} else if (Z_TYPE_P(obj->array) == IS_OBJECT) {
-					    if ((obj->ar_flags & SPL_ARRAY_USE_OTHER) == 0) {
-							obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC);
-					    	break;
-						} else {
-							obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC);
-					    }
+//??? see below
+#if 0
+			if (zend_symtable_del_ind(ht, Z_STR_P(offset)) == FAILURE) {
+#else 
+			zval *data = zend_symtable_find(ht, Z_STR_P(offset));
+
+			if (data) {
+				if (Z_TYPE_P(data) == IS_INDIRECT) {
+					data = Z_INDIRECT_P(data);
+					if (Z_TYPE_P(data) == IS_UNDEF) {
+						zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
 					} else {
-						obj = NULL;
-						break;
-					}
-				}
-				if (obj) {
-					zend_property_info *property_info = zend_get_property_info(obj->std.ce, offset, 1 TSRMLS_CC);
-
-					if (property_info &&
-					    (property_info->flags & ZEND_ACC_STATIC) == 0 &&
-					    property_info->offset >= 0) {
-					    obj->std.properties_table[property_info->offset] = NULL;
+						zval_ptr_dtor(data);
+						ZVAL_UNDEF(data);
 					}
+//??? fix for ext/spl/tests/bug45614.phpt (may be fix is wrong)
+					spl_array_rewind(intern TSRMLS_CC);
+				} else if (zend_symtable_del(ht, Z_STR_P(offset)) == FAILURE) {
+					zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
 				}
+			} else {
+#endif
+				zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
 			}
 		}
 		break;
@@ -563,13 +577,13 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval
 	case IS_RESOURCE:
 	case IS_BOOL:
 	case IS_LONG:
-		if (offset->type == IS_DOUBLE) {
+		if (Z_TYPE_P(offset) == IS_DOUBLE) {
 			index = (long)Z_DVAL_P(offset);
 		} else {
 			index = Z_LVAL_P(offset);
 		}
 		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-		if (ht->nApplyCount > 0) {
+		if (ht->u.v.nApplyCount > 0) {
 			zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
 			return;
 		}
@@ -591,27 +605,29 @@ static void spl_array_unset_dimension(zval *object, zval *offset TSRMLS_DC) /* {
 
 static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *offset, int check_empty TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	long index;
-	zval *rv, *value = NULL, **tmp;
+	zval rv, *value = NULL, *tmp;
 
 	if (check_inherited && intern->fptr_offset_has) {
-		zval *offset_tmp = offset;
-		SEPARATE_ARG_IF_REF(offset_tmp);
-		zend_call_method_with_1_params(&object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset_tmp);
-		zval_ptr_dtor(&offset_tmp);
+//???		zval offset_tmp;
+//???		ZVAL_COPY_VALUE(&offset_tmp, offset);
+//???		SEPARATE_ARG_IF_REF(&offset_tmp);
+//???		zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, &offset_tmp);
+//???		zval_ptr_dtor(&offset_tmp);
+		SEPARATE_ARG_IF_REF(offset);
+		zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset);
+		zval_ptr_dtor(offset);
 
-		if (rv && zend_is_true(rv TSRMLS_CC)) {
+		if (!ZVAL_IS_UNDEF(&rv) && zend_is_true(&rv TSRMLS_CC)) {
 			zval_ptr_dtor(&rv);
 			if (check_empty == 2) {
 				return 1;
 			} else if (intern->fptr_offset_get) {
-				value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R TSRMLS_CC);
+				value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R, &rv TSRMLS_CC);
 			}
 		} else {
-			if (rv) {
-				zval_ptr_dtor(&rv);
-			}
+			zval_ptr_dtor(&rv);
 			return 0;
 		}
 	}
@@ -621,7 +637,7 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
 
 		switch(Z_TYPE_P(offset)) {
 			case IS_STRING: 
-				if (zend_symtable_find(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void **) &tmp) != FAILURE) {
+				if ((tmp = zend_symtable_find(ht, Z_STR_P(offset))) != NULL) {
 					if (check_empty == 2) {
 						return 1;
 					}
@@ -633,12 +649,12 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
 			case IS_RESOURCE:
 			case IS_BOOL: 
 			case IS_LONG:
-				if (offset->type == IS_DOUBLE) {
+				if (Z_TYPE_P(offset) == IS_DOUBLE) {
 					index = (long)Z_DVAL_P(offset);
 				} else {
 					index = Z_LVAL_P(offset);
 				}
-				if (zend_hash_index_find(ht, index, (void **)&tmp) != FAILURE) {
+				if ((tmp = zend_hash_index_find(ht, index)) != NULL) {
 					if (check_empty == 2) {
 						return 1;
 					}
@@ -652,9 +668,9 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
 		}
 
 		if (check_inherited && intern->fptr_offset_get) {
-			value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R TSRMLS_CC);
+			value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R, &rv TSRMLS_CC);
 		} else {
-			value = *tmp;
+			value = tmp;
 		}
 	}
 
@@ -683,7 +699,7 @@ static inline int spl_array_object_verify_pos_ex(spl_array_object *object, HashT
 		return FAILURE;
 	}
 
-	if (object->pos && (object->ar_flags & SPL_ARRAY_IS_REF) && spl_hash_verify_pos_ex(object, ht TSRMLS_CC) == FAILURE) {
+	if (object->pos != INVALID_IDX && (object->ar_flags & SPL_ARRAY_IS_REF) && spl_hash_verify_pos_ex(object, ht TSRMLS_CC) == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%sArray was modified outside object and internal position is no longer valid", msg_prefix);
 		return FAILURE;
 	}
@@ -714,12 +730,14 @@ SPL_METHOD(Array, offsetExists)
    Returns the value at the specified $index. */
 SPL_METHOD(Array, offsetGet)
 {
-	zval *index, *value;
+	zval *value, *index;
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &index) == FAILURE) {
 		return;
 	}
-	value = spl_array_read_dimension_ex(0, getThis(), index, BP_VAR_R TSRMLS_CC);
-	RETURN_ZVAL(value, 1, 0);
+	value = spl_array_read_dimension_ex(0, getThis(), index, BP_VAR_R, return_value TSRMLS_CC);
+	if (value != return_value) {
+		RETURN_ZVAL(value, 1, 0);
+	}
 } /* }}} */
 
 /* {{{ proto void ArrayObject::offsetSet(mixed $index, mixed $newval)
@@ -736,7 +754,7 @@ SPL_METHOD(Array, offsetSet)
 
 void spl_array_iterator_append(zval *object, zval *append_value TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (!aht) {
@@ -744,14 +762,16 @@ void spl_array_iterator_append(zval *object, zval *append_value TSRMLS_DC) /* {{
 		return;
 	}
 
-	if (Z_TYPE_P(intern->array) == IS_OBJECT) {
-		php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Cannot append properties to objects, use %s::offsetSet() instead", Z_OBJCE_P(object)->name);
+	if (Z_TYPE(intern->array) == IS_OBJECT) {
+		php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Cannot append properties to objects, use %s::offsetSet() instead", Z_OBJCE_P(object)->name->val);
 		return;
 	}
 
 	spl_array_write_dimension(object, NULL, append_value TSRMLS_CC);
-	if (!intern->pos) {
-		spl_array_set_pos(intern, aht->pListTail);
+	if (intern->pos == INVALID_IDX) {
+		if (aht->nNumUsed && !ZVAL_IS_UNDEF(&aht->arData[aht->nNumUsed-1].val)) {
+			spl_array_set_pos(intern, aht, aht->nNumUsed - 1);
+		}
 	}
 } /* }}} */
 
@@ -785,16 +805,16 @@ SPL_METHOD(Array, offsetUnset)
    Return a copy of the contained array */
 SPL_METHOD(Array, getArrayCopy)
 {
-	zval *object = getThis(), *tmp;
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	zval *object = getThis();
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
     array_init(return_value);
-	zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
+	zend_hash_copy(Z_ARRVAL_P(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t) zval_add_ref);
 } /* }}} */
 
 static HashTable *spl_array_get_properties(zval *object TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *result;
 
 	if (intern->nApplyCount > 1) {
@@ -809,11 +829,10 @@ static HashTable *spl_array_get_properties(zval *object TSRMLS_DC) /* {{{ */
 
 static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(obj TSRMLS_CC);
-	zval *tmp, *storage;
-	int name_len;
-	char *zname;
+	zval *storage;
+	zend_string *zname;
 	zend_class_entry *base;
+	spl_array_object *intern = Z_SPLARRAY_P(obj);
 
 	*is_temp = 0;
 
@@ -821,7 +840,7 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /*
 		rebuild_object_properties(&intern->std);
 	}
 
-	if (HASH_OF(intern->array) == intern->std.properties) {
+	if (HASH_OF(&intern->array) == intern->std.properties) {
 		return intern->std.properties;
 	} else {
 		if (intern->debug_info == NULL) {
@@ -829,17 +848,17 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /*
 			ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(intern->std.properties) + 1, 0);
 		}
 
-		if (intern->debug_info->nApplyCount == 0) {
+		if (intern->debug_info->u.v.nApplyCount == 0) {
 			zend_hash_clean(intern->debug_info);
-			zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+			zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref);
 
-			storage = intern->array;
-			zval_add_ref(&storage);
+			storage = &intern->array;
+			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_update(intern->debug_info, zname, name_len+1, &storage, sizeof(zval *), NULL);
-			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;
@@ -847,62 +866,64 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /*
 }
 /* }}} */
 
-static zval *spl_array_read_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *spl_array_read_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
-		return spl_array_read_dimension(object, member, type TSRMLS_CC);
+		&& !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
+		return spl_array_read_dimension(object, member, type, rv TSRMLS_CC);
 	}
-	return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
+	return std_object_handlers.read_property(object, member, type, cache_slot, rv TSRMLS_CC);
 } /* }}} */
 
-static void spl_array_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void spl_array_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+	&& !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
 		spl_array_write_dimension(object, member, value TSRMLS_CC);
 		return;
 	}
-	std_object_handlers.write_property(object, member, value, key TSRMLS_CC);
+	std_object_handlers.write_property(object, member, value, cache_slot TSRMLS_CC);
 } /* }}} */
 
-static zval **spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *spl_array_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
-		return spl_array_get_dimension_ptr_ptr(1, object, member, type TSRMLS_CC);
+		&& !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
+		return spl_array_get_dimension_ptr(1, object, member, type TSRMLS_CC);
 	}
-	return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
+	//!!! FIXME
+	//return std_object_handlers.get_property_ptr_ptr(object, member, type, key TSRMLS_CC);
+	return NULL;
 } /* }}} */
 
-static int spl_array_has_property(zval *object, zval *member, int has_set_exists, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int spl_array_has_property(zval *object, zval *member, int has_set_exists, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+		&& !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
 		return spl_array_has_dimension(object, member, has_set_exists TSRMLS_CC);
 	}
-	return std_object_handlers.has_property(object, member, has_set_exists, key TSRMLS_CC);
+	return std_object_handlers.has_property(object, member, has_set_exists, cache_slot TSRMLS_CC);
 } /* }}} */
 
-static void spl_array_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void spl_array_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
-	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
+		&& !std_object_handlers.has_property(object, member, 2, cache_slot TSRMLS_CC)) {
 		spl_array_unset_dimension(object, member TSRMLS_CC);
 		spl_array_rewind(intern TSRMLS_CC); /* because deletion might invalidate position */
 		return;
 	}
-	std_object_handlers.unset_property(object, member, key TSRMLS_CC);
+	std_object_handlers.unset_property(object, member, cache_slot TSRMLS_CC);
 } /* }}} */
 
 static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
@@ -914,8 +935,8 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 	int					result	= 0;
 	zval				temp_zv;
 
-	intern1	= (spl_array_object*)zend_object_store_get_object(o1 TSRMLS_CC);
-	intern2	= (spl_array_object*)zend_object_store_get_object(o2 TSRMLS_CC);
+	intern1	= Z_SPLARRAY_P(o1);
+	intern2	= Z_SPLARRAY_P(o2);
 	ht1		= spl_array_get_hash_table(intern1, 0 TSRMLS_CC);
 	ht2		= spl_array_get_hash_table(intern2, 0 TSRMLS_CC);
 
@@ -931,14 +952,18 @@ static int spl_array_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 
 static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */
 {
-	char *string_key;
-	uint string_length;
+	zend_string *string_key;
 	ulong num_key;
+	zval *data;
 
-	if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+	if (Z_TYPE(intern->array) == IS_OBJECT) {
 		do {
-			if (zend_hash_get_current_key_ex(aht, &string_key, &string_length, &num_key, 0, &intern->pos) == HASH_KEY_IS_STRING) {
-				if (!string_length || string_key[0]) {
+			if (zend_hash_get_current_key_ex(aht, &string_key, &num_key, 0, &intern->pos) == HASH_KEY_IS_STRING) {
+				data = zend_hash_get_current_data_ex(aht, &intern->pos);
+				if (data && Z_TYPE_P(data) == IS_INDIRECT &&
+				    Z_TYPE_P(data = Z_INDIRECT_P(data)) == IS_UNDEF) {
+					/* skip */
+				} else if (!string_key->len || string_key->val[0]) {
 					return SUCCESS;
 				}
 			} else {
@@ -948,7 +973,7 @@ static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSR
 				return FAILURE;
 			}
 			zend_hash_move_forward_ex(aht, &intern->pos);
-			spl_array_update_pos(intern);
+			spl_array_update_pos(aht, intern);
 		} while (1);
 	}
 	return FAILURE;
@@ -957,8 +982,8 @@ static int spl_array_skip_protected(spl_array_object *intern, HashTable *aht TSR
 static int spl_array_next_no_verify(spl_array_object *intern, HashTable *aht TSRMLS_DC) /* {{{ */
 {
 	zend_hash_move_forward_ex(aht, &intern->pos);
-	spl_array_update_pos(intern);
-	if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+	spl_array_update_pos(aht, intern);
+	if (Z_TYPE(intern->array) == IS_OBJECT) {
 		return spl_array_skip_protected(intern, aht TSRMLS_CC);
 	} else {
 		return zend_hash_has_more_elements_ex(aht, &intern->pos);
@@ -983,28 +1008,17 @@ static int spl_array_next(spl_array_object *intern TSRMLS_DC) /* {{{ */
 
 } /* }}} */
 
-/* define an overloaded iterator structure */
-typedef struct {
-	zend_user_iterator    intern;
-	spl_array_object      *object;
-} spl_array_it;
-
 static void spl_array_it_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_array_it *iterator = (spl_array_it *)iter;
-
 	zend_user_it_invalidate_current(iter TSRMLS_CC);
-	zval_ptr_dtor((zval**)&iterator->intern.it.data);
-
-	efree(iterator);
+	zval_ptr_dtor(&iter->data);
 }
 /* }}} */
 
 static int spl_array_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_array_it       *iterator = (spl_array_it *)iter;
-	spl_array_object   *object   = iterator->object;
-	HashTable          *aht      = spl_array_get_hash_table(object, 0 TSRMLS_CC);
+	spl_array_object *object = Z_SPLARRAY_P(&iter->data);
+	HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC);
 
 	if (object->ar_flags & SPL_ARRAY_OVERLOADED_VALID) {
 		return zend_user_it_valid(iter TSRMLS_CC);
@@ -1018,27 +1032,27 @@ static int spl_array_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static void spl_array_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *spl_array_it_get_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_array_it       *iterator = (spl_array_it *)iter;
-	spl_array_object   *object   = iterator->object;
-	HashTable          *aht      = spl_array_get_hash_table(object, 0 TSRMLS_CC);
+	spl_array_object *object = Z_SPLARRAY_P(&iter->data);
+	HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC);
 
 	if (object->ar_flags & SPL_ARRAY_OVERLOADED_CURRENT) {
-		zend_user_it_get_current_data(iter, data TSRMLS_CC);
+		return zend_user_it_get_current_data(iter TSRMLS_CC);
 	} else {
-		if (zend_hash_get_current_data_ex(aht, (void**)data, &object->pos) == FAILURE) {
-			*data = NULL;
+		zval *data = zend_hash_get_current_data_ex(aht, &object->pos);
+		if (Z_TYPE_P(data) == IS_INDIRECT) {
+			data = Z_INDIRECT_P(data);
 		}
+		return data;
 	}
 }
 /* }}} */
 
 static void spl_array_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
 {
-	spl_array_it       *iterator = (spl_array_it *)iter;
-	spl_array_object   *object   = iterator->object;
-	HashTable          *aht      = spl_array_get_hash_table(object, 0 TSRMLS_CC);
+	spl_array_object *object = Z_SPLARRAY_P(&iter->data);
+	HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC);
 
 	if (object->ar_flags & SPL_ARRAY_OVERLOADED_KEY) {
 		zend_user_it_get_current_key(iter, key TSRMLS_CC);
@@ -1054,9 +1068,8 @@ static void spl_array_it_get_current_key(zend_object_iterator *iter, zval *key T
 
 static void spl_array_it_move_forward(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_array_it       *iterator = (spl_array_it *)iter;
-	spl_array_object   *object   = iterator->object;
-	HashTable          *aht      = spl_array_get_hash_table(object, 0 TSRMLS_CC);
+	spl_array_object *object = Z_SPLARRAY_P(&iter->data);
+	HashTable *aht = spl_array_get_hash_table(object, 0 TSRMLS_CC);
 
 	if (object->ar_flags & SPL_ARRAY_OVERLOADED_NEXT) {
 		zend_user_it_move_forward(iter TSRMLS_CC);
@@ -1080,14 +1093,14 @@ static void spl_array_rewind_ex(spl_array_object *intern, HashTable *aht TSRMLS_
 {
 
 	zend_hash_internal_pointer_reset_ex(aht, &intern->pos);
-	spl_array_update_pos(intern);
+	spl_array_update_pos(aht, intern);
 	spl_array_skip_protected(intern, aht TSRMLS_CC);
 
 } /* }}} */
 
 static void spl_array_rewind(spl_array_object *intern TSRMLS_DC) /* {{{ */
 {
-	HashTable          *aht      = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
+	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (!aht) {
 		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "ArrayIterator::rewind(): Array was modified outside object and is no longer an array");
@@ -1100,8 +1113,7 @@ static void spl_array_rewind(spl_array_object *intern TSRMLS_DC) /* {{{ */
 
 static void spl_array_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_array_it       *iterator = (spl_array_it *)iter;
-	spl_array_object   *object   = iterator->object;
+	spl_array_object *object = Z_SPLARRAY_P(&iter->data);
 
 	if (object->ar_flags & SPL_ARRAY_OVERLOADED_REWIND) {
 		zend_user_it_rewind(iter TSRMLS_CC);
@@ -1113,41 +1125,41 @@ static void spl_array_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 /* }}} */
 
 /* {{{ spl_array_set_array */
-static void spl_array_set_array(zval *object, spl_array_object *intern, zval **array, long ar_flags, int just_array TSRMLS_DC) {
+static void spl_array_set_array(zval *object, spl_array_object *intern, zval *array, long ar_flags, int just_array TSRMLS_DC) {
 
-	if (Z_TYPE_PP(array) == IS_ARRAY) {
+	if (Z_TYPE_P(array) == IS_ARRAY) {
 		SEPARATE_ZVAL_IF_NOT_REF(array);
 	}
 
-	if (Z_TYPE_PP(array) == IS_OBJECT && (Z_OBJ_HT_PP(array) == &spl_handler_ArrayObject || Z_OBJ_HT_PP(array) == &spl_handler_ArrayIterator)) {
+	if (Z_TYPE_P(array) == IS_OBJECT && (Z_OBJ_HT_P(array) == &spl_handler_ArrayObject || Z_OBJ_HT_P(array) == &spl_handler_ArrayIterator)) {
 		zval_ptr_dtor(&intern->array);
 		if (just_array)	{
-			spl_array_object *other = (spl_array_object*)zend_object_store_get_object(*array TSRMLS_CC);
+			spl_array_object *other = Z_SPLARRAY_P(array);
 			ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK;
 		}
 		ar_flags |= SPL_ARRAY_USE_OTHER;
-		intern->array = *array;
+		ZVAL_COPY_VALUE(&intern->array, array);
 	} else {
-		if (Z_TYPE_PP(array) != IS_OBJECT && Z_TYPE_PP(array) != IS_ARRAY) {
+		if (Z_TYPE_P(array) != IS_OBJECT && Z_TYPE_P(array) != IS_ARRAY) {
 			zend_throw_exception(spl_ce_InvalidArgumentException, "Passed variable is not an array or object, using empty array instead", 0 TSRMLS_CC);
 			return;
 		}
 		zval_ptr_dtor(&intern->array);
-		intern->array = *array;
+		ZVAL_COPY_VALUE(&intern->array, array);
 	}
-	if (object == *array) {
+	if (Z_TYPE_P(array) == IS_OBJECT && Z_OBJ_P(object) == Z_OBJ_P(array)) {
 		intern->ar_flags |= SPL_ARRAY_IS_SELF;
 		intern->ar_flags &= ~SPL_ARRAY_USE_OTHER;
 	} else {
 		intern->ar_flags &= ~SPL_ARRAY_IS_SELF;
 	}
 	intern->ar_flags |= ar_flags;
-	Z_ADDREF_P(intern->array);
-	if (Z_TYPE_PP(array) == IS_OBJECT) {
-		zend_object_get_properties_t handler = Z_OBJ_HANDLER_PP(array, get_properties);
+	Z_ADDREF_P(&intern->array);
+	if (Z_TYPE_P(array) == IS_OBJECT) {
+		zend_object_get_properties_t handler = Z_OBJ_HANDLER_P(array, get_properties);
 		if ((handler != std_object_handlers.get_properties && handler != spl_array_get_properties)
 		|| !spl_array_get_hash_table(intern, 0 TSRMLS_CC)) {
-			zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Overloaded object of type %s is not compatible with %s", Z_OBJCE_PP(array)->name, intern->std.ce->name);
+			zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Overloaded object of type %s is not compatible with %s", Z_OBJCE_P(array)->name, intern->std.ce->name);
 		}
 	}
 
@@ -1167,23 +1179,23 @@ zend_object_iterator_funcs spl_array_it_funcs = {
 
 zend_object_iterator *spl_array_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
-	spl_array_it       *iterator;
-	spl_array_object   *array_object = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	zend_user_iterator *iterator;
+	spl_array_object *array_object = Z_SPLARRAY_P(object);
 
 	if (by_ref && (array_object->ar_flags & SPL_ARRAY_OVERLOADED_CURRENT)) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
 
-	iterator     = emalloc(sizeof(spl_array_it));
+	iterator = emalloc(sizeof(zend_user_iterator));
+
+	zend_iterator_init(&iterator->it TSRMLS_CC);
 
-	Z_ADDREF_P(object);
-	iterator->intern.it.data = (void*)object;
-	iterator->intern.it.funcs = &spl_array_it_funcs;
-	iterator->intern.ce = ce;
-	iterator->intern.value = NULL;
-	iterator->object = array_object;
+	ZVAL_COPY(&iterator->it.data, object);
+	iterator->it.funcs = &spl_array_it_funcs;
+	iterator->ce = ce;
+	ZVAL_UNDEF(&iterator->value);
 
-	return (zend_object_iterator*)iterator;
+	return &iterator->it;
 }
 /* }}} */
 
@@ -1194,7 +1206,7 @@ SPL_METHOD(Array, __construct)
 {
 	zval *object = getThis();
 	spl_array_object *intern;
-	zval **array;
+	zval *array;
 	long ar_flags = 0;
 	zend_class_entry *ce_get_iterator = spl_ce_Iterator;
 	zend_error_handling error_handling;
@@ -1205,9 +1217,9 @@ SPL_METHOD(Array, __construct)
 
 	zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
 
-	intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLARRAY_P(object);
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|lC", &array, &ar_flags, &ce_get_iterator) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|lC", &array, &ar_flags, &ce_get_iterator) == FAILURE) {
 		zend_restore_error_handling(&error_handling TSRMLS_CC);
 		return;
 	}
@@ -1230,7 +1242,7 @@ SPL_METHOD(Array, __construct)
 SPL_METHOD(Array, setIteratorClass)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	zend_class_entry * ce_get_iterator = spl_ce_Iterator;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "C", &ce_get_iterator) == FAILURE) {
@@ -1246,13 +1258,14 @@ SPL_METHOD(Array, setIteratorClass)
 SPL_METHOD(Array, getIteratorClass)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	RETURN_STRING(intern->ce_get_iterator->name, 1);
+	STR_ADDREF(intern->ce_get_iterator->name);
+	RETURN_STR(intern->ce_get_iterator->name);
 }
 /* }}} */
 
@@ -1261,7 +1274,7 @@ SPL_METHOD(Array, getIteratorClass)
 SPL_METHOD(Array, getFlags)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1276,7 +1289,7 @@ SPL_METHOD(Array, getFlags)
 SPL_METHOD(Array, setFlags)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	long ar_flags = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ar_flags) == FAILURE) {
@@ -1291,18 +1304,16 @@ SPL_METHOD(Array, setFlags)
    Replace the referenced array or object with a new one and return the old one (right now copy - to be changed) */
 SPL_METHOD(Array, exchangeArray)
 {
-	zval *object = getThis(), *tmp, **array;
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	zval *object = getThis(), *array;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	array_init(return_value);
-	zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t) zval_add_ref, &tmp, sizeof(zval*));
-
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &array) == FAILURE) {
+	zend_hash_copy(HASH_OF(return_value), spl_array_get_hash_table(intern, 0 TSRMLS_CC), (copy_ctor_func_t)zval_add_ref);
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
 		return;
 	}
 
 	spl_array_set_array(object, intern, array, 0L, 1 TSRMLS_CC);
-
 }
 /* }}} */
 
@@ -1311,8 +1322,7 @@ SPL_METHOD(Array, exchangeArray)
 SPL_METHOD(Array, getIterator)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
-	spl_array_object *iterator;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1324,10 +1334,9 @@ SPL_METHOD(Array, getIterator)
 		return;
 	}
 
-	return_value->type = IS_OBJECT;
-	return_value->value.obj = spl_array_object_new_ex(intern->ce_get_iterator, &iterator, object, 0 TSRMLS_CC);
+	ZVAL_OBJ(return_value, spl_array_object_new_ex(intern->ce_get_iterator, object, 0 TSRMLS_CC));
 	Z_SET_REFCOUNT_P(return_value, 1);
-	Z_SET_ISREF_P(return_value);
+	//!!!PZ_SET_ISREF_P(return_value);
 }
 /* }}} */
 
@@ -1336,7 +1345,7 @@ SPL_METHOD(Array, getIterator)
 SPL_METHOD(Array, rewind)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1352,7 +1361,7 @@ SPL_METHOD(Array, seek)
 {
 	long opos, position;
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 	int result;
 
@@ -1391,16 +1400,16 @@ int static spl_array_object_count_elements_helper(spl_array_object *intern, long
 		return FAILURE;
 	}
 
-	if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+	if (Z_TYPE(intern->array) == IS_OBJECT) {
 		/* We need to store the 'pos' since we'll modify it in the functions
 		 * we're going to call and which do not support 'pos' as parameter. */
 		pos = intern->pos;
 		*count = 0;
 		spl_array_rewind(intern TSRMLS_CC);
-		while(intern->pos && spl_array_next(intern TSRMLS_CC) == SUCCESS) {
+		while(intern->pos != INVALID_IDX && spl_array_next(intern TSRMLS_CC) == SUCCESS) {
 			(*count)++;
 		}
-		spl_array_set_pos(intern, pos);
+		spl_array_set_pos(intern, aht, pos);
 		return SUCCESS;
 	} else {
 		*count = zend_hash_num_elements(aht);
@@ -1410,17 +1419,16 @@ int static spl_array_object_count_elements_helper(spl_array_object *intern, long
 
 int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 
 	if (intern->fptr_count) {
-		zval *rv;
-		zend_call_method_with_0_params(&object, intern->std.ce, &intern->fptr_count, "count", &rv);
-		if (rv) {
+		zval rv;
+		zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
+		if (Z_TYPE(rv) != IS_UNDEF) {
 			zval_ptr_dtor(&intern->retval);
-			MAKE_STD_ZVAL(intern->retval);
-			ZVAL_ZVAL(intern->retval, rv, 1, 1);
-			convert_to_long(intern->retval);
-			*count = (long) Z_LVAL_P(intern->retval);
+			ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+			convert_to_long(&intern->retval);
+			*count = (long)Z_LVAL(intern->retval);
 			return SUCCESS;
 		}
 		*count = 0;
@@ -1435,7 +1443,7 @@ int spl_array_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{
 SPL_METHOD(Array, count)
 {
 	long count;
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1448,44 +1456,48 @@ SPL_METHOD(Array, count)
 
 static void spl_array_method(INTERNAL_FUNCTION_PARAMETERS, char *fname, int fname_len, int use_arg) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(getThis());
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-	zval *tmp, *arg = NULL;
-	zval *retval_ptr = NULL;
+	zval tmp, *arg = NULL;
+	zval retval;
 
-	MAKE_STD_ZVAL(tmp);
-	Z_TYPE_P(tmp) = IS_ARRAY;
-	Z_ARRVAL_P(tmp) = aht;
+	/* A tricky way to pass "aht" by reference, copy HashTable */
+	//??? It may be not safe, if user comparison handler accesses "aht"
+	ZVAL_NEW_ARR(&tmp);
+	*Z_ARRVAL(tmp) = *aht;
 
 	if (!use_arg) {
-		aht->nApplyCount++;
-		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, 1, tmp, NULL TSRMLS_CC);
-		aht->nApplyCount--;
+		aht->u.v.nApplyCount++;
+		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 1, &tmp, NULL TSRMLS_CC);
+		aht->u.v.nApplyCount--;
 	} else if (use_arg == SPL_ARRAY_METHOD_MAY_USER_ARG) {
 		if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "|z", &arg) == FAILURE) {
-			Z_TYPE_P(tmp) = IS_NULL;
 			zval_ptr_dtor(&tmp);
 			zend_throw_exception(spl_ce_BadMethodCallException, "Function expects one argument at most", 0 TSRMLS_CC);
 			return;
 		}
-		aht->nApplyCount++;
-		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, arg? 2 : 1, tmp, arg TSRMLS_CC);
-		aht->nApplyCount--;
+		aht->u.v.nApplyCount++;
+		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, arg? 2 : 1, &tmp, arg TSRMLS_CC);
+		aht->u.v.nApplyCount--;
 	} else {
 		if (ZEND_NUM_ARGS() != 1 || zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
-			Z_TYPE_P(tmp) = IS_NULL;
 			zval_ptr_dtor(&tmp);
 			zend_throw_exception(spl_ce_BadMethodCallException, "Function expects exactly one argument", 0 TSRMLS_CC);
 			return;
 		}
-		aht->nApplyCount++;
-		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, 2, tmp, arg TSRMLS_CC);
-		aht->nApplyCount--;
+		aht->u.v.nApplyCount++;
+		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 2, &tmp, arg TSRMLS_CC);
+		aht->u.v.nApplyCount--;
+	}
+	/* A tricky way to pass "aht" by reference, copy back and cleanup */
+	if (Z_ISREF(tmp) && Z_TYPE_P(Z_REFVAL(tmp))) {
+		*aht = *Z_ARRVAL_P(Z_REFVAL(tmp));
+		GC_REMOVE_FROM_BUFFER(Z_ARR_P(Z_REFVAL(tmp)));
+		efree(Z_ARR_P(Z_REFVAL(tmp)));
+		efree(Z_REF(tmp));
 	}
-	Z_TYPE_P(tmp) = IS_NULL; /* we want to destroy the zval, not the hashtable */
-	zval_ptr_dtor(&tmp);
-	if (retval_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, retval_ptr);
+	if (!ZVAL_IS_UNDEF(&retval)) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 } /* }}} */
 
@@ -1530,8 +1542,8 @@ SPL_ARRAY_METHOD(Array, natcasesort, SPL_ARRAY_METHOD_NO_ARG) /* }}} */
 SPL_METHOD(Array, current)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
-	zval **entry;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
+	zval *entry;
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1542,10 +1554,16 @@ SPL_METHOD(Array, current)
 		return;
 	}
 
-	if (zend_hash_get_current_data_ex(aht, (void **) &entry, &intern->pos) == FAILURE) {
+	if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
 		return;
 	}
-	RETVAL_ZVAL(*entry, 1, 0);
+	if (Z_TYPE_P(entry) == IS_INDIRECT) {
+		entry = Z_INDIRECT_P(entry);
+		if (Z_TYPE_P(entry) == IS_UNDEF) {
+			return;
+		}
+	}
+	RETVAL_ZVAL(entry, 1, 0);
 }
 /* }}} */
 
@@ -1562,7 +1580,7 @@ SPL_METHOD(Array, key)
 
 void spl_array_iterator_key(zval *object, zval *return_value TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (spl_array_object_verify_pos(intern, aht TSRMLS_CC) == FAILURE) {
@@ -1578,7 +1596,7 @@ void spl_array_iterator_key(zval *object, zval *return_value TSRMLS_DC) /* {{{ *
 SPL_METHOD(Array, next)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1598,7 +1616,7 @@ SPL_METHOD(Array, next)
 SPL_METHOD(Array, valid)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1617,8 +1635,8 @@ SPL_METHOD(Array, valid)
    Check whether current element has children (e.g. is an array) */
 SPL_METHOD(Array, hasChildren)
 {
-	zval *object = getThis(), **entry;
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	zval *object = getThis(), *entry;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1629,11 +1647,11 @@ SPL_METHOD(Array, hasChildren)
 		RETURN_FALSE;
 	}
 
-	if (zend_hash_get_current_data_ex(aht, (void **) &entry, &intern->pos) == FAILURE) {
+	if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
 		RETURN_FALSE;
 	}
 
-	RETURN_BOOL(Z_TYPE_PP(entry) == IS_ARRAY || (Z_TYPE_PP(entry) == IS_OBJECT && (intern->ar_flags & SPL_ARRAY_CHILD_ARRAYS_ONLY) == 0));
+	RETURN_BOOL(Z_TYPE_P(entry) == IS_ARRAY || (Z_TYPE_P(entry) == IS_OBJECT && (intern->ar_flags & SPL_ARRAY_CHILD_ARRAYS_ONLY) == 0));
 }
 /* }}} */
 
@@ -1641,8 +1659,8 @@ SPL_METHOD(Array, hasChildren)
    Create a sub iterator for the current element (same class as $this) */
 SPL_METHOD(Array, getChildren)
 {
-	zval *object = getThis(), **entry, *flags;
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	zval *object = getThis(), *entry, flags;
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1653,23 +1671,21 @@ SPL_METHOD(Array, getChildren)
 		return;
 	}
 
-	if (zend_hash_get_current_data_ex(aht, (void **) &entry, &intern->pos) == FAILURE) {
+	if ((entry = zend_hash_get_current_data_ex(aht, &intern->pos)) == NULL) {
 		return;
 	}
 
-	if (Z_TYPE_PP(entry) == IS_OBJECT) {
+	if (Z_TYPE_P(entry) == IS_OBJECT) {
 		if ((intern->ar_flags & SPL_ARRAY_CHILD_ARRAYS_ONLY) != 0) {
 			return;
 		}
-		if (instanceof_function(Z_OBJCE_PP(entry), Z_OBJCE_P(getThis()) TSRMLS_CC)) {
-			RETURN_ZVAL(*entry, 1, 0);
+		if (instanceof_function(Z_OBJCE_P(entry), Z_OBJCE_P(getThis()) TSRMLS_CC)) {
+			RETURN_ZVAL(entry, 1, 0);
 		}
 	}
 
-	MAKE_STD_ZVAL(flags);
-	ZVAL_LONG(flags, SPL_ARRAY_USE_OTHER | intern->ar_flags);
-	spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, *entry, flags TSRMLS_CC);
-	zval_ptr_dtor(&flags);
+	ZVAL_LONG(&flags, SPL_ARRAY_USE_OTHER | intern->ar_flags);
+	spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, entry, &flags TSRMLS_CC);
 }
 /* }}} */
 
@@ -1678,12 +1694,11 @@ SPL_METHOD(Array, getChildren)
 SPL_METHOD(Array, serialize)
 {
 	zval *object = getThis();
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-	zval members, *pmembers;
+	zval members, flags;
 	php_serialize_data_t var_hash;
 	smart_str buf = {0};
-	zval *flags;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1696,13 +1711,12 @@ SPL_METHOD(Array, serialize)
 
 	PHP_VAR_SERIALIZE_INIT(var_hash);
 
-	MAKE_STD_ZVAL(flags);
-	ZVAL_LONG(flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK));
+	ZVAL_LONG(&flags, (intern->ar_flags & SPL_ARRAY_CLONE_MASK));
 
 	/* storage */
 	smart_str_appendl(&buf, "x:", 2);
+	//!!! php_var_serialize need to be modified
 	php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC);
-	zval_ptr_dtor(&flags);
 
 	if (!(intern->ar_flags & SPL_ARRAY_IS_SELF)) {
 		php_var_serialize(&buf, &intern->array, &var_hash TSRMLS_CC);
@@ -1711,20 +1725,22 @@ SPL_METHOD(Array, serialize)
 
 	/* members */
 	smart_str_appendl(&buf, "m:", 2);
-	INIT_PZVAL(&members);
 	if (!intern->std.properties) {
 		rebuild_object_properties(&intern->std);
 	}
-	Z_ARRVAL(members) = intern->std.properties;
-	Z_TYPE(members) = IS_ARRAY;
-	pmembers = &members;
-	php_var_serialize(&buf, &pmembers, &var_hash TSRMLS_CC); /* finishes the string */
+
+	array_init(&members);
+	zend_hash_copy(Z_ARRVAL(members), intern->std.properties, (copy_ctor_func_t)zval_add_ref);
+
+	php_var_serialize(&buf, &members, &var_hash TSRMLS_CC); /* finishes the string */
+
+	zval_ptr_dtor(&members);
 
 	/* done */
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
 
-	if (buf.c) {
-		RETURN_STRINGL(buf.c, buf.len, 0);
+	if (buf.s) {
+		RETURN_STR(buf.s);
 	}
 
 	RETURN_NULL();
@@ -1735,13 +1751,13 @@ SPL_METHOD(Array, serialize)
  */
 SPL_METHOD(Array, unserialize)
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_array_object *intern = Z_SPLARRAY_P(getThis());
 
 	char *buf;
 	int buf_len;
 	const unsigned char *p, *s;
 	php_unserialize_data_t var_hash;
-	zval *pmembers, *pflags = NULL;
+	zval members, zflags;
 	long flags;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
@@ -1762,15 +1778,12 @@ SPL_METHOD(Array, unserialize)
 	}
 	++p;
 
-	ALLOC_INIT_ZVAL(pflags);
-	if (!php_var_unserialize(&pflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE_P(pflags) != IS_LONG) {
-		zval_ptr_dtor(&pflags);
+	if (!php_var_unserialize(&zflags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE(zflags) != IS_LONG) {
 		goto outexcept;
 	}
 
 	--p; /* for ';' */
-	flags = Z_LVAL_P(pflags);
-	zval_ptr_dtor(&pflags);
+	flags = Z_LVAL(zflags);
 	/* flags needs to be verified and we also need to verify whether the next
 	 * thing we get is ';'. After that we require an 'm' or somethign else
 	 * where 'm' stands for members and anything else should be an array. If
@@ -1788,7 +1801,6 @@ SPL_METHOD(Array, unserialize)
 		intern->ar_flags &= ~SPL_ARRAY_CLONE_MASK;
 		intern->ar_flags |= flags & SPL_ARRAY_CLONE_MASK;
 		zval_ptr_dtor(&intern->array);
-		ALLOC_INIT_ZVAL(intern->array);
 		if (!php_var_unserialize(&intern->array, &p, s + buf_len, &var_hash TSRMLS_CC)) {
 			goto outexcept;
 		}
@@ -1804,18 +1816,13 @@ SPL_METHOD(Array, unserialize)
 	}
 	++p;
 
-	ALLOC_INIT_ZVAL(pmembers);
-	if (!php_var_unserialize(&pmembers, &p, s + buf_len, &var_hash TSRMLS_CC)) {
-		zval_ptr_dtor(&pmembers);
+	if (!php_var_unserialize(&members, &p, s + buf_len, &var_hash TSRMLS_CC)) {
 		goto outexcept;
 	}
 
 	/* copy members */
-	if (!intern->std.properties) {
-		rebuild_object_properties(&intern->std);
-	}
-	zend_hash_copy(intern->std.properties, Z_ARRVAL_P(pmembers), (copy_ctor_func_t) zval_add_ref, (void *) NULL, sizeof(zval *));
-	zval_ptr_dtor(&pmembers);
+	object_properties_load(&intern->std, Z_ARRVAL(members) TSRMLS_CC);
+	zval_ptr_dtor(&members);
 
 	/* done reading $serialized */
 
@@ -1947,6 +1954,8 @@ PHP_MINIT_FUNCTION(spl_array)
 	REGISTER_SPL_IMPLEMENTS(ArrayObject, Countable);
 	memcpy(&spl_handler_ArrayObject, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 
+	spl_handler_ArrayObject.offset = XtOffsetOf(spl_array_object, std);
+
 	spl_handler_ArrayObject.clone_obj = spl_array_object_clone;
 	spl_handler_ArrayObject.read_dimension = spl_array_read_dimension;
 	spl_handler_ArrayObject.write_dimension = spl_array_write_dimension;
@@ -1963,6 +1972,8 @@ PHP_MINIT_FUNCTION(spl_array)
 	spl_handler_ArrayObject.unset_property = spl_array_unset_property;
 
 	spl_handler_ArrayObject.compare_objects = spl_array_compare_objects;
+	spl_handler_ArrayObject.dtor_obj = zend_objects_destroy_object;
+	spl_handler_ArrayObject.free_obj = spl_array_object_free_storage;
 
 	REGISTER_SPL_STD_CLASS_EX(ArrayIterator, spl_array_object_new, spl_funcs_ArrayIterator);
 	REGISTER_SPL_IMPLEMENTS(ArrayIterator, Iterator);
diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c
index edb4c071cf..ca6c4adbb2 100644
--- a/ext/spl/spl_directory.c
+++ b/ext/spl/spl_directory.c
@@ -66,15 +66,15 @@ static void spl_filesystem_file_free_line(spl_filesystem_object *intern TSRMLS_D
 		efree(intern->u.file.current_line);
 		intern->u.file.current_line = NULL;
 	}
-	if (intern->u.file.current_zval) {
+	if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
 		zval_ptr_dtor(&intern->u.file.current_zval);
-		intern->u.file.current_zval = NULL;
+		ZVAL_UNDEF(&intern->u.file.current_zval);
 	}
 } /* }}} */
 
-static void spl_filesystem_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void spl_filesystem_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)object;
+	spl_filesystem_object *intern = spl_filesystem_from_obj(object);
 
 	if (intern->oth_handler && intern->oth_handler->dtor) {
 		intern->oth_handler->dtor(intern TSRMLS_CC);
@@ -102,9 +102,11 @@ static void spl_filesystem_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 		break;
 	case SPL_FS_FILE:
 		if (intern->u.file.stream) {
+			/*
 			if (intern->u.file.zcontext) {
-/*				zend_list_delref(Z_RESVAL_P(intern->zcontext));*/
+			   zend_list_delref(Z_RESVAL_P(intern->zcontext));
 			}
+			*/
 			if (!intern->u.file.stream->is_persistent) {
 				php_stream_free(intern->u.file.stream, PHP_STREAM_FREE_CLOSE);
 			} else {
@@ -121,16 +123,9 @@ static void spl_filesystem_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 		break;
 	}
 
-	{
-		zend_object_iterator *iterator;
-		iterator = (zend_object_iterator*)
-				spl_filesystem_object_to_iterator(intern);
-		if (iterator->data != NULL) {
-			iterator->data = NULL;
-			iterator->funcs->dtor(iterator TSRMLS_CC);
-		}
+	if (intern->it) {
+		//????zend_iterator_dtor(&intern->it->intern);
 	}
-	efree(object);
 } /* }}} */
 
 /* {{{ spl_ce_dir_object_new */
@@ -144,45 +139,40 @@ static void spl_filesystem_object_free_storage(void *object TSRMLS_DC) /* {{{ */
    - clone
    - new
  */
-static zend_object_value spl_filesystem_object_new_ex(zend_class_entry *class_type, spl_filesystem_object **obj TSRMLS_DC)
+static zend_object *spl_filesystem_object_new_ex(zend_class_entry *class_type TSRMLS_DC)
 {
-	zend_object_value retval;
 	spl_filesystem_object *intern;
 
-	intern = emalloc(sizeof(spl_filesystem_object));
-	memset(intern, 0, sizeof(spl_filesystem_object));
+	intern = ecalloc(1, sizeof(spl_filesystem_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 	/* intern->type = SPL_FS_INFO; done by set 0 */
 	intern->file_class = spl_ce_SplFileObject;
 	intern->info_class = spl_ce_SplFileInfo;
-	if (obj) *obj = intern;
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
+	intern->std.handlers = &spl_filesystem_object_handlers;
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t) zend_objects_destroy_object, (zend_objects_free_object_storage_t) spl_filesystem_object_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &spl_filesystem_object_handlers;
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
 /* {{{ spl_filesystem_object_new */
 /* See spl_filesystem_object_new_ex */
-static zend_object_value spl_filesystem_object_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_filesystem_object_new(zend_class_entry *class_type TSRMLS_DC)
 {
-	return spl_filesystem_object_new_ex(class_type, NULL TSRMLS_CC);
+	return spl_filesystem_object_new_ex(class_type TSRMLS_CC);
 }
 /* }}} */
 
-/* {{{ spl_filesystem_object_new_ex */
-static zend_object_value spl_filesystem_object_new_check(zend_class_entry *class_type TSRMLS_DC)
+/* {{{ spl_filesystem_object_new_check */
+static zend_object *spl_filesystem_object_new_check(zend_class_entry *class_type TSRMLS_DC)
 {
-	zend_object_value ret = spl_filesystem_object_new_ex(class_type, NULL TSRMLS_CC);
-	ret.handlers = &spl_filesystem_object_check_handlers;
-	return ret;
+	spl_filesystem_object *ret = spl_filesystem_from_obj(spl_filesystem_object_new_ex(class_type TSRMLS_CC));
+	ret->std.handlers = &spl_filesystem_object_check_handlers;
+	return &ret->std;
 }
 /* }}} */
 
-
 PHPAPI char* spl_filesystem_object_get_path(spl_filesystem_object *intern, int *len TSRMLS_DC) /* {{{ */
 {
 #ifdef HAVE_GLOB
@@ -270,7 +260,7 @@ static void spl_filesystem_dir_open(spl_filesystem_object* intern, char *path TS
 
 static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_include_path, int silent TSRMLS_DC) /* {{{ */
 {
-	zval  tmp;
+	zval tmp;
 
 	intern->type = SPL_FS_FILE;
 
@@ -294,9 +284,12 @@ static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_inclu
 		return FAILURE;
 	}
 
+	/*
 	if (intern->u.file.zcontext) {
-		zend_list_addref(Z_RESVAL_P(intern->u.file.zcontext));
+		//zend_list_addref(Z_RES_VAL(intern->u.file.zcontext));
+		Z_ADDREF_P(intern->u.file.zcontext);
 	}
+	*/
 
 	if (intern->file_name_len > 1 && IS_SLASH_AT(intern->file_name, intern->file_name_len-1)) {
 		intern->file_name_len--;
@@ -308,14 +301,16 @@ static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_inclu
 	intern->u.file.open_mode = estrndup(intern->u.file.open_mode, intern->u.file.open_mode_len);
 
 	/* avoid reference counting in debug mode, thus do it manually */
-	ZVAL_RESOURCE(&intern->u.file.zresource, php_stream_get_resource_id(intern->u.file.stream));
+	ZVAL_RES(&intern->u.file.zresource, intern->u.file.stream->res);
+	/*!!! TODO: maybe bug? 
 	Z_SET_REFCOUNT(intern->u.file.zresource, 1);
+	*/
 	
 	intern->u.file.delimiter = ',';
 	intern->u.file.enclosure = '"';
 	intern->u.file.escape = '\\';
 
-	zend_hash_find(&intern->std.ce->function_table, "getcurrentline", sizeof("getcurrentline"), (void **) &intern->u.file.func_getCurr);
+	intern->u.file.func_getCurr = zend_hash_str_find_ptr(&intern->std.ce->function_table, "getcurrentline", sizeof("getcurrentline") - 1);
 
 	return SUCCESS;
 } /* }}} */
@@ -327,45 +322,42 @@ static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_inclu
    Open the directory
    Clone other members (properties)
  */
-static zend_object_value spl_filesystem_object_clone(zval *zobject TSRMLS_DC)
+static zend_object *spl_filesystem_object_clone(zval *zobject TSRMLS_DC)
 {
-	zend_object_value new_obj_val;
 	zend_object *old_object;
 	zend_object *new_object;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
 	spl_filesystem_object *intern;
 	spl_filesystem_object *source;
 	int index, skip_dots;
 
-	old_object = zend_objects_get_address(zobject TSRMLS_CC);
-	source = (spl_filesystem_object*)old_object;
-
-	new_obj_val = spl_filesystem_object_new_ex(old_object->ce, &intern TSRMLS_CC);
-	new_object = &intern->std;
+	old_object = Z_OBJ_P(zobject);
+	source = spl_filesystem_from_obj(old_object);
+	new_object = spl_filesystem_object_new_ex(old_object->ce TSRMLS_CC);
+	intern = spl_filesystem_from_obj(new_object);
 
 	intern->flags = source->flags;
 
 	switch (source->type) {
-	case SPL_FS_INFO:
-		intern->_path_len = source->_path_len;
-		intern->_path = estrndup(source->_path, source->_path_len);
-		intern->file_name_len = source->file_name_len;
-		intern->file_name = estrndup(source->file_name, intern->file_name_len);
-		break;
-	case SPL_FS_DIR:
-		spl_filesystem_dir_open(intern, source->_path TSRMLS_CC);
-		/* read until we hit the position in which we were before */
-		skip_dots = SPL_HAS_FLAG(source->flags, SPL_FILE_DIR_SKIPDOTS);
-		for(index = 0; index < source->u.dir.index; ++index) {
-			do {
-				spl_filesystem_dir_read(intern TSRMLS_CC);
-			} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
-		}
-		intern->u.dir.index = index;
-		break;
-	case SPL_FS_FILE:
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "An object of class %s cannot be cloned", old_object->ce->name);
-		break;
+		case SPL_FS_INFO:
+			intern->_path_len = source->_path_len;
+			intern->_path = estrndup(source->_path, source->_path_len);
+			intern->file_name_len = source->file_name_len;
+			intern->file_name = estrndup(source->file_name, intern->file_name_len);
+			break;
+		case SPL_FS_DIR:
+			spl_filesystem_dir_open(intern, source->_path TSRMLS_CC);
+			/* read until we hit the position in which we were before */
+			skip_dots = SPL_HAS_FLAG(source->flags, SPL_FILE_DIR_SKIPDOTS);
+			for(index = 0; index < source->u.dir.index; ++index) {
+				do {
+					spl_filesystem_dir_read(intern TSRMLS_CC);
+				} while (skip_dots && spl_filesystem_is_dot(intern->u.dir.entry.d_name));
+			}
+			intern->u.dir.index = index;
+			break;
+		case SPL_FS_FILE:
+			php_error_docref(NULL TSRMLS_CC, E_ERROR, "An object of class %s cannot be cloned", old_object->ce->name->val);
+			break;
 	}
 	
 	intern->file_class = source->file_class;
@@ -373,13 +365,13 @@ static zend_object_value spl_filesystem_object_clone(zval *zobject TSRMLS_DC)
 	intern->oth = source->oth;
 	intern->oth_handler = source->oth_handler;
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
 	if (intern->oth_handler && intern->oth_handler->clone) {
 		intern->oth_handler->clone(source, intern TSRMLS_CC);
 	}
 
-	return new_obj_val;
+	return new_object;
 }
 /* }}} */
 
@@ -394,7 +386,7 @@ void spl_filesystem_info_set_filename(spl_filesystem_object *intern, char *path,
 	intern->file_name = use_copy ? estrndup(path, len) : path;
 	intern->file_name_len = len;
 
-	while(IS_SLASH_AT(intern->file_name, intern->file_name_len-1) && intern->file_name_len > 1) {
+	while (IS_SLASH_AT(intern->file_name, intern->file_name_len-1) && intern->file_name_len > 1) {
 		intern->file_name[intern->file_name_len-1] = 0;
 		intern->file_name_len--;
 	}
@@ -417,10 +409,10 @@ void spl_filesystem_info_set_filename(spl_filesystem_object *intern, char *path,
 	intern->_path = estrndup(path, intern->_path_len);
 } /* }}} */
 
-static spl_filesystem_object * spl_filesystem_object_create_info(spl_filesystem_object *source, char *file_path, int file_path_len, int use_copy, zend_class_entry *ce, zval *return_value TSRMLS_DC) /* {{{ */
+static spl_filesystem_object *spl_filesystem_object_create_info(spl_filesystem_object *source, char *file_path, int file_path_len, int use_copy, zend_class_entry *ce, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	spl_filesystem_object *intern;
-	zval *arg1;
+	zval arg1;
 	zend_error_handling error_handling;
 
 	if (!file_path || !file_path_len) {
@@ -445,13 +437,12 @@ static spl_filesystem_object * spl_filesystem_object_create_info(spl_filesystem_
 
 	zend_update_class_constants(ce TSRMLS_CC);
 
-	return_value->value.obj = spl_filesystem_object_new_ex(ce, &intern TSRMLS_CC);
-	Z_TYPE_P(return_value) = IS_OBJECT;
+	intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce TSRMLS_CC));
+	ZVAL_OBJ(return_value, &intern->std);
 
 	if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
-		MAKE_STD_ZVAL(arg1);
-		ZVAL_STRINGL(arg1, file_path, file_path_len, use_copy);
-		zend_call_method_with_1_params(&return_value, ce, &ce->constructor, "__construct", NULL, arg1);
+		ZVAL_STRINGL(&arg1, file_path, file_path_len);
+		zend_call_method_with_1_params(return_value, ce, &ce->constructor, "__construct", NULL, &arg1);
 		zval_ptr_dtor(&arg1);
 	} else {
 		spl_filesystem_info_set_filename(intern, file_path, file_path_len, use_copy TSRMLS_CC);
@@ -461,99 +452,97 @@ static spl_filesystem_object * spl_filesystem_object_create_info(spl_filesystem_
 	return intern;
 } /* }}} */
 
-static spl_filesystem_object * spl_filesystem_object_create_type(int ht, spl_filesystem_object *source, int type, zend_class_entry *ce, zval *return_value TSRMLS_DC) /* {{{ */
+static spl_filesystem_object *spl_filesystem_object_create_type(int ht, spl_filesystem_object *source, int type, zend_class_entry *ce, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	spl_filesystem_object *intern;
 	zend_bool use_include_path = 0;
-	zval *arg1, *arg2;
+	zval arg1, arg2;
 	zend_error_handling error_handling;
 
 	zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
 
 	switch (source->type) {
-	case SPL_FS_INFO:
-	case SPL_FS_FILE:
-		break;
-	case SPL_FS_DIR:
-		if (!source->u.dir.entry.d_name[0]) {
-			zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Could not open file");
-			zend_restore_error_handling(&error_handling TSRMLS_CC);
-			return NULL;
-		}
+		case SPL_FS_INFO:
+		case SPL_FS_FILE:
+			break;
+		case SPL_FS_DIR:
+			if (!source->u.dir.entry.d_name[0]) {
+				zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Could not open file");
+				zend_restore_error_handling(&error_handling TSRMLS_CC);
+				return NULL;
+			}
 	}
 
 	switch (type) {
-	case SPL_FS_INFO:
-		ce = ce ? ce : source->info_class;
+		case SPL_FS_INFO:
+			ce = ce ? ce : source->info_class;
 
-		zend_update_class_constants(ce TSRMLS_CC);
+			zend_update_class_constants(ce TSRMLS_CC);
 
-		return_value->value.obj = spl_filesystem_object_new_ex(ce, &intern TSRMLS_CC);
-		Z_TYPE_P(return_value) = IS_OBJECT;
+			intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce TSRMLS_CC));
+			ZVAL_OBJ(return_value, &intern->std);
 
-		spl_filesystem_object_get_file_name(source TSRMLS_CC);
-		if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
-			MAKE_STD_ZVAL(arg1);
-			ZVAL_STRINGL(arg1, source->file_name, source->file_name_len, 1);
-			zend_call_method_with_1_params(&return_value, ce, &ce->constructor, "__construct", NULL, arg1);
-			zval_ptr_dtor(&arg1);
-		} else {
-			intern->file_name = estrndup(source->file_name, source->file_name_len);
-			intern->file_name_len = source->file_name_len;
-			intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len TSRMLS_CC);
-			intern->_path = estrndup(intern->_path, intern->_path_len);
-		}
-		break;
-	case SPL_FS_FILE:
-		ce = ce ? ce : source->file_class;
+			spl_filesystem_object_get_file_name(source TSRMLS_CC);
+			if (ce->constructor->common.scope != spl_ce_SplFileInfo) {
+				ZVAL_STRINGL(&arg1, source->file_name, source->file_name_len);
+				zend_call_method_with_1_params(return_value, ce, &ce->constructor, "__construct", NULL, &arg1);
+				zval_ptr_dtor(&arg1);
+			} else {
+				intern->file_name = estrndup(source->file_name, source->file_name_len);
+				intern->file_name_len = source->file_name_len;
+				intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len TSRMLS_CC);
+				intern->_path = estrndup(intern->_path, intern->_path_len);
+			}
+			break;
+		case SPL_FS_FILE:
+			ce = ce ? ce : source->file_class;
 
-		zend_update_class_constants(ce TSRMLS_CC);
+			zend_update_class_constants(ce TSRMLS_CC);
 
-		return_value->value.obj = spl_filesystem_object_new_ex(ce, &intern TSRMLS_CC);
-		Z_TYPE_P(return_value) = IS_OBJECT;
-	
-		spl_filesystem_object_get_file_name(source TSRMLS_CC);
+			intern = spl_filesystem_from_obj(spl_filesystem_object_new_ex(ce TSRMLS_CC));
 
-		if (ce->constructor->common.scope != spl_ce_SplFileObject) {
-			MAKE_STD_ZVAL(arg1);
-			MAKE_STD_ZVAL(arg2);
-			ZVAL_STRINGL(arg1, source->file_name, source->file_name_len, 1);
-			ZVAL_STRINGL(arg2, "r", 1, 1);
-			zend_call_method_with_2_params(&return_value, ce, &ce->constructor, "__construct", NULL, arg1, arg2);
-			zval_ptr_dtor(&arg1);
-			zval_ptr_dtor(&arg2);
-		} else {
-			intern->file_name = source->file_name;
-			intern->file_name_len = source->file_name_len;
-			intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len TSRMLS_CC);
-			intern->_path = estrndup(intern->_path, intern->_path_len);
-		
-			intern->u.file.open_mode = "r";
-			intern->u.file.open_mode_len = 1;
-		
-			if (ht && zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|sbr", 
-					&intern->u.file.open_mode, &intern->u.file.open_mode_len, 
-					&use_include_path, &intern->u.file.zcontext) == FAILURE) {
-				zend_restore_error_handling(&error_handling TSRMLS_CC);
-				intern->u.file.open_mode = NULL;
-				intern->file_name = NULL;
-				zval_dtor(return_value);
-				Z_TYPE_P(return_value) = IS_NULL;
-				return NULL;
-			}
-		
-			if (spl_filesystem_file_open(intern, use_include_path, 0 TSRMLS_CC) == FAILURE) {
-				zend_restore_error_handling(&error_handling TSRMLS_CC);
-				zval_dtor(return_value);
-				Z_TYPE_P(return_value) = IS_NULL;
-				return NULL;
+			ZVAL_OBJ(return_value, &intern->std);
+
+			spl_filesystem_object_get_file_name(source TSRMLS_CC);
+
+			if (ce->constructor->common.scope != spl_ce_SplFileObject) {
+				ZVAL_STRINGL(&arg1, source->file_name, source->file_name_len);
+				ZVAL_STRINGL(&arg2, "r", 1);
+				zend_call_method_with_2_params(return_value, ce, &ce->constructor, "__construct", NULL, &arg1, &arg2);
+				zval_ptr_dtor(&arg1);
+				zval_ptr_dtor(&arg2);
+			} else {
+				intern->file_name = source->file_name;
+				intern->file_name_len = source->file_name_len;
+				intern->_path = spl_filesystem_object_get_path(source, &intern->_path_len TSRMLS_CC);
+				intern->_path = estrndup(intern->_path, intern->_path_len);
+
+				intern->u.file.open_mode = "r";
+				intern->u.file.open_mode_len = 1;
+
+				if (ht && zend_parse_parameters(ht TSRMLS_CC, "|sbr", 
+							&intern->u.file.open_mode, &intern->u.file.open_mode_len, 
+							&use_include_path, &intern->u.file.zcontext) == FAILURE) {
+					zend_restore_error_handling(&error_handling TSRMLS_CC);
+					intern->u.file.open_mode = NULL;
+					intern->file_name = NULL;
+					zval_ptr_dtor(return_value);
+					ZVAL_NULL(return_value);
+					return NULL;
+				}
+
+				if (spl_filesystem_file_open(intern, use_include_path, 0 TSRMLS_CC) == FAILURE) {
+					zend_restore_error_handling(&error_handling TSRMLS_CC);
+					zval_ptr_dtor(return_value);
+					ZVAL_NULL(return_value);
+					return NULL;
+				}
 			}
-		}
-		break;
-	case SPL_FS_DIR:	
-		zend_restore_error_handling(&error_handling TSRMLS_CC);
-		zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Operation not supported");
-		return NULL;
+			break;
+		case SPL_FS_DIR:	
+			zend_restore_error_handling(&error_handling TSRMLS_CC);
+			zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Operation not supported");
+			return NULL;
 	}
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 	return NULL;
@@ -567,29 +556,30 @@ static int spl_filesystem_is_invalid_or_dot(const char * d_name) /* {{{ */
 
 static char *spl_filesystem_object_get_pathname(spl_filesystem_object *intern, int *len TSRMLS_DC) { /* {{{ */
 	switch (intern->type) {
-	case SPL_FS_INFO:
-	case SPL_FS_FILE:
-		*len = intern->file_name_len;
-		return intern->file_name;
-	case SPL_FS_DIR:
-		if (intern->u.dir.entry.d_name[0]) {
-			spl_filesystem_object_get_file_name(intern TSRMLS_CC);
+		case SPL_FS_INFO:
+		case SPL_FS_FILE:
 			*len = intern->file_name_len;
 			return intern->file_name;
-		}
+		case SPL_FS_DIR:
+			if (intern->u.dir.entry.d_name[0]) {
+				spl_filesystem_object_get_file_name(intern TSRMLS_CC);
+				*len = intern->file_name_len;
+				return intern->file_name;
+			}
 	}
 	*len = 0;
 	return NULL;
 }
 /* }}} */
 
-static HashTable* spl_filesystem_object_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
+static HashTable *spl_filesystem_object_get_debug_info(zval *object, int *is_temp TSRMLS_DC) /* {{{ */
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(obj TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(object);
+	zval tmp;
 	HashTable *rv;
-	zval *tmp, zrv;
-	char *pnstr, *path;
-	int  pnlen, path_len;
+	zend_string *pnstr;
+	char *path;
+	int  path_len;
 	char stmp[2];
 
 	*is_temp = 1;
@@ -601,75 +591,81 @@ static HashTable* spl_filesystem_object_get_debug_info(zval *obj, int *is_temp T
 	ALLOC_HASHTABLE(rv);
 	ZEND_INIT_SYMTABLE_EX(rv, zend_hash_num_elements(intern->std.properties) + 3, 0);
 
-	INIT_PZVAL(&zrv);
-	Z_ARRVAL(zrv) = rv;
+	zend_hash_copy(rv, intern->std.properties, (copy_ctor_func_t) zval_add_ref);
 
-	zend_hash_copy(rv, intern->std.properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
-
-	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);
-	add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, path, path_len, 1);
-	efree(pnstr);
+	ZVAL_STRINGL(&tmp, path, path_len);
+	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) {
-			add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1), 1);
+			ZVAL_STRINGL(&tmp, intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1));
 		} else {
-			add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->file_name, intern->file_name_len, 1);
+			ZVAL_STRINGL(&tmp, intern->file_name, intern->file_name_len);
 		}
-		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)) {
-			add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->_path, intern->_path_len, 1);
+			ZVAL_STRINGL(&tmp, intern->_path, intern->_path_len);
 		} else {
-			add_assoc_bool_ex(&zrv, pnstr, pnlen+1, 0);
+			ZVAL_BOOL(&tmp, 0);
 		}
-		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) {
-			add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->u.dir.sub_path, intern->u.dir.sub_path_len, 1);
+			ZVAL_STRINGL(&tmp, intern->u.dir.sub_path, intern->u.dir.sub_path_len);
 		} else {
-			add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, "", 0, 1);
+			ZVAL_EMPTY_STRING(&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);
-		add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, intern->u.file.open_mode, intern->u.file.open_mode_len, 1);
-		efree(pnstr);
+		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_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);
-		add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, stmp, 1, 1);
-		efree(pnstr);
+		pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "delimiter", sizeof("delimiter")-1 TSRMLS_CC);
+		ZVAL_STRINGL(&tmp, stmp, 1);
+		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);
-		add_assoc_stringl_ex(&zrv, pnstr, pnlen+1, stmp, 1, 1);
-		efree(pnstr);
+		pnstr = spl_gen_private_prop_name(spl_ce_SplFileObject, "enclosure", sizeof("enclosure")-1 TSRMLS_CC);
+		ZVAL_STRINGL(&tmp, stmp, 1);
+		zend_symtable_update(rv, pnstr, &tmp);
+		STR_RELEASE(pnstr);
 	}
 
 	return rv;
 }
 /* }}} */
 
-zend_function *spl_filesystem_object_get_method_check(zval **object_ptr, char *method, int method_len, const struct _zend_literal *key TSRMLS_DC) /* {{{ */
+zend_function *spl_filesystem_object_get_method_check(zend_object **object, zend_string *method, const zval *key TSRMLS_DC) /* {{{ */
 {
-	spl_filesystem_object *fsobj = zend_object_store_get_object(*object_ptr TSRMLS_CC);
+	spl_filesystem_object *fsobj = spl_filesystem_from_obj(*object);
 	
 	if (fsobj->u.dir.entry.d_name[0] == '\0' && fsobj->orig_path == NULL) {
-		method = "_bad_state_ex";
-		method_len = sizeof("_bad_state_ex") - 1;
-		key = NULL;
+		zend_function *func;
+		zend_string *tmp = STR_INIT("_bad_state_ex", sizeof("_bad_state_ex") - 1, 0);
+		func = zend_get_std_object_handlers()->get_method(object, tmp, NULL TSRMLS_CC);
+		STR_RELEASE(tmp);
+		return func;
 	}
 	
-	return zend_get_std_object_handlers()->get_method(object_ptr, method, method_len, key TSRMLS_CC);
+	return zend_get_std_object_handlers()->get_method(object, method, key TSRMLS_CC);
 }
 /* }}} */
 
@@ -709,7 +705,7 @@ void spl_filesystem_object_construct(INTERNAL_FUNCTION_PARAMETERS, long ctor_fla
 		return;
 	}
 
-	intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLFILESYSTEM_P(getThis());
 	if (intern->_path) {
 		/* object is alreay initialized */
 		zend_restore_error_handling(&error_handling TSRMLS_CC);
@@ -747,7 +743,7 @@ SPL_METHOD(DirectoryIterator, __construct)
    Rewind dir back to the start */
 SPL_METHOD(DirectoryIterator, rewind)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -765,7 +761,7 @@ SPL_METHOD(DirectoryIterator, rewind)
    Return current dir entry */
 SPL_METHOD(DirectoryIterator, key)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -794,7 +790,7 @@ SPL_METHOD(DirectoryIterator, current)
    Move to next entry */
 SPL_METHOD(DirectoryIterator, next)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
 	
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -816,9 +812,9 @@ SPL_METHOD(DirectoryIterator, next)
    Seek to the given position */
 SPL_METHOD(DirectoryIterator, seek)
 {
-	spl_filesystem_object *intern    = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	zval                  *retval    = NULL;
-	long                   pos;
+	spl_filesystem_object *intern    = Z_SPLFILESYSTEM_P(getThis());
+	zval retval;
+	long pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &pos) == FAILURE) {
 		return;
@@ -826,26 +822,20 @@ SPL_METHOD(DirectoryIterator, seek)
 
 	if (intern->u.dir.index > pos) {
 		/* we first rewind */
-		zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_rewind, "rewind", &retval);
-		if (retval) {
-			zval_ptr_dtor(&retval);
-		}
+		zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_rewind, "rewind", NULL);
 	}
 
 	while (intern->u.dir.index < pos) {
 		int valid = 0;
-		zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_valid, "valid", &retval);
-		if (retval) {
-			valid = zend_is_true(retval TSRMLS_CC);
+		zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_valid, "valid", &retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			valid = zend_is_true(&retval TSRMLS_CC);
 			zval_ptr_dtor(&retval);
 		}
 		if (!valid) {
 			break;
 		}
-		zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.dir.func_next, "next", &retval);
-		if (retval) {
-			zval_ptr_dtor(&retval);
-		}
+		zend_call_method_with_0_params(&EG(This), Z_OBJCE(EG(This)), &intern->u.dir.func_next, "next", NULL);
 	}
 } /* }}} */
 
@@ -853,7 +843,7 @@ SPL_METHOD(DirectoryIterator, seek)
    Check whether dir contains more entries */
 SPL_METHOD(DirectoryIterator, valid)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -867,7 +857,7 @@ SPL_METHOD(DirectoryIterator, valid)
    Return the path */
 SPL_METHOD(SplFileInfo, getPath)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char *path;
 	int path_len;
 	
@@ -876,7 +866,7 @@ SPL_METHOD(SplFileInfo, getPath)
 	}
 
   	path = spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
-	RETURN_STRINGL(path, path_len, 1);
+	RETURN_STRINGL(path, path_len);
 }
 /* }}} */
 
@@ -884,7 +874,7 @@ SPL_METHOD(SplFileInfo, getPath)
    Return filename only */
 SPL_METHOD(SplFileInfo, getFilename)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	int path_len;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -894,9 +884,9 @@ SPL_METHOD(SplFileInfo, getFilename)
 	spl_filesystem_object_get_path(intern, &path_len TSRMLS_CC);
 	
 	if (path_len && path_len < intern->file_name_len) {
-		RETURN_STRINGL(intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1), 1);
+		RETURN_STRINGL(intern->file_name + path_len + 1, intern->file_name_len - (path_len + 1));
 	} else {
-		RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
+		RETURN_STRINGL(intern->file_name, intern->file_name_len);
 	}
 }
 /* }}} */
@@ -905,13 +895,13 @@ SPL_METHOD(SplFileInfo, getFilename)
    Return filename of current dir entry */
 SPL_METHOD(DirectoryIterator, getFilename)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	RETURN_STRING(intern->u.dir.entry.d_name, 1);
+	RETURN_STRING(intern->u.dir.entry.d_name);
 }
 /* }}} */
 
@@ -919,11 +909,12 @@ SPL_METHOD(DirectoryIterator, getFilename)
    Returns file extension component of path */
 SPL_METHOD(SplFileInfo, getExtension)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char *fname = NULL;
 	const char *p;
 	size_t flen;
 	int path_len, idx;
+	zend_string *ret;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -939,18 +930,16 @@ SPL_METHOD(SplFileInfo, getExtension)
 		flen = intern->file_name_len;
 	}
 
-	php_basename(fname, flen, NULL, 0, &fname, &flen TSRMLS_CC);
+	ret = php_basename(fname, flen, NULL, 0 TSRMLS_CC);
 
-	p = zend_memrchr(fname, '.', flen);
+	p = zend_memrchr(ret->val, '.', ret->len);
 	if (p) {
-		idx = p - fname;
-		RETVAL_STRINGL(fname + idx + 1, flen - idx - 1, 1);
-		efree(fname);
+		idx = p - ret->val;
+		RETVAL_STRINGL(ret->val + idx + 1, ret->len - idx - 1);
+		STR_RELEASE(ret);
 		return;
 	} else {
-		if (fname) {
-			efree(fname);
-		}
+		STR_RELEASE(ret);
 		RETURN_EMPTY_STRING();
 	}
 }
@@ -960,28 +949,24 @@ SPL_METHOD(SplFileInfo, getExtension)
    Returns the file extension component of path */
 SPL_METHOD(DirectoryIterator, getExtension)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	char *fname = NULL;
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	const char *p;
-	size_t flen;
 	int idx;
+	zend_string *fname;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), NULL, 0, &fname, &flen TSRMLS_CC);
+	fname = php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), NULL, 0 TSRMLS_CC);
 
-	p = zend_memrchr(fname, '.', flen);
+	p = zend_memrchr(fname->val, '.', fname->len);
 	if (p) {
-		idx = p - fname;
-		RETVAL_STRINGL(fname + idx + 1, flen - idx - 1, 1);
-		efree(fname);
-		return;
+		idx = p - fname->val;
+		RETVAL_STRINGL(fname->val + idx + 1, fname->len - idx - 1);
+		STR_RELEASE(fname);
 	} else {
-		if (fname) {
-			efree(fname);
-		}
+		STR_RELEASE(fname);
 		RETURN_EMPTY_STRING();
 	}
 }
@@ -991,7 +976,7 @@ SPL_METHOD(DirectoryIterator, getExtension)
    Returns filename component of path */
 SPL_METHOD(SplFileInfo, getBasename)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char *fname, *suffix = 0;
 	size_t flen;
 	int slen = 0, path_len;
@@ -1010,9 +995,7 @@ SPL_METHOD(SplFileInfo, getBasename)
 		flen = intern->file_name_len;
 	}
 
-	php_basename(fname, flen, suffix, slen, &fname, &flen TSRMLS_CC);
-
-	RETURN_STRINGL(fname, flen, 0);
+	RETURN_STR(php_basename(fname, flen, suffix, slen TSRMLS_CC));
 }
 /* }}}*/   
 
@@ -1020,18 +1003,18 @@ SPL_METHOD(SplFileInfo, getBasename)
    Returns filename component of current dir entry */
 SPL_METHOD(DirectoryIterator, getBasename)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	char *suffix = 0, *fname;
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
+	char *suffix = 0;
 	int slen = 0;
-	size_t flen;
+	zend_string *fname;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &suffix, &slen) == FAILURE) {
 		return;
 	}
 
-	php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), suffix, slen, &fname, &flen TSRMLS_CC);
+	fname = php_basename(intern->u.dir.entry.d_name, strlen(intern->u.dir.entry.d_name), suffix, slen TSRMLS_CC);
 
-	RETURN_STRINGL(fname, flen, 0);
+	RETVAL_STR(fname);
 }
 /* }}} */
 
@@ -1039,7 +1022,7 @@ SPL_METHOD(DirectoryIterator, getBasename)
    Return path and filename */
 SPL_METHOD(SplFileInfo, getPathname)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char *path;
 	int path_len;
 
@@ -1048,7 +1031,7 @@ SPL_METHOD(SplFileInfo, getPathname)
 	}
 	path = spl_filesystem_object_get_pathname(intern, &path_len TSRMLS_CC);
 	if (path != NULL) {
-		RETURN_STRINGL(path, path_len, 1);
+		RETURN_STRINGL(path, path_len);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1059,17 +1042,17 @@ SPL_METHOD(SplFileInfo, getPathname)
    Return getPathname() or getFilename() depending on flags */
 SPL_METHOD(FilesystemIterator, key)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	if (SPL_FILE_DIR_KEY(intern, SPL_FILE_DIR_KEY_AS_FILENAME)) {
-		RETURN_STRING(intern->u.dir.entry.d_name, 1);
+		RETURN_STRING(intern->u.dir.entry.d_name);
 	} else {
 		spl_filesystem_object_get_file_name(intern TSRMLS_CC);
-		RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
+		RETURN_STRINGL(intern->file_name, intern->file_name_len);
 	}
 }
 /* }}} */
@@ -1078,7 +1061,7 @@ SPL_METHOD(FilesystemIterator, key)
    Return getFilename(), getFileInfo() or $this depending on flags */
 SPL_METHOD(FilesystemIterator, current)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1086,7 +1069,7 @@ SPL_METHOD(FilesystemIterator, current)
 
 	if (SPL_FILE_DIR_CURRENT(intern, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
 		spl_filesystem_object_get_file_name(intern TSRMLS_CC);
-		RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
+		RETURN_STRINGL(intern->file_name, intern->file_name_len);
 	} else if (SPL_FILE_DIR_CURRENT(intern, SPL_FILE_DIR_CURRENT_AS_FILEINFO)) {
 		spl_filesystem_object_get_file_name(intern TSRMLS_CC);
 		spl_filesystem_object_create_type(0, intern, SPL_FS_INFO, NULL, return_value TSRMLS_CC);
@@ -1101,7 +1084,7 @@ SPL_METHOD(FilesystemIterator, current)
    Returns true if current entry is '.' or  '..' */
 SPL_METHOD(DirectoryIterator, isDot)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1134,7 +1117,7 @@ SPL_METHOD(SplFileInfo, __construct)
 		return;
 	}
 
-	intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	spl_filesystem_info_set_filename(intern, path, len, 1 TSRMLS_CC);
 
@@ -1148,7 +1131,7 @@ SPL_METHOD(SplFileInfo, __construct)
 #define FileInfoFunction(func_name, func_num) \
 SPL_METHOD(SplFileInfo, func_name) \
 { \
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); \
 	zend_error_handling error_handling; \
 	if (zend_parse_parameters_none() == FAILURE) { \
 		return; \
@@ -1240,7 +1223,7 @@ FileInfoFunction(isLink, FS_IS_LINK)
    Return the target of a symbolic link */
 SPL_METHOD(SplFileInfo, getLinkTarget)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	int ret;
 	char buff[MAXPATHLEN];
 	zend_error_handling error_handling;
@@ -1276,7 +1259,7 @@ SPL_METHOD(SplFileInfo, getLinkTarget)
 		/* Append NULL to the end of the string */
 		buff[ret] = '\0';
 
-		RETVAL_STRINGL(buff, ret, 1);
+		RETVAL_STRINGL(buff, ret);
 	}
 
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
@@ -1288,7 +1271,7 @@ SPL_METHOD(SplFileInfo, getLinkTarget)
    Return the resolved path */
 SPL_METHOD(SplFileInfo, getRealPath)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char buff[MAXPATHLEN];
 	char *filename;
 	zend_error_handling error_handling;
@@ -1316,7 +1299,7 @@ SPL_METHOD(SplFileInfo, getRealPath)
 			RETVAL_FALSE;
 		} else
 #endif
-		RETVAL_STRING(buff, 1);
+		RETVAL_STRING(buff);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -1330,9 +1313,9 @@ SPL_METHOD(SplFileInfo, getRealPath)
    Open the current file */
 SPL_METHOD(SplFileInfo, openFile)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
-	spl_filesystem_object_create_type(ht, intern, SPL_FS_FILE, NULL, return_value TSRMLS_CC);
+	spl_filesystem_object_create_type(ZEND_NUM_ARGS(), intern, SPL_FS_FILE, NULL, return_value TSRMLS_CC);
 }
 /* }}} */
 
@@ -1340,7 +1323,7 @@ SPL_METHOD(SplFileInfo, openFile)
    Class to use in openFile() */
 SPL_METHOD(SplFileInfo, setFileClass)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	zend_class_entry *ce = spl_ce_SplFileObject;
 	zend_error_handling error_handling;
 	
@@ -1358,7 +1341,7 @@ SPL_METHOD(SplFileInfo, setFileClass)
    Class to use in getFileInfo(), getPathInfo() */
 SPL_METHOD(SplFileInfo, setInfoClass)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	zend_class_entry *ce = spl_ce_SplFileInfo;
 	zend_error_handling error_handling;
 	
@@ -1376,14 +1359,14 @@ SPL_METHOD(SplFileInfo, setInfoClass)
    Get/copy file info */
 SPL_METHOD(SplFileInfo, getFileInfo)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	zend_class_entry *ce = intern->info_class;
 	zend_error_handling error_handling;
 	
 	zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|C", &ce) == SUCCESS) {
-		spl_filesystem_object_create_type(ht, intern, SPL_FS_INFO, ce, return_value TSRMLS_CC);
+		spl_filesystem_object_create_type(ZEND_NUM_ARGS(), intern, SPL_FS_INFO, ce, return_value TSRMLS_CC);
 	}
 
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
@@ -1394,7 +1377,7 @@ SPL_METHOD(SplFileInfo, getFileInfo)
    Get/copy file info */
 SPL_METHOD(SplFileInfo, getPathInfo)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	zend_class_entry *ce = intern->info_class;
 	zend_error_handling error_handling;
 	
@@ -1415,7 +1398,7 @@ SPL_METHOD(SplFileInfo, getPathInfo)
 }
 /* }}} */
 
-/* {{{ */
+/* {{{  proto SplFileInfo::_bad_state_ex(void) */
 SPL_METHOD(SplFileInfo, _bad_state_ex)
 {
 	zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC,
@@ -1436,7 +1419,7 @@ SPL_METHOD(FilesystemIterator, __construct)
    Rewind dir back to the start */
 SPL_METHOD(FilesystemIterator, rewind)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	int skip_dots = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_SKIPDOTS);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1457,7 +1440,7 @@ SPL_METHOD(FilesystemIterator, rewind)
    Get handling flags */
 SPL_METHOD(FilesystemIterator, getFlags)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1470,7 +1453,7 @@ SPL_METHOD(FilesystemIterator, getFlags)
    Set handling flags */
 SPL_METHOD(FilesystemIterator, setFlags)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	long flags;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) {
@@ -1486,7 +1469,7 @@ SPL_METHOD(FilesystemIterator, setFlags)
 SPL_METHOD(RecursiveDirectoryIterator, hasChildren)
 {
 	zend_bool allow_links = 0;
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &allow_links) == FAILURE) {
 		return;
@@ -1510,8 +1493,8 @@ SPL_METHOD(RecursiveDirectoryIterator, hasChildren)
    Returns an iterator for the current entry if it is a directory */
 SPL_METHOD(RecursiveDirectoryIterator, getChildren)
 {
-	zval *zpath, *zflags;
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	zval zpath, zflags;
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	spl_filesystem_object *subdir;
 	char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
 	
@@ -1522,17 +1505,15 @@ SPL_METHOD(RecursiveDirectoryIterator, getChildren)
 	spl_filesystem_object_get_file_name(intern TSRMLS_CC);
 
 	if (SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
-		RETURN_STRINGL(intern->file_name, intern->file_name_len, 1);
+		RETURN_STRINGL(intern->file_name, intern->file_name_len);
 	} else {
-		MAKE_STD_ZVAL(zflags);
-		MAKE_STD_ZVAL(zpath);
-		ZVAL_LONG(zflags, intern->flags);
-		ZVAL_STRINGL(zpath, intern->file_name, intern->file_name_len, 1);
-		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, zpath, zflags TSRMLS_CC);
+		ZVAL_LONG(&zflags, intern->flags);
+		ZVAL_STRINGL(&zpath, intern->file_name, intern->file_name_len);
+		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, &zpath, &zflags TSRMLS_CC);
 		zval_ptr_dtor(&zpath);
 		zval_ptr_dtor(&zflags);
 		
-		subdir = (spl_filesystem_object*)zend_object_store_get_object(return_value TSRMLS_CC);
+		subdir = Z_SPLFILESYSTEM_P(return_value);
 		if (subdir) {
 			if (intern->u.dir.sub_path && intern->u.dir.sub_path[0]) {
 				subdir->u.dir.sub_path_len = spprintf(&subdir->u.dir.sub_path, 0, "%s%c%s", intern->u.dir.sub_path, slash, intern->u.dir.entry.d_name);
@@ -1552,16 +1533,16 @@ SPL_METHOD(RecursiveDirectoryIterator, getChildren)
    Get sub path */
 SPL_METHOD(RecursiveDirectoryIterator, getSubPath)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	if (intern->u.dir.sub_path) {
-		RETURN_STRINGL(intern->u.dir.sub_path, intern->u.dir.sub_path_len, 1);
+		RETURN_STRINGL(intern->u.dir.sub_path, intern->u.dir.sub_path_len);
 	} else {
-		RETURN_STRINGL("", 0, 1);
+		RETURN_EMPTY_STRING();
 	}
 }
 /* }}} */
@@ -1570,7 +1551,7 @@ SPL_METHOD(RecursiveDirectoryIterator, getSubPath)
    Get sub path and file name */
 SPL_METHOD(RecursiveDirectoryIterator, getSubPathname)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char *sub_name;
 	int len;
 	char slash = SPL_HAS_FLAG(intern->flags, SPL_FILE_DIR_UNIXPATHS) ? '/' : DEFAULT_SLASH;
@@ -1581,9 +1562,10 @@ SPL_METHOD(RecursiveDirectoryIterator, getSubPathname)
 
 	if (intern->u.dir.sub_path) {
 		len = spprintf(&sub_name, 0, "%s%c%s", intern->u.dir.sub_path, slash, intern->u.dir.entry.d_name);
-		RETURN_STRINGL(sub_name, len, 0);
+		RETVAL_STRINGL(sub_name, len);
+		efree(sub_name);
 	} else {
-		RETURN_STRING(intern->u.dir.entry.d_name, 1);
+		RETURN_STRING(intern->u.dir.entry.d_name);
 	}
 }
 /* }}} */
@@ -1609,7 +1591,7 @@ SPL_METHOD(GlobIterator, __construct)
    Return the number of directories and files found by globbing */
 SPL_METHOD(GlobIterator, count)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1628,7 +1610,7 @@ SPL_METHOD(GlobIterator, count)
 /* {{{ forward declarations to the iterator handlers */
 static void spl_filesystem_dir_it_dtor(zend_object_iterator *iter TSRMLS_DC);
 static int spl_filesystem_dir_it_valid(zend_object_iterator *iter TSRMLS_DC);
-static void spl_filesystem_dir_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC);
+static zval *spl_filesystem_dir_it_current_data(zend_object_iterator *iter TSRMLS_DC);
 static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC);
 static void spl_filesystem_dir_it_move_forward(zend_object_iterator *iter TSRMLS_DC);
 static void spl_filesystem_dir_it_rewind(zend_object_iterator *iter TSRMLS_DC);
@@ -1648,25 +1630,20 @@ zend_object_iterator_funcs spl_filesystem_dir_it_funcs = {
 zend_object_iterator *spl_filesystem_dir_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator;
-	spl_filesystem_object   *dir_object;
+	spl_filesystem_object *dir_object;
 
 	if (by_ref) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
-	dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
-	iterator   = spl_filesystem_object_to_iterator(dir_object);
-
-	/* initialize iterator if it wasn't gotten before */
-	if (iterator->intern.data == NULL) {
-		iterator->intern.data = object;
-		iterator->intern.funcs = &spl_filesystem_dir_it_funcs;
-		/* ->current must be initialized; rewind doesn't set it and valid
-		 * doesn't check whether it's set */
-		iterator->current = object;
-	}
-	zval_add_ref(&object);
+	dir_object = Z_SPLFILESYSTEM_P(object);
+	iterator = spl_filesystem_object_to_iterator(dir_object TSRMLS_CC);
+	ZVAL_COPY(&iterator->intern.data, object);
+	iterator->intern.funcs = &spl_filesystem_dir_it_funcs;
+	/* ->current must be initialized; rewind doesn't set it and valid
+	 * doesn't check whether it's set */
+	iterator->current = *object;
 	
-	return (zend_object_iterator*)iterator;
+	return &iterator->intern;
 }
 /* }}} */
 
@@ -1675,9 +1652,9 @@ static void spl_filesystem_dir_it_dtor(zend_object_iterator *iter TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
 
-	if (iterator->intern.data) {
-		zval *object =  iterator->intern.data;
-		zval_ptr_dtor(&object);
+	if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+		zval *object = &iterator->intern.data;
+		zval_ptr_dtor(object);
 	}
 	/* Otherwise we were called from the owning object free storage handler as
 	 * it sets
@@ -1690,25 +1667,25 @@ static void spl_filesystem_dir_it_dtor(zend_object_iterator *iter TSRMLS_DC)
 /* {{{ spl_filesystem_dir_it_valid */
 static int spl_filesystem_dir_it_valid(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
+	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC);
 
 	return object->u.dir.entry.d_name[0] != '\0' ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 /* {{{ spl_filesystem_dir_it_current_data */
-static void spl_filesystem_dir_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
+static zval *spl_filesystem_dir_it_current_data(zend_object_iterator *iter TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
 	
-	*data = &iterator->current;
+	return &iterator->current;
 }
 /* }}} */
 
 /* {{{ spl_filesystem_dir_it_current_key */
 static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 {
-	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
+	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC);
 
 	ZVAL_LONG(key, object->u.dir.index);
 }
@@ -1717,7 +1694,7 @@ static void spl_filesystem_dir_it_current_key(zend_object_iterator *iter, zval *
 /* {{{ spl_filesystem_dir_it_move_forward */
 static void spl_filesystem_dir_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
+	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC);
 	
 	object->u.dir.index++;
 	spl_filesystem_dir_read(object TSRMLS_CC);
@@ -1731,7 +1708,7 @@ static void spl_filesystem_dir_it_move_forward(zend_object_iterator *iter TSRMLS
 /* {{{ spl_filesystem_dir_it_rewind */
 static void spl_filesystem_dir_it_rewind(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
+	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC);
 	
 	object->u.dir.index = 0;
 	if (object->u.dir.dirp) {
@@ -1746,39 +1723,38 @@ static void spl_filesystem_tree_it_dtor(zend_object_iterator *iter TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
 
-	if (iterator->intern.data) {
-		zval *object = 	iterator->intern.data;
-		zval_ptr_dtor(&object);
+	if (!ZVAL_IS_UNDEF(&iterator->intern.data)) {
+		zval *object = &iterator->intern.data;
+		zval_ptr_dtor(object);
 	} else {
-		if (iterator->current) {
+		if (!ZVAL_IS_UNDEF(&iterator->current)) {
 			zval_ptr_dtor(&iterator->current);
+			ZVAL_UNDEF(&iterator->current);
 		}
 	}
 }
 /* }}} */
 
 /* {{{ spl_filesystem_tree_it_current_data */
-static void spl_filesystem_tree_it_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
+static zval *spl_filesystem_tree_it_current_data(zend_object_iterator *iter TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
-	spl_filesystem_object   *object   = spl_filesystem_iterator_to_object(iterator);
+	spl_filesystem_object   *object   = spl_filesystem_iterator_to_object(iterator TSRMLS_CC);
 
 	if (SPL_FILE_DIR_CURRENT(object, SPL_FILE_DIR_CURRENT_AS_PATHNAME)) {
-		if (!iterator->current) {
-			ALLOC_INIT_ZVAL(iterator->current);
+		if (ZVAL_IS_UNDEF(&iterator->current)) {
 			spl_filesystem_object_get_file_name(object TSRMLS_CC);
-			ZVAL_STRINGL(iterator->current, object->file_name, object->file_name_len, 1);
+			ZVAL_STRINGL(&iterator->current, object->file_name, object->file_name_len);
 		}
-		*data = &iterator->current;
+		return &iterator->current;
 	} else if (SPL_FILE_DIR_CURRENT(object, SPL_FILE_DIR_CURRENT_AS_FILEINFO)) {
-		if (!iterator->current) {
-			ALLOC_INIT_ZVAL(iterator->current);
+		if (ZVAL_IS_UNDEF(&iterator->current)) {
 			spl_filesystem_object_get_file_name(object TSRMLS_CC);
-			spl_filesystem_object_create_type(0, object, SPL_FS_INFO, NULL, iterator->current TSRMLS_CC);
+			spl_filesystem_object_create_type(0, object, SPL_FS_INFO, NULL, &iterator->current TSRMLS_CC);
 		}
-		*data = &iterator->current;
+		return &iterator->current;
 	} else {
-		*data = (zval**)&iterator->intern.data;
+		return &iterator->intern.data;
 	}
 }
 /* }}} */
@@ -1786,13 +1762,13 @@ static void spl_filesystem_tree_it_current_data(zend_object_iterator *iter, zval
 /* {{{ spl_filesystem_tree_it_current_key */
 static void spl_filesystem_tree_it_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 {
-	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter);
+	spl_filesystem_object *object = spl_filesystem_iterator_to_object((spl_filesystem_iterator *)iter TSRMLS_CC);
 
 	if (SPL_FILE_DIR_KEY(object, SPL_FILE_DIR_KEY_AS_FILENAME)) {
-		ZVAL_STRING(key, object->u.dir.entry.d_name, 1);
+		ZVAL_STRING(key, object->u.dir.entry.d_name);
 	} else {
 		spl_filesystem_object_get_file_name(object TSRMLS_CC);
-		ZVAL_STRINGL(key, object->file_name, object->file_name_len, 1);
+		ZVAL_STRINGL(key, object->file_name, object->file_name_len);
 	}
 }
 /* }}} */
@@ -1801,7 +1777,7 @@ static void spl_filesystem_tree_it_current_key(zend_object_iterator *iter, zval
 static void spl_filesystem_tree_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
-	spl_filesystem_object   *object   = spl_filesystem_iterator_to_object(iterator);
+	spl_filesystem_object   *object   = spl_filesystem_iterator_to_object(iterator TSRMLS_CC);
 	
 	object->u.dir.index++;
 	do {
@@ -1811,9 +1787,9 @@ static void spl_filesystem_tree_it_move_forward(zend_object_iterator *iter TSRML
 		efree(object->file_name);
 		object->file_name = NULL;
 	}
-	if (iterator->current) {
+	if (!ZVAL_IS_UNDEF(&iterator->current)) {
 		zval_ptr_dtor(&iterator->current);
-		iterator->current = NULL;
+		ZVAL_UNDEF(&iterator->current);
 	}
 }
 /* }}} */
@@ -1822,7 +1798,7 @@ static void spl_filesystem_tree_it_move_forward(zend_object_iterator *iter TSRML
 static void spl_filesystem_tree_it_rewind(zend_object_iterator *iter TSRMLS_DC)
 {
 	spl_filesystem_iterator *iterator = (spl_filesystem_iterator *)iter;
-	spl_filesystem_object   *object   = spl_filesystem_iterator_to_object(iterator);
+	spl_filesystem_object   *object   = spl_filesystem_iterator_to_object(iterator TSRMLS_CC);
 	
 	object->u.dir.index = 0;
 	if (object->u.dir.dirp) {
@@ -1831,9 +1807,9 @@ static void spl_filesystem_tree_it_rewind(zend_object_iterator *iter TSRMLS_DC)
 	do {
 		spl_filesystem_dir_read(object TSRMLS_CC);
 	} while (spl_filesystem_is_dot(object->u.dir.entry.d_name));
-	if (iterator->current) {
+	if (!ZVAL_IS_UNDEF(&iterator->current)) {
 		zval_ptr_dtor(&iterator->current);
-		iterator->current = NULL;
+		ZVAL_UNDEF(&iterator->current);
 	}
 }
 /* }}} */
@@ -1858,24 +1834,20 @@ zend_object_iterator *spl_filesystem_tree_get_iterator(zend_class_entry *ce, zva
 	if (by_ref) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
-	dir_object = (spl_filesystem_object*)zend_object_store_get_object(object TSRMLS_CC);
-	iterator   = spl_filesystem_object_to_iterator(dir_object);
+	dir_object = Z_SPLFILESYSTEM_P(object);
+	iterator = spl_filesystem_object_to_iterator(dir_object TSRMLS_CC);
 
-	/* initialize iterator if wasn't gotten before */
-	if (iterator->intern.data == NULL) {
-		iterator->intern.data = object;
-		iterator->intern.funcs = &spl_filesystem_tree_it_funcs;
-	}
-	zval_add_ref(&object);
+	ZVAL_COPY(&iterator->intern.data, object);
+	iterator->intern.funcs = &spl_filesystem_tree_it_funcs;
 	
-	return (zend_object_iterator*)iterator;
+	return &iterator->intern;
 }
 /* }}} */
 
 /* {{{ spl_filesystem_object_cast */
 static int spl_filesystem_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(readobj TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(readobj);
 
 	if (type == IS_STRING) {
 		if (Z_OBJCE_P(readobj)->__tostring) {
@@ -1889,11 +1861,11 @@ static int spl_filesystem_object_cast(zval *readobj, zval *writeobj, int type TS
 				zval retval;
 				zval *retval_ptr = &retval;
 
-				ZVAL_STRINGL(retval_ptr, intern->file_name, intern->file_name_len, 1);
+				ZVAL_STRINGL(retval_ptr, intern->file_name, intern->file_name_len);
 				zval_dtor(readobj);
 				ZVAL_ZVAL(writeobj, retval_ptr, 0, 0);
 			} else {
-				ZVAL_STRINGL(writeobj, intern->file_name, intern->file_name_len, 1);
+				ZVAL_STRINGL(writeobj, intern->file_name, intern->file_name_len);
 			}
 			return SUCCESS;
 		case SPL_FS_DIR:
@@ -1901,11 +1873,11 @@ static int spl_filesystem_object_cast(zval *readobj, zval *writeobj, int type TS
 				zval retval;
 				zval *retval_ptr = &retval;
 
-				ZVAL_STRING(retval_ptr, intern->u.dir.entry.d_name, 1);
+				ZVAL_STRING(retval_ptr, intern->u.dir.entry.d_name);
 				zval_dtor(readobj);
 				ZVAL_ZVAL(writeobj, retval_ptr, 0, 0);
 			} else {
-				ZVAL_STRING(writeobj, intern->u.dir.entry.d_name, 1);
+				ZVAL_STRING(writeobj, intern->u.dir.entry.d_name);
 			}
 			return SUCCESS;
 		}
@@ -2051,7 +2023,7 @@ static int spl_filesystem_file_read(spl_filesystem_object *intern, int silent TS
 {
 	char *buf;
 	size_t line_len = 0;
-	long line_add = (intern->u.file.current_line || intern->u.file.current_zval) ? 1 : 0;
+	long line_add = (intern->u.file.current_line || !ZVAL_IS_UNDEF(&intern->u.file.current_zval)) ? 1 : 0;
 
 	spl_filesystem_file_free_line(intern TSRMLS_CC);
 	
@@ -2095,45 +2067,42 @@ static int spl_filesystem_file_call(spl_filesystem_object *intern, zend_function
 {
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcic;
-	zval z_fname;
-	zval * zresource_ptr = &intern->u.file.zresource, *retval;
+	zval *zresource_ptr = &intern->u.file.zresource, retval;
 	int result;
 	int num_args = pass_num_args + (arg2 ? 2 : 1);
 
-	zval ***params = (zval***)safe_emalloc(num_args, sizeof(zval**), 0);
+	zval *params = (zval*)safe_emalloc(num_args, sizeof(zval), 0);
 
-	params[0] = &zresource_ptr;
+	params[0] = *zresource_ptr;
 	
 	if (arg2) {
-		params[1] = &arg2;
+		params[1] = *arg2;
 	}
 
-	zend_get_parameters_array_ex(pass_num_args, params+(arg2 ? 2 : 1));
-
-	ZVAL_STRING(&z_fname, func_ptr->common.function_name, 0);
+	zend_get_parameters_array_ex(pass_num_args, params + (arg2 ? 2 : 1));
 
 	fci.size = sizeof(fci);
 	fci.function_table = EG(function_table);
-	fci.object_ptr = NULL;
-	fci.function_name = &z_fname;
-	fci.retval_ptr_ptr = &retval;
+	fci.object = NULL;
+	fci.retval = &retval;
 	fci.param_count = num_args;
 	fci.params = params;
 	fci.no_separation = 1;
 	fci.symbol_table = NULL;
+	ZVAL_STR(&fci.function_name, func_ptr->common.function_name);
 
 	fcic.initialized = 1;
 	fcic.function_handler = func_ptr;
 	fcic.calling_scope = NULL;
 	fcic.called_scope = NULL;
-	fcic.object_ptr = NULL;
+	fcic.object = NULL;
 
 	result = zend_call_function(&fci, &fcic TSRMLS_CC);
 	
-	if (result == FAILURE) {
+	if (result == FAILURE || ZVAL_IS_UNDEF(&retval)) {
 		RETVAL_FALSE;
 	} else {
-		ZVAL_ZVAL(return_value, retval, 1, 1);
+		ZVAL_ZVAL(return_value, &retval, 0, 0);
 	}
 
 	efree(params);
@@ -2143,9 +2112,8 @@ static int spl_filesystem_file_call(spl_filesystem_object *intern, zend_function
 #define FileFunctionCall(func_name, pass_num_args, arg2) /* {{{ */ \
 { \
 	zend_function *func_ptr; \
-	int ret; \
-	ret = zend_hash_find(EG(function_table), #func_name, sizeof(#func_name), (void **) &func_ptr); \
-	if (ret != SUCCESS) { \
+	func_ptr = (zend_function *)zend_hash_str_find_ptr(EG(function_table), #func_name, sizeof(#func_name) - 1); \
+	if (func_ptr == NULL) { \
 		zend_throw_exception_ex(spl_ce_RuntimeException, 0 TSRMLS_CC, "Internal error, function '%s' not found. Please report", #func_name); \
 		return; \
 	} \
@@ -2164,18 +2132,18 @@ static int spl_filesystem_file_read_csv(spl_filesystem_object *intern, char deli
 		size_t buf_len = intern->u.file.current_line_len;
 		char *buf = estrndup(intern->u.file.current_line, buf_len);
 
-		if (intern->u.file.current_zval) {
+		if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
 			zval_ptr_dtor(&intern->u.file.current_zval);
+			ZVAL_UNDEF(&intern->u.file.current_zval);
 		}
-		ALLOC_INIT_ZVAL(intern->u.file.current_zval);
 
-		php_fgetcsv(intern->u.file.stream, delimiter, enclosure, escape, buf_len, buf, intern->u.file.current_zval TSRMLS_CC);
+		php_fgetcsv(intern->u.file.stream, delimiter, enclosure, escape, buf_len, buf, &intern->u.file.current_zval TSRMLS_CC);
 		if (return_value) {
 			if (Z_TYPE_P(return_value) != IS_NULL) {
 				zval_dtor(return_value);
 				ZVAL_NULL(return_value);
 			}
-			ZVAL_ZVAL(return_value, intern->u.file.current_zval, 1, 0);
+			ZVAL_ZVAL(return_value, &intern->u.file.current_zval, 1, 0);
 		}
 	}
 	return ret;
@@ -2184,7 +2152,7 @@ static int spl_filesystem_file_read_csv(spl_filesystem_object *intern, char deli
 
 static int spl_filesystem_file_read_line_ex(zval * this_ptr, spl_filesystem_object *intern, int silent TSRMLS_DC) /* {{{ */
 {
-	zval *retval = NULL;
+	zval retval;
 
 	/* 1) use fgetcsv? 2) overloaded call the function, 3) do it directly */
 	if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || intern->u.file.func_getCurr->common.scope != spl_ce_SplFileObject) {
@@ -2197,19 +2165,18 @@ static int spl_filesystem_file_read_line_ex(zval * this_ptr, spl_filesystem_obje
 		if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV)) {
 			return spl_filesystem_file_read_csv(intern, intern->u.file.delimiter, intern->u.file.enclosure, intern->u.file.escape, NULL TSRMLS_CC);
 		} else {
-			zend_call_method_with_0_params(&this_ptr, Z_OBJCE_P(getThis()), &intern->u.file.func_getCurr, "getCurrentLine", &retval);
+			zend_call_method_with_0_params(this_ptr, Z_OBJCE_P(getThis()), &intern->u.file.func_getCurr, "getCurrentLine", &retval);
 		}
-		if (retval) {
-			if (intern->u.file.current_line || intern->u.file.current_zval) {
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			if (intern->u.file.current_line || !ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
 				intern->u.file.current_line_num++;
 			}
 			spl_filesystem_file_free_line(intern TSRMLS_CC);
-			if (Z_TYPE_P(retval) == IS_STRING) {
-				intern->u.file.current_line = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
-				intern->u.file.current_line_len = Z_STRLEN_P(retval);
+			if (Z_TYPE(retval) == IS_STRING) {
+				intern->u.file.current_line = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
+				intern->u.file.current_line_len = Z_STRLEN(retval);
 			} else {
-				MAKE_STD_ZVAL(intern->u.file.current_zval);
-				ZVAL_ZVAL(intern->u.file.current_zval, retval, 1, 0);
+				ZVAL_ZVAL(&intern->u.file.current_zval, &retval, 1, 0);
 			}
 			zval_ptr_dtor(&retval);
 			return SUCCESS;
@@ -2225,22 +2192,27 @@ static int spl_filesystem_file_is_empty_line(spl_filesystem_object *intern TSRML
 {
 	if (intern->u.file.current_line) {
 		return intern->u.file.current_line_len == 0;
-	} else if (intern->u.file.current_zval) {
-		switch(Z_TYPE_P(intern->u.file.current_zval)) {
-		case IS_STRING:
-			return Z_STRLEN_P(intern->u.file.current_zval) == 0;
-		case IS_ARRAY:
-			if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV)
-			&& zend_hash_num_elements(Z_ARRVAL_P(intern->u.file.current_zval)) == 1) {
-				zval ** first = Z_ARRVAL_P(intern->u.file.current_zval)->pListHead->pData;
-					
-				return Z_TYPE_PP(first) == IS_STRING && Z_STRLEN_PP(first) == 0;
-			}
-			return zend_hash_num_elements(Z_ARRVAL_P(intern->u.file.current_zval)) == 0;
-		case IS_NULL:
-			return 1;
-		default:
-			return 0;
+	} else if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+		switch(Z_TYPE(intern->u.file.current_zval)) {
+			case IS_STRING:
+				return Z_STRLEN(intern->u.file.current_zval) == 0;
+			case IS_ARRAY:
+				if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV)
+						&& zend_hash_num_elements(Z_ARRVAL(intern->u.file.current_zval)) == 1) {
+					uint idx = 0;
+					zval *first;
+
+					while (ZVAL_IS_UNDEF(&Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val)) {
+						idx++;
+					}
+					first = &Z_ARRVAL(intern->u.file.current_zval)->arData[idx].val;
+					return Z_TYPE_P(first) == IS_STRING && Z_STRLEN_P(first) == 0;
+				}
+				return zend_hash_num_elements(Z_ARRVAL(intern->u.file.current_zval)) == 0;
+			case IS_NULL:
+				return 1;
+			default:
+				return 0;
 		}
 	} else {
 		return 1;
@@ -2278,7 +2250,7 @@ static void spl_filesystem_file_rewind(zval * this_ptr, spl_filesystem_object *i
    Construct a new file object */
 SPL_METHOD(SplFileObject, __construct)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	zend_bool use_include_path = 0;
 	char *p1, *p2;
 	char *tmp_path;
@@ -2341,7 +2313,7 @@ SPL_METHOD(SplTempFileObject, __construct)
 {
 	long max_memory = PHP_STREAM_MAX_MEM;
 	char tmp_fname[48];
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	zend_error_handling error_handling;
 
 	zend_replace_error_handling(EH_THROW, spl_ce_RuntimeException, &error_handling TSRMLS_CC);
@@ -2363,7 +2335,6 @@ SPL_METHOD(SplTempFileObject, __construct)
 	}
 	intern->u.file.open_mode = "wb";
 	intern->u.file.open_mode_len = 1;
-	intern->u.file.zcontext = NULL;
 	
 	if (spl_filesystem_file_open(intern, 0, 0 TSRMLS_CC) == SUCCESS) {
 		intern->_path_len = 0;
@@ -2376,7 +2347,7 @@ SPL_METHOD(SplTempFileObject, __construct)
    Rewind the file and read the first line */
 SPL_METHOD(SplFileObject, rewind)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2389,7 +2360,7 @@ SPL_METHOD(SplFileObject, rewind)
    Return whether end of file is reached */
 SPL_METHOD(SplFileObject, eof)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2402,14 +2373,14 @@ SPL_METHOD(SplFileObject, eof)
    Return !eof() */
 SPL_METHOD(SplFileObject, valid)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	if (SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_AHEAD)) {
-		RETURN_BOOL(intern->u.file.current_line || intern->u.file.current_zval);
+		RETURN_BOOL(intern->u.file.current_line || !ZVAL_IS_UNDEF(&intern->u.file.current_zval));
 	} else {
 		RETVAL_BOOL(!php_stream_eof(intern->u.file.stream));
 	}
@@ -2419,7 +2390,7 @@ SPL_METHOD(SplFileObject, valid)
    Rturn next line from file */
 SPL_METHOD(SplFileObject, fgets)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2428,26 +2399,26 @@ SPL_METHOD(SplFileObject, fgets)
 	if (spl_filesystem_file_read(intern, 0 TSRMLS_CC) == FAILURE) {
 		RETURN_FALSE;
 	}
-	RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
+	RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len);
 } /* }}} */
 
 /* {{{ proto string SplFileObject::current()
    Return current line from file */
 SPL_METHOD(SplFileObject, current)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (!intern->u.file.current_line && !intern->u.file.current_zval) {
+	if (!intern->u.file.current_line && ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
 		spl_filesystem_file_read_line(getThis(), intern, 1 TSRMLS_CC);
 	}
-	if (intern->u.file.current_line && (!SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || !intern->u.file.current_zval)) {
-		RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len, 1);
-	} else if (intern->u.file.current_zval) {
-		RETURN_ZVAL(intern->u.file.current_zval, 1, 0);
+	if (intern->u.file.current_line && (!SPL_HAS_FLAG(intern->flags, SPL_FILE_OBJECT_READ_CSV) || ZVAL_IS_UNDEF(&intern->u.file.current_zval))) {
+		RETURN_STRINGL(intern->u.file.current_line, intern->u.file.current_line_len);
+	} else if (!ZVAL_IS_UNDEF(&intern->u.file.current_zval)) {
+		RETURN_ZVAL(&intern->u.file.current_zval, 1, 0);
 	}
 	RETURN_FALSE;
 } /* }}} */
@@ -2456,7 +2427,7 @@ SPL_METHOD(SplFileObject, current)
    Return line number */
 SPL_METHOD(SplFileObject, key)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2473,7 +2444,7 @@ SPL_METHOD(SplFileObject, key)
    Read next line */
 SPL_METHOD(SplFileObject, next)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2490,7 +2461,7 @@ SPL_METHOD(SplFileObject, next)
    Set file handling flags */
 SPL_METHOD(SplFileObject, setFlags)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &intern->flags) == FAILURE) {
 		return;
@@ -2501,7 +2472,7 @@ SPL_METHOD(SplFileObject, setFlags)
    Get file handling flags */
 SPL_METHOD(SplFileObject, getFlags)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2516,7 +2487,7 @@ SPL_METHOD(SplFileObject, setMaxLineLen)
 {
 	long max_len;
 
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &max_len) == FAILURE) {
 		return;
@@ -2534,7 +2505,7 @@ SPL_METHOD(SplFileObject, setMaxLineLen)
    Get maximum line length */
 SPL_METHOD(SplFileObject, getMaxLineLen)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2568,7 +2539,7 @@ SPL_METHOD(SplFileObject, getChildren)
 #define FileFunction(func_name) \
 SPL_METHOD(SplFileObject, func_name) \
 { \
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC); \
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis()); \
 	FileFunctionCall(func_name, ZEND_NUM_ARGS(), NULL); \
 }
 /* }}} */
@@ -2577,7 +2548,7 @@ SPL_METHOD(SplFileObject, func_name) \
    Return current line as csv */
 SPL_METHOD(SplFileObject, fgetcsv)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure, escape = intern->u.file.escape;
 	char *delim = NULL, *enclo = NULL, *esc = NULL;
 	int d_len = 0, e_len = 0, esc_len = 0;
@@ -2618,7 +2589,7 @@ SPL_METHOD(SplFileObject, fgetcsv)
    Output a field array as a CSV line */
 SPL_METHOD(SplFileObject, fputcsv)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char delimiter = intern->u.file.delimiter, enclosure = intern->u.file.enclosure, escape = intern->u.file.escape;
 	char *delim = NULL, *enclo = NULL;
 	int d_len = 0, e_len = 0, ret;
@@ -2655,7 +2626,7 @@ SPL_METHOD(SplFileObject, fputcsv)
    Set the delimiter and enclosure character used in fgetcsv */
 SPL_METHOD(SplFileObject, setCsvControl)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char delimiter = ',', enclosure = '"', escape='\\';
 	char *delim = NULL, *enclo = NULL, *esc = NULL;
 	int d_len = 0, e_len = 0, esc_len = 0;
@@ -2698,7 +2669,7 @@ SPL_METHOD(SplFileObject, setCsvControl)
    Get the delimiter and enclosure character used in fgetcsv */
 SPL_METHOD(SplFileObject, getCsvControl)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char delimiter[2], enclosure[2];
 
 	array_init(return_value);
@@ -2708,8 +2679,8 @@ SPL_METHOD(SplFileObject, getCsvControl)
 	enclosure[0] = intern->u.file.enclosure;
 	enclosure[1] = '\0';
 
-	add_next_index_string(return_value, delimiter, 1);
-	add_next_index_string(return_value, enclosure, 1);
+	add_next_index_string(return_value, delimiter);
+	add_next_index_string(return_value, enclosure);
 }
 /* }}} */
 
@@ -2722,7 +2693,7 @@ FileFunction(flock)
    Flush the file */
 SPL_METHOD(SplFileObject, fflush)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	RETURN_BOOL(!php_stream_flush(intern->u.file.stream));
 } /* }}} */
@@ -2731,7 +2702,7 @@ SPL_METHOD(SplFileObject, fflush)
    Return current file position */
 SPL_METHOD(SplFileObject, ftell)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);	
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());	
 	long ret = php_stream_tell(intern->u.file.stream);
 
 	if (ret == -1) {
@@ -2745,7 +2716,7 @@ SPL_METHOD(SplFileObject, ftell)
    Return current file position */
 SPL_METHOD(SplFileObject, fseek)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	long pos, whence = SEEK_SET;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l|l", &pos, &whence) == FAILURE) {
@@ -2760,7 +2731,7 @@ SPL_METHOD(SplFileObject, fseek)
    Get a character form the file */
 SPL_METHOD(SplFileObject, fgetc)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char buf[2];
 	int result;
 
@@ -2777,7 +2748,7 @@ SPL_METHOD(SplFileObject, fgetc)
 		buf[0] = result;
 		buf[1] = '\0';
 
-		RETURN_STRINGL(buf, 1, 1);
+		RETURN_STRINGL(buf, 1);
 	}
 } /* }}} */
 
@@ -2785,29 +2756,26 @@ SPL_METHOD(SplFileObject, fgetc)
    Get a line from file pointer and strip HTML tags */
 SPL_METHOD(SplFileObject, fgetss)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	zval *arg2 = NULL;
-	MAKE_STD_ZVAL(arg2);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
+	zval arg2;
 
 	if (intern->u.file.max_line_len > 0) {
-		ZVAL_LONG(arg2, intern->u.file.max_line_len);
+		ZVAL_LONG(&arg2, intern->u.file.max_line_len);
 	} else {
-		ZVAL_LONG(arg2, 1024);
+		ZVAL_LONG(&arg2, 1024);
 	}
 
 	spl_filesystem_file_free_line(intern TSRMLS_CC);
 	intern->u.file.current_line_num++;
 
-	FileFunctionCall(fgetss, ZEND_NUM_ARGS(), arg2);
-
-	zval_ptr_dtor(&arg2);
+	FileFunctionCall(fgetss, ZEND_NUM_ARGS(), &arg2);
 } /* }}} */
 
 /* {{{ proto int SplFileObject::fpassthru()
    Output all remaining data from a file pointer */
 SPL_METHOD(SplFileObject, fpassthru)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	RETURN_LONG(php_stream_passthru(intern->u.file.stream));
 } /* }}} */
@@ -2816,7 +2784,7 @@ SPL_METHOD(SplFileObject, fpassthru)
    Implements a mostly ANSI compatible fscanf() */
 SPL_METHOD(SplFileObject, fscanf)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 
 	spl_filesystem_file_free_line(intern TSRMLS_CC);
 	intern->u.file.current_line_num++;
@@ -2829,7 +2797,7 @@ SPL_METHOD(SplFileObject, fscanf)
    Binary-safe file write */
 SPL_METHOD(SplFileObject, fwrite)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	char *str;
 	int str_len;
 	long length = 0;
@@ -2850,7 +2818,7 @@ SPL_METHOD(SplFileObject, fwrite)
 
 SPL_METHOD(SplFileObject, fread)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	long length = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &length) == FAILURE) {
@@ -2862,12 +2830,11 @@ SPL_METHOD(SplFileObject, fread)
 		RETURN_FALSE;
 	}
 
-	Z_STRVAL_P(return_value) = emalloc(length + 1);
+	ZVAL_STR(return_value, STR_ALLOC(length, 0));
 	Z_STRLEN_P(return_value) = php_stream_read(intern->u.file.stream, Z_STRVAL_P(return_value), length);
 
 	/* needed because recv/read/gzread doesnt put a null at the end*/
 	Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0;
-	Z_TYPE_P(return_value) = IS_STRING;
 }
 
 /* {{{ proto bool SplFileObject::fstat()
@@ -2879,7 +2846,7 @@ FileFunction(fstat)
    Truncate file to 'size' length */
 SPL_METHOD(SplFileObject, ftruncate)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	long size;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &size) == FAILURE) {
@@ -2898,7 +2865,7 @@ SPL_METHOD(SplFileObject, ftruncate)
    Seek to specified line */
 SPL_METHOD(SplFileObject, seek)
 {
-	spl_filesystem_object *intern = (spl_filesystem_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_filesystem_object *intern = Z_SPLFILESYSTEM_P(getThis());
 	long line_pos;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &line_pos) == FAILURE) {
@@ -3036,12 +3003,16 @@ PHP_MINIT_FUNCTION(spl_directory)
 {
 	REGISTER_SPL_STD_CLASS_EX(SplFileInfo, spl_filesystem_object_new, spl_SplFileInfo_functions);
 	memcpy(&spl_filesystem_object_handlers, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
-	spl_filesystem_object_handlers.clone_obj       = spl_filesystem_object_clone;
-	spl_filesystem_object_handlers.cast_object     = spl_filesystem_object_cast;
+	spl_filesystem_object_handlers.offset = XtOffsetOf(spl_filesystem_object, std);
+	spl_filesystem_object_handlers.clone_obj = spl_filesystem_object_clone;
+	spl_filesystem_object_handlers.cast_object = spl_filesystem_object_cast;
 	spl_filesystem_object_handlers.get_debug_info  = spl_filesystem_object_get_debug_info;
+	spl_filesystem_object_handlers.dtor_obj = zend_objects_destroy_object;
+	spl_filesystem_object_handlers.free_obj = spl_filesystem_object_free_storage;
 	spl_ce_SplFileInfo->serialize = zend_class_serialize_deny;
 	spl_ce_SplFileInfo->unserialize = zend_class_unserialize_deny;
 
+
 	REGISTER_SPL_SUB_CLASS_EX(DirectoryIterator, SplFileInfo, spl_filesystem_object_new, spl_DirectoryIterator_functions);
 	zend_class_implements(spl_ce_DirectoryIterator TSRMLS_CC, 1, zend_ce_iterator);
 	REGISTER_SPL_IMPLEMENTS(DirectoryIterator, SeekableIterator);
diff --git a/ext/spl/spl_directory.h b/ext/spl/spl_directory.h
index 8cff7d98d0..3276d51463 100644
--- a/ext/spl/spl_directory.h
+++ b/ext/spl/spl_directory.h
@@ -55,12 +55,11 @@ typedef struct _spl_other_handler {
 /* define an overloaded iterator structure */
 typedef struct {
 	zend_object_iterator  intern;
-	zval                  *current;
-	spl_filesystem_object *object;
+	zval                  current;
+	void                 *object;
 } spl_filesystem_iterator;
 
 struct _spl_filesystem_object {
-	zend_object        std;
 	void               *oth;
 	spl_other_handler  *oth_handler;
 	char               *_path;
@@ -90,7 +89,7 @@ struct _spl_filesystem_object {
 			zval               *zcontext;
 			char               *open_mode;
 			int                open_mode_len;
-			zval               *current_zval;
+			zval               current_zval;
 			char               *current_line;
 			size_t             current_line_len;
 			size_t             max_line_len;
@@ -102,17 +101,28 @@ struct _spl_filesystem_object {
 			char               escape;
 		} file;
 	} u;
-	spl_filesystem_iterator    it;
+	spl_filesystem_iterator    *it;
+	zend_object        std;
 };
 
-static inline spl_filesystem_iterator* spl_filesystem_object_to_iterator(spl_filesystem_object *obj)
+static inline spl_filesystem_object *spl_filesystem_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_filesystem_object*)((char*)(obj) - XtOffsetOf(spl_filesystem_object, std));
+}
+/* }}} */
+
+#define Z_SPLFILESYSTEM_P(zv)  spl_filesystem_from_obj(Z_OBJ_P((zv)))
+
+static inline spl_filesystem_iterator* spl_filesystem_object_to_iterator(spl_filesystem_object *obj TSRMLS_DC)
 {
-	return &obj->it;
+	obj->it = ecalloc(1, sizeof(spl_filesystem_iterator));
+	obj->it->object = (void *)obj;
+	zend_iterator_init(&obj->it->intern TSRMLS_CC);
+	return obj->it;
 }
 
-static inline spl_filesystem_object* spl_filesystem_iterator_to_object(spl_filesystem_iterator *it)
+static inline spl_filesystem_object* spl_filesystem_iterator_to_object(spl_filesystem_iterator *it TSRMLS_DC)
 {
-	return (spl_filesystem_object*)((char*)it - XtOffsetOf(spl_filesystem_object, it));
+	return (spl_filesystem_object*)it->object;
 }
 
 #define SPL_FILE_OBJECT_DROP_NEW_LINE      0x00000001 /* drop new lines */
diff --git a/ext/spl/spl_dllist.c b/ext/spl/spl_dllist.c
index 772d780e01..d2f17452ac 100644
--- a/ext/spl/spl_dllist.c
+++ b/ext/spl/spl_dllist.c
@@ -67,7 +67,7 @@ typedef struct _spl_ptr_llist_element {
 	struct _spl_ptr_llist_element *prev;
 	struct _spl_ptr_llist_element *next;
 	int                            rc;
-	void                          *data;
+	zval                           data;
 } spl_ptr_llist_element;
 
 typedef void (*spl_ptr_llist_dtor_func)(spl_ptr_llist_element * TSRMLS_DC);
@@ -85,11 +85,10 @@ typedef struct _spl_dllist_object spl_dllist_object;
 typedef struct _spl_dllist_it spl_dllist_it;
 
 struct _spl_dllist_object {
-	zend_object            std;
 	spl_ptr_llist         *llist;
 	int                    traverse_position;
 	spl_ptr_llist_element *traverse_pointer;
-	zval                  *retval;
+	zval                   retval;
 	int                    flags;
 	zend_function         *fptr_offset_get;
 	zend_function         *fptr_offset_set;
@@ -98,6 +97,7 @@ struct _spl_dllist_object {
 	zend_function         *fptr_count;
 	zend_class_entry      *ce_get_iterator;
 	HashTable             *debug_info;
+	zend_object            std;
 };
 
 /* define an overloaded iterator structure */
@@ -106,19 +106,28 @@ struct _spl_dllist_it {
 	int                    traverse_position;
 	spl_ptr_llist_element *traverse_pointer;
 	int                    flags;
-	spl_dllist_object     *object;
 };
 
+static inline spl_dllist_object *spl_dllist_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_dllist_object*)((char*)(obj) - XtOffsetOf(spl_dllist_object, std));
+}
+/* }}} */
+
+#define Z_SPLDLLIST_P(zv)  spl_dllist_from_obj(Z_OBJ_P((zv)))
+
 /* {{{  spl_ptr_llist */
 static void spl_ptr_llist_zval_dtor(spl_ptr_llist_element *elem TSRMLS_DC) { /* {{{ */
-	if (elem->data) {
-		zval_ptr_dtor((zval **)&elem->data);
+	if (!ZVAL_IS_UNDEF(&elem->data)) {
+		zval_ptr_dtor(&elem->data);
+		ZVAL_UNDEF(&elem->data);
 	}
 }
 /* }}} */
 
 static void spl_ptr_llist_zval_ctor(spl_ptr_llist_element *elem TSRMLS_DC) { /* {{{ */
-	Z_ADDREF_P((zval *)elem->data);
+	if (Z_REFCOUNTED(elem->data)) {
+		Z_ADDREF(elem->data);
+	}
 }
 /* }}} */
 
@@ -185,14 +194,14 @@ static spl_ptr_llist_element *spl_ptr_llist_offset(spl_ptr_llist *llist, long of
 }
 /* }}} */
 
-static void spl_ptr_llist_unshift(spl_ptr_llist *llist, void *data TSRMLS_DC) /* {{{ */
+static void spl_ptr_llist_unshift(spl_ptr_llist *llist, zval *data TSRMLS_DC) /* {{{ */
 {
 	spl_ptr_llist_element *elem = emalloc(sizeof(spl_ptr_llist_element));
 
-	elem->data = data;
 	elem->rc   = 1;
 	elem->prev = NULL;
 	elem->next = llist->head;
+	ZVAL_COPY_VALUE(&elem->data, data);
 
 	if (llist->head) {
 		llist->head->prev = elem;
@@ -209,14 +218,14 @@ static void spl_ptr_llist_unshift(spl_ptr_llist *llist, void *data TSRMLS_DC) /*
 }
 /* }}} */
 
-static void spl_ptr_llist_push(spl_ptr_llist *llist, void *data TSRMLS_DC) /* {{{ */
+static void spl_ptr_llist_push(spl_ptr_llist *llist, zval *data TSRMLS_DC) /* {{{ */
 {
 	spl_ptr_llist_element *elem = emalloc(sizeof(spl_ptr_llist_element));
 
-	elem->data = data;
 	elem->rc   = 1;
 	elem->prev = llist->tail;
 	elem->next = NULL;
+	ZVAL_COPY_VALUE(&elem->data, data);
 
 	if (llist->tail) {
 		llist->tail->next = elem;
@@ -233,13 +242,13 @@ static void spl_ptr_llist_push(spl_ptr_llist *llist, void *data TSRMLS_DC) /* {{
 }
 /* }}} */
 
-static void *spl_ptr_llist_pop(spl_ptr_llist *llist TSRMLS_DC) /* {{{ */
+static void spl_ptr_llist_pop(spl_ptr_llist *llist, zval *ret TSRMLS_DC) /* {{{ */
 {
-	void                     *data;
 	spl_ptr_llist_element    *tail = llist->tail;
 
 	if (tail == NULL) {
-		return NULL;
+		ZVAL_UNDEF(ret);
+		return;
 	}
 
 	if (tail->prev) {
@@ -250,51 +259,49 @@ static void *spl_ptr_llist_pop(spl_ptr_llist *llist TSRMLS_DC) /* {{{ */
 
 	llist->tail = tail->prev;
 	llist->count--;
-	data = tail->data;
+	ZVAL_COPY(ret, &tail->data);
 
 	if (llist->dtor) {
 		llist->dtor(tail TSRMLS_CC);
 	}
 
-	tail->data = NULL;
+	ZVAL_UNDEF(&tail->data);
 
 	SPL_LLIST_DELREF(tail);
-
-	return data;
 }
 /* }}} */
 
-static void *spl_ptr_llist_last(spl_ptr_llist *llist) /* {{{ */
+static zval *spl_ptr_llist_last(spl_ptr_llist *llist) /* {{{ */
 {
 	spl_ptr_llist_element *tail = llist->tail;
 
 	if (tail == NULL) {
 		return NULL;
 	} else {
-		return tail->data;
+		return &tail->data;
 	}
 }
 /* }}} */
 
-static void *spl_ptr_llist_first(spl_ptr_llist *llist) /* {{{ */
+static zval *spl_ptr_llist_first(spl_ptr_llist *llist) /* {{{ */
 {
 	spl_ptr_llist_element *head = llist->head;
 
 	if (head == NULL) {
 		return NULL;
 	} else {
-		return head->data;
+		return &head->data;
 	}
 }
 /* }}} */
 
-static void *spl_ptr_llist_shift(spl_ptr_llist *llist TSRMLS_DC) /* {{{ */
+static void spl_ptr_llist_shift(spl_ptr_llist *llist, zval *ret TSRMLS_DC) /* {{{ */
 {
-	void                    *data;
 	spl_ptr_llist_element   *head = llist->head;
 
 	if (head == NULL) {
-		return NULL;
+		ZVAL_UNDEF(ret);
+		return;
 	}
 
 	if (head->next) {
@@ -305,32 +312,32 @@ static void *spl_ptr_llist_shift(spl_ptr_llist *llist TSRMLS_DC) /* {{{ */
 
 	llist->head = head->next;
 	llist->count--;
-	data = head->data;
+	ZVAL_COPY(ret, &head->data);
 
 	if (llist->dtor) {
 		llist->dtor(head TSRMLS_CC);
 	}
-	head->data = NULL;
+	ZVAL_UNDEF(&head->data);
 
 	SPL_LLIST_DELREF(head);
-
-	return data;
 }
 /* }}} */
 
 static void spl_ptr_llist_copy(spl_ptr_llist *from, spl_ptr_llist *to TSRMLS_DC) /* {{{ */
 {
-	spl_ptr_llist_element   *current = from->head, *next;
-	spl_ptr_llist_ctor_func  ctor    = from->ctor;
+	spl_ptr_llist_element *current = from->head, *next;
+//???	spl_ptr_llist_ctor_func ctor = from->ctor;
 
 	while (current) {
 		next = current->next;
 
+		/*??? FIXME
 		if (ctor) {
 			ctor(current TSRMLS_CC);
 		}
+		*/
 
-		spl_ptr_llist_push(to, current->data TSRMLS_CC);
+		spl_ptr_llist_push(to, &current->data TSRMLS_CC);
 		current = next;
 	}
 
@@ -339,15 +346,15 @@ static void spl_ptr_llist_copy(spl_ptr_llist *from, spl_ptr_llist *to TSRMLS_DC)
 
 /* }}} */
 
-static void spl_dllist_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void spl_dllist_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	spl_dllist_object *intern = (spl_dllist_object *)object;
-	zval              *tmp    = NULL;
+	spl_dllist_object *intern = spl_dllist_from_obj(object);
+	zval tmp;
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 
-	while(intern->llist->count > 0) {
-		tmp = (zval *)spl_ptr_llist_pop(intern->llist TSRMLS_CC);
+	while (intern->llist->count > 0) {
+		spl_ptr_llist_pop(intern->llist, &tmp TSRMLS_CC);
 		zval_ptr_dtor(&tmp);
 	}
 
@@ -359,23 +366,18 @@ static void spl_dllist_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 		zend_hash_destroy(intern->debug_info);
 		efree(intern->debug_info);
 	}
-
-	efree(object);
 }
 /* }}} */
 
 zend_object_iterator *spl_dllist_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 
-static zend_object_value spl_dllist_object_new_ex(zend_class_entry *class_type, spl_dllist_object **obj, zval *orig, int clone_orig TSRMLS_DC) /* {{{ */
+static zend_object *spl_dllist_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig TSRMLS_DC) /* {{{ */
 {
-	zend_object_value  retval = {0};
 	spl_dllist_object *intern;
 	zend_class_entry  *parent = class_type;
 	int                inherited = 0;
 
-	intern = ecalloc(1, sizeof(spl_dllist_object));
-	*obj = intern;
-	ALLOC_INIT_ZVAL(intern->retval);
+	intern = ecalloc(1, sizeof(spl_dllist_object) + sizeof(zval) * (parent->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
@@ -385,7 +387,7 @@ static zend_object_value spl_dllist_object_new_ex(zend_class_entry *class_type,
 	intern->debug_info = NULL;
 
 	if (orig) {
-		spl_dllist_object *other = (spl_dllist_object*)zend_object_store_get_object(orig TSRMLS_CC);
+		spl_dllist_object *other = Z_SPLDLLIST_P(orig);
 		intern->ce_get_iterator = other->ce_get_iterator;
 
 		if (clone_orig) {
@@ -409,14 +411,14 @@ static zend_object_value spl_dllist_object_new_ex(zend_class_entry *class_type,
 	while (parent) {
 		if (parent == spl_ce_SplStack) {
 			intern->flags |= (SPL_DLLIST_IT_FIX | SPL_DLLIST_IT_LIFO);
-			retval.handlers = &spl_handler_SplDoublyLinkedList;
+			intern->std.handlers = &spl_handler_SplDoublyLinkedList;
 		} else if (parent == spl_ce_SplQueue) {
 			intern->flags |= SPL_DLLIST_IT_FIX;
-			retval.handlers = &spl_handler_SplDoublyLinkedList;
+			intern->std.handlers = &spl_handler_SplDoublyLinkedList;
 		}
 
 		if (parent == spl_ce_SplDoublyLinkedList) {
-			retval.handlers = &spl_handler_SplDoublyLinkedList;
+			intern->std.handlers = &spl_handler_SplDoublyLinkedList;
 			break;
 		}
 
@@ -424,76 +426,68 @@ static zend_object_value spl_dllist_object_new_ex(zend_class_entry *class_type,
 		inherited = 1;
 	}
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, spl_dllist_object_free_storage, NULL TSRMLS_CC);
-
 	if (!parent) { /* this must never happen */
 		php_error_docref(NULL TSRMLS_CC, E_COMPILE_ERROR, "Internal compiler error, Class is not child of SplDoublyLinkedList");
 	}
 	if (inherited) {
-		zend_hash_find(&class_type->function_table, "offsetget",    sizeof("offsetget"),    (void **) &intern->fptr_offset_get);
+		intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1);
 		if (intern->fptr_offset_get->common.scope == parent) {
 			intern->fptr_offset_get = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetset",    sizeof("offsetset"),    (void **) &intern->fptr_offset_set);
+		intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1);
 		if (intern->fptr_offset_set->common.scope == parent) {
 			intern->fptr_offset_set = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetexists", sizeof("offsetexists"), (void **) &intern->fptr_offset_has);
+		intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1);
 		if (intern->fptr_offset_has->common.scope == parent) {
 			intern->fptr_offset_has = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetunset",  sizeof("offsetunset"),  (void **) &intern->fptr_offset_del);
+		intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset", sizeof("offsetunset") - 1);
 		if (intern->fptr_offset_del->common.scope == parent) {
 			intern->fptr_offset_del = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "count",        sizeof("count"),        (void **) &intern->fptr_count);
+		intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
 		if (intern->fptr_count->common.scope == parent) {
 			intern->fptr_count = NULL;
 		}
 	}
 
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
-static zend_object_value spl_dllist_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *spl_dllist_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	spl_dllist_object *tmp;
-	return spl_dllist_object_new_ex(class_type, &tmp, NULL, 0 TSRMLS_CC);
+	return spl_dllist_object_new_ex(class_type, NULL, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static zend_object_value spl_dllist_object_clone(zval *zobject TSRMLS_DC) /* {{{ */
+static zend_object *spl_dllist_object_clone(zval *zobject TSRMLS_DC) /* {{{ */
 {
-	zend_object_value   new_obj_val;
 	zend_object        *old_object;
 	zend_object        *new_object;
-	zend_object_handle  handle = Z_OBJ_HANDLE_P(zobject);
-	spl_dllist_object  *intern;
 
-	old_object  = zend_objects_get_address(zobject TSRMLS_CC);
-	new_obj_val = spl_dllist_object_new_ex(old_object->ce, &intern, zobject, 1 TSRMLS_CC);
-	new_object  = &intern->std;
+	old_object  = Z_OBJ_P(zobject);
+	new_object = spl_dllist_object_new_ex(old_object->ce, zobject, 1 TSRMLS_CC);
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
-	return new_obj_val;
+	return new_object;
 }
 /* }}} */
 
 static int spl_dllist_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
 {
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(object);
 
 	if (intern->fptr_count) {
-		zval *rv;
-		zend_call_method_with_0_params(&object, intern->std.ce, &intern->fptr_count, "count", &rv);
-		if (rv) {
+		zval rv;
+		zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
+		if (!ZVAL_IS_UNDEF(&rv)) {
 			zval_ptr_dtor(&intern->retval);
-			MAKE_STD_ZVAL(intern->retval);
-			ZVAL_ZVAL(intern->retval, rv, 1, 1);
-			convert_to_long(intern->retval);
-			*count = (long) Z_LVAL_P(intern->retval);
+			ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+			convert_to_long(&intern->retval);
+			*count = (long) Z_LVAL(intern->retval);
 			return SUCCESS;
 		}
 		*count = 0;
@@ -507,11 +501,10 @@ static int spl_dllist_object_count_elements(zval *object, long *count TSRMLS_DC)
 
 static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{{ */
 {
-	spl_dllist_object     *intern  = (spl_dllist_object*)zend_object_store_get_object(obj TSRMLS_CC);
+	spl_dllist_object     *intern  = Z_SPLDLLIST_P(obj);
 	spl_ptr_llist_element *current = intern->llist->head, *next;
-	zval *tmp, zrv, *dllist_array;
-	char *pnstr;
-	int  pnlen;
+	zval tmp, dllist_array;
+	zend_string *pnstr;
 	int  i = 0;
 
 	*is_temp = 0;
@@ -521,42 +514,42 @@ static HashTable* spl_dllist_object_get_debug_info(zval *obj, int *is_temp TSRML
 		zend_hash_init(intern->debug_info, 1, NULL, ZVAL_PTR_DTOR, 0);
 	}
 
-	if (intern->debug_info->nApplyCount == 0) {
-		INIT_PZVAL(&zrv);
-		Z_ARRVAL(zrv) = intern->debug_info;
+	if (intern->debug_info->u.v.nApplyCount == 0) {
 
 		if (!intern->std.properties) {
 			rebuild_object_properties(&intern->std);
 		}
-		zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+		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);
-		add_assoc_long_ex(&zrv, pnstr, pnlen+1, intern->flags);
-		efree(pnstr);
+		pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "flags", sizeof("flags")-1 TSRMLS_CC);
+		ZVAL_LONG(&tmp, intern->flags);
+		zend_hash_add(intern->debug_info, pnstr, &tmp);
+		STR_RELEASE(pnstr);
 
-		ALLOC_INIT_ZVAL(dllist_array);
-		array_init(dllist_array);
+		array_init(&dllist_array);
 
 		while (current) {
 			next = current->next;
 
-			add_index_zval(dllist_array, i, (zval *)current->data);
-			Z_ADDREF_P(current->data);
+			add_index_zval(&dllist_array, i, &current->data);
+			if (Z_REFCOUNTED(current->data)) {
+				Z_ADDREF(current->data);
+			}
 			i++;
 
 			current = next;
 		}
 
-		pnstr = spl_gen_private_prop_name(spl_ce_SplDoublyLinkedList, "dllist", sizeof("dllist")-1, &pnlen TSRMLS_CC);
-		add_assoc_zval_ex(&zrv, pnstr, pnlen+1, 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;
 }
 /* }}}} */
 
-/* {{{ proto bool SplDoublyLinkedList::push(mixed $value) U
+/* {{{ proto bool SplDoublyLinkedList::push(mixed $value)
 	   Push $value on the SplDoublyLinkedList */
 SPL_METHOD(SplDoublyLinkedList, push)
 {
@@ -567,16 +560,16 @@ SPL_METHOD(SplDoublyLinkedList, push)
 		return;
 	}
 
-	SEPARATE_ARG_IF_REF(value);
+	SEPARATE_ZVAL_IF_REF(value);
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 	spl_ptr_llist_push(intern->llist, value TSRMLS_CC);
 
 	RETURN_TRUE;
 } 
 /* }}} */
 
-/* {{{ proto bool SplDoublyLinkedList::unshift(mixed $value) U
+/* {{{ proto bool SplDoublyLinkedList::unshift(mixed $value)
 	   Unshift $value on the SplDoublyLinkedList */
 SPL_METHOD(SplDoublyLinkedList, unshift)
 {
@@ -587,62 +580,56 @@ SPL_METHOD(SplDoublyLinkedList, unshift)
 		return;
 	}
 
-	SEPARATE_ARG_IF_REF(value);
+	SEPARATE_ZVAL_IF_REF(value);
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 	spl_ptr_llist_unshift(intern->llist, value TSRMLS_CC);
 
 	RETURN_TRUE;
 }
 /* }}} */
 
-/* {{{ proto mixed SplDoublyLinkedList::pop() U
+/* {{{ proto mixed SplDoublyLinkedList::pop()
 	   Pop an element out of the SplDoublyLinkedList */
 SPL_METHOD(SplDoublyLinkedList, pop)
 {
-	zval *value;
 	spl_dllist_object *intern;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	value = (zval *)spl_ptr_llist_pop(intern->llist TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
+	spl_ptr_llist_pop(intern->llist, return_value TSRMLS_CC);
 
-	if (value == NULL) {
+	if (ZVAL_IS_UNDEF(return_value)) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't pop from an empty datastructure", 0 TSRMLS_CC);
-		return;
+		RETURN_NULL();
 	}
-
-	RETURN_ZVAL(value, 1, 1);
 } 
 /* }}} */
 
-/* {{{ proto mixed SplDoublyLinkedList::shift() U
+/* {{{ proto mixed SplDoublyLinkedList::shift()
 	   Shift an element out of the SplDoublyLinkedList */
 SPL_METHOD(SplDoublyLinkedList, shift)
 {
-	zval *value;
 	spl_dllist_object *intern;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	value  = (zval *)spl_ptr_llist_shift(intern->llist TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
+	spl_ptr_llist_shift(intern->llist, return_value TSRMLS_CC);
 
-	if (value == NULL) {
+	if (ZVAL_IS_UNDEF(return_value)) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't shift from an empty datastructure", 0 TSRMLS_CC);
-		return;
+		RETURN_NULL();
 	}
-
-	RETURN_ZVAL(value, 1, 1);
 } 
 /* }}} */
 
-/* {{{ proto mixed SplDoublyLinkedList::top() U
+/* {{{ proto mixed SplDoublyLinkedList::top()
 	   Peek at the top element of the SplDoublyLinkedList */
 SPL_METHOD(SplDoublyLinkedList, top)
 {
@@ -653,10 +640,10 @@ SPL_METHOD(SplDoublyLinkedList, top)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	value  = (zval *)spl_ptr_llist_last(intern->llist);
+	intern = Z_SPLDLLIST_P(getThis());
+	value = spl_ptr_llist_last(intern->llist);
 
-	if (value == NULL) {
+	if (value == NULL || ZVAL_IS_UNDEF(value)) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't peek at an empty datastructure", 0 TSRMLS_CC);
 		return;
 	}
@@ -665,7 +652,7 @@ SPL_METHOD(SplDoublyLinkedList, top)
 }
 /* }}} */
 
-/* {{{ proto mixed SplDoublyLinkedList::bottom() U
+/* {{{ proto mixed SplDoublyLinkedList::bottom()
 	   Peek at the bottom element of the SplDoublyLinkedList */
 SPL_METHOD(SplDoublyLinkedList, bottom)
 {
@@ -676,10 +663,10 @@ SPL_METHOD(SplDoublyLinkedList, bottom)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	value  = (zval *)spl_ptr_llist_first(intern->llist);
+	intern = Z_SPLDLLIST_P(getThis());
+	value  = spl_ptr_llist_first(intern->llist);
 
-	if (value == NULL) {
+	if (value == NULL || ZVAL_IS_UNDEF(value)) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't peek at an empty datastructure", 0 TSRMLS_CC);
 		return;
 	}
@@ -688,12 +675,12 @@ SPL_METHOD(SplDoublyLinkedList, bottom)
 }
 /* }}} */
 
-/* {{{ proto int SplDoublyLinkedList::count() U
+/* {{{ proto int SplDoublyLinkedList::count()
  Return the number of elements in the datastructure. */
 SPL_METHOD(SplDoublyLinkedList, count)
 {
 	long count;
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -704,7 +691,7 @@ SPL_METHOD(SplDoublyLinkedList, count)
 }
 /* }}} */
 
-/* {{{ proto int SplDoublyLinkedList::isEmpty() U
+/* {{{ proto int SplDoublyLinkedList::isEmpty()
  Return true if the SplDoublyLinkedList is empty. */
 SPL_METHOD(SplDoublyLinkedList, isEmpty)
 {
@@ -715,11 +702,11 @@ SPL_METHOD(SplDoublyLinkedList, isEmpty)
 	}
 
 	spl_dllist_object_count_elements(getThis(), &count TSRMLS_CC);
-	RETURN_BOOL(count==0);
+	RETURN_BOOL(count == 0);
 }
 /* }}} */
 
-/* {{{ proto int SplDoublyLinkedList::setIteratorMode($flags) U
+/* {{{ proto int SplDoublyLinkedList::setIteratorMode($flags)
  Set the mode of iteration */
 SPL_METHOD(SplDoublyLinkedList, setIteratorMode)
 {
@@ -730,7 +717,7 @@ SPL_METHOD(SplDoublyLinkedList, setIteratorMode)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 
 	if (intern->flags & SPL_DLLIST_IT_FIX
 		&& (intern->flags & SPL_DLLIST_IT_LIFO) != (value & SPL_DLLIST_IT_LIFO)) {
@@ -744,7 +731,7 @@ SPL_METHOD(SplDoublyLinkedList, setIteratorMode)
 }
 /* }}} */
 
-/* {{{ proto int SplDoublyLinkedList::getIteratorMode() U
+/* {{{ proto int SplDoublyLinkedList::getIteratorMode()
  Return the mode of iteration */
 SPL_METHOD(SplDoublyLinkedList, getIteratorMode)
 {
@@ -754,13 +741,13 @@ SPL_METHOD(SplDoublyLinkedList, getIteratorMode)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 
 	RETURN_LONG(intern->flags);
 }
 /* }}} */
 
-/* {{{ proto bool SplDoublyLinkedList::offsetExists(mixed $index) U
+/* {{{ proto bool SplDoublyLinkedList::offsetExists(mixed $index)
  Returns whether the requested $index exists. */
 SPL_METHOD(SplDoublyLinkedList, offsetExists)
 {
@@ -772,17 +759,17 @@ SPL_METHOD(SplDoublyLinkedList, offsetExists)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 	index  = spl_offset_convert_to_long(zindex TSRMLS_CC);
 
 	RETURN_BOOL(index >= 0 && index < intern->llist->count);
 } /* }}} */
 
-/* {{{ proto mixed SplDoublyLinkedList::offsetGet(mixed $index) U
+/* {{{ proto mixed SplDoublyLinkedList::offsetGet(mixed $index) 
  Returns the value at the specified $index. */
 SPL_METHOD(SplDoublyLinkedList, offsetGet)
 {
-	zval                  *zindex, *value;
+	zval                  *zindex;
 	long                   index;
 	spl_dllist_object     *intern;
 	spl_ptr_llist_element *element;
@@ -791,7 +778,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetGet)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 	index  = spl_offset_convert_to_long(zindex TSRMLS_CC);
 
 	if (index < 0 || index >= intern->llist->count) {
@@ -802,15 +789,14 @@ SPL_METHOD(SplDoublyLinkedList, offsetGet)
 	element = spl_ptr_llist_offset(intern->llist, index, intern->flags & SPL_DLLIST_IT_LIFO);
 
 	if (element != NULL) {
-		value = (zval *)element->data;
-		RETURN_ZVAL(value, 1, 0);
+		RETURN_ZVAL(&element->data, 1, 0);
 	} else {
 		zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid", 0 TSRMLS_CC);
 		return;
 	}
 } /* }}} */
 
-/* {{{ proto void SplDoublyLinkedList::offsetSet(mixed $index, mixed $newval) U
+/* {{{ proto void SplDoublyLinkedList::offsetSet(mixed $index, mixed $newval)
  Sets the value at the specified $index to $newval. */
 SPL_METHOD(SplDoublyLinkedList, offsetSet)
 {
@@ -820,9 +806,9 @@ SPL_METHOD(SplDoublyLinkedList, offsetSet)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &zindex, &value) == FAILURE) {
 		return;
 	}
-	SEPARATE_ARG_IF_REF(value);
+	SEPARATE_ZVAL_IF_REF(value);
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 
 	if (Z_TYPE_P(zindex) == IS_NULL) {
 		/* $obj[] = ... */
@@ -835,7 +821,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetSet)
 		index = spl_offset_convert_to_long(zindex TSRMLS_CC);
 
 		if (index < 0 || index >= intern->llist->count) {
-			zval_ptr_dtor(&value);
+			zval_ptr_dtor(value);
 			zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid or out of range", 0 TSRMLS_CC);
 			return;
 		}
@@ -850,22 +836,22 @@ SPL_METHOD(SplDoublyLinkedList, offsetSet)
 
 			/* the element is replaced, delref the old one as in
 			 * SplDoublyLinkedList::pop() */
-			zval_ptr_dtor((zval **)&element->data);
-			element->data = value;
+			zval_ptr_dtor(&element->data);
+			ZVAL_COPY_VALUE(&element->data, value);
 
 			/* new element, call ctor as in spl_ptr_llist_push */
 			if (intern->llist->ctor) {
 				intern->llist->ctor(element TSRMLS_CC);
 			}
 		} else {
-			zval_ptr_dtor(&value);
+			zval_ptr_dtor(value);
 			zend_throw_exception(spl_ce_OutOfRangeException, "Offset invalid", 0 TSRMLS_CC);
 			return;
 		}
 	}
 } /* }}} */
 
-/* {{{ proto void SplDoublyLinkedList::offsetUnset(mixed $index) U
+/* {{{ proto void SplDoublyLinkedList::offsetUnset(mixed $index)
  Unsets the value at the specified $index. */
 SPL_METHOD(SplDoublyLinkedList, offsetUnset)
 {
@@ -879,7 +865,7 @@ SPL_METHOD(SplDoublyLinkedList, offsetUnset)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 	index  = spl_offset_convert_to_long(zindex TSRMLS_CC);
 	llist  = intern->llist;
 
@@ -916,8 +902,8 @@ SPL_METHOD(SplDoublyLinkedList, offsetUnset)
 			llist->dtor(element TSRMLS_CC);
 		}
 
-		zval_ptr_dtor((zval **)&element->data);
-		element->data = NULL;
+		zval_ptr_dtor(&element->data);
+		ZVAL_UNDEF(&element->data);
 
 		SPL_LLIST_DELREF(element);
 	} else {
@@ -933,9 +919,7 @@ static void spl_dllist_it_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 	SPL_LLIST_CHECK_DELREF(iterator->traverse_pointer);
 
 	zend_user_it_invalidate_current(iter TSRMLS_CC);
-	zval_ptr_dtor((zval**)&iterator->intern.it.data);
-
-	efree(iterator);
+	zval_ptr_dtor(&iterator->intern.it.data);
 }
 /* }}} */
 
@@ -965,21 +949,19 @@ static void spl_dllist_it_helper_move_forward(spl_ptr_llist_element **traverse_p
 			(*traverse_position_ptr)--;
 
 			if (flags & SPL_DLLIST_IT_DELETE) {
-				zval *prev = (zval *)spl_ptr_llist_pop(llist TSRMLS_CC);
+				zval prev;
+				spl_ptr_llist_pop(llist, &prev TSRMLS_CC);
 
-				if (prev) {
-					zval_ptr_dtor((zval **)&prev);
-				}
+				zval_ptr_dtor(&prev);
 			}
 		} else {
 			*traverse_pointer_ptr = old->next;
 
 			if (flags & SPL_DLLIST_IT_DELETE) {
-				zval *prev = (zval *)spl_ptr_llist_shift(llist TSRMLS_CC);
+				zval prev;
+				spl_ptr_llist_shift(llist, &prev TSRMLS_CC);
 
-				if (prev) {
-					zval_ptr_dtor((zval **)&prev);
-				}
+				zval_ptr_dtor(&prev);
 			} else {
 				(*traverse_position_ptr)++;
 			}
@@ -993,9 +975,9 @@ static void spl_dllist_it_helper_move_forward(spl_ptr_llist_element **traverse_p
 
 static void spl_dllist_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_dllist_it     *iterator = (spl_dllist_it *)iter;
-	spl_dllist_object *object   = iterator->object;
-	spl_ptr_llist     *llist    = object->llist;
+	spl_dllist_it *iterator = (spl_dllist_it *)iter;
+	spl_dllist_object *object = Z_SPLDLLIST_P(&iter->data);
+	spl_ptr_llist *llist = object->llist;
 
 	spl_dllist_it_helper_rewind(&iterator->traverse_pointer, &iterator->traverse_position, llist, object->flags TSRMLS_CC);
 }
@@ -1010,16 +992,16 @@ static int spl_dllist_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static void spl_dllist_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *spl_dllist_it_get_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
 	spl_dllist_it         *iterator = (spl_dllist_it *)iter;
 	spl_ptr_llist_element *element  = iterator->traverse_pointer;
 
-	if (element == NULL || element->data == NULL) {
-		*data = NULL;
-	} else {
-		*data = (zval **)&element->data;
+	if (element == NULL || ZVAL_IS_UNDEF(&element->data)) {
+		return NULL;
 	}
+
+	return &element->data;
 }
 /* }}} */
 
@@ -1033,8 +1015,8 @@ static void spl_dllist_it_get_current_key(zend_object_iterator *iter, zval *key
 
 static void spl_dllist_it_move_forward(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_dllist_it     *iterator = (spl_dllist_it *)iter;
-	spl_dllist_object *object   = iterator->object;
+	spl_dllist_it *iterator = (spl_dllist_it *)iter;
+	spl_dllist_object *object = Z_SPLDLLIST_P(&iter->data);
 
 	zend_user_it_invalidate_current(iter TSRMLS_CC);
 
@@ -1042,11 +1024,11 @@ static void spl_dllist_it_move_forward(zend_object_iterator *iter TSRMLS_DC) /*
 }
 /* }}} */
 
-/* {{{  proto int SplDoublyLinkedList::key() U
+/* {{{  proto int SplDoublyLinkedList::key()
    Return current array key */
 SPL_METHOD(SplDoublyLinkedList, key)
 {
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1056,11 +1038,11 @@ SPL_METHOD(SplDoublyLinkedList, key)
 }
 /* }}} */
 
-/* {{{ proto void SplDoublyLinkedList::prev() U
+/* {{{ proto void SplDoublyLinkedList::prev()
    Move to next entry */
 SPL_METHOD(SplDoublyLinkedList, prev)
 {
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1070,11 +1052,11 @@ SPL_METHOD(SplDoublyLinkedList, prev)
 }
 /* }}} */
 
-/* {{{ proto void SplDoublyLinkedList::next() U
+/* {{{ proto void SplDoublyLinkedList::next()
    Move to next entry */
 SPL_METHOD(SplDoublyLinkedList, next)
 {
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1084,11 +1066,11 @@ SPL_METHOD(SplDoublyLinkedList, next)
 }
 /* }}} */
 
-/* {{{ proto bool SplDoublyLinkedList::valid() U
+/* {{{ proto bool SplDoublyLinkedList::valid()
    Check whether the datastructure contains more entries */
 SPL_METHOD(SplDoublyLinkedList, valid)
 {
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1098,11 +1080,11 @@ SPL_METHOD(SplDoublyLinkedList, valid)
 }
 /* }}} */
 
-/* {{{ proto void SplDoublyLinkedList::rewind() U
+/* {{{ proto void SplDoublyLinkedList::rewind()
    Rewind the datastructure back to the start */
 SPL_METHOD(SplDoublyLinkedList, rewind)
 {
-	spl_dllist_object *intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1112,33 +1094,33 @@ SPL_METHOD(SplDoublyLinkedList, rewind)
 }
 /* }}} */
 
-/* {{{ proto mixed|NULL SplDoublyLinkedList::current() U
+/* {{{ proto mixed|NULL SplDoublyLinkedList::current()
    Return current datastructure entry */
 SPL_METHOD(SplDoublyLinkedList, current)
 {
-	spl_dllist_object     *intern  = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object     *intern  = Z_SPLDLLIST_P(getThis());
 	spl_ptr_llist_element *element = intern->traverse_pointer;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (element == NULL || element->data == NULL) {
+	if (element == NULL || ZVAL_IS_UNDEF(&element->data)) {
 		RETURN_NULL();
 	} else {
-		zval *data    = (zval *)element->data;
-		RETURN_ZVAL(data, 1, 0);
+		RETURN_ZVAL(&element->data, 1, 0);
 	}
 }
 /* }}} */
+
 /* {{{ proto string SplDoublyLinkedList::serialize()
  Serializes storage */
 SPL_METHOD(SplDoublyLinkedList, serialize)
 {
-	spl_dllist_object     *intern   = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dllist_object     *intern   = Z_SPLDLLIST_P(getThis());
 	smart_str              buf      = {0};
 	spl_ptr_llist_element *current  = intern->llist->head, *next;
-	zval                   *flags;
+	zval                   flags;
 	php_serialize_data_t   var_hash;
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1148,8 +1130,7 @@ SPL_METHOD(SplDoublyLinkedList, serialize)
 	PHP_VAR_SERIALIZE_INIT(var_hash);
 
 	/* flags */
-	MAKE_STD_ZVAL(flags);
-	ZVAL_LONG(flags, intern->flags);
+	ZVAL_LONG(&flags, intern->flags);
 	php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC);
 	zval_ptr_dtor(&flags);
 
@@ -1158,7 +1139,7 @@ SPL_METHOD(SplDoublyLinkedList, serialize)
 		smart_str_appendc(&buf, ':');
 		next = current->next;
 
-		php_var_serialize(&buf, (zval **)&current->data, &var_hash TSRMLS_CC);
+		php_var_serialize(&buf, &current->data, &var_hash TSRMLS_CC);
 
 		current = next;
 	}
@@ -1168,8 +1149,8 @@ SPL_METHOD(SplDoublyLinkedList, serialize)
 	/* done */
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
 
-	if (buf.c) {
-		RETURN_STRINGL(buf.c, buf.len, 0);
+	if (buf.s) {
+		RETURN_STR(buf.s);
 	} else {
 		RETURN_NULL();
 	}
@@ -1180,8 +1161,8 @@ SPL_METHOD(SplDoublyLinkedList, serialize)
  Unserializes storage */
 SPL_METHOD(SplDoublyLinkedList, unserialize)
 {
-	spl_dllist_object     *intern   = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	zval                  *flags, *elem;
+	spl_dllist_object *intern = Z_SPLDLLIST_P(getThis());
+	zval flags, elem;
 	char *buf;
 	int buf_len;
 	const unsigned char *p, *s;
@@ -1200,24 +1181,27 @@ SPL_METHOD(SplDoublyLinkedList, unserialize)
 	PHP_VAR_UNSERIALIZE_INIT(var_hash);
 
 	/* flags */
-	ALLOC_INIT_ZVAL(flags);
-	if (!php_var_unserialize(&flags, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE_P(flags) != IS_LONG) {
+	if (!php_var_unserialize(&flags, &p, s + buf_len, &var_hash TSRMLS_CC)) {
+		goto error;
+	}
+
+	if (Z_TYPE(flags) != IS_LONG) {
 		zval_ptr_dtor(&flags);
 		goto error;
 	}
-	intern->flags = Z_LVAL_P(flags);
+
+	intern->flags = Z_LVAL(flags);
 	zval_ptr_dtor(&flags);
 
 	/* elements */
 	while(*p == ':') {
 		++p;
-		ALLOC_INIT_ZVAL(elem);
 		if (!php_var_unserialize(&elem, &p, s + buf_len, &var_hash TSRMLS_CC)) {
-			zval_ptr_dtor(&elem);
 			goto error;
 		}
 
-		spl_ptr_llist_push(intern->llist, elem TSRMLS_CC);
+		spl_ptr_llist_push(intern->llist, &elem TSRMLS_CC);
+		zval_ptr_dtor(&elem);
 	}
 
 	if (*p != '\0') {
@@ -1234,7 +1218,7 @@ error:
 
 } /* }}} */
 
-/* {{{ proto void SplDoublyLinkedList::add(mixed $index, mixed $newval) U
+/* {{{ proto void SplDoublyLinkedList::add(mixed $index, mixed $newval)
  Inserts a new entry before the specified $index consisting of $newval. */
 SPL_METHOD(SplDoublyLinkedList, add)
 {
@@ -1247,7 +1231,7 @@ SPL_METHOD(SplDoublyLinkedList, add)
 		return;
 	}
 
-	intern = (spl_dllist_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDLLIST_P(getThis());
 	index  = spl_offset_convert_to_long(zindex TSRMLS_CC);
 
 	if (index < 0 || index > intern->llist->count) {
@@ -1255,7 +1239,9 @@ SPL_METHOD(SplDoublyLinkedList, add)
 		return;
 	}
 
-	Z_ADDREF_P(value);
+	if (Z_REFCOUNTED_P(value)) {
+		Z_ADDREF_P(value);
+	}
 	if (index == intern->llist->count) {
 		/* If index is the last entry+1 then we do a push because we're not inserting before any entry */
 		spl_ptr_llist_push(intern->llist, value TSRMLS_CC);
@@ -1266,7 +1252,7 @@ SPL_METHOD(SplDoublyLinkedList, add)
 		/* Get the element we want to insert before */
 		element = spl_ptr_llist_offset(intern->llist, index, intern->flags & SPL_DLLIST_IT_LIFO);
 
-		elem->data = value;
+		ZVAL_COPY_VALUE(&elem->data, value);
 		elem->rc   = 1;
 		/* connect to the neighbours */
 		elem->next = element;
@@ -1288,8 +1274,7 @@ SPL_METHOD(SplDoublyLinkedList, add)
 	}
 } /* }}} */
 
-
-/* iterator handler table */
+/* {{{ iterator handler table */
 zend_object_iterator_funcs spl_dllist_it_funcs = {
 	spl_dllist_it_dtor,
 	spl_dllist_it_valid,
@@ -1297,34 +1282,33 @@ zend_object_iterator_funcs spl_dllist_it_funcs = {
 	spl_dllist_it_get_current_key,
 	spl_dllist_it_move_forward,
 	spl_dllist_it_rewind
-};
+}; /* }}} */
 
 zend_object_iterator *spl_dllist_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
-	spl_dllist_it     *iterator;
-	spl_dllist_object *dllist_object = (spl_dllist_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_dllist_it *iterator;
+	spl_dllist_object *dllist_object = Z_SPLDLLIST_P(object);
 
 	if (by_ref) {
 		zend_throw_exception(spl_ce_RuntimeException, "An iterator cannot be used with foreach by reference", 0 TSRMLS_CC);
 		return NULL;
 	}
 
-	Z_ADDREF_P(object);
+	iterator = emalloc(sizeof(spl_dllist_it));
 
-	iterator                     = emalloc(sizeof(spl_dllist_it));
-	iterator->intern.it.data     = (void*)object;
+	zend_iterator_init((zend_object_iterator*)iterator TSRMLS_CC);
+	
+	ZVAL_COPY(&iterator->intern.it.data, object);
 	iterator->intern.it.funcs    = &spl_dllist_it_funcs;
 	iterator->intern.ce          = ce;
-	iterator->intern.value       = NULL;
 	iterator->traverse_position  = dllist_object->traverse_position;
 	iterator->traverse_pointer   = dllist_object->traverse_pointer;
 	iterator->flags              = dllist_object->flags & SPL_DLLIST_IT_MASK;
-	iterator->object             = dllist_object;
+	ZVAL_UNDEF(&iterator->intern.value);
 
 	SPL_LLIST_CHECK_ADDREF(iterator->traverse_pointer);
 
-
-	return (zend_object_iterator*)iterator;
+	return &iterator->intern.it;
 }
 /* }}} */
 
@@ -1398,9 +1382,12 @@ PHP_MINIT_FUNCTION(spl_dllist) /* {{{ */
 	REGISTER_SPL_STD_CLASS_EX(SplDoublyLinkedList, spl_dllist_object_new, spl_funcs_SplDoublyLinkedList);
 	memcpy(&spl_handler_SplDoublyLinkedList, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 
-	spl_handler_SplDoublyLinkedList.clone_obj      = spl_dllist_object_clone;
+	spl_handler_SplDoublyLinkedList.offset = XtOffsetOf(spl_dllist_object, std);
+	spl_handler_SplDoublyLinkedList.clone_obj = spl_dllist_object_clone;
 	spl_handler_SplDoublyLinkedList.count_elements = spl_dllist_object_count_elements;
 	spl_handler_SplDoublyLinkedList.get_debug_info = spl_dllist_object_get_debug_info;
+	spl_handler_SplDoublyLinkedList.dtor_obj = zend_objects_destroy_object;
+	spl_handler_SplDoublyLinkedList.free_obj = spl_dllist_object_free_storage;
 
 	REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_LIFO",  SPL_DLLIST_IT_LIFO);
 	REGISTER_SPL_CLASS_CONST_LONG(SplDoublyLinkedList, "IT_MODE_FIFO",  0);
@@ -1423,6 +1410,7 @@ PHP_MINIT_FUNCTION(spl_dllist) /* {{{ */
 	return SUCCESS;
 }
 /* }}} */
+
 /*
  * Local variables:
  * tab-width: 4
diff --git a/ext/spl/spl_engine.c b/ext/spl/spl_engine.c
index c07ce6846f..3d12b04799 100644
--- a/ext/spl/spl_engine.c
+++ b/ext/spl/spl_engine.c
@@ -32,14 +32,11 @@
 #include "spl_array.h"
 
 /* {{{ spl_instantiate */
-PHPAPI void spl_instantiate(zend_class_entry *pce, zval **object, int alloc TSRMLS_DC)
+PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC)
 {
-	if (alloc) {
-		ALLOC_ZVAL(*object);
-	}
-	object_init_ex(*object, pce);
-	Z_SET_REFCOUNT_PP(object, 1);
-	Z_SET_ISREF_PP(object); /* check if this can be hold always */
+	object_init_ex(object, pce);
+	Z_SET_REFCOUNT_P(object, 1);
+	// !!!PZ_SET_ISREF_P(object); /* check if this can be hold always */
 }
 /* }}} */
 
diff --git a/ext/spl/spl_engine.h b/ext/spl/spl_engine.h
index a67e60c105..8c72ca9691 100644
--- a/ext/spl/spl_engine.h
+++ b/ext/spl/spl_engine.h
@@ -25,26 +25,28 @@
 #include "php_spl.h"
 #include "zend_interfaces.h"
 
-PHPAPI void spl_instantiate(zend_class_entry *pce, zval **object, int alloc TSRMLS_DC);
+PHPAPI void spl_instantiate(zend_class_entry *pce, zval *object TSRMLS_DC);
 
 PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC);
 
 /* {{{ spl_instantiate_arg_ex1 */
-static inline int spl_instantiate_arg_ex1(zend_class_entry *pce, zval **retval, int alloc, zval *arg1 TSRMLS_DC)
+static inline int spl_instantiate_arg_ex1(zend_class_entry *pce, zval *retval, zval *arg1 TSRMLS_DC)
 {
-	spl_instantiate(pce, retval, alloc TSRMLS_CC);
+	zend_function *func = pce->constructor;
+	spl_instantiate(pce, retval TSRMLS_CC);
 	
-	zend_call_method(retval, pce, &pce->constructor, pce->constructor->common.function_name, strlen(pce->constructor->common.function_name), NULL, 1, arg1, NULL TSRMLS_CC);
+	zend_call_method(retval, pce, &func, func->common.function_name->val, func->common.function_name->len, NULL, 1, arg1, NULL TSRMLS_CC);
 	return 0;
 }
 /* }}} */
 
 /* {{{ spl_instantiate_arg_ex2 */
-static inline int spl_instantiate_arg_ex2(zend_class_entry *pce, zval **retval, int alloc, zval *arg1, zval *arg2 TSRMLS_DC)
+static inline int spl_instantiate_arg_ex2(zend_class_entry *pce, zval *retval, zval *arg1, zval *arg2 TSRMLS_DC)
 {
-	spl_instantiate(pce, retval, alloc TSRMLS_CC);
+	zend_function *func = pce->constructor;
+	spl_instantiate(pce, retval TSRMLS_CC);
 	
-	zend_call_method(retval, pce, &pce->constructor, pce->constructor->common.function_name, strlen(pce->constructor->common.function_name), NULL, 2, arg1, arg2 TSRMLS_CC);
+	zend_call_method(retval, pce, &func, func->common.function_name->val, func->common.function_name->len, NULL, 2, arg1, arg2 TSRMLS_CC);
 	return 0;
 }
 /* }}} */
diff --git a/ext/spl/spl_fixedarray.c b/ext/spl/spl_fixedarray.c
index dcd1582d60..5f7452bed2 100644
--- a/ext/spl/spl_fixedarray.c
+++ b/ext/spl/spl_fixedarray.c
@@ -44,14 +44,13 @@ ZEND_GET_MODULE(spl_fixedarray)
 
 typedef struct _spl_fixedarray { /* {{{ */
 	long size;
-	zval **elements;
+	zval *elements;
 } spl_fixedarray;
 /* }}} */
 
 typedef struct _spl_fixedarray_object { /* {{{ */
-	zend_object            std;
-	spl_fixedarray         *array;
-	zval                  *retval;
+	spl_fixedarray        *array;
+	zval                   retval;
 	zend_function         *fptr_offset_get;
 	zend_function         *fptr_offset_set;
 	zend_function         *fptr_offset_has;
@@ -60,12 +59,12 @@ typedef struct _spl_fixedarray_object { /* {{{ */
 	int                    current;
 	int                    flags;
 	zend_class_entry      *ce_get_iterator;
+	zend_object            std;
 } spl_fixedarray_object;
 /* }}} */
 
 typedef struct _spl_fixedarray_it { /* {{{ */
 	zend_user_iterator     intern;
-	spl_fixedarray_object  *object;
 } spl_fixedarray_it;
 /* }}} */
 
@@ -75,11 +74,18 @@ typedef struct _spl_fixedarray_it { /* {{{ */
 #define SPL_FIXEDARRAY_OVERLOADED_CURRENT 0x0008
 #define SPL_FIXEDARRAY_OVERLOADED_NEXT    0x0010
 
+static inline spl_fixedarray_object *spl_fixed_array_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_fixedarray_object*)((char*)(obj) - XtOffsetOf(spl_fixedarray_object, std));
+}
+/* }}} */
+
+#define Z_SPLFIXEDARRAY_P(zv)  spl_fixed_array_from_obj(Z_OBJ_P((zv)))
+
 static void spl_fixedarray_init(spl_fixedarray *array, long size TSRMLS_DC) /* {{{ */
 {
 	if (size > 0) {
 		array->size = 0; /* reset size in case ecalloc() fails */
-		array->elements = ecalloc(size, sizeof(zval *));
+		array->elements = ecalloc(size, sizeof(zval));
 		array->size = size;
 	} else {
 		array->elements = NULL;
@@ -106,9 +112,7 @@ static void spl_fixedarray_resize(spl_fixedarray *array, long size TSRMLS_DC) /*
 		long i;
 
 		for (i = 0; i < array->size; i++) {
-			if (array->elements[i]) {
-				zval_ptr_dtor(&(array->elements[i]));
-			}
+			zval_ptr_dtor(&(array->elements[i]));
 		}
 
 		if (array->elements) {
@@ -116,17 +120,15 @@ static void spl_fixedarray_resize(spl_fixedarray *array, long size TSRMLS_DC) /*
 			array->elements = NULL;
 		}
 	} else if (size > array->size) {
-		array->elements = erealloc(array->elements, sizeof(zval *) * size);
-		memset(array->elements + array->size, '\0', sizeof(zval *) * (size - array->size));
+		array->elements = erealloc(array->elements, sizeof(zval) * size);
+		memset(array->elements + array->size, '\0', sizeof(zval) * (size - array->size));
 	} else { /* size < array->size */
 		long i;
 
 		for (i = size; i < array->size; i++) {
-			if (array->elements[i]) {
-				zval_ptr_dtor(&(array->elements[i]));
-			}
+			zval_ptr_dtor(&(array->elements[i]));
 		}
-		array->elements = erealloc(array->elements, sizeof(zval *) * size);
+		array->elements = erealloc(array->elements, sizeof(zval) * size);
 	}
 
 	array->size = size;
@@ -137,19 +139,14 @@ static void spl_fixedarray_copy(spl_fixedarray *to, spl_fixedarray *from TSRMLS_
 {
 	int i;
 	for (i = 0; i < from->size; i++) {
-		if (from->elements[i]) {
-			Z_ADDREF_P(from->elements[i]);
-			to->elements[i] = from->elements[i];
-		} else {
-			to->elements[i] = NULL;
-		}
+		ZVAL_COPY(&to->elements[i], &from->elements[i]);
 	}
 }
 /* }}} */
 
-static HashTable* spl_fixedarray_object_get_gc(zval *obj, zval ***table, int *n TSRMLS_DC) /* {{{{ */
+static HashTable* spl_fixedarray_object_get_gc(zval *obj, zval **table, int *n TSRMLS_DC) /* {{{{ */
 {
-	spl_fixedarray_object *intern  = (spl_fixedarray_object*)zend_object_store_get_object(obj TSRMLS_CC);
+	spl_fixedarray_object *intern  = Z_SPLFIXEDARRAY_P(obj);
 	HashTable *ht = zend_std_get_properties(obj TSRMLS_CC);
 
 	if (intern->array) {
@@ -166,7 +163,7 @@ static HashTable* spl_fixedarray_object_get_gc(zval *obj, zval ***table, int *n
 
 static HashTable* spl_fixedarray_object_get_properties(zval *obj TSRMLS_DC) /* {{{{ */
 {
-	spl_fixedarray_object *intern  = (spl_fixedarray_object*)zend_object_store_get_object(obj TSRMLS_CC);
+	spl_fixedarray_object *intern  = Z_SPLFIXEDARRAY_P(obj);
 	HashTable *ht = zend_std_get_properties(obj TSRMLS_CC);
 	int  i = 0;
 
@@ -174,12 +171,13 @@ static HashTable* spl_fixedarray_object_get_properties(zval *obj TSRMLS_DC) /* {
 		int j = zend_hash_num_elements(ht);
 
 		for (i = 0; i < intern->array->size; i++) {
-			if (intern->array->elements[i]) {
-				zend_hash_index_update(ht, i, (void *)&intern->array->elements[i], sizeof(zval *), NULL);
-				Z_ADDREF_P(intern->array->elements[i]);
+			if (!ZVAL_IS_UNDEF(&intern->array->elements[i])) {
+				zend_hash_index_update(ht, i, &intern->array->elements[i]);
+				if (Z_REFCOUNTED(intern->array->elements[i])){
+					Z_ADDREF(intern->array->elements[i]);
+				}
 			} else {
-				zend_hash_index_update(ht, i, (void *)&EG(uninitialized_zval_ptr), sizeof(zval *), NULL);
-				Z_ADDREF_P(EG(uninitialized_zval_ptr));
+				zend_hash_index_update(ht, i, &EG(uninitialized_zval));
 			}
 		}
 		if (j > intern->array->size) {
@@ -193,16 +191,14 @@ static HashTable* spl_fixedarray_object_get_properties(zval *obj TSRMLS_DC) /* {
 }
 /* }}}} */
 
-static void spl_fixedarray_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void spl_fixedarray_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_object *intern = (spl_fixedarray_object *)object;
+	spl_fixedarray_object *intern = spl_fixed_array_from_obj(object);
 	long i;
 
 	if (intern->array) {
 		for (i = 0; i < intern->array->size; i++) {
-			if (intern->array->elements[i]) {
-				zval_ptr_dtor(&(intern->array->elements[i]));
-			}
+			zval_ptr_dtor(&(intern->array->elements[i]));
 		}
 
 		if (intern->array->size > 0 && intern->array->elements) {
@@ -213,23 +209,18 @@ static void spl_fixedarray_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 	zval_ptr_dtor(&intern->retval);
-
-	efree(object);
 }
 /* }}} */
 
 zend_object_iterator *spl_fixedarray_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 
-static zend_object_value spl_fixedarray_object_new_ex(zend_class_entry *class_type, spl_fixedarray_object **obj, zval *orig, int clone_orig TSRMLS_DC) /* {{{ */
+static zend_object *spl_fixedarray_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig TSRMLS_DC) /* {{{ */
 {
-	zend_object_value     retval;
 	spl_fixedarray_object *intern;
 	zend_class_entry     *parent = class_type;
 	int                   inherited = 0;
 
-	intern = ecalloc(1, sizeof(spl_fixedarray_object));
-	*obj = intern;
-	ALLOC_INIT_ZVAL(intern->retval);
+	intern = ecalloc(1, sizeof(spl_fixedarray_object) + (sizeof(zval) * parent->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
@@ -238,7 +229,7 @@ static zend_object_value spl_fixedarray_object_new_ex(zend_class_entry *class_ty
 	intern->flags = 0;
 
 	if (orig && clone_orig) {
-		spl_fixedarray_object *other = (spl_fixedarray_object*)zend_object_store_get_object(orig TSRMLS_CC);
+		spl_fixedarray_object *other = Z_SPLFIXEDARRAY_P(orig);
 		intern->ce_get_iterator = other->ce_get_iterator;
 		if (!other->array) {
 			/* leave a empty object, will be dtor later by CLONE handler */
@@ -252,7 +243,7 @@ static zend_object_value spl_fixedarray_object_new_ex(zend_class_entry *class_ty
 
 	while (parent) {
 		if (parent == spl_ce_SplFixedArray) {
-			retval.handlers = &spl_handler_SplFixedArray;
+			intern->std.handlers = &spl_handler_SplFixedArray;
 			class_type->get_iterator = spl_fixedarray_get_iterator;
 			break;
 		}
@@ -261,17 +252,16 @@ static zend_object_value spl_fixedarray_object_new_ex(zend_class_entry *class_ty
 		inherited = 1;
 	}
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, spl_fixedarray_object_free_storage, NULL TSRMLS_CC);
-
 	if (!parent) { /* this must never happen */
 		php_error_docref(NULL TSRMLS_CC, E_COMPILE_ERROR, "Internal compiler error, Class is not child of SplFixedArray");
 	}
+
 	if (!class_type->iterator_funcs.zf_current) {
-		zend_hash_find(&class_type->function_table, "rewind",  sizeof("rewind"),  (void **) &class_type->iterator_funcs.zf_rewind);
-		zend_hash_find(&class_type->function_table, "valid",   sizeof("valid"),   (void **) &class_type->iterator_funcs.zf_valid);
-		zend_hash_find(&class_type->function_table, "key",     sizeof("key"),     (void **) &class_type->iterator_funcs.zf_key);
-		zend_hash_find(&class_type->function_table, "current", sizeof("current"), (void **) &class_type->iterator_funcs.zf_current);
-		zend_hash_find(&class_type->function_table, "next",    sizeof("next"),    (void **) &class_type->iterator_funcs.zf_next);
+		class_type->iterator_funcs.zf_rewind = zend_hash_str_find_ptr(&class_type->function_table, "rewind", sizeof("rewind") - 1);
+		class_type->iterator_funcs.zf_valid = zend_hash_str_find_ptr(&class_type->function_table, "valid", sizeof("valid") - 1);
+		class_type->iterator_funcs.zf_key = zend_hash_str_find_ptr(&class_type->function_table, "key", sizeof("key") - 1);
+		class_type->iterator_funcs.zf_current = zend_hash_str_find_ptr(&class_type->function_table, "current", sizeof("current") - 1);
+		class_type->iterator_funcs.zf_next = zend_hash_str_find_ptr(&class_type->function_table, "next", sizeof("next") - 1);
 	}
 	if (inherited) {
 		if (class_type->iterator_funcs.zf_rewind->common.scope  != parent) { 
@@ -290,58 +280,53 @@ static zend_object_value spl_fixedarray_object_new_ex(zend_class_entry *class_ty
 			intern->flags |= SPL_FIXEDARRAY_OVERLOADED_NEXT;
 		}
 
-		zend_hash_find(&class_type->function_table, "offsetget",    sizeof("offsetget"),    (void **) &intern->fptr_offset_get);
+		intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1);
 		if (intern->fptr_offset_get->common.scope == parent) {
 			intern->fptr_offset_get = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetset",    sizeof("offsetset"),    (void **) &intern->fptr_offset_set);
+		intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1);
 		if (intern->fptr_offset_set->common.scope == parent) {
 			intern->fptr_offset_set = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetexists", sizeof("offsetexists"), (void **) &intern->fptr_offset_has);
+		intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1);
 		if (intern->fptr_offset_has->common.scope == parent) {
 			intern->fptr_offset_has = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "offsetunset",  sizeof("offsetunset"),  (void **) &intern->fptr_offset_del);
+		intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset", sizeof("offsetunset") - 1);
 		if (intern->fptr_offset_del->common.scope == parent) {
 			intern->fptr_offset_del = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "count",        sizeof("count"),        (void **) &intern->fptr_count);
+		intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
 		if (intern->fptr_count->common.scope == parent) {
 			intern->fptr_count = NULL;
 		}
 	}
 
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
-static zend_object_value spl_fixedarray_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *spl_fixedarray_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_object *tmp;
-	return spl_fixedarray_object_new_ex(class_type, &tmp, NULL, 0 TSRMLS_CC);
+	return spl_fixedarray_object_new_ex(class_type, NULL, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static zend_object_value spl_fixedarray_object_clone(zval *zobject TSRMLS_DC) /* {{{ */
+static zend_object *spl_fixedarray_object_clone(zval *zobject TSRMLS_DC) /* {{{ */
 {
-	zend_object_value      new_obj_val;
-	zend_object           *old_object;
-	zend_object           *new_object;
-	zend_object_handle     handle = Z_OBJ_HANDLE_P(zobject);
-	spl_fixedarray_object  *intern;
+	zend_object *old_object;
+	zend_object *new_object;
 
-	old_object  = zend_objects_get_address(zobject TSRMLS_CC);
-	new_obj_val = spl_fixedarray_object_new_ex(old_object->ce, &intern, zobject, 1 TSRMLS_CC);
-	new_object  = &intern->std;
+	old_object  = Z_OBJ_P(zobject);
+	new_object = spl_fixedarray_object_new_ex(old_object->ce, zobject, 1 TSRMLS_CC);
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
-	return new_obj_val;
+	return new_object;
 }
 /* }}} */
 
-static inline zval **spl_fixedarray_object_read_dimension_helper(spl_fixedarray_object *intern, zval *offset TSRMLS_DC) /* {{{ */
+static inline zval *spl_fixedarray_object_read_dimension_helper(spl_fixedarray_object *intern, zval *offset TSRMLS_DC) /* {{{ */
 {
 	long index;
 
@@ -361,7 +346,7 @@ static inline zval **spl_fixedarray_object_read_dimension_helper(spl_fixedarray_
 	if (index < 0 || intern->array == NULL || index >= intern->array->size) {
 		zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0 TSRMLS_CC);
 		return NULL;
-	} else if(!intern->array->elements[index]) {
+	} else if (ZVAL_IS_UNDEF(&intern->array->elements[index])) {
 		return NULL;
 	} else {
 		return &intern->array->elements[index];
@@ -369,36 +354,31 @@ static inline zval **spl_fixedarray_object_read_dimension_helper(spl_fixedarray_
 }
 /* }}} */
 
-static zval *spl_fixedarray_object_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
+static zval *spl_fixedarray_object_read_dimension(zval *object, zval *offset, int type, zval *rv TSRMLS_DC) /* {{{ */
 {
 	spl_fixedarray_object *intern;
-	zval **retval;
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 
 	if (intern->fptr_offset_get) {
-		zval *rv;
+		zval tmp, rv;
 		if (!offset) {
-			ALLOC_INIT_ZVAL(offset);
+			ZVAL_UNDEF(&tmp);
+			offset = &tmp;
 		} else {
 			SEPARATE_ARG_IF_REF(offset);
 		}
-		zend_call_method_with_1_params(&object, intern->std.ce, &intern->fptr_offset_get, "offsetGet", &rv, offset);
-		zval_ptr_dtor(&offset);
-		if (rv) {
+		zend_call_method_with_1_params(object, intern->std.ce, &intern->fptr_offset_get, "offsetGet", &rv, offset);
+		zval_ptr_dtor(offset);
+		if (!ZVAL_IS_UNDEF(&rv)) {
 			zval_ptr_dtor(&intern->retval);
-			MAKE_STD_ZVAL(intern->retval);
-			ZVAL_ZVAL(intern->retval, rv, 1, 1);
-			return intern->retval;
+			ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+			return &intern->retval;
 		}
-		return EG(uninitialized_zval_ptr);
+		return &EG(uninitialized_zval);
 	}
 
-	retval = spl_fixedarray_object_read_dimension_helper(intern, offset TSRMLS_CC);
-	if (retval) {
-		return *retval;
-	}
-	return NULL;
+	return spl_fixedarray_object_read_dimension_helper(intern, offset TSRMLS_CC);
 }
 /* }}} */
 
@@ -422,11 +402,11 @@ static inline void spl_fixedarray_object_write_dimension_helper(spl_fixedarray_o
 		zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0 TSRMLS_CC);
 		return;
 	} else {
-		if (intern->array->elements[index]) {
+		if (!ZVAL_IS_UNDEF(&intern->array->elements[index])) {
 			zval_ptr_dtor(&(intern->array->elements[index]));
 		}
 		SEPARATE_ARG_IF_REF(value);
-		intern->array->elements[index] = value;
+		ZVAL_COPY_VALUE(&intern->array->elements[index], value);
 	}
 }
 /* }}} */
@@ -435,18 +415,20 @@ static void spl_fixedarray_object_write_dimension(zval *object, zval *offset, zv
 {
 	spl_fixedarray_object *intern;
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 
 	if (intern->fptr_offset_set) {
+		zval tmp;
 		if (!offset) {
-			ALLOC_INIT_ZVAL(offset);
+			ZVAL_NULL(&tmp);
+			offset = &tmp;
 		} else {
 			SEPARATE_ARG_IF_REF(offset);
 		}
 		SEPARATE_ARG_IF_REF(value);
-		zend_call_method_with_2_params(&object, intern->std.ce, &intern->fptr_offset_set, "offsetSet", NULL, offset, value);
-		zval_ptr_dtor(&value);
-		zval_ptr_dtor(&offset);
+		zend_call_method_with_2_params(object, intern->std.ce, &intern->fptr_offset_set, "offsetSet", NULL, offset, value);
+		zval_ptr_dtor(value);
+		zval_ptr_dtor(offset);
 		return;
 	}
 
@@ -468,10 +450,8 @@ static inline void spl_fixedarray_object_unset_dimension_helper(spl_fixedarray_o
 		zend_throw_exception(spl_ce_RuntimeException, "Index invalid or out of range", 0 TSRMLS_CC);
 		return;
 	} else {
-		if (intern->array->elements[index]) {
-			zval_ptr_dtor(&(intern->array->elements[index]));
-		}
-		intern->array->elements[index] = NULL;
+		zval_ptr_dtor(&(intern->array->elements[index]));
+		ZVAL_UNDEF(&intern->array->elements[index]);
 	}
 }
 /* }}} */
@@ -480,12 +460,12 @@ static void spl_fixedarray_object_unset_dimension(zval *object, zval *offset TSR
 {
 	spl_fixedarray_object *intern;
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 
 	if (intern->fptr_offset_del) {
 		SEPARATE_ARG_IF_REF(offset);
-		zend_call_method_with_1_params(&object, intern->std.ce, &intern->fptr_offset_del, "offsetUnset", NULL, offset);
-		zval_ptr_dtor(&offset);
+		zend_call_method_with_1_params(object, intern->std.ce, &intern->fptr_offset_del, "offsetUnset", NULL, offset);
+		zval_ptr_dtor(offset);
 		return;
 	}
 
@@ -508,10 +488,10 @@ static inline int spl_fixedarray_object_has_dimension_helper(spl_fixedarray_obje
 	if (index < 0 || intern->array == NULL || index >= intern->array->size) {
 		retval = 0;
 	} else {
-		if (!intern->array->elements[index]) {
+		if (ZVAL_IS_UNDEF(&intern->array->elements[index])) {
 			retval = 0;
 		} else if (check_empty) {
-			if (zend_is_true(intern->array->elements[index] TSRMLS_CC)) {
+			if (zend_is_true(&intern->array->elements[index] TSRMLS_CC)) {
 				retval = 1;
 			} else {
 				retval = 0;
@@ -529,18 +509,17 @@ static int spl_fixedarray_object_has_dimension(zval *object, zval *offset, int c
 {
 	spl_fixedarray_object *intern;
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 
 	if (intern->fptr_offset_get) {
-		zval *rv;
+		zval rv;
 		SEPARATE_ARG_IF_REF(offset);
-		zend_call_method_with_1_params(&object, intern->std.ce, &intern->fptr_offset_has, "offsetExists", &rv, offset);
-		zval_ptr_dtor(&offset);
-		if (rv) {
+		zend_call_method_with_1_params(object, intern->std.ce, &intern->fptr_offset_has, "offsetExists", &rv, offset);
+		zval_ptr_dtor(offset);
+		if (!ZVAL_IS_UNDEF(&rv)) {
 			zval_ptr_dtor(&intern->retval);
-			MAKE_STD_ZVAL(intern->retval);
-			ZVAL_ZVAL(intern->retval, rv, 1, 1);
-			return zend_is_true(intern->retval TSRMLS_CC);
+			ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+			return zend_is_true(&intern->retval TSRMLS_CC);
 		}
 		return 0;
 	}
@@ -553,16 +532,15 @@ static int spl_fixedarray_object_count_elements(zval *object, long *count TSRMLS
 {
 	spl_fixedarray_object *intern;
 	
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 	if (intern->fptr_count) {
-		zval *rv;
-		zend_call_method_with_0_params(&object, intern->std.ce, &intern->fptr_count, "count", &rv);
-		if (rv) {
+		zval rv;
+		zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
+		if (!ZVAL_IS_UNDEF(&rv)) {
 			zval_ptr_dtor(&intern->retval);
-			MAKE_STD_ZVAL(intern->retval);
-			ZVAL_ZVAL(intern->retval, rv, 1, 1);
-			convert_to_long(intern->retval);
-			*count = (long) Z_LVAL_P(intern->retval);
+			ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+			convert_to_long(&intern->retval);
+			*count = (long) Z_LVAL(intern->retval);
 			return SUCCESS;
 		}
 	} else if (intern->array) {
@@ -592,7 +570,7 @@ SPL_METHOD(SplFixedArray, __construct)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 
 	if (intern->array) {
 		/* called __construct() twice, bail out */
@@ -608,10 +586,10 @@ SPL_METHOD(SplFixedArray, __construct)
 */
 SPL_METHOD(SplFixedArray, __wakeup)
 {
-	spl_fixedarray_object *intern = (spl_fixedarray_object *) zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(getThis());
 	HashPosition ptr;
 	HashTable *intern_ht = zend_std_get_properties(getThis() TSRMLS_CC);
-	zval **data;
+	zval *data;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -624,9 +602,11 @@ SPL_METHOD(SplFixedArray, __wakeup)
 		intern->array = emalloc(sizeof(spl_fixedarray));
 		spl_fixedarray_init(intern->array, size TSRMLS_CC);
 
-		for (zend_hash_internal_pointer_reset_ex(intern_ht, &ptr); zend_hash_get_current_data_ex(intern_ht, (void **) &data, &ptr) == SUCCESS; zend_hash_move_forward_ex(intern_ht, &ptr)) {
-			Z_ADDREF_PP(data);
-			intern->array->elements[index++] = *data;
+		for (zend_hash_internal_pointer_reset_ex(intern_ht, &ptr); (data = zend_hash_get_current_data_ex(intern_ht, &ptr)) != NULL; zend_hash_move_forward_ex(intern_ht, &ptr)) {
+			if (Z_REFCOUNTED_P(data)) {
+				Z_ADDREF_P(data);
+			}
+			ZVAL_COPY_VALUE(&intern->array->elements[index++], data);
 		}
 
 		/* Remove the unserialised properties, since we now have the elements
@@ -647,7 +627,7 @@ SPL_METHOD(SplFixedArray, count)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 	if (intern->array) {
 		RETURN_LONG(intern->array->size);
 	}
@@ -665,18 +645,19 @@ SPL_METHOD(SplFixedArray, toArray)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(getThis());
 
 	array_init(return_value);
 	if (intern->array) {
 		int i = 0;
 		for (; i < intern->array->size; i++) {
-			if (intern->array->elements[i]) {
-				zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *)&intern->array->elements[i], sizeof(zval *), NULL);
-				Z_ADDREF_P(intern->array->elements[i]);
+			if (!ZVAL_IS_UNDEF(&intern->array->elements[i])) {
+				zend_hash_index_update(Z_ARRVAL_P(return_value), i, &intern->array->elements[i]);
+				if (Z_REFCOUNTED(intern->array->elements[i])) {
+					Z_ADDREF(intern->array->elements[i]);
+				}
 			} else {
-				zend_hash_index_update(Z_ARRVAL_P(return_value), i, (void *)&EG(uninitialized_zval_ptr), sizeof(zval *), NULL);
-				Z_ADDREF_P(EG(uninitialized_zval_ptr));
+				zend_hash_index_update(Z_ARRVAL_P(return_value), i, &EG(uninitialized_zval));
 			}
 		}
 	}
@@ -697,17 +678,17 @@ SPL_METHOD(SplFixedArray, fromArray)
 		return;
 	}
 
-	array = ecalloc(1, sizeof(*array));
+	array = ecalloc(1, sizeof(spl_fixedarray));
 	num = zend_hash_num_elements(Z_ARRVAL_P(data));
 	
 	if (num > 0 && save_indexes) {
-		zval **element, *value;
-		char *str_index;
+		zval *element;
+		zend_string *str_index;
 		ulong num_index, max_index = 0;
 		long tmp;
 
 		for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
-			zend_hash_get_current_data(Z_ARRVAL_P(data), (void **) &element) == SUCCESS;
+			(element = zend_hash_get_current_data(Z_ARRVAL_P(data))) != NULL;
 			zend_hash_move_forward(Z_ARRVAL_P(data))
 			) {
 			if (zend_hash_get_current_key(Z_ARRVAL_P(data), &str_index, &num_index, 0) != HASH_KEY_IS_LONG || (long)num_index < 0) {
@@ -730,32 +711,29 @@ SPL_METHOD(SplFixedArray, fromArray)
 		spl_fixedarray_init(array, tmp TSRMLS_CC);
 
 		for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
-			zend_hash_get_current_data(Z_ARRVAL_P(data), (void **) &element) == SUCCESS;
+			(element = zend_hash_get_current_data(Z_ARRVAL_P(data))) != NULL;
 			zend_hash_move_forward(Z_ARRVAL_P(data))
 			) {
 			
 			zend_hash_get_current_key(Z_ARRVAL_P(data), &str_index, &num_index, 0);
-			value = *element;
 
-			SEPARATE_ARG_IF_REF(value);
-			array->elements[num_index] = value;
+			SEPARATE_ARG_IF_REF(element);
+			ZVAL_COPY_VALUE(&array->elements[num_index], element);
 		}
 
 	} else if (num > 0 && !save_indexes) {
-		zval **element, *value;
+		zval *element;
 		long i = 0;
 		
 		spl_fixedarray_init(array, num TSRMLS_CC);
 		
 		for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
-			zend_hash_get_current_data(Z_ARRVAL_P(data), (void **) &element) == SUCCESS;
+			(element = zend_hash_get_current_data(Z_ARRVAL_P(data))) != NULL;
 			zend_hash_move_forward(Z_ARRVAL_P(data))
 			) {
 			
-			value = *element;
-
-			SEPARATE_ARG_IF_REF(value);
-			array->elements[i] = value;
+			SEPARATE_ARG_IF_REF(element);
+			ZVAL_COPY_VALUE(&array->elements[i], element);
 			i++;
 		}
 	} else {
@@ -763,9 +741,8 @@ SPL_METHOD(SplFixedArray, fromArray)
 	}
 
 	object_init_ex(return_value, spl_ce_SplFixedArray);
-	Z_TYPE_P(return_value) = IS_OBJECT;
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(return_value TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(return_value);
 	intern->array = array;
 }
 /* }}} */
@@ -781,7 +758,7 @@ SPL_METHOD(SplFixedArray, getSize)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 	if (intern->array) {
 		RETURN_LONG(intern->array->size);
 	}
@@ -806,7 +783,7 @@ SPL_METHOD(SplFixedArray, setSize)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(object);
 	if (!intern->array) {
 		intern->array = ecalloc(1, sizeof(spl_fixedarray));
 	}
@@ -816,7 +793,7 @@ SPL_METHOD(SplFixedArray, setSize)
 }
 /* }}} */
 
-/* {{{ proto bool SplFixedArray::offsetExists(mixed $index) U
+/* {{{ proto bool SplFixedArray::offsetExists(mixed $index)
  Returns whether the requested $index exists. */
 SPL_METHOD(SplFixedArray, offsetExists)
 {
@@ -827,32 +804,32 @@ SPL_METHOD(SplFixedArray, offsetExists)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(getThis());
 
 	RETURN_BOOL(spl_fixedarray_object_has_dimension_helper(intern, zindex, 0 TSRMLS_CC));
 } /* }}} */
 
-/* {{{ proto mixed SplFixedArray::offsetGet(mixed $index) U
+/* {{{ proto mixed SplFixedArray::offsetGet(mixed $index)
  Returns the value at the specified $index. */
 SPL_METHOD(SplFixedArray, offsetGet)
 {
-	zval                  *zindex, **value_pp;
+	zval *zindex, *value;
 	spl_fixedarray_object  *intern;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zindex) == FAILURE) {
 		return;
 	}
 
-	intern    = (spl_fixedarray_object *)zend_object_store_get_object(getThis() TSRMLS_CC);
-	value_pp  = spl_fixedarray_object_read_dimension_helper(intern, zindex TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(getThis());
+	value = spl_fixedarray_object_read_dimension_helper(intern, zindex TSRMLS_CC);
 
-	if (value_pp) {
-		RETURN_ZVAL(*value_pp, 1, 0);
+	if (value) {
+		RETURN_ZVAL(value, 1, 0);
 	}
 	RETURN_NULL();
 } /* }}} */
 
-/* {{{ proto void SplFixedArray::offsetSet(mixed $index, mixed $newval) U
+/* {{{ proto void SplFixedArray::offsetSet(mixed $index, mixed $newval)
  Sets the value at the specified $index to $newval. */
 SPL_METHOD(SplFixedArray, offsetSet)
 {
@@ -863,12 +840,12 @@ SPL_METHOD(SplFixedArray, offsetSet)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(getThis());
 	spl_fixedarray_object_write_dimension_helper(intern, zindex, value TSRMLS_CC);
 
 } /* }}} */
 
-/* {{{ proto void SplFixedArray::offsetUnset(mixed $index) U
+/* {{{ proto void SplFixedArray::offsetUnset(mixed $index)
  Unsets the value at the specified $index. */
 SPL_METHOD(SplFixedArray, offsetUnset)
 {
@@ -879,7 +856,7 @@ SPL_METHOD(SplFixedArray, offsetUnset)
 		return;
 	}
 
-	intern = (spl_fixedarray_object *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLFIXEDARRAY_P(getThis());
 	spl_fixedarray_object_unset_dimension_helper(intern, zindex TSRMLS_CC);
 
 } /* }}} */
@@ -889,35 +866,31 @@ static void spl_fixedarray_it_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{
 	spl_fixedarray_it  *iterator = (spl_fixedarray_it *)iter;
 
 	zend_user_it_invalidate_current(iter TSRMLS_CC);
-	zval_ptr_dtor((zval**)&iterator->intern.it.data);
-
-	efree(iterator);
+	zval_ptr_dtor(&iterator->intern.it.data);
 }
 /* }}} */
 
 static void spl_fixedarray_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_it     *iterator = (spl_fixedarray_it *)iter;
-	spl_fixedarray_object *intern   = iterator->object;
+	spl_fixedarray_object *object = Z_SPLFIXEDARRAY_P(&iter->data);
 
-	if (intern->flags & SPL_FIXEDARRAY_OVERLOADED_REWIND) {
+	if (object->flags & SPL_FIXEDARRAY_OVERLOADED_REWIND) {
 		zend_user_it_rewind(iter TSRMLS_CC);
 	} else {
-		iterator->object->current = 0;
+		object->current = 0;
 	}
 }
 /* }}} */
 
 static int spl_fixedarray_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_it     *iterator = (spl_fixedarray_it *)iter;
-	spl_fixedarray_object *intern   = iterator->object;
+	spl_fixedarray_object *object = Z_SPLFIXEDARRAY_P(&iter->data);
 
-	if (intern->flags & SPL_FIXEDARRAY_OVERLOADED_VALID) {
+	if (object->flags & SPL_FIXEDARRAY_OVERLOADED_VALID) {
 		return zend_user_it_valid(iter TSRMLS_CC);
 	}
 
-	if (iterator->object->current >= 0 && iterator->object->array && iterator->object->current < iterator->object->array->size) {
+	if (object->current >= 0 && object->array && object->current < object->array->size) {
 		return SUCCESS;
 	}
 
@@ -925,61 +898,59 @@ static int spl_fixedarray_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-static void spl_fixedarray_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *spl_fixedarray_it_get_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	zval                  *zindex;
-	spl_fixedarray_it     *iterator = (spl_fixedarray_it *)iter;
-	spl_fixedarray_object *intern   = iterator->object;
+	zval zindex;
+	spl_fixedarray_object *object = Z_SPLFIXEDARRAY_P(&iter->data);
 
-	if (intern->flags & SPL_FIXEDARRAY_OVERLOADED_CURRENT) {
-		zend_user_it_get_current_data(iter, data TSRMLS_CC);
+	if (object->flags & SPL_FIXEDARRAY_OVERLOADED_CURRENT) {
+		return zend_user_it_get_current_data(iter TSRMLS_CC);
 	} else {
-		ALLOC_INIT_ZVAL(zindex);
-		ZVAL_LONG(zindex, iterator->object->current);
+		zval *data;
 
-		*data = spl_fixedarray_object_read_dimension_helper(intern, zindex TSRMLS_CC);
-
-		if (*data == NULL) {
-			*data = &EG(uninitialized_zval_ptr);
-		}
+		ZVAL_LONG(&zindex, object->current);
 
+		data = spl_fixedarray_object_read_dimension_helper(object, &zindex TSRMLS_CC);
 		zval_ptr_dtor(&zindex);
+
+		if (data == NULL) {
+			data = &EG(uninitialized_zval);
+		}
+		return data;
 	}
 }
 /* }}} */
 
 static void spl_fixedarray_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_it     *iterator = (spl_fixedarray_it *)iter;
-	spl_fixedarray_object *intern   = iterator->object;
+	spl_fixedarray_object *object = Z_SPLFIXEDARRAY_P(&iter->data);
 
-	if (intern->flags & SPL_FIXEDARRAY_OVERLOADED_KEY) {
+	if (object->flags & SPL_FIXEDARRAY_OVERLOADED_KEY) {
 		zend_user_it_get_current_key(iter, key TSRMLS_CC);
 	} else {
-		ZVAL_LONG(key, iterator->object->current);
+		ZVAL_LONG(key, object->current);
 	}
 }
 /* }}} */
 
 static void spl_fixedarray_it_move_forward(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_it     *iterator = (spl_fixedarray_it *)iter;
-	spl_fixedarray_object *intern   = iterator->object;
+	spl_fixedarray_object *object = Z_SPLFIXEDARRAY_P(&iter->data);
 
-	if (intern->flags & SPL_FIXEDARRAY_OVERLOADED_NEXT) {
+	if (object->flags & SPL_FIXEDARRAY_OVERLOADED_NEXT) {
 		zend_user_it_move_forward(iter TSRMLS_CC);
 	} else {
 		zend_user_it_invalidate_current(iter TSRMLS_CC);
-		iterator->object->current++;
+		object->current++;
 	}
 }
 /* }}} */
 
-/* {{{  proto int SplFixedArray::key() U
+/* {{{  proto int SplFixedArray::key()
    Return current array key */
 SPL_METHOD(SplFixedArray, key)
 {
-	spl_fixedarray_object *intern = (spl_fixedarray_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -989,11 +960,11 @@ SPL_METHOD(SplFixedArray, key)
 }
 /* }}} */
 
-/* {{{ proto void SplFixedArray::next() U
+/* {{{ proto void SplFixedArray::next()
    Move to next entry */
 SPL_METHOD(SplFixedArray, next)
 {
-	spl_fixedarray_object *intern = (spl_fixedarray_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1003,11 +974,11 @@ SPL_METHOD(SplFixedArray, next)
 }
 /* }}} */
 
-/* {{{ proto bool SplFixedArray::valid() U
+/* {{{ proto bool SplFixedArray::valid()
    Check whether the datastructure contains more entries */
 SPL_METHOD(SplFixedArray, valid)
 {
-	spl_fixedarray_object *intern = (spl_fixedarray_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1017,11 +988,11 @@ SPL_METHOD(SplFixedArray, valid)
 }
 /* }}} */
 
-/* {{{ proto void SplFixedArray::rewind() U
+/* {{{ proto void SplFixedArray::rewind()
    Rewind the datastructure back to the start */
 SPL_METHOD(SplFixedArray, rewind)
 {
-	spl_fixedarray_object *intern = (spl_fixedarray_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_fixedarray_object *intern = Z_SPLFIXEDARRAY_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1031,26 +1002,25 @@ SPL_METHOD(SplFixedArray, rewind)
 }
 /* }}} */
 
-/* {{{ proto mixed|NULL SplFixedArray::current() U
+/* {{{ proto mixed|NULL SplFixedArray::current()
    Return current datastructure entry */
 SPL_METHOD(SplFixedArray, current)
 {
-	zval                 *zindex, **value_pp;
-	spl_fixedarray_object *intern  = (spl_fixedarray_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	zval zindex, *value;
+	spl_fixedarray_object *intern  = Z_SPLFIXEDARRAY_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	ALLOC_INIT_ZVAL(zindex);
-	ZVAL_LONG(zindex, intern->current);
+	ZVAL_LONG(&zindex, intern->current);
 
-	value_pp  = spl_fixedarray_object_read_dimension_helper(intern, zindex TSRMLS_CC);
+	value = spl_fixedarray_object_read_dimension_helper(intern, &zindex TSRMLS_CC);
 
 	zval_ptr_dtor(&zindex);
 
-	if (value_pp) {
-		RETURN_ZVAL(*value_pp, 1, 0);
+	if (value) {
+		RETURN_ZVAL(value, 1, 0);
 	}
 	RETURN_NULL();
 }
@@ -1068,24 +1038,23 @@ zend_object_iterator_funcs spl_fixedarray_it_funcs = {
 
 zend_object_iterator *spl_fixedarray_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
-	spl_fixedarray_it      *iterator;
-	spl_fixedarray_object  *fixedarray_object = (spl_fixedarray_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_fixedarray_it *iterator;
 
 	if (by_ref) {
 		zend_throw_exception(spl_ce_RuntimeException, "An iterator cannot be used with foreach by reference", 0 TSRMLS_CC);
 		return NULL;
 	}
 
-	Z_ADDREF_P(object);
+	iterator = emalloc(sizeof(spl_fixedarray_it));
 
-	iterator                     = emalloc(sizeof(spl_fixedarray_it));
-	iterator->intern.it.data     = (void*)object;
-	iterator->intern.it.funcs    = &spl_fixedarray_it_funcs;
-	iterator->intern.ce          = ce;
-	iterator->intern.value       = NULL;
-	iterator->object             = fixedarray_object;
+	zend_iterator_init((zend_object_iterator*)iterator TSRMLS_CC);
+	
+	ZVAL_COPY(&iterator->intern.it.data, object);
+	iterator->intern.it.funcs = &spl_fixedarray_it_funcs;
+	iterator->intern.ce = ce;
+	ZVAL_UNDEF(&iterator->intern.value);
 
-	return (zend_object_iterator*)iterator;
+	return &iterator->intern.it;
 }
 /* }}} */
 
@@ -1141,6 +1110,7 @@ PHP_MINIT_FUNCTION(spl_fixedarray)
 	REGISTER_SPL_STD_CLASS_EX(SplFixedArray, spl_fixedarray_new, spl_funcs_SplFixedArray);
 	memcpy(&spl_handler_SplFixedArray, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 
+	spl_handler_SplFixedArray.offset          = XtOffsetOf(spl_fixedarray_object, std);
 	spl_handler_SplFixedArray.clone_obj       = spl_fixedarray_object_clone;
 	spl_handler_SplFixedArray.read_dimension  = spl_fixedarray_object_read_dimension;
 	spl_handler_SplFixedArray.write_dimension = spl_fixedarray_object_write_dimension;
@@ -1149,6 +1119,8 @@ PHP_MINIT_FUNCTION(spl_fixedarray)
 	spl_handler_SplFixedArray.count_elements  = spl_fixedarray_object_count_elements;
 	spl_handler_SplFixedArray.get_properties  = spl_fixedarray_object_get_properties;
 	spl_handler_SplFixedArray.get_gc          = spl_fixedarray_object_get_gc;
+	spl_handler_SplFixedArray.dtor_obj        = zend_objects_destroy_object;
+	spl_handler_SplFixedArray.free_obj        = spl_fixedarray_object_free_storage;
 
 	REGISTER_SPL_IMPLEMENTS(SplFixedArray, Iterator);
 	REGISTER_SPL_IMPLEMENTS(SplFixedArray, ArrayAccess);
diff --git a/ext/spl/spl_functions.c b/ext/spl/spl_functions.c
index f1e59c0234..97a9509caa 100644
--- a/ext/spl/spl_functions.c
+++ b/ext/spl/spl_functions.c
@@ -58,7 +58,7 @@ PHPAPI void spl_register_sub_class(zend_class_entry ** ppce, zend_class_entry *
 	zend_class_entry ce;
 	
 	INIT_CLASS_ENTRY_EX(ce, class_name, strlen(class_name), function_list);
-	*ppce = zend_register_internal_class_ex(&ce, parent_ce, NULL TSRMLS_CC);
+	*ppce = zend_register_internal_class_ex(&ce, parent_ce TSRMLS_CC);
 
 	/* entries changed by initialize */
 	if (obj_ctor) {
@@ -77,16 +77,16 @@ void spl_register_property( zend_class_entry * class_entry, char *prop_name, int
 /* }}} */
 
 /* {{{ spl_add_class_name */
-void spl_add_class_name(zval *list, zend_class_entry * pce, int allow, int ce_flags TSRMLS_DC)
+void spl_add_class_name(zval *list, zend_class_entry *pce, int allow, int ce_flags TSRMLS_DC)
 {
 	if (!allow || (allow > 0 && pce->ce_flags & ce_flags) || (allow < 0 && !(pce->ce_flags & ce_flags))) {
-		size_t len = pce->name_length;
 		zval *tmp;
 
-		if (zend_hash_find(Z_ARRVAL_P(list), pce->name, len+1, (void*)&tmp) == FAILURE) {
-			MAKE_STD_ZVAL(tmp);
-			ZVAL_STRINGL(tmp, pce->name, pce->name_length, 1);
-			zend_hash_add(Z_ARRVAL_P(list), pce->name, len+1, &tmp, sizeof(zval *), NULL);
+		if ((tmp = zend_hash_find(Z_ARRVAL_P(list), pce->name)) == NULL) {
+			zval t;
+			STR_ADDREF(pce->name);
+			ZVAL_STR(&t, pce->name);
+			zend_hash_add(Z_ARRVAL_P(list), pce->name, &t);
 		}
 	}
 }
@@ -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, ce->name_length, 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 214780f869..1d116ff783 100644
--- a/ext/spl/spl_functions.h
+++ b/ext/spl/spl_functions.h
@@ -23,7 +23,7 @@
 
 #include "php.h"
 
-typedef zend_object_value (*create_object_func_t)(zend_class_entry *class_type TSRMLS_DC);
+typedef zend_object* (*create_object_func_t)(zend_class_entry *class_type TSRMLS_DC);
 
 #define REGISTER_SPL_STD_CLASS(class_name, obj_ctor) \
 	spl_register_std_class(&spl_ce_ ## class_name, # class_name, obj_ctor, NULL TSRMLS_CC);
@@ -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 8ad6e0de3b..f8ce102967 100644
--- a/ext/spl/spl_heap.c
+++ b/ext/spl/spl_heap.c
@@ -49,14 +49,13 @@ PHPAPI zend_class_entry  *spl_ce_SplMaxHeap;
 PHPAPI zend_class_entry  *spl_ce_SplMinHeap;
 PHPAPI zend_class_entry  *spl_ce_SplPriorityQueue;
 
-typedef void *spl_ptr_heap_element;
 
-typedef void (*spl_ptr_heap_dtor_func)(spl_ptr_heap_element TSRMLS_DC);
-typedef void (*spl_ptr_heap_ctor_func)(spl_ptr_heap_element TSRMLS_DC);
-typedef int  (*spl_ptr_heap_cmp_func)(spl_ptr_heap_element, spl_ptr_heap_element, void* TSRMLS_DC);
+typedef void (*spl_ptr_heap_dtor_func)(zval * TSRMLS_DC);
+typedef void (*spl_ptr_heap_ctor_func)(zval * TSRMLS_DC);
+typedef int  (*spl_ptr_heap_cmp_func)(zval *, zval *, zval * TSRMLS_DC);
 
 typedef struct _spl_ptr_heap {
-	spl_ptr_heap_element   *elements;
+	zval                    *elements;
 	spl_ptr_heap_ctor_func  ctor;
 	spl_ptr_heap_dtor_func  dtor;
 	spl_ptr_heap_cmp_func   cmp;
@@ -69,68 +68,74 @@ typedef struct _spl_heap_object spl_heap_object;
 typedef struct _spl_heap_it spl_heap_it;
 
 struct _spl_heap_object {
-	zend_object         std;
 	spl_ptr_heap       *heap;
-	zval               *retval;
+	zval                retval;
 	int                 flags;
 	zend_class_entry   *ce_get_iterator;
 	zend_function      *fptr_cmp;
 	zend_function      *fptr_count;
 	HashTable          *debug_info;
+	zend_object         std;
 };
 
 /* define an overloaded iterator structure */
 struct _spl_heap_it {
 	zend_user_iterator  intern;
 	int                 flags;
-	spl_heap_object    *object;
 };
 
-/* {{{  spl_ptr_heap */
-static void spl_ptr_heap_zval_dtor(spl_ptr_heap_element elem TSRMLS_DC) { /* {{{ */
-	if (elem) {
-		zval_ptr_dtor((zval **)&elem);
+static inline spl_heap_object *spl_heap_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_heap_object*)((char*)(obj) - XtOffsetOf(spl_heap_object, std));
+}
+/* }}} */
+
+#define Z_SPLHEAP_P(zv)  spl_heap_from_obj(Z_OBJ_P((zv)))
+
+static void spl_ptr_heap_zval_dtor(zval *elem TSRMLS_DC) { /* {{{ */
+	if (!ZVAL_IS_UNDEF(elem)) {
+		zval_ptr_dtor(elem);
 	}
 }
 /* }}} */
 
-static void spl_ptr_heap_zval_ctor(spl_ptr_heap_element elem TSRMLS_DC) { /* {{{ */
-	Z_ADDREF_P((zval *)elem);
+static void spl_ptr_heap_zval_ctor(zval *elem TSRMLS_DC) { /* {{{ */
+	if (Z_REFCOUNTED_P(elem)) {
+		Z_ADDREF_P(elem);
+	}
 }
 /* }}} */
 
 static int spl_ptr_heap_cmp_cb_helper(zval *object, spl_heap_object *heap_object, zval *a, zval *b, long *result TSRMLS_DC) { /* {{{ */
-		zval *result_p = NULL;
+	zval zresult;
 
-		zend_call_method_with_2_params(&object, heap_object->std.ce, &heap_object->fptr_cmp, "compare", &result_p, a, b);
+	zend_call_method_with_2_params(object, heap_object->std.ce, &heap_object->fptr_cmp, "compare", &zresult, a, b);
 
-		if (EG(exception)) {
-			return FAILURE;
-		}
+	if (EG(exception)) {
+		return FAILURE;
+	}
 
-		convert_to_long(result_p);
-		*result = Z_LVAL_P(result_p);
+	convert_to_long(&zresult);
+	*result = Z_LVAL(zresult);
 
-		zval_ptr_dtor(&result_p);
+	zval_ptr_dtor(&zresult);
 
-		return SUCCESS;
+	return SUCCESS;
 }
 /* }}} */
 
-static zval **spl_pqueue_extract_helper(zval **value, int flags) /* {{{ */
+static zval *spl_pqueue_extract_helper(zval *value, int flags) /* {{{ */
 {
 	if ((flags & SPL_PQUEUE_EXTR_BOTH) == SPL_PQUEUE_EXTR_BOTH) {
 		return value;
 	} else if ((flags & SPL_PQUEUE_EXTR_BOTH) > 0) {
-
 		if ((flags & SPL_PQUEUE_EXTR_DATA) == SPL_PQUEUE_EXTR_DATA) {
-			zval **data;
-			if (zend_hash_find(Z_ARRVAL_PP(value), "data", sizeof("data"), (void **) &data) == SUCCESS) {
+			zval *data;
+			if ((data = zend_hash_str_find(Z_ARRVAL_P(value), "data", sizeof("data") - 1)) != NULL) {
 				return data;
 			}
 		} else {
-			zval **priority;
-			if (zend_hash_find(Z_ARRVAL_PP(value), "priority", sizeof("priority"), (void **) &priority) == SUCCESS) {
+			zval *priority;
+			if ((priority = zend_hash_str_find(Z_ARRVAL_P(value), "priority", sizeof("priority") - 1)) != NULL) {
 				return priority;
 			}
 		}
@@ -140,7 +145,7 @@ static zval **spl_pqueue_extract_helper(zval **value, int flags) /* {{{ */
 }
 /* }}} */
 
-static int spl_ptr_heap_zval_max_cmp(spl_ptr_heap_element a, spl_ptr_heap_element b, void* object TSRMLS_DC) { /* {{{ */
+static int spl_ptr_heap_zval_max_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { /* {{{ */
 	zval result;
 
 	if (EG(exception)) {
@@ -148,10 +153,10 @@ static int spl_ptr_heap_zval_max_cmp(spl_ptr_heap_element a, spl_ptr_heap_elemen
 	}
 
 	if (object) {
-		spl_heap_object *heap_object = (spl_heap_object*)zend_object_store_get_object((zval *)object TSRMLS_CC);
+		spl_heap_object *heap_object = Z_SPLHEAP_P(object);
 		if (heap_object->fptr_cmp) {
 			long lval = 0;
-			if (spl_ptr_heap_cmp_cb_helper((zval *)object, heap_object, (zval *)a, (zval *)b, &lval TSRMLS_CC) == FAILURE) {
+			if (spl_ptr_heap_cmp_cb_helper(object, heap_object, a, b, &lval TSRMLS_CC) == FAILURE) {
 				/* exception or call failure */
 				return 0;
 			}
@@ -159,13 +164,12 @@ static int spl_ptr_heap_zval_max_cmp(spl_ptr_heap_element a, spl_ptr_heap_elemen
 		}
 	}
 
-	INIT_ZVAL(result);
-	compare_function(&result, (zval *)a, (zval *)b TSRMLS_CC);
+	compare_function(&result, a, b TSRMLS_CC);
 	return Z_LVAL(result);
 }
 /* }}} */
 
-static int spl_ptr_heap_zval_min_cmp(spl_ptr_heap_element a, spl_ptr_heap_element b, void* object TSRMLS_DC) { /* {{{ */
+static int spl_ptr_heap_zval_min_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { /* {{{ */
 	zval result;
 
 	if (EG(exception)) {
@@ -173,10 +177,10 @@ static int spl_ptr_heap_zval_min_cmp(spl_ptr_heap_element a, spl_ptr_heap_elemen
 	}
 
 	if (object) {
-		spl_heap_object *heap_object = (spl_heap_object*)zend_object_store_get_object((zval *)object TSRMLS_CC);
+		spl_heap_object *heap_object = Z_SPLHEAP_P(object);
 		if (heap_object->fptr_cmp) {
 			long lval = 0;
-			if (spl_ptr_heap_cmp_cb_helper((zval *)object, heap_object, (zval *)a, (zval *)b, &lval TSRMLS_CC) == FAILURE) {
+			if (spl_ptr_heap_cmp_cb_helper(object, heap_object, a, b, &lval TSRMLS_CC) == FAILURE) {
 				/* exception or call failure */
 				return 0;
 			}
@@ -184,30 +188,30 @@ static int spl_ptr_heap_zval_min_cmp(spl_ptr_heap_element a, spl_ptr_heap_elemen
 		}
 	}
 
-	INIT_ZVAL(result);
-	compare_function(&result, (zval *)b, (zval *)a TSRMLS_CC);
+	compare_function(&result, b, a TSRMLS_CC);
 	return Z_LVAL(result);
 }
 /* }}} */
 
-static int spl_ptr_pqueue_zval_cmp(spl_ptr_heap_element a, spl_ptr_heap_element b, void* object TSRMLS_DC) { /* {{{ */
+static int spl_ptr_pqueue_zval_cmp(zval *a, zval *b, zval *object TSRMLS_DC) { /* {{{ */
 	zval result;
-	zval **a_priority_pp = spl_pqueue_extract_helper((zval **)&a, SPL_PQUEUE_EXTR_PRIORITY);
-	zval **b_priority_pp = spl_pqueue_extract_helper((zval **)&b, SPL_PQUEUE_EXTR_PRIORITY);
+	zval *a_priority_p = spl_pqueue_extract_helper(a, SPL_PQUEUE_EXTR_PRIORITY);
+	zval *b_priority_p = spl_pqueue_extract_helper(b, SPL_PQUEUE_EXTR_PRIORITY);
 
-	if ((!a_priority_pp) || (!b_priority_pp)) {
+	if ((!a_priority_p) || (!b_priority_p)) {
 		zend_error(E_RECOVERABLE_ERROR, "Unable to extract from the PriorityQueue node");
 		return 0;
 	}
+
 	if (EG(exception)) {
 		return 0;
 	}
 
 	if (object) {
-		spl_heap_object *heap_object = (spl_heap_object*)zend_object_store_get_object(object TSRMLS_CC);
+		spl_heap_object *heap_object = Z_SPLHEAP_P(object);
 		if (heap_object->fptr_cmp) {
 			long lval = 0;
-			if (spl_ptr_heap_cmp_cb_helper((zval *)object, heap_object, *a_priority_pp, *b_priority_pp, &lval TSRMLS_CC) == FAILURE) {
+			if (spl_ptr_heap_cmp_cb_helper((zval *)object, heap_object, a_priority_p, b_priority_p, &lval TSRMLS_CC) == FAILURE) {
 				/* exception or call failure */
 				return 0;
 			}
@@ -215,8 +219,7 @@ static int spl_ptr_pqueue_zval_cmp(spl_ptr_heap_element a, spl_ptr_heap_element
 		}
 	}
 
-	INIT_ZVAL(result);
-	compare_function(&result, *a_priority_pp, *b_priority_pp TSRMLS_CC);
+	compare_function(&result, a_priority_p, b_priority_p TSRMLS_CC);
 	return Z_LVAL(result);
 }
 /* }}} */
@@ -228,7 +231,7 @@ static spl_ptr_heap *spl_ptr_heap_init(spl_ptr_heap_cmp_func cmp, spl_ptr_heap_c
 	heap->dtor     = dtor;
 	heap->ctor     = ctor;
 	heap->cmp      = cmp;
-	heap->elements = safe_emalloc(sizeof(spl_ptr_heap_element), PTR_HEAP_BLOCK_SIZE, 0);
+	heap->elements = ecalloc(PTR_HEAP_BLOCK_SIZE, sizeof(zval));
 	heap->max_size = PTR_HEAP_BLOCK_SIZE;
 	heap->count    = 0;
 	heap->flags    = 0;
@@ -237,19 +240,20 @@ static spl_ptr_heap *spl_ptr_heap_init(spl_ptr_heap_cmp_func cmp, spl_ptr_heap_c
 }
 /* }}} */
 
-static void spl_ptr_heap_insert(spl_ptr_heap *heap, spl_ptr_heap_element elem, void *cmp_userdata TSRMLS_DC) { /* {{{ */
+static void spl_ptr_heap_insert(spl_ptr_heap *heap, zval *elem, void *cmp_userdata TSRMLS_DC) { /* {{{ */
 	int i;
 
 	if (heap->count+1 > heap->max_size) {
 		/* we need to allocate more memory */
-		heap->elements  = (void **) safe_erealloc(heap->elements, sizeof(spl_ptr_heap_element), (heap->max_size), (sizeof(spl_ptr_heap_element) * (heap->max_size)));
+		heap->elements  = erealloc(heap->elements, heap->max_size * 2 * sizeof(zval));
+		memset(heap->elements + heap->max_size, 0, heap->max_size * sizeof(zval));
 		heap->max_size *= 2;
 	}
 
 	heap->ctor(elem TSRMLS_CC);
 
 	/* sifting up */
-	for(i = heap->count++; i > 0 && heap->cmp(heap->elements[(i-1)/2], elem, cmp_userdata TSRMLS_CC) < 0; i = (i-1)/2) {
+	for (i = heap->count++; i > 0 && heap->cmp(&heap->elements[(i-1)/2], elem, cmp_userdata TSRMLS_CC) < 0; i = (i-1)/2) {
 		heap->elements[i] = heap->elements[(i-1)/2];
 	}
 
@@ -258,43 +262,41 @@ static void spl_ptr_heap_insert(spl_ptr_heap *heap, spl_ptr_heap_element elem, v
 		heap->flags |= SPL_HEAP_CORRUPTED;
 	}
 
-	heap->elements[i] = elem;
-
+	ZVAL_COPY_VALUE(&heap->elements[i], elem);
 }
 /* }}} */
 
-static spl_ptr_heap_element spl_ptr_heap_top(spl_ptr_heap *heap) { /* {{{ */
+static zval *spl_ptr_heap_top(spl_ptr_heap *heap) { /* {{{ */
 	if (heap->count == 0) {
 		return NULL;
 	}
 
-	return heap->elements[0];
+	return ZVAL_IS_UNDEF(&heap->elements[0])? NULL : &heap->elements[0];
 }
 /* }}} */
 
-static spl_ptr_heap_element spl_ptr_heap_delete_top(spl_ptr_heap *heap, void *cmp_userdata TSRMLS_DC) { /* {{{ */
+static void spl_ptr_heap_delete_top(spl_ptr_heap *heap, zval *elem, void *cmp_userdata TSRMLS_DC) { /* {{{ */
 	int i, j;
 	const int limit = (heap->count-1)/2;
-	spl_ptr_heap_element top;
-	spl_ptr_heap_element bottom;
+	zval *bottom;
 
 	if (heap->count == 0) {
-		return NULL;
+		ZVAL_UNDEF(elem);
+		return;
 	}
 
-	top    = heap->elements[0];
-	bottom = heap->elements[--heap->count];
+	ZVAL_COPY_VALUE(elem, &heap->elements[0]);
+	bottom = &heap->elements[--heap->count];
 
-	for( i = 0; i < limit; i = j)
-	{
+	for (i = 0; i < limit; i = j) {
 		/* Find smaller child */
-		j = i*2+1;
-		if(j != heap->count && heap->cmp(heap->elements[j+1], heap->elements[j], cmp_userdata TSRMLS_CC) > 0) {
+		j = i * 2 + 1;
+		if(j != heap->count && heap->cmp(&heap->elements[j+1], &heap->elements[j], cmp_userdata TSRMLS_CC) > 0) {
 			j++; /* next child is bigger */
 		}
 
 		/* swap elements between two levels */
-		if(heap->cmp(bottom, heap->elements[j], cmp_userdata TSRMLS_CC) < 0) {
+		if(heap->cmp(bottom, &heap->elements[j], cmp_userdata TSRMLS_CC) < 0) {
 			heap->elements[i] = heap->elements[j];
 		} else {
 			break;
@@ -306,9 +308,8 @@ static spl_ptr_heap_element spl_ptr_heap_delete_top(spl_ptr_heap *heap, void *cm
 		heap->flags |= SPL_HEAP_CORRUPTED;
 	}
 
-	heap->elements[i] = bottom;
-	heap->dtor(top TSRMLS_CC);
-	return top;
+	ZVAL_COPY_VALUE(&heap->elements[i], bottom);
+	heap->dtor(elem TSRMLS_CC);
 }
 /* }}} */
 
@@ -324,11 +325,11 @@ static spl_ptr_heap *spl_ptr_heap_clone(spl_ptr_heap *from TSRMLS_DC) { /* {{{ *
 	heap->count    = from->count;
 	heap->flags    = from->flags;
 
-	heap->elements = safe_emalloc(sizeof(spl_ptr_heap_element),from->max_size,0);
-	memcpy(heap->elements, from->elements, sizeof(spl_ptr_heap_element)*from->max_size);
+	heap->elements = safe_emalloc(sizeof(zval), from->max_size, 0);
+	memcpy(heap->elements, from->elements, sizeof(zval)*from->max_size);
 
 	for (i=0; i < heap->count; ++i) {
-		heap->ctor(heap->elements[i] TSRMLS_CC);
+		heap->ctor(&heap->elements[i] TSRMLS_CC);
 	}
 
 	return heap;
@@ -339,7 +340,7 @@ static void spl_ptr_heap_destroy(spl_ptr_heap *heap TSRMLS_DC) { /* {{{ */
 	int i;
 
 	for (i=0; i < heap->count; ++i) {
-		heap->dtor(heap->elements[i] TSRMLS_CC);
+		heap->dtor(&heap->elements[i] TSRMLS_CC);
 	}
 
 	efree(heap->elements);
@@ -355,16 +356,16 @@ static int spl_ptr_heap_count(spl_ptr_heap *heap) { /* {{{ */
 
 zend_object_iterator *spl_heap_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC);
 
-static void spl_heap_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void spl_heap_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
 	int i;
-	spl_heap_object *intern = (spl_heap_object *)object;
+	spl_heap_object *intern = spl_heap_from_obj(object);
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 
 	for (i = 0; i < intern->heap->count; ++i) {
-		if (intern->heap->elements[i]) {
-			zval_ptr_dtor((zval **)&intern->heap->elements[i]);
+		if (!ZVAL_IS_UNDEF(&intern->heap->elements[i])) {
+			zval_ptr_dtor(&intern->heap->elements[i]);
 		}
 	}
 
@@ -376,21 +377,16 @@ static void spl_heap_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 		zend_hash_destroy(intern->debug_info);
 		efree(intern->debug_info);
 	}
-
-	efree(object);
 }
 /* }}} */
 
-static zend_object_value spl_heap_object_new_ex(zend_class_entry *class_type, spl_heap_object **obj, zval *orig, int clone_orig TSRMLS_DC) /* {{{ */
+static zend_object *spl_heap_object_new_ex(zend_class_entry *class_type, zval *orig, int clone_orig TSRMLS_DC) /* {{{ */
 {
-	zend_object_value  retval;
 	spl_heap_object   *intern;
 	zend_class_entry  *parent = class_type;
 	int                inherited = 0;
 
-	intern = ecalloc(1, sizeof(spl_heap_object));
-	*obj = intern;
-	ALLOC_INIT_ZVAL(intern->retval);
+	intern = ecalloc(1, sizeof(spl_heap_object) + sizeof(zval) * (parent->default_properties_count - 1));
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
@@ -400,15 +396,15 @@ static zend_object_value spl_heap_object_new_ex(zend_class_entry *class_type, sp
 	intern->debug_info = NULL;
 
 	if (orig) {
-		spl_heap_object *other = (spl_heap_object*)zend_object_store_get_object(orig TSRMLS_CC);
+		spl_heap_object *other = Z_SPLHEAP_P(orig);
 		intern->ce_get_iterator = other->ce_get_iterator;
 
 		if (clone_orig) {
 			int i;
 			intern->heap = spl_ptr_heap_clone(other->heap TSRMLS_CC);
 			for (i = 0; i < intern->heap->count; ++i) {
-				if (intern->heap->elements[i]) {
-					Z_ADDREF_P((zval *)intern->heap->elements[i]);
+				if (Z_REFCOUNTED(intern->heap->elements[i])) {
+					Z_ADDREF(intern->heap->elements[i]);
 				}
 			}
 		} else {
@@ -420,13 +416,13 @@ static zend_object_value spl_heap_object_new_ex(zend_class_entry *class_type, sp
 		intern->heap = spl_ptr_heap_init(spl_ptr_heap_zval_max_cmp, spl_ptr_heap_zval_ctor, spl_ptr_heap_zval_dtor);
 	}
 
-	retval.handlers = &spl_handler_SplHeap;
+	intern->std.handlers = &spl_handler_SplHeap;
 
 	while (parent) {
 		if (parent == spl_ce_SplPriorityQueue) {
 			intern->heap->cmp = spl_ptr_pqueue_zval_cmp;
-			intern->flags     = SPL_PQUEUE_EXTR_DATA;
-			retval.handlers   = &spl_handler_SplPriorityQueue;
+			intern->flags = SPL_PQUEUE_EXTR_DATA;
+			intern->std.handlers = &spl_handler_SplPriorityQueue;
 			break;
 		}
 
@@ -448,65 +444,57 @@ static zend_object_value spl_heap_object_new_ex(zend_class_entry *class_type, sp
 		inherited = 1;
 	}
 
-	retval.handle   = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, spl_heap_object_free_storage, NULL TSRMLS_CC);
-
 	if (!parent) { /* this must never happen */
 		php_error_docref(NULL TSRMLS_CC, E_COMPILE_ERROR, "Internal compiler error, Class is not child of SplHeap");
 	}
 
 	if (inherited) {
-		zend_hash_find(&class_type->function_table, "compare",    sizeof("compare"),    (void **) &intern->fptr_cmp);
+		intern->fptr_cmp = zend_hash_str_find_ptr(&class_type->function_table, "compare", sizeof("compare") - 1);
 		if (intern->fptr_cmp->common.scope == parent) {
 			intern->fptr_cmp = NULL;
 		}
-		zend_hash_find(&class_type->function_table, "count",        sizeof("count"),        (void **) &intern->fptr_count);
+		intern->fptr_count = zend_hash_str_find_ptr(&class_type->function_table, "count", sizeof("count") - 1);
 		if (intern->fptr_count->common.scope == parent) {
 			intern->fptr_count = NULL;
 		}
 	}
 
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
-static zend_object_value spl_heap_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *spl_heap_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	spl_heap_object *tmp;
-	return spl_heap_object_new_ex(class_type, &tmp, NULL, 0 TSRMLS_CC);
+	return spl_heap_object_new_ex(class_type, NULL, 0 TSRMLS_CC);
 }
 /* }}} */
 
-static zend_object_value spl_heap_object_clone(zval *zobject TSRMLS_DC) /* {{{ */
+static zend_object *spl_heap_object_clone(zval *zobject TSRMLS_DC) /* {{{ */
 {
-	zend_object_value   new_obj_val;
 	zend_object        *old_object;
 	zend_object        *new_object;
-	zend_object_handle  handle = Z_OBJ_HANDLE_P(zobject);
-	spl_heap_object    *intern;
 
-	old_object  = zend_objects_get_address(zobject TSRMLS_CC);
-	new_obj_val = spl_heap_object_new_ex(old_object->ce, &intern, zobject, 1 TSRMLS_CC);
-	new_object  = &intern->std;
+	old_object  = Z_OBJ_P(zobject);
+	new_object = spl_heap_object_new_ex(old_object->ce, zobject, 1 TSRMLS_CC);
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
-	return new_obj_val;
+	return new_object;
 }
 /* }}} */
 
 static int spl_heap_object_count_elements(zval *object, long *count TSRMLS_DC) /* {{{ */
 {
-	spl_heap_object *intern = (spl_heap_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_heap_object *intern = Z_SPLHEAP_P(object);
 
 	if (intern->fptr_count) {
-		zval *rv;
-		zend_call_method_with_0_params(&object, intern->std.ce, &intern->fptr_count, "count", &rv);
-		if (rv) {
+		zval rv;
+		zend_call_method_with_0_params(object, intern->std.ce, &intern->fptr_count, "count", &rv);
+		if (!ZVAL_IS_UNDEF(&rv)) {
 			zval_ptr_dtor(&intern->retval);
-			MAKE_STD_ZVAL(intern->retval);
-			ZVAL_ZVAL(intern->retval, rv, 1, 1);
-			convert_to_long(intern->retval);
-			*count = (long) Z_LVAL_P(intern->retval);
+			ZVAL_ZVAL(&intern->retval, &rv, 0, 0);
+			convert_to_long(&intern->retval);
+			*count = (long) Z_LVAL(intern->retval);
 			return SUCCESS;
 		}
 		*count = 0;
@@ -520,10 +508,9 @@ 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*)zend_object_store_get_object(obj TSRMLS_CC);
-	zval *tmp, zrv, *heap_array;
-	char *pnstr;
-	int  pnlen;
+	spl_heap_object *intern  = Z_SPLHEAP_P(obj);
+	zval tmp, heap_array;
+	zend_string *pnstr;
 	int  i;
 
 	*is_temp = 0;
@@ -537,31 +524,32 @@ static HashTable* spl_heap_object_get_debug_info_helper(zend_class_entry *ce, zv
 		ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(intern->std.properties) + 1, 0);
 	}
 
-	if (intern->debug_info->nApplyCount == 0) {
-		INIT_PZVAL(&zrv);
-		Z_ARRVAL(zrv) = intern->debug_info;
+	if (intern->debug_info->u.v.nApplyCount == 0) {
 
-		zend_hash_copy(intern->debug_info, intern->std.properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+		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);
-		add_assoc_long_ex(&zrv, pnstr, pnlen+1, intern->flags);
-		efree(pnstr);
+		pnstr = spl_gen_private_prop_name(ce, "flags", sizeof("flags")-1 TSRMLS_CC);
+		ZVAL_LONG(&tmp, intern->flags);
+		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);
-		add_assoc_bool_ex(&zrv, pnstr, pnlen+1, intern->heap->flags&SPL_HEAP_CORRUPTED);
-		efree(pnstr);
+		pnstr = spl_gen_private_prop_name(ce, "isCorrupted", sizeof("isCorrupted")-1 TSRMLS_CC);
+		ZVAL_BOOL(&tmp, intern->heap->flags&SPL_HEAP_CORRUPTED);
+		zend_hash_update(intern->debug_info, pnstr, &tmp);
+		STR_RELEASE(pnstr);
 
-		ALLOC_INIT_ZVAL(heap_array);
-		array_init(heap_array);
+		array_init(&heap_array);
 
 		for (i = 0; i < intern->heap->count; ++i) {
-			add_index_zval(heap_array, i, (zval *)intern->heap->elements[i]);
-			Z_ADDREF_P(intern->heap->elements[i]);
+			add_index_zval(&heap_array, i, &intern->heap->elements[i]);
+			if (Z_REFCOUNTED(intern->heap->elements[i])) {
+				Z_ADDREF(intern->heap->elements[i]);
+			}
 		}
 
-		pnstr = spl_gen_private_prop_name(ce, "heap", sizeof("heap")-1, &pnlen TSRMLS_CC);
-		add_assoc_zval_ex(&zrv, pnstr, pnlen+1, 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;
@@ -580,12 +568,12 @@ static HashTable* spl_pqueue_object_get_debug_info(zval *obj, int *is_temp TSRML
 }
 /* }}} */
 
-/* {{{ proto int SplHeap::count() U
+/* {{{ proto int SplHeap::count()
  Return the number of elements in the heap. */
 SPL_METHOD(SplHeap, count)
 {
 	long count;
-	spl_heap_object *intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_heap_object *intern = Z_SPLHEAP_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -596,21 +584,21 @@ SPL_METHOD(SplHeap, count)
 }
 /* }}} */
 
-/* {{{ proto int SplHeap::isEmpty() U
+/* {{{ proto int SplHeap::isEmpty()
  Return true if the heap is empty. */
 SPL_METHOD(SplHeap, isEmpty)
 {
-	spl_heap_object *intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_heap_object *intern = Z_SPLHEAP_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	RETURN_BOOL(spl_ptr_heap_count(intern->heap)==0);
+	RETURN_BOOL(spl_ptr_heap_count(intern->heap) == 0);
 }
 /* }}} */
 
-/* {{{ proto bool SplHeap::insert(mixed $value) U
+/* {{{ proto bool SplHeap::insert(mixed $value)
 	   Push $value on the heap */
 SPL_METHOD(SplHeap, insert)
 {
@@ -621,7 +609,7 @@ SPL_METHOD(SplHeap, insert)
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	if (intern->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
@@ -629,54 +617,53 @@ SPL_METHOD(SplHeap, insert)
 	}
 
 	SEPARATE_ARG_IF_REF(value);
-
 	spl_ptr_heap_insert(intern->heap, value, getThis() TSRMLS_CC);
 
 	RETURN_TRUE;
 } 
 /* }}} */
 
-/* {{{ proto mixed SplHeap::extract() U
+/* {{{ proto mixed SplHeap::extract()
 	   extract the element out of the top of the heap */
 SPL_METHOD(SplHeap, extract)
 {
-	zval *value;
+	zval value;
 	spl_heap_object *intern;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	if (intern->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
 		return;
 	}
 
-	value  = (zval *)spl_ptr_heap_delete_top(intern->heap, getThis() TSRMLS_CC);
+	spl_ptr_heap_delete_top(intern->heap, &value, getThis() TSRMLS_CC);
 
-	if (!value) {
+	if (ZVAL_IS_UNDEF(&value)) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't extract from an empty heap", 0 TSRMLS_CC);
 		return;
 	}
 
-	RETURN_ZVAL(value, 1, 1);
+	RETURN_ZVAL(&value, 1, 1);
 } 
 /* }}} */
 
-/* {{{ proto bool SplPriorityQueue::insert(mixed $value, mixed $priority) U
+/* {{{ proto bool SplPriorityQueue::insert(mixed $value, mixed $priority)
 	   Push $value with the priority $priodiry on the priorityqueue */
 SPL_METHOD(SplPriorityQueue, insert)
 {
-	zval *data, *priority, *elem;
+	zval *data, *priority, elem;
 	spl_heap_object *intern;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zz", &data, &priority) == FAILURE) {
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	if (intern->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
@@ -686,98 +673,95 @@ SPL_METHOD(SplPriorityQueue, insert)
 	SEPARATE_ARG_IF_REF(data);
 	SEPARATE_ARG_IF_REF(priority);
 
-	ALLOC_INIT_ZVAL(elem);
+	array_init(&elem);
+	add_assoc_zval_ex(&elem, "data", sizeof("data") - 1, data);
+	add_assoc_zval_ex(&elem, "priority", sizeof("priority") - 1, priority);
 
-	array_init(elem);
-	add_assoc_zval_ex(elem, "data",     sizeof("data"),     data);
-	add_assoc_zval_ex(elem, "priority", sizeof("priority"), priority);
-
-	spl_ptr_heap_insert(intern->heap, elem, getThis() TSRMLS_CC);
+	spl_ptr_heap_insert(intern->heap, &elem, getThis() TSRMLS_CC);
 
 	RETURN_TRUE;
 } 
 /* }}} */
 
-/* {{{ proto mixed SplPriorityQueue::extract() U
+/* {{{ proto mixed SplPriorityQueue::extract()
 	   extract the element out of the top of the priority queue */
 SPL_METHOD(SplPriorityQueue, extract)
 {
-	zval *value, *value_out, **value_out_pp;
+	zval value, *value_out;
 	spl_heap_object *intern;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	if (intern->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
 		return;
 	}
 
-	value  = (zval *)spl_ptr_heap_delete_top(intern->heap, getThis() TSRMLS_CC);
+	spl_ptr_heap_delete_top(intern->heap, &value, getThis() TSRMLS_CC);
 
-	if (!value) {
+	if (ZVAL_IS_UNDEF(&value)) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't extract from an empty heap", 0 TSRMLS_CC);
 		return;
 	}
 
-	value_out_pp = spl_pqueue_extract_helper(&value, intern->flags);
-
+	value_out = spl_pqueue_extract_helper(&value, intern->flags);
 
-	if (!value_out_pp) {
+	if (!value_out) {
 		zend_error(E_RECOVERABLE_ERROR, "Unable to extract from the PriorityQueue node");
 		zval_ptr_dtor(&value);
 		return;
 	}
 
-	value_out = *value_out_pp;
+	if (Z_REFCOUNTED_P(value_out)) {
+		Z_ADDREF_P(value_out);
+	}
 
-	Z_ADDREF_P(value_out);
+	RETVAL_ZVAL(value_out, 1, 0);
 	zval_ptr_dtor(&value);
-
-	RETURN_ZVAL(value_out, 1, 1);
 } 
 /* }}} */
 
-/* {{{ proto mixed SplPriorityQueue::top() U
+/* {{{ proto mixed SplPriorityQueue::top()
 	   Peek at the top element of the priority queue */
 SPL_METHOD(SplPriorityQueue, top)
 {
-	zval *value, **value_out;
+	zval *value, *value_out;
 	spl_heap_object *intern;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	if (intern->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
 		return;
 	}
 
-	value  = (zval *)spl_ptr_heap_top(intern->heap);
+	value = spl_ptr_heap_top(intern->heap);
 
 	if (!value) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't peek at an empty heap", 0 TSRMLS_CC);
 		return;
 	}
 
-	value_out = spl_pqueue_extract_helper(&value, intern->flags);
+	value_out = spl_pqueue_extract_helper(value, intern->flags);
 
 	if (!value_out) {
 		zend_error(E_RECOVERABLE_ERROR, "Unable to extract from the PriorityQueue node");
 		return;
 	}
 
-	RETURN_ZVAL(*value_out, 1, 0);
+	RETURN_ZVAL(value_out, 1, 0);
 }
 /* }}} */
 
-/* {{{ proto int SplPriorityQueue::setIteratorMode($flags) U
+/* {{{ proto int SplPriorityQueue::setIteratorMode($flags)
  Set the flags of extraction*/
 SPL_METHOD(SplPriorityQueue, setExtractFlags)
 {
@@ -788,7 +772,7 @@ SPL_METHOD(SplPriorityQueue, setExtractFlags)
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	intern->flags = value & SPL_PQUEUE_EXTR_MASK;
 
@@ -796,7 +780,7 @@ SPL_METHOD(SplPriorityQueue, setExtractFlags)
 }
 /* }}} */
 
-/* {{{ proto int SplHeap::recoverFromCorruption() U
+/* {{{ proto int SplHeap::recoverFromCorruption()
  Recover from a corrupted state*/
 SPL_METHOD(SplHeap, recoverFromCorruption)
 {
@@ -806,7 +790,7 @@ SPL_METHOD(SplHeap, recoverFromCorruption)
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	intern->heap->flags = intern->heap->flags & ~SPL_HEAP_CORRUPTED;
 
@@ -814,7 +798,7 @@ SPL_METHOD(SplHeap, recoverFromCorruption)
 }
 /* }}} */
 
-/* {{{ proto bool SplPriorityQueue::compare(mixed $a, mixed $b) U
+/* {{{ proto bool SplPriorityQueue::compare(mixed $a, mixed $b)
 	   compare the priorities */
 SPL_METHOD(SplPriorityQueue, compare)
 {
@@ -828,7 +812,7 @@ SPL_METHOD(SplPriorityQueue, compare)
 } 
 /* }}} */
 
-/* {{{ proto mixed SplHeap::top() U
+/* {{{ proto mixed SplHeap::top()
 	   Peek at the top element of the heap */
 SPL_METHOD(SplHeap, top)
 {
@@ -839,14 +823,14 @@ SPL_METHOD(SplHeap, top)
 		return;
 	}
 
-	intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLHEAP_P(getThis());
 
 	if (intern->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
 		return;
 	}
 
-	value  = (zval *)spl_ptr_heap_top(intern->heap);
+	value = spl_ptr_heap_top(intern->heap);
 
 	if (!value) {
 		zend_throw_exception(spl_ce_RuntimeException, "Can't peek at an empty heap", 0 TSRMLS_CC);
@@ -857,7 +841,7 @@ SPL_METHOD(SplHeap, top)
 }
 /* }}} */
 
-/* {{{ proto bool SplMinHeap::compare(mixed $a, mixed $b) U
+/* {{{ proto bool SplMinHeap::compare(mixed $a, mixed $b)
 	   compare the values */
 SPL_METHOD(SplMinHeap, compare)
 {
@@ -871,7 +855,7 @@ SPL_METHOD(SplMinHeap, compare)
 } 
 /* }}} */
 
-/* {{{ proto bool SplMaxHeap::compare(mixed $a, mixed $b) U
+/* {{{ proto bool SplMaxHeap::compare(mixed $a, mixed $b)
 	   compare the values */
 SPL_METHOD(SplMaxHeap, compare)
 {
@@ -890,9 +874,7 @@ static void spl_heap_it_dtor(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 	spl_heap_it *iterator = (spl_heap_it *)iter;
 
 	zend_user_it_invalidate_current(iter TSRMLS_CC);
-	zval_ptr_dtor((zval**)&iterator->intern.it.data);
-
-	efree(iterator);
+	zval_ptr_dtor(&iterator->intern.it.data);
 }
 /* }}} */
 
@@ -904,85 +886,81 @@ static void spl_heap_it_rewind(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 
 static int spl_heap_it_valid(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_heap_it         *iterator = (spl_heap_it *)iter;
-
-	return (iterator->object->heap->count != 0 ? SUCCESS : FAILURE);
+	return ((Z_SPLHEAP_P(&iter->data))->heap->count != 0 ? SUCCESS : FAILURE);
 }
 /* }}} */
 
-static void spl_heap_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *spl_heap_it_get_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_heap_it  *iterator = (spl_heap_it *)iter;
-	zval        **element  = (zval **)&iterator->object->heap->elements[0];
+	spl_heap_object *object = Z_SPLHEAP_P(&iter->data);
+	zval *element = &object->heap->elements[0];
 
-	if (iterator->object->heap->flags & SPL_HEAP_CORRUPTED) {
+	if (object->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
-		return;
+		return NULL;
 	}
 
-	if (iterator->object->heap->count == 0 || !*element) {
-		*data = NULL;
+	if (object->heap->count == 0 || ZVAL_IS_UNDEF(element)) {
+		return NULL;
 	} else {
-		*data = element;
+		return element;
 	}
 }
 /* }}} */
 
-static void spl_pqueue_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC) /* {{{ */
+static zval *spl_pqueue_it_get_current_data(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	spl_heap_it  *iterator = (spl_heap_it *)iter;
-	zval        **element  = (zval **)&iterator->object->heap->elements[0];
+	spl_heap_object *object = Z_SPLHEAP_P(&iter->data);
+	zval *element = &object->heap->elements[0];
 
-	if (iterator->object->heap->flags & SPL_HEAP_CORRUPTED) {
+	if (object->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
-		return;
+		return NULL;
 	}
 
-	if (iterator->object->heap->count == 0 || !*element) {
-		*data = NULL;
+	if (object->heap->count == 0 || ZVAL_IS_UNDEF(element)) {
+		return NULL;
 	} else {
-		*data = spl_pqueue_extract_helper(element, iterator->object->flags);
-		if (!*data) {
+		zval *data = spl_pqueue_extract_helper(element, object->flags);
+		if (!data) {
 			zend_error(E_RECOVERABLE_ERROR, "Unable to extract from the PriorityQueue node");
 		}
+		return data;
 	}
 }
 /* }}} */
 
 static void spl_heap_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC) /* {{{ */
 {
-	spl_heap_it *iterator = (spl_heap_it *)iter;
+	spl_heap_object *object = Z_SPLHEAP_P(&iter->data);
 
-	ZVAL_LONG(key, iterator->object->heap->count - 1);
+	ZVAL_LONG(key, object->heap->count - 1);
 }
 /* }}} */
 
 static void spl_heap_it_move_forward(zend_object_iterator *iter TSRMLS_DC) /* {{{ */
 {
-	zval                 *object   = (zval*)((zend_user_iterator *)iter)->it.data;
-	spl_heap_it          *iterator = (spl_heap_it *)iter;
-	spl_ptr_heap_element elem;
+	spl_heap_object *object = Z_SPLHEAP_P(&iter->data);
+	zval elem;
 
-	if (iterator->object->heap->flags & SPL_HEAP_CORRUPTED) {
+	if (object->heap->flags & SPL_HEAP_CORRUPTED) {
 		zend_throw_exception(spl_ce_RuntimeException, "Heap is corrupted, heap properties are no longer ensured.", 0 TSRMLS_CC);
 		return;
 	}
 
-	elem = spl_ptr_heap_delete_top(iterator->object->heap, object TSRMLS_CC);
+	spl_ptr_heap_delete_top(object->heap, &elem, &iter->data TSRMLS_CC);
 
-	if (elem != NULL) {
-		zval_ptr_dtor((zval **)&elem);
-	}
+	zval_ptr_dtor(&elem);
 
 	zend_user_it_invalidate_current(iter TSRMLS_CC);
 }
 /* }}} */
 
-/* {{{  proto int SplHeap::key() U
+/* {{{  proto int SplHeap::key()
    Return current array key */
 SPL_METHOD(SplHeap, key)
 {
-	spl_heap_object *intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_heap_object *intern = Z_SPLHEAP_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -992,28 +970,27 @@ SPL_METHOD(SplHeap, key)
 }
 /* }}} */
 
-/* {{{ proto void SplHeap::next() U
+/* {{{ proto void SplHeap::next()
    Move to next entry */
 SPL_METHOD(SplHeap, next)
 {
-	spl_heap_object      *intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	spl_ptr_heap_element  elem   = spl_ptr_heap_delete_top(intern->heap, getThis() TSRMLS_CC);
+	spl_heap_object *intern = Z_SPLHEAP_P(getThis());
+	zval elem;
+	spl_ptr_heap_delete_top(intern->heap, &elem, getThis() TSRMLS_CC);
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (elem != NULL) {
-		zval_ptr_dtor((zval **)&elem);
-	}
+	zval_ptr_dtor(&elem);
 }
 /* }}} */
 
-/* {{{ proto bool SplHeap::valid() U
+/* {{{ proto bool SplHeap::valid()
    Check whether the datastructure contains more entries */
 SPL_METHOD(SplHeap, valid)
 {
-	spl_heap_object *intern = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_heap_object *intern = Z_SPLHEAP_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1023,7 +1000,7 @@ SPL_METHOD(SplHeap, valid)
 }
 /* }}} */
 
-/* {{{ proto void SplHeap::rewind() U
+/* {{{ proto void SplHeap::rewind()
    Rewind the datastructure back to the start */
 SPL_METHOD(SplHeap, rewind)
 {
@@ -1034,18 +1011,18 @@ SPL_METHOD(SplHeap, rewind)
 }
 /* }}} */
 
-/* {{{ proto mixed|NULL SplHeap::current() U
+/* {{{ proto mixed|NULL SplHeap::current()
    Return current datastructure entry */
 SPL_METHOD(SplHeap, current)
 {
-	spl_heap_object *intern  = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	zval            *element = (zval *)intern->heap->elements[0];
+	spl_heap_object *intern  = Z_SPLHEAP_P(getThis());
+	zval *element = &intern->heap->elements[0];
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (!intern->heap->count || !element) {
+	if (!intern->heap->count || ZVAL_IS_UNDEF(element)) {
 		RETURN_NULL();
 	} else {
 		RETURN_ZVAL(element, 1, 0);
@@ -1053,28 +1030,28 @@ SPL_METHOD(SplHeap, current)
 }
 /* }}} */
 
-/* {{{ proto mixed|NULL SplPriorityQueue::current() U
+/* {{{ proto mixed|NULL SplPriorityQueue::current()
    Return current datastructure entry */
 SPL_METHOD(SplPriorityQueue, current)
 {
-	spl_heap_object  *intern  = (spl_heap_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	zval            **element = (zval **)&intern->heap->elements[0];
+	spl_heap_object  *intern  = Z_SPLHEAP_P(getThis());
+	zval *element = &intern->heap->elements[0];
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (!intern->heap->count || !*element) {
+	if (!intern->heap->count || ZVAL_IS_UNDEF(element)) {
 		RETURN_NULL();
 	} else {
-		zval **data = spl_pqueue_extract_helper(element, intern->flags);
+		zval *data = spl_pqueue_extract_helper(element, intern->flags);
 
 		if (!data) {
 			zend_error(E_RECOVERABLE_ERROR, "Unable to extract from the PriorityQueue node");
 			RETURN_NULL();
 		}
 
-		RETURN_ZVAL(*data, 1, 0);
+		RETURN_ZVAL(data, 1, 0);
 	}
 }
 /* }}} */
@@ -1101,48 +1078,49 @@ zend_object_iterator_funcs spl_pqueue_it_funcs = {
 zend_object_iterator *spl_heap_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
 	spl_heap_it     *iterator;
-	spl_heap_object *heap_object = (spl_heap_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_heap_object *heap_object = Z_SPLHEAP_P(object);
 
 	if (by_ref) {
 		zend_throw_exception(spl_ce_RuntimeException, "An iterator cannot be used with foreach by reference", 0 TSRMLS_CC);
 		return NULL;
 	}
 
-	Z_ADDREF_P(object);
+	iterator = emalloc(sizeof(spl_heap_it));
+	
+	zend_iterator_init(&iterator->intern.it TSRMLS_CC);
 
-	iterator                  = emalloc(sizeof(spl_heap_it));
-	iterator->intern.it.data  = (void*)object;
+	ZVAL_COPY(&iterator->intern.it.data, object);
 	iterator->intern.it.funcs = &spl_heap_it_funcs;
 	iterator->intern.ce       = ce;
-	iterator->intern.value    = NULL;
 	iterator->flags           = heap_object->flags;
-	iterator->object          = heap_object;
+	ZVAL_UNDEF(&iterator->intern.value);
 
-	return (zend_object_iterator*)iterator;
+	return &iterator->intern.it;
 }
 /* }}} */
 
 zend_object_iterator *spl_pqueue_get_iterator(zend_class_entry *ce, zval *object, int by_ref TSRMLS_DC) /* {{{ */
 {
 	spl_heap_it     *iterator;
-	spl_heap_object *heap_object = (spl_heap_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_heap_object *heap_object = Z_SPLHEAP_P(object);
 
 	if (by_ref) {
 		zend_throw_exception(spl_ce_RuntimeException, "An iterator cannot be used with foreach by reference", 0 TSRMLS_CC);
 		return NULL;
 	}
 
-	Z_ADDREF_P(object);
+	iterator = emalloc(sizeof(spl_heap_it));
 
-	iterator                  = emalloc(sizeof(spl_heap_it));
-	iterator->intern.it.data  = (void*)object;
+	zend_iterator_init((zend_object_iterator*)iterator TSRMLS_CC);
+
+	ZVAL_COPY(&iterator->intern.it.data, object);
 	iterator->intern.it.funcs = &spl_pqueue_it_funcs;
 	iterator->intern.ce       = ce;
-	iterator->intern.value    = NULL;
 	iterator->flags           = heap_object->flags;
-	iterator->object          = heap_object;
 
-	return (zend_object_iterator*)iterator;
+	ZVAL_UNDEF(&iterator->intern.value);
+
+	return &iterator->intern.it;
 }
 /* }}} */
 
@@ -1215,9 +1193,12 @@ PHP_MINIT_FUNCTION(spl_heap) /* {{{ */
 	REGISTER_SPL_STD_CLASS_EX(SplHeap, spl_heap_object_new, spl_funcs_SplHeap);
 	memcpy(&spl_handler_SplHeap, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 
+	spl_handler_SplHeap.offset         = XtOffsetOf(spl_heap_object, std);
 	spl_handler_SplHeap.clone_obj      = spl_heap_object_clone;
 	spl_handler_SplHeap.count_elements = spl_heap_object_count_elements;
 	spl_handler_SplHeap.get_debug_info = spl_heap_object_get_debug_info;
+	spl_handler_SplHeap.dtor_obj = zend_objects_destroy_object;
+	spl_handler_SplHeap.free_obj = spl_heap_object_free_storage;
 
 	REGISTER_SPL_IMPLEMENTS(SplHeap, Iterator);
 	REGISTER_SPL_IMPLEMENTS(SplHeap, Countable);
@@ -1233,9 +1214,12 @@ PHP_MINIT_FUNCTION(spl_heap) /* {{{ */
 	REGISTER_SPL_STD_CLASS_EX(SplPriorityQueue, spl_heap_object_new, spl_funcs_SplPriorityQueue);
 	memcpy(&spl_handler_SplPriorityQueue, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 
+	spl_handler_SplPriorityQueue.offset         = XtOffsetOf(spl_heap_object, std);
 	spl_handler_SplPriorityQueue.clone_obj      = spl_heap_object_clone;
 	spl_handler_SplPriorityQueue.count_elements = spl_heap_object_count_elements;
 	spl_handler_SplPriorityQueue.get_debug_info = spl_pqueue_object_get_debug_info;
+	spl_handler_SplPriorityQueue.dtor_obj = zend_objects_destroy_object;
+	spl_handler_SplPriorityQueue.free_obj = spl_heap_object_free_storage;
 
 	REGISTER_SPL_IMPLEMENTS(SplPriorityQueue, Iterator);
 	REGISTER_SPL_IMPLEMENTS(SplPriorityQueue, Countable);
diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index 3068ccc795..cb7024d0a3 100644
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -95,13 +95,12 @@ typedef enum {
 
 typedef struct _spl_sub_iterator {
 	zend_object_iterator    *iterator;
-	zval                    *zobject;
+	zval                    zobject;
 	zend_class_entry        *ce;
 	RecursiveIteratorState  state;
 } spl_sub_iterator;
 
 typedef struct _spl_recursive_it_object {
-	zend_object              std;
 	spl_sub_iterator         *iterators;
 	int                      level;
 	RecursiveIteratorMode    mode;
@@ -118,43 +117,49 @@ typedef struct _spl_recursive_it_object {
 	zend_class_entry         *ce;
 	smart_str                prefix[6];
 	smart_str                postfix[1];
+	zend_object              std;
 } spl_recursive_it_object;
 
 typedef struct _spl_recursive_it_iterator {
 	zend_object_iterator   intern;
-	zval                   *zobject;
 } spl_recursive_it_iterator;
 
 static zend_object_handlers spl_handlers_rec_it_it;
 static zend_object_handlers spl_handlers_dual_it;
 
-#define SPL_FETCH_AND_CHECK_DUAL_IT(var, objzval) \
-	do { \
-		spl_dual_it_object *it = zend_object_store_get_object((objzval) TSRMLS_CC); \
-		if (it->dit_type == DIT_Unknown) { \
-			zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, \
-				"The object is in an invalid state as the parent constructor was not called"); \
-			return; \
-		} \
-		(var) = it; \
+static inline spl_recursive_it_object *spl_recursive_it_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_recursive_it_object*)((char*)(obj) - XtOffsetOf(spl_recursive_it_object, std));
+}
+/* }}} */
+
+#define Z_SPLRECURSIVE_IT_P(zv)  spl_recursive_it_from_obj(Z_OBJ_P((zv)))
+
+#define SPL_FETCH_AND_CHECK_DUAL_IT(var, objzval) 												\
+	do { 																						\
+		spl_dual_it_object *it = Z_SPLDUAL_IT_P(objzval); 										\
+		if (it->dit_type == DIT_Unknown) { 														\
+			zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, 						\
+				"The object is in an invalid state as the parent constructor was not called"); 	\
+			return; 																			\
+		} 																						\
+		(var) = it; 																			\
 	} while (0)
 
 static void spl_recursive_it_dtor(zend_object_iterator *_iter TSRMLS_DC)
 {
 	spl_recursive_it_iterator *iter   = (spl_recursive_it_iterator*)_iter;
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)_iter->data;
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(&iter->intern.data);
 	zend_object_iterator      *sub_iter;
 
 	while (object->level > 0) {
 		sub_iter = object->iterators[object->level].iterator;
-		sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
+		zend_iterator_dtor(sub_iter TSRMLS_CC);
 		zval_ptr_dtor(&object->iterators[object->level--].zobject);
 	}
 	object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator));
 	object->level = 0;
 
-	zval_ptr_dtor(&iter->zobject);
-	efree(iter);
+	zval_ptr_dtor(&iter->intern.data);
 }
 
 static int spl_recursive_it_valid_ex(spl_recursive_it_object *object, zval *zthis TSRMLS_DC)
@@ -162,7 +167,7 @@ static int spl_recursive_it_valid_ex(spl_recursive_it_object *object, zval *zthi
 	zend_object_iterator      *sub_iter;
 	int                       level = object->level;
 	
-	while (level >=0) {
+	while (level >= 0) {
 		sub_iter = object->iterators[level].iterator;
 		if (sub_iter->funcs->valid(sub_iter TSRMLS_CC) == SUCCESS) {
 			return SUCCESS;
@@ -170,7 +175,7 @@ static int spl_recursive_it_valid_ex(spl_recursive_it_object *object, zval *zthi
 		level--;
 	}
 	if (object->endIteration && object->in_iteration) {
-		zend_call_method_with_0_params(&zthis, object->ce, &object->endIteration, "endIteration", NULL);
+		zend_call_method_with_0_params(zthis, object->ce, &object->endIteration, "endIteration", NULL);
 	}
 	object->in_iteration = 0;
 	return FAILURE;
@@ -178,23 +183,21 @@ static int spl_recursive_it_valid_ex(spl_recursive_it_object *object, zval *zthi
 
 static int spl_recursive_it_valid(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)iter->data;
-	
-	return spl_recursive_it_valid_ex(object, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC);
+	return spl_recursive_it_valid_ex(Z_SPLRECURSIVE_IT_P(&iter->data), &iter->data TSRMLS_CC);
 }
 
-static void spl_recursive_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
+static zval *spl_recursive_it_get_current_data(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)iter->data;
-	zend_object_iterator      *sub_iter = object->iterators[object->level].iterator;
+	spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(&iter->data);
+	zend_object_iterator *sub_iter = object->iterators[object->level].iterator;
 	
-	sub_iter->funcs->get_current_data(sub_iter, data TSRMLS_CC);
+	return sub_iter->funcs->get_current_data(sub_iter TSRMLS_CC);
 }
 
 static void spl_recursive_it_get_current_key(zend_object_iterator *iter, zval *key TSRMLS_DC)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)iter->data;
-	zend_object_iterator      *sub_iter = object->iterators[object->level].iterator;
+	spl_recursive_it_object *object = Z_SPLRECURSIVE_IT_P(&iter->data);
+	zend_object_iterator *sub_iter = object->iterators[object->level].iterator;
 
 	if (sub_iter->funcs->get_current_key) {
 		sub_iter->funcs->get_current_key(sub_iter, key TSRMLS_CC);
@@ -208,7 +211,7 @@ static void spl_recursive_it_move_forward_ex(spl_recursive_it_object *object, zv
 	zend_object_iterator      *iterator;
 	zval                      *zobject;
 	zend_class_entry          *ce;
-	zval                      *retval, *child;
+	zval                      retval, child;
 	zend_object_iterator      *sub_iter;
 	int                       has_children;
 
@@ -234,11 +237,11 @@ next_step:
 				/* break; */
 			case RS_TEST:
 				ce = object->iterators[object->level].ce;
-				zobject = object->iterators[object->level].zobject;
+				zobject = &object->iterators[object->level].zobject;
 				if (object->callHasChildren) {
-					zend_call_method_with_0_params(&zthis, object->ce, &object->callHasChildren, "callHasChildren", &retval);
+					zend_call_method_with_0_params(zthis, object->ce, &object->callHasChildren, "callHasChildren", &retval);
 				} else {
-					zend_call_method_with_0_params(&zobject, ce, NULL, "haschildren", &retval);
+					zend_call_method_with_0_params(zobject, ce, NULL, "haschildren", &retval);
 				}
 				if (EG(exception)) {
 					if (!(object->flags & RIT_CATCH_GET_CHILD)) {
@@ -248,8 +251,8 @@ next_step:
 						zend_clear_exception(TSRMLS_C);
 					}
 				}
-				if (retval) {
-					has_children = zend_is_true(retval TSRMLS_CC);
+				if (Z_TYPE(retval) != IS_UNDEF) {
+					has_children = zend_is_true(&retval TSRMLS_CC);
 					zval_ptr_dtor(&retval);
 					if (has_children) {
 						if (object->max_depth == -1 || object->max_depth > object->level) {
@@ -273,7 +276,7 @@ next_step:
 					}
 				}
 				if (object->nextElement) {
-					zend_call_method_with_0_params(&zthis, object->ce, &object->nextElement, "nextelement", NULL);
+					zend_call_method_with_0_params(zthis, object->ce, &object->nextElement, "nextelement", NULL);
 				}
 				object->iterators[object->level].state = RS_NEXT;
 				if (EG(exception)) {
@@ -286,7 +289,7 @@ next_step:
 				return /* self */;
 			case RS_SELF:
 				if (object->nextElement && (object->mode == RIT_SELF_FIRST || object->mode == RIT_CHILD_FIRST)) {
-					zend_call_method_with_0_params(&zthis, object->ce, &object->nextElement, "nextelement", NULL);
+					zend_call_method_with_0_params(zthis, object->ce, &object->nextElement, "nextelement", NULL);
 				}
 				if (object->mode == RIT_SELF_FIRST) {
 					object->iterators[object->level].state = RS_CHILD;
@@ -296,11 +299,11 @@ next_step:
 				return /* self */;
 			case RS_CHILD:
 				ce = object->iterators[object->level].ce;
-				zobject = object->iterators[object->level].zobject;
+				zobject = &object->iterators[object->level].zobject;
 				if (object->callGetChildren) {
-					zend_call_method_with_0_params(&zthis, object->ce, &object->callGetChildren, "callGetChildren", &child);
+					zend_call_method_with_0_params(zthis, object->ce, &object->callGetChildren, "callGetChildren", &child);
 				} else {
-					zend_call_method_with_0_params(&zobject, ce, NULL, "getchildren", &child);
+					zend_call_method_with_0_params(zobject, ce, NULL, "getchildren", &child);
 				}
 
 				if (EG(exception)) {
@@ -308,38 +311,35 @@ next_step:
 						return;
 					} else {
 						zend_clear_exception(TSRMLS_C);
-						if (child) {
-							zval_ptr_dtor(&child);
-						}
+						zval_ptr_dtor(&child);
 						object->iterators[object->level].state = RS_NEXT;
 						goto next_step;
 					}
 				}
 
-				ce = child && Z_TYPE_P(child) == IS_OBJECT ? Z_OBJCE_P(child) : NULL;
-				if (!ce || !instanceof_function(ce, spl_ce_RecursiveIterator TSRMLS_CC)) {
-					if (child) {
-						zval_ptr_dtor(&child);
-					}
+				if (Z_TYPE(child) == IS_UNDEF || Z_TYPE(child) != IS_OBJECT || 
+						!((ce = Z_OBJCE(child)) && instanceof_function(ce, spl_ce_RecursiveIterator TSRMLS_CC))) {
+					zval_ptr_dtor(&child);
 					zend_throw_exception(spl_ce_UnexpectedValueException, "Objects returned by RecursiveIterator::getChildren() must implement RecursiveIterator", 0 TSRMLS_CC);
 					return;
-				}
+				} 
+
 				if (object->mode == RIT_CHILD_FIRST) {
 					object->iterators[object->level].state = RS_SELF;
 				} else {
 					object->iterators[object->level].state = RS_NEXT;
 				}
 				object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator) * (++object->level+1));
-				sub_iter = ce->get_iterator(ce, child, 0 TSRMLS_CC);
+				sub_iter = ce->get_iterator(ce, &child, 0 TSRMLS_CC);
+				ZVAL_COPY_VALUE(&object->iterators[object->level].zobject, &child);
 				object->iterators[object->level].iterator = sub_iter;
-				object->iterators[object->level].zobject = child;
 				object->iterators[object->level].ce = ce;
 				object->iterators[object->level].state = RS_START;
 				if (sub_iter->funcs->rewind) {
 					sub_iter->funcs->rewind(sub_iter TSRMLS_CC);
 				}
 				if (object->beginChildren) {
-					zend_call_method_with_0_params(&zthis, object->ce, &object->beginChildren, "beginchildren", NULL);
+					zend_call_method_with_0_params(zthis, object->ce, &object->beginChildren, "beginchildren", NULL);
 					if (EG(exception)) {
 						if (!(object->flags & RIT_CATCH_GET_CHILD)) {
 							return;
@@ -353,7 +353,7 @@ next_step:
 		/* no more elements */
 		if (object->level > 0) {
 			if (object->endChildren) {
-				zend_call_method_with_0_params(&zthis, object->ce, &object->endChildren, "endchildren", NULL);
+				zend_call_method_with_0_params(zthis, object->ce, &object->endChildren, "endchildren", NULL);
 				if (EG(exception)) {
 					if (!(object->flags & RIT_CATCH_GET_CHILD)) {
 						return;
@@ -362,7 +362,7 @@ next_step:
 					}
 				}
 			}
-			iterator->funcs->dtor(iterator TSRMLS_CC);
+			zend_iterator_dtor(iterator TSRMLS_CC);
 			zval_ptr_dtor(&object->iterators[object->level].zobject);
 			object->level--;
 		} else {
@@ -373,18 +373,18 @@ next_step:
 
 static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zthis TSRMLS_DC)
 {
-	zend_object_iterator      *sub_iter;
+	zend_object_iterator *sub_iter;
 	
 	if (!object->iterators) {
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_P(zthis)->name);
+		php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_P(zthis)->name->val);
 	}
 
 	while (object->level) {
 		sub_iter = object->iterators[object->level].iterator;
-		sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
+		zend_iterator_dtor(sub_iter TSRMLS_CC);
 		zval_ptr_dtor(&object->iterators[object->level--].zobject);
 		if (!EG(exception) && (!object->endChildren || object->endChildren->common.scope != spl_ce_RecursiveIteratorIterator)) {
-			zend_call_method_with_0_params(&zthis, object->ce, &object->endChildren, "endchildren", NULL);
+			zend_call_method_with_0_params(zthis, object->ce, &object->endChildren, "endchildren", NULL);
 		}
 	}
 	object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator));
@@ -394,7 +394,7 @@ static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zt
 		sub_iter->funcs->rewind(sub_iter TSRMLS_CC);
 	}
 	if (!EG(exception) && object->beginIteration && !object->in_iteration) {
-		zend_call_method_with_0_params(&zthis, object->ce, &object->beginIteration, "beginIteration", NULL);
+		zend_call_method_with_0_params(zthis, object->ce, &object->beginIteration, "beginIteration", NULL);
 	}
 	object->in_iteration = 1;
 	spl_recursive_it_move_forward_ex(object, zthis TSRMLS_CC);
@@ -402,33 +402,33 @@ static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zt
 
 static void spl_recursive_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_recursive_it_move_forward_ex((spl_recursive_it_object*)iter->data, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC);
+	spl_recursive_it_move_forward_ex(Z_SPLRECURSIVE_IT_P(&iter->data), &iter->data TSRMLS_CC);
 }
 
 static void spl_recursive_it_rewind(zend_object_iterator *iter TSRMLS_DC)
 {
-	spl_recursive_it_rewind_ex((spl_recursive_it_object*)iter->data, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC);
+	spl_recursive_it_rewind_ex(Z_SPLRECURSIVE_IT_P(&iter->data), &iter->data TSRMLS_CC);
 }
 
 static zend_object_iterator *spl_recursive_it_get_iterator(zend_class_entry *ce, zval *zobject, int by_ref TSRMLS_DC)
 {
 	spl_recursive_it_iterator *iterator;
-	spl_recursive_it_object   *object;
+	spl_recursive_it_object *object;
 
 	if (by_ref) {
 		zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
 	}
 	iterator = emalloc(sizeof(spl_recursive_it_iterator));
-	object   = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC);
+	object   = Z_SPLRECURSIVE_IT_P(zobject); 
 	if (object->iterators == NULL) {
 		zend_error(E_ERROR, "The object to be iterated is in an invalid state: "
 				"the parent constructor has not been called");
 	}
 
-	Z_ADDREF_P(zobject);
-	iterator->intern.data = (void*)object;
+	zend_iterator_init((zend_object_iterator*)iterator TSRMLS_CC);
+	
+	ZVAL_COPY(&iterator->intern.data, zobject);
 	iterator->intern.funcs = ce->iterator_funcs.funcs;
-	iterator->zobject = zobject;
 	return (zend_object_iterator*)iterator;
 }
 
@@ -443,43 +443,42 @@ zend_object_iterator_funcs spl_recursive_it_iterator_funcs = {
 
 static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_base, zend_class_entry *ce_inner, recursive_it_it_type rit_type)
 {
-	zval                      *object = getThis();
-	spl_recursive_it_object   *intern;
-	zval                      *iterator;
-	zend_class_entry          *ce_iterator;
-	long                       mode, flags;
-	int                        inc_refcount = 1;
-	zend_error_handling        error_handling;
+	zval *object = getThis();
+	spl_recursive_it_object *intern;
+	zval *iterator;
+	zend_class_entry *ce_iterator;
+	long mode, flags;
+	int inc_refcount = 1;
+	zend_error_handling error_handling;
 
 	zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
 
-	switch(rit_type) {
+	switch (rit_type) {
 		case RIT_RecursiveTreeIterator: {
 
-			zval *caching_it, *caching_it_flags, *user_caching_it_flags = NULL;
+			zval caching_it, caching_it_flags, *user_caching_it_flags = NULL;
 			mode = RIT_SELF_FIRST;
 			flags = RTIT_BYPASS_KEY;
 
 			if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|lzl", &iterator, &flags, &user_caching_it_flags, &mode) == SUCCESS) {
 				if (instanceof_function(Z_OBJCE_P(iterator), zend_ce_aggregate TSRMLS_CC)) {
 					zval *aggregate = iterator;
-					zend_call_method_with_0_params(&aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", &iterator);
-					inc_refcount = 0;
+					zend_call_method_with_0_params(aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", iterator);
+//???					inc_refcount = 0;
 				}
 
-				MAKE_STD_ZVAL(caching_it_flags);
 				if (user_caching_it_flags) {
-					ZVAL_ZVAL(caching_it_flags, user_caching_it_flags, 1, 0);
+					ZVAL_ZVAL(&caching_it_flags, user_caching_it_flags, 1, 0);
 				} else {
-					ZVAL_LONG(caching_it_flags, CIT_CATCH_GET_CHILD);
+					ZVAL_LONG(&caching_it_flags, CIT_CATCH_GET_CHILD);
 				}
-				spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &caching_it, 1, iterator, caching_it_flags TSRMLS_CC);
+				spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &caching_it, iterator, &caching_it_flags TSRMLS_CC);
 				zval_ptr_dtor(&caching_it_flags);
 				if (inc_refcount == 0 && iterator) {
-					zval_ptr_dtor(&iterator);
+					zval_ptr_dtor(iterator);
 				}
-				iterator = caching_it;
-				inc_refcount = 0;
+				iterator = &caching_it;
+//???				inc_refcount = 0;
 			} else {
 				iterator = NULL;
 			}
@@ -493,8 +492,8 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla
 			if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|ll", &iterator, &mode, &flags) == SUCCESS) {
 				if (instanceof_function(Z_OBJCE_P(iterator), zend_ce_aggregate TSRMLS_CC)) {
 					zval *aggregate = iterator;
-					zend_call_method_with_0_params(&aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", &iterator);
-					inc_refcount = 0;
+					zend_call_method_with_0_params(aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", iterator);
+//???					inc_refcount = 0;
 				}
 			} else {
 				iterator = NULL;
@@ -504,14 +503,14 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla
 	}
 	if (!iterator || !instanceof_function(Z_OBJCE_P(iterator), spl_ce_RecursiveIterator TSRMLS_CC)) {
 		if (iterator && !inc_refcount) {
-			zval_ptr_dtor(&iterator);
+			zval_ptr_dtor(iterator);
 		}
 		zend_throw_exception(spl_ce_InvalidArgumentException, "An instance of RecursiveIterator or IteratorAggregate creating it is required", 0 TSRMLS_CC);
 		zend_restore_error_handling(&error_handling TSRMLS_CC);
 		return;
 	}
 
-	intern = (spl_recursive_it_object*)zend_object_store_get_object(object TSRMLS_CC);
+	intern = Z_SPLRECURSIVE_IT_P(object);
 	intern->iterators = emalloc(sizeof(spl_sub_iterator));
 	intern->level = 0;
 	intern->mode = mode;
@@ -520,40 +519,42 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla
 	intern->in_iteration = 0;
 	intern->ce = Z_OBJCE_P(object);
 
-	zend_hash_find(&intern->ce->function_table, "beginiteration", sizeof("beginiteration"), (void **) &intern->beginIteration);
+	intern->beginIteration = zend_hash_str_find_ptr(&intern->ce->function_table, "beginiteration", sizeof("beginiteration") - 1);
 	if (intern->beginIteration->common.scope == ce_base) {
 		intern->beginIteration = NULL;
 	}
-	zend_hash_find(&intern->ce->function_table, "enditeration", sizeof("enditeration"), (void **) &intern->endIteration);
+	intern->endIteration = zend_hash_str_find_ptr(&intern->ce->function_table, "enditeration", sizeof("enditeration") - 1);
 	if (intern->endIteration->common.scope == ce_base) {
 		intern->endIteration = NULL;
 	}
-	zend_hash_find(&intern->ce->function_table, "callhaschildren", sizeof("callHasChildren"), (void **) &intern->callHasChildren);
+	intern->callHasChildren = zend_hash_str_find_ptr(&intern->ce->function_table, "callhaschildren", sizeof("callHasChildren") - 1);
 	if (intern->callHasChildren->common.scope == ce_base) {
 		intern->callHasChildren = NULL;
 	}
-	zend_hash_find(&intern->ce->function_table, "callgetchildren", sizeof("callGetChildren"), (void **) &intern->callGetChildren);
+	intern->callGetChildren = zend_hash_str_find_ptr(&intern->ce->function_table, "callgetchildren", sizeof("callGetChildren") - 1);
 	if (intern->callGetChildren->common.scope == ce_base) {
 		intern->callGetChildren = NULL;
 	}
-	zend_hash_find(&intern->ce->function_table, "beginchildren", sizeof("beginchildren"), (void **) &intern->beginChildren);
+	intern->beginChildren = zend_hash_str_find_ptr(&intern->ce->function_table, "beginchildren", sizeof("beginchildren") - 1);
 	if (intern->beginChildren->common.scope == ce_base) {
 		intern->beginChildren = NULL;
 	}
-	zend_hash_find(&intern->ce->function_table, "endchildren", sizeof("endchildren"), (void **) &intern->endChildren);
+	intern->endChildren = zend_hash_str_find_ptr(&intern->ce->function_table, "endchildren", sizeof("endchildren") - 1);
 	if (intern->endChildren->common.scope == ce_base) {
 		intern->endChildren = NULL;
 	}
-	zend_hash_find(&intern->ce->function_table, "nextelement", sizeof("nextElement"), (void **) &intern->nextElement);
+	intern->nextElement = zend_hash_str_find_ptr(&intern->ce->function_table, "nextelement", sizeof("nextElement") - 1);
 	if (intern->nextElement->common.scope == ce_base) {
 		intern->nextElement = NULL;
 	}
+
 	ce_iterator = Z_OBJCE_P(iterator); /* respect inheritance, don't use spl_ce_RecursiveIterator */
 	intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator, 0 TSRMLS_CC);
-	if (inc_refcount) {
-		Z_ADDREF_P(iterator);
-	}
-	intern->iterators[0].zobject = iterator;
+//???	if (inc_refcount) {
+		ZVAL_COPY(&intern->iterators[0].zobject, iterator);
+//???	} else {
+//???		ZVAL_COPY_VALUE(&intern->iterators[0].zobject, iterator);
+//???	}
 	intern->iterators[0].ce = ce_iterator;
 	intern->iterators[0].state = RS_START;
 
@@ -564,7 +565,7 @@ static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_cla
 
 		while (intern->level >= 0) {
 			sub_iter = intern->iterators[intern->level].iterator;
-			sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
+			zend_iterator_dtor(sub_iter TSRMLS_CC);
 			zval_ptr_dtor(&intern->iterators[intern->level--].zobject);
 		}
 		efree(intern->iterators);
@@ -583,7 +584,7 @@ SPL_METHOD(RecursiveIteratorIterator, __construct)
    Rewind the iterator to the first element of the top level inner iterator. */
 SPL_METHOD(RecursiveIteratorIterator, rewind)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -596,7 +597,7 @@ SPL_METHOD(RecursiveIteratorIterator, rewind)
    Check whether the current position is valid */
 SPL_METHOD(RecursiveIteratorIterator, valid)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -609,7 +610,7 @@ SPL_METHOD(RecursiveIteratorIterator, valid)
    Access the current key */
 SPL_METHOD(RecursiveIteratorIterator, key)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	zend_object_iterator      *iterator = object->iterators[object->level].iterator;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -627,17 +628,17 @@ SPL_METHOD(RecursiveIteratorIterator, key)
    Access the current element value */
 SPL_METHOD(RecursiveIteratorIterator, current)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	zend_object_iterator      *iterator = object->iterators[object->level].iterator;
-	zval                      **data;
+	zval                      *data;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	iterator->funcs->get_current_data(iterator, &data TSRMLS_CC);
-	if (data && *data) {
-		RETURN_ZVAL(*data, 1, 0);
+	data = iterator->funcs->get_current_data(iterator TSRMLS_CC);
+	if (data) {
+		RETURN_ZVAL(data, 1, 0);
 	}
 } /* }}} */
 
@@ -645,7 +646,7 @@ SPL_METHOD(RecursiveIteratorIterator, current)
    Move forward to the next element */
 SPL_METHOD(RecursiveIteratorIterator, next)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -658,7 +659,7 @@ SPL_METHOD(RecursiveIteratorIterator, next)
    Get the current depth of the recursive iteration */
 SPL_METHOD(RecursiveIteratorIterator, getDepth)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -671,7 +672,7 @@ SPL_METHOD(RecursiveIteratorIterator, getDepth)
    The current active sub iterator or the iterator at specified level */
 SPL_METHOD(RecursiveIteratorIterator, getSubIterator)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	long  level = object->level;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &level) == FAILURE) {
@@ -680,21 +681,21 @@ SPL_METHOD(RecursiveIteratorIterator, getSubIterator)
 	if (level < 0 || level > object->level) {
 		RETURN_NULL();
 	}
-	RETURN_ZVAL(object->iterators[level].zobject, 1, 0);
+	RETURN_ZVAL(&object->iterators[level].zobject, 1, 0);
 } /* }}} */
 
 /* {{{ proto RecursiveIterator RecursiveIteratorIterator::getInnerIterator()
    The current active sub iterator */
 SPL_METHOD(RecursiveIteratorIterator, getInnerIterator)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	long  level = object->level;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 	
-	RETURN_ZVAL(object->iterators[level].zobject, 1, 0);
+	RETURN_ZVAL(&object->iterators[level].zobject, 1, 0);
 } /* }}} */
 
 /* {{{ proto RecursiveIterator RecursiveIteratorIterator::beginIteration()
@@ -721,22 +722,20 @@ SPL_METHOD(RecursiveIteratorIterator, endIteration)
    Called for each element to test whether it has children */
 SPL_METHOD(RecursiveIteratorIterator, callHasChildren)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	zend_class_entry *ce = object->iterators[object->level].ce;
-	zval *retval, *zobject;
+	zval *zobject;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	zobject = object->iterators[object->level].zobject;
-	if (!zobject) {
+	zobject = &object->iterators[object->level].zobject;
+	if (Z_TYPE_P(zobject) == IS_UNDEF) {
 		RETURN_FALSE;
 	} else {
-		zend_call_method_with_0_params(&zobject, ce, NULL, "haschildren", &retval);
-		if (retval) {
-			RETURN_ZVAL(retval, 0, 1);
-		} else {
+		zend_call_method_with_0_params(zobject, ce, NULL, "haschildren", return_value);
+		if (Z_TYPE_P(return_value) == IS_UNDEF) {
 			RETURN_FALSE;
 		}
 	}
@@ -746,22 +745,22 @@ SPL_METHOD(RecursiveIteratorIterator, callHasChildren)
    Return children of current element */
 SPL_METHOD(RecursiveIteratorIterator, callGetChildren)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	zend_class_entry *ce = object->iterators[object->level].ce;
-	zval *retval, *zobject;
+	zval *zobject;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	zobject = object->iterators[object->level].zobject;
-	if (!zobject) {
+	zobject = &object->iterators[object->level].zobject;
+	if (Z_TYPE_P(zobject) == IS_UNDEF) {
 		return;
 	} else {
-		zend_call_method_with_0_params(&zobject, ce, NULL, "getchildren", &retval);
-		if (retval) {
-			RETURN_ZVAL(retval, 0, 1);
-		}
+		zend_call_method_with_0_params(zobject, ce, NULL, "getchildren", return_value);
+		if (Z_TYPE_P(return_value) == IS_UNDEF) {
+			RETURN_NULL();
+		} 
 	}
 } /* }}} */
 
@@ -799,7 +798,7 @@ SPL_METHOD(RecursiveIteratorIterator, nextElement)
    Set the maximum allowed depth (or any depth if pmax_depth = -1] */
 SPL_METHOD(RecursiveIteratorIterator, setMaxDepth)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	long  max_depth = -1;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &max_depth) == FAILURE) {
@@ -816,7 +815,7 @@ SPL_METHOD(RecursiveIteratorIterator, setMaxDepth)
    Return the maximum accepted depth or false if any depth is allowed */
 SPL_METHOD(RecursiveIteratorIterator, getMaxDepth)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -829,24 +828,24 @@ SPL_METHOD(RecursiveIteratorIterator, getMaxDepth)
 	}
 } /* }}} */
 
-static union _zend_function *spl_recursive_it_get_method(zval **object_ptr, char *method, int method_len, const zend_literal *key TSRMLS_DC)
+static union _zend_function *spl_recursive_it_get_method(zend_object **zobject, zend_string *method, const zval *key TSRMLS_DC)
 {
 	union _zend_function    *function_handler;
-	spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(*object_ptr TSRMLS_CC);
+	spl_recursive_it_object *object = spl_recursive_it_from_obj(*zobject);
 	long                     level = object->level;
 	zval                    *zobj;
 
 	if (!object->iterators) {
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_PP(object_ptr)->name);
+		php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", zend_get_class_entry(*zobject TSRMLS_CC)->name->val);
 	}
-	zobj = object->iterators[level].zobject;
+	zobj = &object->iterators[level].zobject;
 
-	function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
+	function_handler = std_object_handlers.get_method(zobject, method, key TSRMLS_CC);
 	if (!function_handler) {
-		if (zend_hash_find(&Z_OBJCE_P(zobj)->function_table, method, method_len+1, (void **) &function_handler) == FAILURE) {
+		if ((function_handler = zend_hash_find_ptr(&Z_OBJCE_P(zobj)->function_table, method)) == NULL) {
 			if (Z_OBJ_HT_P(zobj)->get_method) {
-				*object_ptr = zobj;
-				function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
+				*zobject = Z_OBJ_P(zobj);
+				function_handler = (*zobject)->handlers->get_method(zobject, method, key TSRMLS_CC);
 			}
 		}
 	}
@@ -854,18 +853,18 @@ static union _zend_function *spl_recursive_it_get_method(zval **object_ptr, char
 }
 
 /* {{{ spl_RecursiveIteratorIterator_dtor */
-static void spl_RecursiveIteratorIterator_dtor(zend_object *_object, zend_object_handle handle TSRMLS_DC)
+static void spl_RecursiveIteratorIterator_dtor(zend_object *_object TSRMLS_DC)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object *)_object;
-	zend_object_iterator      *sub_iter;
+	spl_recursive_it_object *object = spl_recursive_it_from_obj(_object);
+	zend_object_iterator *sub_iter;
 
 	/* call standard dtor */
-	zend_objects_destroy_object(_object, handle TSRMLS_CC);
+	zend_objects_destroy_object(_object TSRMLS_CC);
 
 	if (object->iterators) {
 		while (object->level >= 0) {
 			sub_iter = object->iterators[object->level].iterator;
-			sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
+			zend_iterator_dtor(sub_iter TSRMLS_CC);
 			zval_ptr_dtor(&object->iterators[object->level--].zobject);
 		}
 		efree(object->iterators);
@@ -875,9 +874,9 @@ static void spl_RecursiveIteratorIterator_dtor(zend_object *_object, zend_object
 /* }}} */
 
 /* {{{ spl_RecursiveIteratorIterator_free_storage */
-static void spl_RecursiveIteratorIterator_free_storage(void *_object TSRMLS_DC)
+static void spl_RecursiveIteratorIterator_free_storage(zend_object *_object TSRMLS_DC)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object *)_object;
+	spl_recursive_it_object *object = spl_recursive_it_from_obj(_object);
 
 	zend_object_std_dtor(&object->std TSRMLS_CC);
 	smart_str_free(&object->prefix[0]);
@@ -888,19 +887,15 @@ static void spl_RecursiveIteratorIterator_free_storage(void *_object TSRMLS_DC)
 	smart_str_free(&object->prefix[5]);
 
 	smart_str_free(&object->postfix[0]);
-
-	efree(object);
 }
 /* }}} */
 
 /* {{{ spl_RecursiveIteratorIterator_new_ex */
-static zend_object_value spl_RecursiveIteratorIterator_new_ex(zend_class_entry *class_type, int init_prefix TSRMLS_DC)
+static zend_object *spl_RecursiveIteratorIterator_new_ex(zend_class_entry *class_type, int init_prefix TSRMLS_DC)
 {
-	zend_object_value retval;
 	spl_recursive_it_object *intern;
 
-	intern = emalloc(sizeof(spl_recursive_it_object));
-	memset(intern, 0, sizeof(spl_recursive_it_object));
+	intern = ecalloc(1, sizeof(spl_recursive_it_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	if (init_prefix) {
 		smart_str_appendl(&intern->prefix[0], "",    0);
@@ -916,21 +911,20 @@ static zend_object_value spl_RecursiveIteratorIterator_new_ex(zend_class_entry *
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)spl_RecursiveIteratorIterator_dtor, (zend_objects_free_object_storage_t) spl_RecursiveIteratorIterator_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &spl_handlers_rec_it_it;
-	return retval;
+	intern->std.handlers = &spl_handlers_rec_it_it;
+	return &intern->std;
 }
 /* }}} */
 
 /* {{{ spl_RecursiveIteratorIterator_new */
-static zend_object_value spl_RecursiveIteratorIterator_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_RecursiveIteratorIterator_new(zend_class_entry *class_type TSRMLS_DC)
 {
 	return spl_RecursiveIteratorIterator_new_ex(class_type, 0 TSRMLS_CC);
 }
 /* }}} */
 
 /* {{{ spl_RecursiveTreeIterator_new */
-static zend_object_value spl_RecursiveTreeIterator_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_RecursiveTreeIterator_new(zend_class_entry *class_type TSRMLS_DC)
 {
 	return spl_RecursiveIteratorIterator_new_ex(class_type, 1 TSRMLS_CC);
 }
@@ -975,52 +969,52 @@ static const zend_function_entry spl_funcs_RecursiveIteratorIterator[] = {
 static void spl_recursive_tree_iterator_get_prefix(spl_recursive_it_object *object, zval *return_value TSRMLS_DC)
 {
 	smart_str  str = {0};
-	zval      *has_next;
+	zval       has_next;
 	int        level;
 
-	smart_str_appendl(&str, object->prefix[0].c, object->prefix[0].len);
+	smart_str_appendl(&str, object->prefix[0].s->val, object->prefix[0].s->len);
 	
 	for (level = 0; level < object->level; ++level) {
 		zend_call_method_with_0_params(&object->iterators[level].zobject, object->iterators[level].ce, NULL, "hasnext", &has_next);
-		if (has_next) {
-			if (Z_LVAL_P(has_next)) {
-				smart_str_appendl(&str, object->prefix[1].c, object->prefix[1].len);
+		if (Z_TYPE(has_next) != IS_UNDEF) {
+			if (Z_LVAL(has_next)) {
+				smart_str_appendl(&str, object->prefix[1].s->val, object->prefix[1].s->len);
 			} else {
-				smart_str_appendl(&str, object->prefix[2].c, object->prefix[2].len);
+				smart_str_appendl(&str, object->prefix[2].s->val, object->prefix[2].s->len);
 			}
 			zval_ptr_dtor(&has_next);
 		}
 	}
 	zend_call_method_with_0_params(&object->iterators[level].zobject, object->iterators[level].ce, NULL, "hasnext", &has_next);
-	if (has_next) {
-		if (Z_LVAL_P(has_next)) {
-			smart_str_appendl(&str, object->prefix[3].c, object->prefix[3].len);
+	if (Z_TYPE(has_next) != IS_UNDEF) {
+		if (Z_LVAL(has_next)) {
+			smart_str_appendl(&str, object->prefix[3].s->val, object->prefix[3].s->len);
 		} else {
-			smart_str_appendl(&str, object->prefix[4].c, object->prefix[4].len);
+			smart_str_appendl(&str, object->prefix[4].s->val, object->prefix[4].s->len);
 		}
 		zval_ptr_dtor(&has_next);
 	}
 
-	smart_str_appendl(&str, object->prefix[5].c, object->prefix[5].len);
+	smart_str_appendl(&str, object->prefix[5].s->val, object->prefix[5].s->len);
 	smart_str_0(&str);
 
-	RETVAL_STRINGL(str.c, str.len, 0);
+	RETURN_STR(str.s);
 }
 
-static void spl_recursive_tree_iterator_get_entry(spl_recursive_it_object * object, zval * return_value TSRMLS_DC)
+static void spl_recursive_tree_iterator_get_entry(spl_recursive_it_object *object, zval *return_value TSRMLS_DC)
 {
 	zend_object_iterator      *iterator = object->iterators[object->level].iterator;
-	zval                     **data;
+	zval                      *data;
 	zend_error_handling        error_handling;
 
-	iterator->funcs->get_current_data(iterator, &data TSRMLS_CC);
+	data = iterator->funcs->get_current_data(iterator TSRMLS_CC);
 
 	zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
-	if (data && *data) {
-		RETVAL_ZVAL(*data, 1, 0);
+	if (data) {
+		RETVAL_ZVAL(data, 1, 0);
 		if (Z_TYPE_P(return_value) == IS_ARRAY) {
 			zval_dtor(return_value);
-			ZVAL_STRINGL(return_value, "Array", sizeof("Array")-1, 1);
+			ZVAL_STRINGL(return_value, "Array", sizeof("Array")-1);
 		} else {
 			convert_to_string(return_value);
 		}
@@ -1028,9 +1022,10 @@ static void spl_recursive_tree_iterator_get_entry(spl_recursive_it_object * obje
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 }
 
-static void spl_recursive_tree_iterator_get_postfix(spl_recursive_it_object * object, zval * return_value TSRMLS_DC)
+static void spl_recursive_tree_iterator_get_postfix(spl_recursive_it_object *object, zval *return_value TSRMLS_DC)
 {
-	RETVAL_STRINGL(object->postfix[0].c, object->postfix[0].len, 1);
+	RETVAL_STR(object->postfix[0].s);
+	Z_ADDREF_P(return_value);
 }
 
 /* {{{ proto void RecursiveTreeIterator::__construct(RecursiveIterator|IteratorAggregate it [, int flags = RTIT_BYPASS_KEY [, int cit_flags = CIT_CATCH_GET_CHILD [, mode = RIT_SELF_FIRST ]]]) throws InvalidArgumentException
@@ -1044,14 +1039,15 @@ SPL_METHOD(RecursiveTreeIterator, __construct)
    Sets prefix parts as used in getPrefix() */
 SPL_METHOD(RecursiveTreeIterator, setPrefixPart)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
 	long  part;
 	char* prefix;
 	int   prefix_len;
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &part, &prefix, &prefix_len) == FAILURE) {
 		return;
 	}
+
 	if (0 > part || part > 5) {
 		zend_throw_exception_ex(spl_ce_OutOfRangeException, 0 TSRMLS_CC, "Use RecursiveTreeIterator::PREFIX_* constant");
 		return;
@@ -1065,11 +1061,12 @@ SPL_METHOD(RecursiveTreeIterator, setPrefixPart)
    Returns the string to place in front of current element */
 SPL_METHOD(RecursiveTreeIterator, getPrefix)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
+	
 	spl_recursive_tree_iterator_get_prefix(object, return_value TSRMLS_CC);
 } /* }}} */
 
@@ -1077,7 +1074,7 @@ SPL_METHOD(RecursiveTreeIterator, getPrefix)
    Sets postfix as used in getPostfix() */
 SPL_METHOD(RecursiveTreeIterator, setPostfix)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	char* postfix;
 	int   postfix_len;
 
@@ -1093,7 +1090,7 @@ SPL_METHOD(RecursiveTreeIterator, setPostfix)
    Returns the string presentation built for current element */
 SPL_METHOD(RecursiveTreeIterator, getEntry)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1106,7 +1103,7 @@ SPL_METHOD(RecursiveTreeIterator, getEntry)
    Returns the string to place after the current element */
 SPL_METHOD(RecursiveTreeIterator, getPostfix)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1119,10 +1116,10 @@ SPL_METHOD(RecursiveTreeIterator, getPostfix)
    Returns the current element prefixed and postfixed */
 SPL_METHOD(RecursiveTreeIterator, current)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	zval                       prefix, entry, postfix;
-	char                      *str, *ptr;
-	size_t                     str_len;
+	char                      *ptr;
+	zend_string               *str;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1130,30 +1127,29 @@ SPL_METHOD(RecursiveTreeIterator, current)
 
 	if (object->flags & RTIT_BYPASS_CURRENT) {
 		zend_object_iterator      *iterator = object->iterators[object->level].iterator;
-		zval                      **data;
+		zval                      *data;
 
-		iterator->funcs->get_current_data(iterator, &data TSRMLS_CC);
-		if (data && *data) {
-			RETURN_ZVAL(*data, 1, 0);
+		data = iterator->funcs->get_current_data(iterator TSRMLS_CC);
+		if (data) {
+			RETURN_ZVAL(data, 1, 0);
 		} else {
 			RETURN_NULL();
 		}
 	}
 
-	INIT_ZVAL(prefix);
-	INIT_ZVAL(entry);
+	ZVAL_NULL(&prefix);
+	ZVAL_NULL(&entry);
 	spl_recursive_tree_iterator_get_prefix(object, &prefix TSRMLS_CC);
 	spl_recursive_tree_iterator_get_entry(object, &entry TSRMLS_CC);
 	if (Z_TYPE(entry) != IS_STRING) {
-		zval_dtor(&prefix);
-		zval_dtor(&entry);
+		zval_ptr_dtor(&prefix);
+		zval_ptr_dtor(&entry);
 		RETURN_NULL();
 	}
 	spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC);
 
-	str_len = Z_STRLEN(prefix) + Z_STRLEN(entry) + Z_STRLEN(postfix);
-	str = (char *) emalloc(str_len + 1U);
-	ptr = str;
+	str = STR_ALLOC(Z_STRLEN(prefix) + Z_STRLEN(entry) + Z_STRLEN(postfix), 0);
+	ptr = str->val;
 
 	memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix));
 	ptr += Z_STRLEN(prefix);
@@ -1163,22 +1159,22 @@ SPL_METHOD(RecursiveTreeIterator, current)
 	ptr += Z_STRLEN(postfix);
 	*ptr = 0;
 
-	zval_dtor(&prefix);
-	zval_dtor(&entry);
-	zval_dtor(&postfix);
+	zval_ptr_dtor(&prefix);
+	zval_ptr_dtor(&entry);
+	zval_ptr_dtor(&postfix);
 
-	RETURN_STRINGL(str, str_len, 0);
+	RETURN_NEW_STR(str);
 } /* }}} */
 
 /* {{{ proto mixed RecursiveTreeIterator::key()
    Returns the current key prefixed and postfixed */
 SPL_METHOD(RecursiveTreeIterator, key)
 {
-	spl_recursive_it_object   *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_recursive_it_object   *object = Z_SPLRECURSIVE_IT_P(getThis());
 	zend_object_iterator      *iterator = object->iterators[object->level].iterator;
 	zval                       prefix, key, postfix, key_copy;
-	char                      *str, *ptr;
-	size_t                     str_len;
+	char                      *ptr;
+	zend_string               *str;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1208,9 +1204,8 @@ SPL_METHOD(RecursiveTreeIterator, key)
 	spl_recursive_tree_iterator_get_prefix(object, &prefix TSRMLS_CC);
 	spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC);
 
-	str_len = Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix);
-	str = (char *) emalloc(str_len + 1U);
-	ptr = str;
+	str = STR_ALLOC(Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix), 0);
+	ptr = str->val;
 
 	memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix));
 	ptr += Z_STRLEN(prefix);
@@ -1220,11 +1215,11 @@ SPL_METHOD(RecursiveTreeIterator, key)
 	ptr += Z_STRLEN(postfix);
 	*ptr = 0;
 
-	zval_dtor(&prefix);
-	zval_dtor(&key);
-	zval_dtor(&postfix);
+	zval_ptr_dtor(&prefix);
+	zval_ptr_dtor(&key);
+	zval_ptr_dtor(&postfix);
 
-	RETVAL_STRINGL(str, str_len, 0);
+	RETURN_NEW_STR(str);
 } /* }}} */
 
 ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_tree_it___construct, 0, 0, 1) 
@@ -1277,22 +1272,22 @@ static int spl_dual_it_gets_implemented(zend_class_entry *interface, zend_class_
 }
 #endif
 
-static union _zend_function *spl_dual_it_get_method(zval **object_ptr, char *method, int method_len, const zend_literal *key TSRMLS_DC)
+static union _zend_function *spl_dual_it_get_method(zend_object **object, zend_string *method, const zval *key TSRMLS_DC)
 {
 	union _zend_function *function_handler;
 	spl_dual_it_object   *intern;
 
-	intern = (spl_dual_it_object*)zend_object_store_get_object(*object_ptr TSRMLS_CC);
+	intern = spl_dual_it_from_obj(*object);
 
-	function_handler = std_object_handlers.get_method(object_ptr, method, method_len, key TSRMLS_CC);
+	function_handler = std_object_handlers.get_method(object, method, key TSRMLS_CC);
 	if (!function_handler && intern->inner.ce) {
-		if (zend_hash_find(&intern->inner.ce->function_table, method, method_len+1, (void **) &function_handler) == FAILURE) {
-			if (Z_OBJ_HT_P(intern->inner.zobject)->get_method) {
-				*object_ptr = intern->inner.zobject;
-				function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len, key TSRMLS_CC);
+		if ((function_handler = zend_hash_find_ptr(&intern->inner.ce->function_table, method)) == NULL) {
+			if (Z_OBJ_HT(intern->inner.zobject)->get_method) {
+				*object = Z_OBJ(intern->inner.zobject);
+				function_handler = (*object)->handlers->get_method(object, method, key TSRMLS_CC);
 			}
 		} else {
-			*object_ptr = intern->inner.zobject;
+			*object = Z_OBJ(intern->inner.zobject);
 		}
 	}
 	return function_handler;
@@ -1302,14 +1297,14 @@ static union _zend_function *spl_dual_it_get_method(zval **object_ptr, char *met
 int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
 {
 	zval ***func_params, func;
-	zval *retval_ptr;
+	zval retval;
 	int arg_count;
 	int current = 0;
 	int success;
 	void **p;
 	spl_dual_it_object   *intern;
 
-	intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDUAL_IT_P(getThis());
 
 	ZVAL_STRING(&func, method, 0);
 	if (!zend_is_callable(&func, 0, &method TSRMLS_CC)) {
@@ -1329,8 +1324,8 @@ int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
 	}
 	arg_count = current; /* restore */
 
-	if (call_user_function_ex(EG(function_table), NULL, &func, &retval_ptr, arg_count, func_params, 0, NULL TSRMLS_CC) == SUCCESS && retval_ptr) {
-		RETURN_ZVAL(retval_ptr, 0, 1);
+	if (call_user_function_ex(EG(function_table), NULL, &func, &retval, arg_count, func_params, 0, NULL TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) { 
+		RETURN_ZVAL(&retval, 0, 0);
 		
 		success = SUCCESS;
 	} else {
@@ -1346,7 +1341,7 @@ int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
 #define SPL_CHECK_CTOR(intern, classname) \
 	if (intern->dit_type == DIT_Unknown) { \
 		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Classes derived from %s must call %s::__construct()", \
-				(spl_ce_##classname)->name, (spl_ce_##classname)->name); \
+				(spl_ce_##classname)->name->val, (spl_ce_##classname)->name->val); \
 		return; \
 	}
 
@@ -1368,16 +1363,16 @@ static inline int spl_cit_check_flags(int flags)
 
 static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_base, zend_class_entry *ce_inner, dual_it_type dit_type)
 {
-	zval                 *zobject, *retval;
+	zval                 *zobject, retval;
 	spl_dual_it_object   *intern;
 	zend_class_entry     *ce = NULL;
 	int                   inc_refcount = 1;
 	zend_error_handling   error_handling;
 
-	intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDUAL_IT_P(getThis());
 	
 	if (intern->dit_type != DIT_Unknown) {
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s::getIterator() must be called exactly once per instance", ce_base->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s::getIterator() must be called exactly once per instance", ce_base->name->val);
 		return NULL;
 	}
 
@@ -1417,47 +1412,43 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 				return NULL;
 			}
 			intern->u.caching.flags |= flags & CIT_PUBLIC;
-			MAKE_STD_ZVAL(intern->u.caching.zcache);
-			array_init(intern->u.caching.zcache);
+			array_init(&intern->u.caching.zcache);
 			break;
 		}
 		case DIT_IteratorIterator: {
-			zend_class_entry **pce_cast;
-			char * class_name = NULL;
-			int class_name_len = 0;
+			zend_class_entry *ce_cast;
+			zend_string *class_name;
 
-			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|s", &zobject, ce_inner, &class_name, &class_name_len) == FAILURE) {
+			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|S", &zobject, ce_inner, &class_name) == FAILURE) {
 				zend_restore_error_handling(&error_handling TSRMLS_CC);
 				return NULL;
 			}
 			ce = Z_OBJCE_P(zobject);
 			if (!instanceof_function(ce, zend_ce_iterator TSRMLS_CC)) {
 				if (ZEND_NUM_ARGS() > 1) {
-					if (zend_lookup_class(class_name, class_name_len, &pce_cast TSRMLS_CC) == FAILURE 
-					|| !instanceof_function(ce, *pce_cast TSRMLS_CC)
-					|| !(*pce_cast)->get_iterator
+					if (!(ce_cast = zend_lookup_class(class_name TSRMLS_CC))
+					|| !instanceof_function(ce, ce_cast TSRMLS_CC)
+					|| !ce_cast->get_iterator
 					) {
 						zend_throw_exception(spl_ce_LogicException, "Class to downcast to not found or not base class or does not implement Traversable", 0 TSRMLS_CC);
 						zend_restore_error_handling(&error_handling TSRMLS_CC);
 						return NULL;
 					}
-					ce = *pce_cast;
+					ce = ce_cast;
 				}
 				if (instanceof_function(ce, zend_ce_aggregate TSRMLS_CC)) {
-					zend_call_method_with_0_params(&zobject, ce, &ce->iterator_funcs.zf_new_iterator, "getiterator", &retval);
+					zend_call_method_with_0_params(zobject, ce, &ce->iterator_funcs.zf_new_iterator, "getiterator", &retval);
 					if (EG(exception)) {
-						if (retval) {
-							zval_ptr_dtor(&retval);
-						}
+						zval_ptr_dtor(&retval);
 						zend_restore_error_handling(&error_handling TSRMLS_CC);
 						return NULL;
 					}
-					if (!retval || Z_TYPE_P(retval) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(retval), zend_ce_traversable TSRMLS_CC)) {
-						zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "%s::getIterator() must return an object that implements Traversable", ce->name);
+					if (Z_TYPE(retval) != IS_OBJECT || !instanceof_function(Z_OBJCE(retval), zend_ce_traversable TSRMLS_CC)) {
+						zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "%s::getIterator() must return an object that implements Traversable", ce->name->val);
 						zend_restore_error_handling(&error_handling TSRMLS_CC);
 						return NULL;
 					}
-					zobject = retval;
+					zobject = &retval;
 					ce = Z_OBJCE_P(zobject);
 					inc_refcount = 0;
 				}
@@ -1465,22 +1456,21 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 			break;
 		}
 		case DIT_AppendIterator:
-			spl_instantiate(spl_ce_ArrayIterator, &intern->u.append.zarrayit, 1 TSRMLS_CC);
+			spl_instantiate(spl_ce_ArrayIterator, &intern->u.append.zarrayit TSRMLS_CC);
 			zend_call_method_with_0_params(&intern->u.append.zarrayit, spl_ce_ArrayIterator, &spl_ce_ArrayIterator->constructor, "__construct", NULL);
-			intern->u.append.iterator = spl_ce_ArrayIterator->get_iterator(spl_ce_ArrayIterator, intern->u.append.zarrayit, 0 TSRMLS_CC);
+			intern->u.append.iterator = spl_ce_ArrayIterator->get_iterator(spl_ce_ArrayIterator, &intern->u.append.zarrayit, 0 TSRMLS_CC);
 			zend_restore_error_handling(&error_handling TSRMLS_CC);
 			return intern;
 #if HAVE_PCRE || HAVE_BUNDLED_PCRE
 		case DIT_RegexIterator:
 		case DIT_RecursiveRegexIterator: {
-			char *regex;
-			int regex_len;
+			zend_string *regex;
 			long mode = REGIT_MODE_MATCH;
 
 			intern->u.regex.use_flags = ZEND_NUM_ARGS() >= 5;
 			intern->u.regex.flags = 0;
 			intern->u.regex.preg_flags = 0;
-			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os|lll", &zobject, ce_inner, &regex, &regex_len, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) {
+			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "OS|lll", &zobject, ce_inner, &regex, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) {
 				zend_restore_error_handling(&error_handling TSRMLS_CC);
 				return NULL;
 			}
@@ -1490,9 +1480,8 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 				return NULL;
 			}
 			intern->u.regex.mode = mode;
-			intern->u.regex.regex = estrndup(regex, regex_len);
-			intern->u.regex.regex_len = regex_len;
-			intern->u.regex.pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC);
+			intern->u.regex.regex = STR_COPY(regex);
+			intern->u.regex.pce = pcre_get_compiled_regex_cache(regex TSRMLS_CC);
 			if (intern->u.regex.pce == NULL) {
 				/* pcre_get_compiled_regex_cache has already sent error */
 				zend_restore_error_handling(&error_handling TSRMLS_CC);
@@ -1505,17 +1494,17 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 		case DIT_CallbackFilterIterator:
 		case DIT_RecursiveCallbackFilterIterator: {
 			_spl_cbfilter_it_intern *cfi = emalloc(sizeof(*cfi));
+			cfi->fci.object = NULL;
 			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Of", &zobject, ce_inner, &cfi->fci, &cfi->fcc) == FAILURE) {
 				zend_restore_error_handling(&error_handling TSRMLS_CC);
 				efree(cfi);
 				return NULL;
 			}
-			if (cfi->fci.function_name) {
-				Z_ADDREF_P(cfi->fci.function_name);
-			}
-			if (cfi->fci.object_ptr) {
-				Z_ADDREF_P(cfi->fci.object_ptr);
+			if (Z_REFCOUNTED_P(&cfi->fci.function_name)) {
+				Z_ADDREF(cfi->fci.function_name);
 			}
+			cfi->object = cfi->fcc.object;
+			if (cfi->object) GC_REFCOUNT(cfi->object)++;
 			intern->u.cbfilter = cfi;
 			break;
 		}
@@ -1530,11 +1519,13 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 
 	if (inc_refcount) {
-		Z_ADDREF_P(zobject);
+		ZVAL_COPY(&intern->inner.zobject, zobject);
+	} else {
+		ZVAL_COPY_VALUE(&intern->inner.zobject, zobject);
 	}
-	intern->inner.zobject = zobject;
+
 	intern->inner.ce = dit_type == DIT_IteratorIterator ? ce : Z_OBJCE_P(zobject);
-	intern->inner.object = zend_object_store_get_object(zobject TSRMLS_CC);
+	intern->inner.object = Z_OBJ_P(zobject);
 	intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, zobject, 0 TSRMLS_CC);
 
 	return intern;
@@ -1569,8 +1560,8 @@ SPL_METHOD(dual_it, getInnerIterator)
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	if (intern->inner.zobject) {
-		RETVAL_ZVAL(intern->inner.zobject, 1, 0);
+	if (!ZVAL_IS_UNDEF(&intern->inner.zobject)) {
+		RETVAL_ZVAL(&intern->inner.zobject, 1, 0);
 	} else {
 		RETURN_NULL();
 	}
@@ -1588,22 +1579,22 @@ static inline void spl_dual_it_free(spl_dual_it_object *intern TSRMLS_DC)
 	if (intern->inner.iterator && intern->inner.iterator->funcs->invalidate_current) {
 		intern->inner.iterator->funcs->invalidate_current(intern->inner.iterator TSRMLS_CC);
 	}
-	if (intern->current.data) {
+	if (Z_TYPE(intern->current.data) != IS_UNDEF) {
 		zval_ptr_dtor(&intern->current.data);
-		intern->current.data = NULL;
+		ZVAL_UNDEF(&intern->current.data);
 	}
-	if (intern->current.key) {
+	if (Z_TYPE(intern->current.key) != IS_UNDEF) {
 		zval_ptr_dtor(&intern->current.key);
-		intern->current.key = NULL;
+		ZVAL_UNDEF(&intern->current.key);
 	}
 	if (intern->dit_type == DIT_CachingIterator || intern->dit_type == DIT_RecursiveCachingIterator) {
-		if (intern->u.caching.zstr) {
+		if (Z_TYPE(intern->u.caching.zstr) != IS_UNDEF) {
 			zval_ptr_dtor(&intern->u.caching.zstr);
-			intern->u.caching.zstr = NULL;
+			ZVAL_UNDEF(&intern->u.caching.zstr);
 		}
-		if (intern->u.caching.zchildren) {
+		if (Z_TYPE(intern->u.caching.zchildren) != IS_UNDEF) {
 			zval_ptr_dtor(&intern->u.caching.zchildren);
-			intern->u.caching.zchildren = NULL;
+			ZVAL_UNDEF(&intern->u.caching.zchildren);
 		}
 	}
 }
@@ -1628,25 +1619,23 @@ static inline int spl_dual_it_valid(spl_dual_it_object *intern TSRMLS_DC)
 
 static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more TSRMLS_DC)
 {
-	zval **data;
+	zval *data;
 
 	spl_dual_it_free(intern TSRMLS_CC);
 	if (!check_more || spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
-		intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC);
-		if (data && *data) {
-			intern->current.data = *data;
-			Z_ADDREF_P(intern->current.data);
+		data = intern->inner.iterator->funcs->get_current_data(intern->inner.iterator TSRMLS_CC);
+		if (data) {
+			ZVAL_COPY(&intern->current.data, data);
 		}
 
-		MAKE_STD_ZVAL(intern->current.key);
 		if (intern->inner.iterator->funcs->get_current_key) {
-			intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, intern->current.key TSRMLS_CC);
+			intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &intern->current.key TSRMLS_CC);
 			if (EG(exception)) {
 				zval_ptr_dtor(&intern->current.key);
-				intern->current.key = NULL;
+				ZVAL_UNDEF(&intern->current.key);
 			}
 		} else {
-			ZVAL_LONG(intern->current.key, intern->current.pos);
+			ZVAL_LONG(&intern->current.key, intern->current.pos);
 		}
 		return EG(exception) ? FAILURE : SUCCESS;
 	}
@@ -1697,7 +1686,7 @@ SPL_METHOD(dual_it, valid)
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	RETURN_BOOL(intern->current.data);
+	RETURN_BOOL(Z_TYPE(intern->current.data) != IS_UNDEF);
 } /* }}} */
 
 /* {{{ proto mixed FilterIterator::key()
@@ -1718,8 +1707,8 @@ SPL_METHOD(dual_it, key)
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	if (intern->current.key) {
-		RETURN_ZVAL(intern->current.key, 1, 0);
+	if (Z_TYPE(intern->current.key) != IS_UNDEF) {
+		RETURN_ZVAL(&intern->current.key, 1, 0);
 	}
 	RETURN_NULL();
 } /* }}} */
@@ -1742,8 +1731,8 @@ SPL_METHOD(dual_it, current)
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	if (intern->current.data) {
-		RETVAL_ZVAL(intern->current.data, 1, 0);
+	if (Z_TYPE(intern->current.data) != IS_UNDEF) {
+		RETVAL_ZVAL(&intern->current.data, 1, 0);
 	} else {
 		RETURN_NULL();
 	}
@@ -1769,12 +1758,12 @@ SPL_METHOD(dual_it, next)
 
 static inline void spl_filter_it_fetch(zval *zthis, spl_dual_it_object *intern TSRMLS_DC)
 {
-	zval *retval;
+	zval retval;
 
 	while (spl_dual_it_fetch(intern, 1 TSRMLS_CC) == SUCCESS) {
-		zend_call_method_with_0_params(&zthis, intern->std.ce, NULL, "accept", &retval);
-		if (retval) {
-			if (zend_is_true(retval TSRMLS_CC)) {
+		zend_call_method_with_0_params(zthis, intern->std.ce, NULL, "accept", &retval);
+		if (Z_TYPE(retval) != IS_UNDEF) {
+			if (zend_is_true(&retval TSRMLS_CC)) {
 				zval_ptr_dtor(&retval);
 				return;
 			}
@@ -1848,7 +1837,7 @@ SPL_METHOD(RecursiveFilterIterator, __construct)
 SPL_METHOD(RecursiveFilterIterator, hasChildren)
 {
 	spl_dual_it_object   *intern;
-	zval                 *retval;
+	zval                  retval;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1857,8 +1846,8 @@ SPL_METHOD(RecursiveFilterIterator, hasChildren)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval);
-	if (retval) {
-		RETURN_ZVAL(retval, 0, 1);
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		RETURN_ZVAL(&retval, 0, 1);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1869,7 +1858,7 @@ SPL_METHOD(RecursiveFilterIterator, hasChildren)
 SPL_METHOD(RecursiveFilterIterator, getChildren)
 {
 	spl_dual_it_object   *intern;
-	zval                 *retval;
+	zval                  retval;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1878,12 +1867,10 @@ SPL_METHOD(RecursiveFilterIterator, getChildren)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval);
-	if (!EG(exception) && retval) {
-		spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), &return_value, 0, retval TSRMLS_CC);
-	}
-	if (retval) {
-		zval_ptr_dtor(&retval);
+	if (!EG(exception) && Z_TYPE(retval) != IS_UNDEF) {
+		spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), return_value, &retval TSRMLS_CC);
 	}
+	zval_ptr_dtor(&retval);
 } /* }}} */
 
 /* {{{ proto RecursiveCallbackFilterIterator RecursiveCallbackFilterIterator::getChildren()
@@ -1891,21 +1878,19 @@ SPL_METHOD(RecursiveFilterIterator, getChildren)
 SPL_METHOD(RecursiveCallbackFilterIterator, getChildren)
 {
 	spl_dual_it_object   *intern;
-	zval                 *retval;
+	zval                  retval;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLDUAL_IT_P(getThis());
 
 	zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval);
-	if (!EG(exception) && retval) {
-		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, retval, intern->u.cbfilter->fci.function_name TSRMLS_CC);
-	}
-	if (retval) {
-		zval_ptr_dtor(&retval);
+	if (!EG(exception) && Z_TYPE(retval) != IS_UNDEF) {
+		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, &retval, &intern->u.cbfilter->fci.function_name TSRMLS_CC);
 	}
+	zval_ptr_dtor(&retval);
 } /* }}} */
 /* {{{ proto void ParentIterator::__construct(RecursiveIterator it)
    Create a ParentIterator from a RecursiveIterator */
@@ -1926,37 +1911,37 @@ SPL_METHOD(RegexIterator, __construct)
    Calls the callback with the current value, the current key and the inner iterator as arguments */
 SPL_METHOD(CallbackFilterIterator, accept)
 {
-	spl_dual_it_object     *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dual_it_object     *intern = Z_SPLDUAL_IT_P(getThis());
 	zend_fcall_info        *fci = &intern->u.cbfilter->fci;
 	zend_fcall_info_cache  *fcc = &intern->u.cbfilter->fcc;
-	zval                  **params[3];
-	zval                   *result;
+	zval                    params[3];
+	zval                    result;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	if (intern->current.data == NULL || intern->current.key == NULL) {
+	if (Z_TYPE(intern->current.data) == IS_UNDEF || Z_TYPE(intern->current.key) == IS_UNDEF) {
 		RETURN_FALSE;
 	}
 
-	params[0] = &intern->current.data;
-	params[1] = &intern->current.key;
-	params[2] = &intern->inner.zobject;
+	ZVAL_COPY_VALUE(&params[0], &intern->current.data);
+	ZVAL_COPY_VALUE(&params[1], &intern->current.key);
+	ZVAL_COPY_VALUE(&params[2], &intern->inner.zobject);
 
-	fci->retval_ptr_ptr = &result;
+	fci->retval = &result;
 	fci->param_count = 3;
 	fci->params = params;
 	fci->no_separation = 0;
 
-	if (zend_call_function(fci, fcc TSRMLS_CC) != SUCCESS || !result) {
+	if (zend_call_function(fci, fcc TSRMLS_CC) != SUCCESS || Z_TYPE(result) == IS_UNDEF) {
 		RETURN_FALSE;
 	}
 	if (EG(exception)) {
 		return;
 	}
 
-	RETURN_ZVAL(result, 1, 1);
+	RETURN_ZVAL(&result, 1, 1);
 }
 /* }}} */
 
@@ -1965,9 +1950,10 @@ SPL_METHOD(CallbackFilterIterator, accept)
 SPL_METHOD(RegexIterator, accept)
 {
 	spl_dual_it_object *intern;
-	char       *subject, *result;
-	int        subject_len, use_copy, count = 0, result_len;
-	zval       *subject_ptr, subject_copy, zcount, *replacement, tmp_replacement;
+	char *subject;
+	zend_string *result;
+	int subject_len, use_copy, count = 0;
+	zval *subject_ptr, subject_copy, zcount, *replacement, tmp_replacement;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1975,16 +1961,17 @@ SPL_METHOD(RegexIterator, accept)
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 	
-	if (intern->current.data == NULL) {
+	if (Z_TYPE(intern->current.data) == IS_UNDEF) {
 		RETURN_FALSE;
 	}
 	
 	if (intern->u.regex.flags & REGIT_USE_KEY) {
-		subject_ptr = intern->current.key;
+		subject_ptr = &intern->current.key;
 	} else {
-		subject_ptr = intern->current.data;
+		subject_ptr = &intern->current.data;
 	}
 
+	ZVAL_UNDEF(&subject_copy);
 	zend_make_printable_zval(subject_ptr, &subject_copy, &use_copy);
 	if (use_copy) {
 		subject = Z_STRVAL(subject_copy);
@@ -1994,64 +1981,63 @@ SPL_METHOD(RegexIterator, accept)
 		subject_len = Z_STRLEN_P(subject_ptr);
 	}
 
+	use_copy = 0;
 	switch (intern->u.regex.mode)
 	{
-	case REGIT_MODE_MAX: /* won't happen but makes compiler happy */
-	case REGIT_MODE_MATCH:
-		count = pcre_exec(intern->u.regex.pce->re, intern->u.regex.pce->extra, subject, subject_len, 0, 0, NULL, 0);
-		RETVAL_BOOL(count >= 0);
-		break;
-
-	case REGIT_MODE_ALL_MATCHES:
-	case REGIT_MODE_GET_MATCH:
-		if (!use_copy) {
-			subject = estrndup(subject, subject_len);
-			use_copy = 1;
-		}
-		zval_ptr_dtor(&intern->current.data);
-		ALLOC_INIT_ZVAL(intern->current.data);
-		php_pcre_match_impl(intern->u.regex.pce, subject, subject_len, &zcount, 
-			intern->current.data, intern->u.regex.mode == REGIT_MODE_ALL_MATCHES, intern->u.regex.use_flags, intern->u.regex.preg_flags, 0 TSRMLS_CC);
-		count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data));
-		RETVAL_BOOL(count > 0);
-		break;
-
-	case REGIT_MODE_SPLIT:
-		if (!use_copy) {
-			subject = estrndup(subject, subject_len);
-			use_copy = 1;
-		}
-		zval_ptr_dtor(&intern->current.data);
-		ALLOC_INIT_ZVAL(intern->current.data);
-		php_pcre_split_impl(intern->u.regex.pce, subject, subject_len, intern->current.data, -1, intern->u.regex.preg_flags TSRMLS_CC);
-		count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data));
-		RETVAL_BOOL(count > 1);
-		break;
-
-	case REGIT_MODE_REPLACE:
-		replacement = zend_read_property(intern->std.ce, getThis(), "replacement", sizeof("replacement")-1, 1 TSRMLS_CC);
-		if (Z_TYPE_P(replacement) != IS_STRING) {
-			tmp_replacement = *replacement;
-			zval_copy_ctor(&tmp_replacement);
-			convert_to_string(&tmp_replacement);
-			replacement = &tmp_replacement;
-		}
-		result = php_pcre_replace_impl(intern->u.regex.pce, subject, subject_len, replacement, 0, &result_len, -1, &count TSRMLS_CC);
-		
-		if (intern->u.regex.flags & REGIT_USE_KEY) {
-			zval_ptr_dtor(&intern->current.key);
-			MAKE_STD_ZVAL(intern->current.key);
-			ZVAL_STRINGL(intern->current.key, result, result_len, 0);
-		} else {
+		case REGIT_MODE_MAX: /* won't happen but makes compiler happy */
+		case REGIT_MODE_MATCH:
+			count = pcre_exec(intern->u.regex.pce->re, intern->u.regex.pce->extra, subject, subject_len, 0, 0, NULL, 0);
+			RETVAL_BOOL(count >= 0);
+			break;
+
+		case REGIT_MODE_ALL_MATCHES:
+		case REGIT_MODE_GET_MATCH:
+			if (!use_copy) {
+				subject = estrndup(subject, subject_len);
+				use_copy = 1;
+			}
 			zval_ptr_dtor(&intern->current.data);
-			MAKE_STD_ZVAL(intern->current.data);
-			ZVAL_STRINGL(intern->current.data, result, result_len, 0);
-		}
+			ZVAL_UNDEF(&intern->current.data);
+			php_pcre_match_impl(intern->u.regex.pce, subject, subject_len, &zcount, 
+				&intern->current.data, intern->u.regex.mode == REGIT_MODE_ALL_MATCHES, intern->u.regex.use_flags, intern->u.regex.preg_flags, 0 TSRMLS_CC);
+			count = zend_hash_num_elements(Z_ARRVAL(intern->current.data));
+			RETVAL_BOOL(count > 0);
+			break;
 
-		if (replacement == &tmp_replacement) {
-			zval_dtor(replacement);
-		}
-		RETVAL_BOOL(count > 0);
+		case REGIT_MODE_SPLIT:
+			if (!use_copy) {
+				subject = estrndup(subject, subject_len);
+				use_copy = 1;
+			}
+			zval_ptr_dtor(&intern->current.data);
+			ZVAL_UNDEF(&intern->current.data);
+			php_pcre_split_impl(intern->u.regex.pce, subject, subject_len, &intern->current.data, -1, intern->u.regex.preg_flags TSRMLS_CC);
+			count = zend_hash_num_elements(Z_ARRVAL(intern->current.data));
+			RETVAL_BOOL(count > 1);
+			break;
+
+		case REGIT_MODE_REPLACE:
+			replacement = zend_read_property(intern->std.ce, getThis(), "replacement", sizeof("replacement")-1, 1 TSRMLS_CC);
+			if (Z_TYPE_P(replacement) != IS_STRING) {
+				tmp_replacement = *replacement;
+				zval_copy_ctor(&tmp_replacement);
+				convert_to_string(&tmp_replacement);
+				replacement = &tmp_replacement;
+			}
+			result = php_pcre_replace_impl(intern->u.regex.pce, subject, subject_len, replacement, 0, -1, &count TSRMLS_CC);
+			
+			if (intern->u.regex.flags & REGIT_USE_KEY) {
+				zval_ptr_dtor(&intern->current.key);
+				ZVAL_STR(&intern->current.key, result);
+			} else {
+				zval_ptr_dtor(&intern->current.data);
+				ZVAL_STR(&intern->current.data, result);
+			}
+
+			if (replacement == &tmp_replacement) {
+				zval_dtor(replacement);
+			}
+			RETVAL_BOOL(count > 0);
 	}
 
 	if (intern->u.regex.flags & REGIT_INVERTED) {
@@ -2059,7 +2045,10 @@ SPL_METHOD(RegexIterator, accept)
 	}
 
 	if (use_copy) {
-		str_efree(subject);
+		efree(subject);
+	}
+	if (!ZVAL_IS_UNDEF(&subject_copy)) {
+		zval_ptr_dtor(&subject_copy);
 	}
 } /* }}} */
 
@@ -2067,13 +2056,13 @@ SPL_METHOD(RegexIterator, accept)
    Returns current regular expression */
 SPL_METHOD(RegexIterator, getRegex)
 {
-	spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_dual_it_object *intern = Z_SPLDUAL_IT_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	RETURN_STRINGL(intern->u.regex.regex, intern->u.regex.regex_len, 1);
+	RETURN_STR(STR_COPY(intern->u.regex.regex));
 } /* }}} */
 
 /* {{{ proto bool RegexIterator::getMode()
@@ -2191,7 +2180,7 @@ SPL_METHOD(RecursiveRegexIterator, __construct)
 SPL_METHOD(RecursiveRegexIterator, getChildren)
 {
 	spl_dual_it_object   *intern;
-	zval                 *retval, *regex;
+	zval                 retval, regex;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2201,55 +2190,52 @@ SPL_METHOD(RecursiveRegexIterator, getChildren)
 
 	zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval);
 	if (!EG(exception)) {
-		MAKE_STD_ZVAL(regex);
-		ZVAL_STRING(regex, intern->u.regex.regex, 1);
-		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, retval, regex TSRMLS_CC);
+		ZVAL_STR(&regex, STR_COPY(intern->u.regex.regex));
+		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), return_value, &retval, &regex TSRMLS_CC);
 		zval_ptr_dtor(&regex);
 	}
-	if (retval) {
-		zval_ptr_dtor(&retval);
-	}
+	zval_ptr_dtor(&retval);
 } /* }}} */
 
 #endif
 
 /* {{{ spl_dual_it_dtor */
-static void spl_dual_it_dtor(zend_object *_object, zend_object_handle handle TSRMLS_DC)
+static void spl_dual_it_dtor(zend_object *_object TSRMLS_DC)
 {
-	spl_dual_it_object        *object = (spl_dual_it_object *)_object;
+	spl_dual_it_object *object = spl_dual_it_from_obj(_object);
 
 	/* call standard dtor */
-	zend_objects_destroy_object(_object, handle TSRMLS_CC);
+	zend_objects_destroy_object(_object TSRMLS_CC);
 
 	spl_dual_it_free(object TSRMLS_CC);
 
 	if (object->inner.iterator) {
-		object->inner.iterator->funcs->dtor(object->inner.iterator TSRMLS_CC);
+		zend_iterator_dtor(object->inner.iterator TSRMLS_CC);
 	}
 }
 /* }}} */
 
 /* {{{ spl_dual_it_free_storage */
-static void spl_dual_it_free_storage(void *_object TSRMLS_DC)
+static void spl_dual_it_free_storage(zend_object *_object TSRMLS_DC)
 {
-	spl_dual_it_object        *object = (spl_dual_it_object *)_object;
+	spl_dual_it_object *object = spl_dual_it_from_obj(_object);
 
 
-	if (object->inner.zobject) {
+	if (!ZVAL_IS_UNDEF(&object->inner.zobject)) {
 		zval_ptr_dtor(&object->inner.zobject);
 	}
 	
 	if (object->dit_type == DIT_AppendIterator) {
-		object->u.append.iterator->funcs->dtor(object->u.append.iterator TSRMLS_CC);
-		if (object->u.append.zarrayit) {
+		zend_iterator_dtor(object->u.append.iterator TSRMLS_CC);
+		if (Z_TYPE(object->u.append.zarrayit) != IS_UNDEF) {
 			zval_ptr_dtor(&object->u.append.zarrayit);
 		}
 	}
 
 	if (object->dit_type == DIT_CachingIterator || object->dit_type == DIT_RecursiveCachingIterator) {
-		if (object->u.caching.zcache) {
+		if (Z_TYPE(object->u.caching.zcache) != IS_UNDEF) {
 			zval_ptr_dtor(&object->u.caching.zcache);
-			object->u.caching.zcache = NULL;
+			//ZVAL_UNDEF(&object->u.caching.zcache);
 		}
 	}
 
@@ -2259,45 +2245,40 @@ static void spl_dual_it_free_storage(void *_object TSRMLS_DC)
 			object->u.regex.pce->refcount--;
 		}
 		if (object->u.regex.regex) {
-			efree(object->u.regex.regex);
+			STR_RELEASE(object->u.regex.regex);
 		}
 	}
 #endif
 
 	if (object->dit_type == DIT_CallbackFilterIterator || object->dit_type == DIT_RecursiveCallbackFilterIterator) {
 		if (object->u.cbfilter) {
-			if (object->u.cbfilter->fci.function_name) {
-				zval_ptr_dtor(&object->u.cbfilter->fci.function_name);
-			}
-			if (object->u.cbfilter->fci.object_ptr) {
-				zval_ptr_dtor(&object->u.cbfilter->fci.object_ptr);
+			_spl_cbfilter_it_intern *cbfilter = object->u.cbfilter;
+			object->u.cbfilter = NULL;
+			zval_ptr_dtor(&cbfilter->fci.function_name);
+			if (cbfilter->fci.object) {
+				OBJ_RELEASE(cbfilter->fci.object);
 			}
-			efree(object->u.cbfilter);
+			efree(cbfilter);
 		}
 	}
 
 	zend_object_std_dtor(&object->std TSRMLS_CC);
-
-	efree(object);
 }
 /* }}} */
 
 /* {{{ spl_dual_it_new */
-static zend_object_value spl_dual_it_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_dual_it_new(zend_class_entry *class_type TSRMLS_DC)
 {
-	zend_object_value retval;
 	spl_dual_it_object *intern;
 
-	intern = emalloc(sizeof(spl_dual_it_object));
-	memset(intern, 0, sizeof(spl_dual_it_object));
+	intern = ecalloc(1, sizeof(spl_dual_it_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 	intern->dit_type = DIT_Unknown;
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)spl_dual_it_dtor, (zend_objects_free_object_storage_t) spl_dual_it_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &spl_handlers_dual_it;
-	return retval;
+	intern->std.handlers = &spl_handlers_dual_it;
+	return &intern->std;
 }
 /* }}} */
 
@@ -2419,7 +2400,7 @@ static inline int spl_limit_it_valid(spl_dual_it_object *intern TSRMLS_DC)
 
 static inline void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS_DC)
 {
-	zval  *zpos;
+	zval  zpos;
 
 	spl_dual_it_free(intern TSRMLS_CC);
 	if (pos < intern->u.limit.offset) {
@@ -2431,10 +2412,9 @@ static inline void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS
 		return;
 	}
 	if (pos != intern->current.pos && instanceof_function(intern->inner.ce, spl_ce_SeekableIterator TSRMLS_CC)) {
-		MAKE_STD_ZVAL(zpos);
-		ZVAL_LONG(zpos, pos);
+		ZVAL_LONG(&zpos, pos);
 		spl_dual_it_free(intern TSRMLS_CC);
-		zend_call_method_with_1_params(&intern->inner.zobject, intern->inner.ce, NULL, "seek", NULL, zpos);
+		zend_call_method_with_1_params(&intern->inner.zobject, intern->inner.ce, NULL, "seek", NULL, &zpos);
 		zval_ptr_dtor(&zpos);
 		if (!EG(exception)) {
 			intern->current.pos = pos;
@@ -2484,7 +2464,7 @@ SPL_METHOD(LimitIterator, valid)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 /*	RETURN_BOOL(spl_limit_it_valid(intern TSRMLS_CC) == SUCCESS);*/
-	RETURN_BOOL((intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) && intern->current.data);
+	RETURN_BOOL((intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) && Z_TYPE(intern->current.data) != IS_UNDEF);
 } /* }}} */
 
 /* {{{ proto void LimitIterator::next()
@@ -2574,36 +2554,31 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
 		intern->u.caching.flags |= CIT_VALID;
 		/* Full cache ? */
 		if (intern->u.caching.flags & CIT_FULL_CACHE) {
-			zval *zcacheval;
-			zval *key = intern->current.key;
+			zval zcacheval;
+			zval *key = &intern->current.key;
 			
-			MAKE_STD_ZVAL(zcacheval);
-			ZVAL_ZVAL(zcacheval, intern->current.data, 1, 0);
+			ZVAL_ZVAL(&zcacheval, &intern->current.data, 1, 0);
 
-			array_set_zval_key(HASH_OF(intern->u.caching.zcache), key, zcacheval);
+			array_set_zval_key(HASH_OF(&intern->u.caching.zcache), key, &zcacheval TSRMLS_CC);
 
 			zval_ptr_dtor(&zcacheval);
 		}
 		/* Recursion ? */
 		if (intern->dit_type == DIT_RecursiveCachingIterator) {
-			zval *retval, *zchildren, zflags;
+			zval retval, zchildren, zflags;
 			zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval);
 			if (EG(exception)) {
-				if (retval) {
-					zval_ptr_dtor(&retval);
-				}
+				zval_ptr_dtor(&retval);
 				if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
 					zend_clear_exception(TSRMLS_C);
 				} else {
 					return;
 				}
 			} else {
-				if (zend_is_true(retval TSRMLS_CC)) {
+				if (zend_is_true(&retval TSRMLS_CC)) {
 					zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &zchildren);
 					if (EG(exception)) {
-						if (zchildren) {
-							zval_ptr_dtor(&zchildren);
-						}
+						zval_ptr_dtor(&zchildren);
 						if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
 							zend_clear_exception(TSRMLS_C);
 						} else {
@@ -2611,9 +2586,8 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
 							return;
 						}
 					} else {
-						INIT_PZVAL(&zflags);
 						ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC);
-						spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, 1, zchildren, &zflags TSRMLS_CC);
+						spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, &zchildren, &zflags TSRMLS_CC);
 						zval_ptr_dtor(&zchildren);
 					}
 				}
@@ -2630,21 +2604,21 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
 		if (intern->u.caching.flags & (CIT_TOSTRING_USE_INNER|CIT_CALL_TOSTRING)) {
 			int  use_copy;
 			zval expr_copy;
-			ALLOC_ZVAL(intern->u.caching.zstr);
 			if (intern->u.caching.flags & CIT_TOSTRING_USE_INNER) {
-				*intern->u.caching.zstr = *intern->inner.zobject;
+				ZVAL_COPY_VALUE(&intern->u.caching.zstr, &intern->inner.zobject);
 			} else {
-				*intern->u.caching.zstr = *intern->current.data;
+				ZVAL_COPY_VALUE(&intern->u.caching.zstr, &intern->current.data);
 			}
-			zend_make_printable_zval(intern->u.caching.zstr, &expr_copy, &use_copy);
+			zend_make_printable_zval(&intern->u.caching.zstr, &expr_copy, &use_copy);
 			if (use_copy) {
-				*intern->u.caching.zstr = expr_copy;
-				INIT_PZVAL(intern->u.caching.zstr);
-				zval_copy_ctor(intern->u.caching.zstr);
+				ZVAL_COPY(&intern->u.caching.zstr, &expr_copy);
+//???			INIT_PZVAL(intern->u.caching.zstr);
+				//zval_copy_ctor(&intern->u.caching.zstr);
 				zval_dtor(&expr_copy);
-			} else {
-				INIT_PZVAL(intern->u.caching.zstr);
-				zval_copy_ctor(intern->u.caching.zstr);
+			} else if (Z_REFCOUNTED(intern->u.caching.zstr)) {
+//???			INIT_PZVAL(intern->u.caching.zstr);
+				//zval_copy_ctor(&intern->u.caching.zstr);
+				Z_ADDREF(intern->u.caching.zstr);
 			}
 		}
 		spl_dual_it_next(intern, 0 TSRMLS_CC);	
@@ -2656,7 +2630,7 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
 static inline void spl_caching_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
 {
 	spl_dual_it_rewind(intern TSRMLS_CC);
-	zend_hash_clean(HASH_OF(intern->u.caching.zcache));
+	zend_hash_clean(HASH_OF(&intern->u.caching.zcache));
 	spl_caching_it_next(intern TSRMLS_CC);
 }
 
@@ -2736,20 +2710,20 @@ SPL_METHOD(CachingIterator, __toString)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & (CIT_CALL_TOSTRING|CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT|CIT_TOSTRING_USE_INNER)))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not fetch string value (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not fetch string value (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 	if (intern->u.caching.flags & CIT_TOSTRING_USE_KEY) {
-		MAKE_COPY_ZVAL(&intern->current.key, return_value);
+		ZVAL_DUP(return_value, &intern->current.key);
 		convert_to_string(return_value);
 		return;
 	} else if (intern->u.caching.flags & CIT_TOSTRING_USE_CURRENT) {
-		MAKE_COPY_ZVAL(&intern->current.data, return_value);
+		ZVAL_DUP(return_value, &intern->current.data);
 		convert_to_string(return_value);
 		return;
 	}
-	if (intern->u.caching.zstr) {
-		RETURN_STRINGL(Z_STRVAL_P(intern->u.caching.zstr), Z_STRLEN_P(intern->u.caching.zstr), 1);
+	if (Z_TYPE(intern->u.caching.zstr) == IS_STRING) {
+		RETURN_STR(STR_COPY(Z_STR_P(&intern->u.caching.zstr)));
 	} else {
 		RETURN_NULL();
 	}
@@ -2760,23 +2734,24 @@ SPL_METHOD(CachingIterator, __toString)
 SPL_METHOD(CachingIterator, offsetSet)
 {
 	spl_dual_it_object   *intern;
-	char *arKey;
-	uint nKeyLength;
+	zend_string *key;
 	zval *value;
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &arKey, &nKeyLength, &value) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz", &key, &value) == FAILURE) {
 		return;
 	}
 
-	Z_ADDREF_P(value);
-	zend_symtable_update(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, &value, sizeof(value), NULL);
+	if (Z_REFCOUNTED_P(value)) {
+		Z_ADDREF_P(value);
+	}
+	zend_symtable_update(HASH_OF(&intern->u.caching.zcache), key, value);
 }
 /* }}} */
 
@@ -2785,27 +2760,26 @@ SPL_METHOD(CachingIterator, offsetSet)
 SPL_METHOD(CachingIterator, offsetGet)
 {
 	spl_dual_it_object   *intern;
-	char *arKey;
-	uint nKeyLength;
-	zval **value;
+	zend_string *key;
+	zval *value;
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &key) == FAILURE) {
 		return;
 	}
 
-	if (zend_symtable_find(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, (void**)&value) == FAILURE) {
-		zend_error(E_NOTICE, "Undefined index: %s", arKey);
+	if ((value = zend_symtable_find(HASH_OF(&intern->u.caching.zcache), key)) == NULL) {
+		zend_error(E_NOTICE, "Undefined index: %s", key->val);
 		return;
 	}
 	
-	RETURN_ZVAL(*value, 1, 0);
+	RETURN_ZVAL(value, 1, 0);
 }
 /* }}} */
 
@@ -2814,21 +2788,20 @@ SPL_METHOD(CachingIterator, offsetGet)
 SPL_METHOD(CachingIterator, offsetUnset)
 {
 	spl_dual_it_object   *intern;
-	char *arKey;
-	uint nKeyLength;
+	zend_string *key;
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &key) == FAILURE) {
 		return;
 	}
 
-	zend_symtable_del(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1);
+	zend_symtable_del(HASH_OF(&intern->u.caching.zcache), key);
 }
 /* }}} */
 
@@ -2837,21 +2810,20 @@ SPL_METHOD(CachingIterator, offsetUnset)
 SPL_METHOD(CachingIterator, offsetExists)
 {
 	spl_dual_it_object   *intern;
-	char *arKey;
-	uint nKeyLength;
+	zend_string *key;
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &key) == FAILURE) {
 		return;
 	}
 
-	RETURN_BOOL(zend_symtable_exists(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1));
+	RETURN_BOOL(zend_symtable_exists(HASH_OF(&intern->u.caching.zcache), key));
 }
 /* }}} */
 
@@ -2868,11 +2840,11 @@ SPL_METHOD(CachingIterator, getCache)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%v does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%v does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 
-	RETURN_ZVAL(intern->u.caching.zcache, 1, 0);
+	RETURN_ZVAL(&intern->u.caching.zcache, 1, 0);
 }
 /* }}} */
 
@@ -2919,7 +2891,7 @@ SPL_METHOD(CachingIterator, setFlags)
 	}
 	if ((flags & CIT_FULL_CACHE) != 0 && (intern->u.caching.flags & CIT_FULL_CACHE) == 0) {
 		/* clear on (re)enable */
-		zend_hash_clean(HASH_OF(intern->u.caching.zcache));
+		zend_hash_clean(HASH_OF(&intern->u.caching.zcache));
 	}
 	intern->u.caching.flags = (intern->u.caching.flags & ~CIT_PUBLIC) | (flags & CIT_PUBLIC);
 }
@@ -2938,11 +2910,11 @@ SPL_METHOD(CachingIterator, count)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	if (!(intern->u.caching.flags & CIT_FULL_CACHE))	{
-		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%v does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
+		zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%v does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name->val);
 		return;
 	}
 
-	RETURN_LONG(zend_hash_num_elements(HASH_OF(intern->u.caching.zcache)));
+	RETURN_LONG(zend_hash_num_elements(HASH_OF(&intern->u.caching.zcache)));
 }
 /* }}} */
 
@@ -3004,7 +2976,7 @@ SPL_METHOD(RecursiveCachingIterator, hasChildren)
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	RETURN_BOOL(intern->u.caching.zchildren);
+	RETURN_BOOL(Z_TYPE(intern->u.caching.zchildren) != IS_UNDEF);
 } /* }}} */
 
 /* {{{ proto RecursiveCachingIterator RecursiveCachingIterator::getChildren()
@@ -3019,8 +2991,8 @@ SPL_METHOD(RecursiveCachingIterator, getChildren)
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	if (intern->u.caching.zchildren) {
-		RETURN_ZVAL(intern->u.caching.zchildren, 1, 0);
+	if (Z_TYPE(intern->u.caching.zchildren) != IS_UNDEF) {
+		RETURN_ZVAL(&intern->u.caching.zchildren, 1, 0);
 	} else {
 		RETURN_NULL();
 	}
@@ -3115,16 +3087,16 @@ SPL_METHOD(NoRewindIterator, key)
 SPL_METHOD(NoRewindIterator, current)
 {
 	spl_dual_it_object   *intern;
-	zval **data;
+	zval *data;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
-	intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC);
-	if (data && *data) {
-		RETURN_ZVAL(*data, 1, 0);
+	data = intern->inner.iterator->funcs->get_current_data(intern->inner.iterator TSRMLS_CC);
+	if (data) {
+		RETURN_ZVAL(data, 1, 0);
 	}
 } /* }}} */
 
@@ -3254,25 +3226,22 @@ int spl_append_it_next_iterator(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/
 {
 	spl_dual_it_free(intern TSRMLS_CC);
 
-	if (intern->inner.zobject) {
+	if (!ZVAL_IS_UNDEF(&intern->inner.zobject)) {
 		zval_ptr_dtor(&intern->inner.zobject);
-		intern->inner.zobject = NULL;
+		ZVAL_UNDEF(&intern->inner.zobject);
 		intern->inner.ce = NULL;
-		intern->inner.object = NULL;
 		if (intern->inner.iterator) {
-			intern->inner.iterator->funcs->dtor(intern->inner.iterator TSRMLS_CC);
+			zend_iterator_dtor(intern->inner.iterator TSRMLS_CC);
 			intern->inner.iterator = NULL;
 		}
 	}
 	if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator TSRMLS_CC) == SUCCESS) {
-		zval **it;
-
-		intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator, &it TSRMLS_CC);
-		Z_ADDREF_PP(it);
-		intern->inner.zobject = *it;
-		intern->inner.ce = Z_OBJCE_PP(it);
-		intern->inner.object = zend_object_store_get_object(*it TSRMLS_CC);
-		intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, *it, 0 TSRMLS_CC);
+		zval *it;
+
+		it  = intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator TSRMLS_CC);
+		ZVAL_COPY(&intern->inner.zobject, it);
+		intern->inner.ce = Z_OBJCE_P(it);
+		intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, it, 0 TSRMLS_CC);
 		spl_dual_it_rewind(intern TSRMLS_CC);
 		return SUCCESS;
 	} else {
@@ -3318,7 +3287,7 @@ SPL_METHOD(AppendIterator, append)
 	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "O", &it, zend_ce_iterator) == FAILURE) {
 		return;
 	}
-	spl_array_iterator_append(intern->u.append.zarrayit, it TSRMLS_CC);
+	spl_array_iterator_append(&intern->u.append.zarrayit, it TSRMLS_CC);
 
 	if (!intern->inner.iterator || spl_dual_it_valid(intern TSRMLS_CC) != SUCCESS) {
 		if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator TSRMLS_CC) != SUCCESS) {
@@ -3326,7 +3295,7 @@ SPL_METHOD(AppendIterator, append)
 		}
 		do {
 			spl_append_it_next_iterator(intern TSRMLS_CC);
-		} while (intern->inner.zobject != it);
+		} while (Z_OBJ(intern->inner.zobject) != Z_OBJ_P(it));
 		spl_append_it_fetch(intern TSRMLS_CC);
 	}
 } /* }}} */
@@ -3361,7 +3330,7 @@ SPL_METHOD(AppendIterator, valid)
 	
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	RETURN_BOOL(intern->current.data);
+	RETURN_BOOL(Z_TYPE(intern->current.data) != IS_UNDEF);
 } /* }}} */
 
 /* {{{ proto void AppendIterator::next()
@@ -3392,7 +3361,7 @@ SPL_METHOD(AppendIterator, getIteratorIndex)
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
 	APPENDIT_CHECK_CTOR(intern);
-	spl_array_iterator_key(intern->u.append.zarrayit, return_value TSRMLS_CC);
+	spl_array_iterator_key(&intern->u.append.zarrayit, return_value TSRMLS_CC);
 } /* }}} */
 
 /* {{{ proto ArrayIterator AppendIterator::getArrayIterator()
@@ -3407,7 +3376,7 @@ SPL_METHOD(AppendIterator, getArrayIterator)
 
 	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
 
-	RETURN_ZVAL(intern->u.append.zarrayit, 1, 0);
+	RETURN_ZVAL(&intern->u.append.zarrayit, 1, 0);
 } /* }}} */
 
 ZEND_BEGIN_ARG_INFO(arginfo_append_it_append, 0) 
@@ -3463,7 +3432,7 @@ PHPAPI int spl_iterator_apply(zval *obj, spl_iterator_apply_func_t apply_func, v
 
 done:
 	if (iter) {
-		iter->funcs->dtor(iter TSRMLS_CC);
+		zend_iterator_dtor(iter TSRMLS_CC);
 	}
 	return EG(exception) ? FAILURE : SUCCESS;
 }
@@ -3471,13 +3440,13 @@ done:
 
 static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
 {
-	zval **data, *return_value = (zval*)puser;
+	zval *data, *return_value = (zval*)puser;
 
-	iter->funcs->get_current_data(iter, &data TSRMLS_CC);
+	data = iter->funcs->get_current_data(iter TSRMLS_CC);
 	if (EG(exception)) {
 		return ZEND_HASH_APPLY_STOP;
 	}
-	if (data == NULL || *data == NULL) {
+	if (data == NULL) {
 		return ZEND_HASH_APPLY_STOP;
 	}
 	if (iter->funcs->get_current_key) {
@@ -3486,11 +3455,11 @@ static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser T
 		if (EG(exception)) {
 			return ZEND_HASH_APPLY_STOP;
 		}
-		array_set_zval_key(Z_ARRVAL_P(return_value), &key, *data);
+		array_set_zval_key(Z_ARRVAL_P(return_value), &key, data TSRMLS_CC);
 		zval_dtor(&key);
 	} else {
-		Z_ADDREF_PP(data);
-		add_next_index_zval(return_value, *data);
+		Z_ADDREF_P(data);
+		add_next_index_zval(return_value, data);
 	}
 	return ZEND_HASH_APPLY_KEEP;
 }
@@ -3498,17 +3467,19 @@ static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser T
 
 static int spl_iterator_to_values_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
 {
-	zval **data, *return_value = (zval*)puser;
+	zval *data, *return_value = (zval*)puser;
 
-	iter->funcs->get_current_data(iter, &data TSRMLS_CC);
+	data = iter->funcs->get_current_data(iter TSRMLS_CC);
 	if (EG(exception)) {
 		return ZEND_HASH_APPLY_STOP;
 	}
-	if (data == NULL || *data == NULL) {
+	if (data == NULL) {
 		return ZEND_HASH_APPLY_STOP;
 	}
-	Z_ADDREF_PP(data);
-	add_next_index_zval(return_value, *data);
+	if (Z_REFCOUNTED_P(data)) {
+		Z_ADDREF_P(data);
+	}
+	add_next_index_zval(return_value, data);
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
@@ -3566,14 +3537,14 @@ typedef struct {
 
 static int spl_iterator_func_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
 {
-	zval *retval;
+	zval retval;
 	spl_iterator_apply_info  *apply_info = (spl_iterator_apply_info*)puser;
 	int result;
 
 	apply_info->count++;
 	zend_fcall_info_call(&apply_info->fci, &apply_info->fcc, &retval, NULL TSRMLS_CC);
-	if (retval) {
-		result = zend_is_true(retval TSRMLS_CC) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_STOP;
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		result = zend_is_true(&retval TSRMLS_CC) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_STOP;
 		zval_ptr_dtor(&retval);
 	} else {
 		result = ZEND_HASH_APPLY_STOP;
@@ -3625,13 +3596,19 @@ PHP_MINIT_FUNCTION(spl_iterators)
 	REGISTER_SPL_ITERATOR(RecursiveIteratorIterator);
 
 	memcpy(&spl_handlers_rec_it_it, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	spl_handlers_rec_it_it.offset = XtOffsetOf(spl_recursive_it_object, std);
 	spl_handlers_rec_it_it.get_method = spl_recursive_it_get_method;
 	spl_handlers_rec_it_it.clone_obj = NULL;
+	spl_handlers_rec_it_it.dtor_obj = spl_RecursiveIteratorIterator_dtor;
+	spl_handlers_rec_it_it.free_obj = spl_RecursiveIteratorIterator_free_storage;
 
 	memcpy(&spl_handlers_dual_it, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
+	spl_handlers_dual_it.offset = XtOffsetOf(spl_dual_it_object, std);
 	spl_handlers_dual_it.get_method = spl_dual_it_get_method;
 	/*spl_handlers_dual_it.call_method = spl_dual_it_call_method;*/
 	spl_handlers_dual_it.clone_obj = NULL;
+	spl_handlers_dual_it.dtor_obj = spl_dual_it_dtor;
+	spl_handlers_dual_it.free_obj = spl_dual_it_free_storage;
 	
 	spl_ce_RecursiveIteratorIterator->get_iterator = spl_recursive_it_get_iterator;
 	spl_ce_RecursiveIteratorIterator->iterator_funcs.funcs = &spl_recursive_it_iterator_funcs;
diff --git a/ext/spl/spl_iterators.h b/ext/spl/spl_iterators.h
index 3991ddad33..f51fc3a990 100644
--- a/ext/spl/spl_iterators.h
+++ b/ext/spl/spl_iterators.h
@@ -121,19 +121,19 @@ typedef enum {
 typedef struct _spl_cbfilter_it_intern {
 	zend_fcall_info       fci;
 	zend_fcall_info_cache fcc;
+	zend_object           *object;
 } _spl_cbfilter_it_intern;
 
 typedef struct _spl_dual_it_object {
-	zend_object              std;
 	struct {
-		zval                 *zobject;
+		zval                 zobject;
 		zend_class_entry     *ce;
 		zend_object          *object;
 		zend_object_iterator *iterator;
 	} inner;
 	struct {
-		zval                 *data;
-		zval                 *key;
+		zval                 data;
+		zval                 key;
 		int                  pos;
 	} current;
 	dual_it_type             dit_type;
@@ -144,12 +144,12 @@ typedef struct _spl_dual_it_object {
 		} limit;
 		struct {
 			long             flags; /* CIT_* */
-			zval             *zstr;
-			zval             *zchildren;
-			zval             *zcache;
+			zval             zstr;
+			zval             zchildren;
+			zval             zcache;
 		} caching;
 		struct {
-			zval                 *zarrayit;
+			zval                  zarrayit;
 			zend_object_iterator *iterator;
 		} append;
 #if HAVE_PCRE || HAVE_BUNDLED_PCRE
@@ -159,14 +159,20 @@ typedef struct _spl_dual_it_object {
 			regex_mode       mode;
 			long             preg_flags;
 			pcre_cache_entry *pce;
-			char             *regex;
-			uint             regex_len;
+			zend_string      *regex;
 		} regex;
 #endif
 		_spl_cbfilter_it_intern *cbfilter;
 	} u;
+	zend_object              std;
 } spl_dual_it_object;
 
+static inline spl_dual_it_object *spl_dual_it_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_dual_it_object*)((char*)(obj) - XtOffsetOf(spl_dual_it_object, std));
+} /* }}} */
+
+#define Z_SPLDUAL_IT_P(zv)  spl_dual_it_from_obj(Z_OBJ_P((zv)))
+
 typedef int (*spl_iterator_apply_func_t)(zend_object_iterator *iter, void *puser TSRMLS_DC);
 
 PHPAPI int spl_iterator_apply(zval *obj, spl_iterator_apply_func_t apply_func, void *puser TSRMLS_DC);
diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c
index 91830ab000..4ddd86773e 100644
--- a/ext/spl/spl_observer.c
+++ b/ext/spl/spl_observer.c
@@ -80,24 +80,31 @@ PHPAPI zend_class_entry     *spl_ce_MultipleIterator;
 PHPAPI zend_object_handlers spl_handler_SplObjectStorage;
 
 typedef struct _spl_SplObjectStorage { /* {{{ */
-	zend_object       std;
 	HashTable         storage;
 	long              index;
 	HashPosition      pos;
 	long              flags;
 	zend_function    *fptr_get_hash;
 	HashTable        *debug_info;
+	zend_object       std;
 } spl_SplObjectStorage; /* }}} */
 
 /* {{{ storage is an assoc aray of [zend_object_value]=>[zval *obj, zval *inf] */
 typedef struct _spl_SplObjectStorageElement {
-	zval* obj;
-	zval* inf;
+	zval obj;
+	zval inf;
 } spl_SplObjectStorageElement; /* }}} */
 
-void spl_SplOjectStorage_free_storage(void *object TSRMLS_DC) /* {{{ */
+static inline spl_SplObjectStorage *spl_object_storage_from_obj(zend_object *obj) /* {{{ */ {
+	return (spl_SplObjectStorage*)((char*)(obj) - XtOffsetOf(spl_SplObjectStorage, std));
+}
+/* }}} */
+
+#define Z_SPLOBJSTORAGE_P(zv)  spl_object_storage_from_obj(Z_OBJ_P((zv)))
+
+void spl_SplObjectStorage_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage *)object;
+	spl_SplObjectStorage *intern = spl_object_storage_from_obj(object);
 
 	zend_object_std_dtor(&intern->std TSRMLS_CC);
 	
@@ -107,26 +114,15 @@ void spl_SplOjectStorage_free_storage(void *object TSRMLS_DC) /* {{{ */
 		zend_hash_destroy(intern->debug_info);
 		efree(intern->debug_info);
 	}
-
-	efree(object);
 } /* }}} */
 
-static char *spl_object_storage_get_hash(spl_SplObjectStorage *intern, zval *this,  zval *obj, int *hash_len_ptr TSRMLS_DC) {
+static zend_string *spl_object_storage_get_hash(spl_SplObjectStorage *intern, zval *this, zval *obj TSRMLS_DC) {
 	if (intern->fptr_get_hash) {
-		zval *rv;
-		zend_call_method_with_1_params(&this, intern->std.ce, &intern->fptr_get_hash, "getHash", &rv, obj);
-		if (rv) {
-			if (Z_TYPE_P(rv) == IS_STRING) {
-				int hash_len = Z_STRLEN_P(rv);
-				char *hash = emalloc((hash_len+1)*sizeof(char));
-				strncpy(hash, Z_STRVAL_P(rv), hash_len);
-				hash[hash_len] = 0;
-
-				zval_ptr_dtor(&rv);
-				if (hash_len_ptr) {
-					*hash_len_ptr = hash_len;
-				}
-				return hash;
+		zval rv;
+		zend_call_method_with_1_params(this, intern->std.ce, &intern->fptr_get_hash, "getHash", &rv, obj);
+		if (!ZVAL_IS_UNDEF(&rv)) {
+			if (Z_TYPE(rv) == IS_STRING) {
+				return Z_STR(rv);
 			} else {
 				zend_throw_exception(spl_ce_RuntimeException, "Hash needs to be a string", 0 TSRMLS_CC);
 
@@ -137,6 +133,11 @@ static char *spl_object_storage_get_hash(spl_SplObjectStorage *intern, zval *thi
 			return NULL;
 		}
 	} else {
+		zend_string *hash = STR_ALLOC(sizeof(zend_object*), 0);
+		memcpy(hash->val, (void*)&Z_OBJ_P(obj), sizeof(zend_object*));
+		hash->val[hash->len] = '\0';
+		return hash;
+		/* !!! FIXME
 		int hash_len = sizeof(zend_object_value);
 
 #if HAVE_PACKED_OBJECT_VALUE
@@ -163,75 +164,78 @@ static char *spl_object_storage_get_hash(spl_SplObjectStorage *intern, zval *thi
 
 		return hash;
 #endif
+*/
+		return NULL;
 	}
 }
 
-static void spl_object_storage_free_hash(spl_SplObjectStorage *intern, char *hash) {
+static void spl_object_storage_free_hash(spl_SplObjectStorage *intern, zend_string *hash) {
+	STR_RELEASE(hash);
+/*
 	if (intern->fptr_get_hash) {
-		efree(hash);
 	} else {
 #if HAVE_PACKED_OBJECT_VALUE
-		/* Nothing to do */
 #else
 		efree(hash);
 #endif
 	}
+*/
 }
 
-static void spl_object_storage_dtor(spl_SplObjectStorageElement *element) /* {{{ */
+static void spl_object_storage_dtor(zval *element) /* {{{ */
 {
-	zval_ptr_dtor(&element->obj);
-	zval_ptr_dtor(&element->inf);
+	spl_SplObjectStorageElement *el = Z_PTR_P(element);
+	zval_ptr_dtor(&el->obj);
+	zval_ptr_dtor(&el->inf);
+	efree(el);
 } /* }}} */
 
-spl_SplObjectStorageElement* spl_object_storage_get(spl_SplObjectStorage *intern, char *hash, int hash_len TSRMLS_DC) /* {{{ */
+spl_SplObjectStorageElement* spl_object_storage_get(spl_SplObjectStorage *intern, zend_string *hash TSRMLS_DC) /* {{{ */
 {
-	spl_SplObjectStorageElement *element;
-	if (zend_hash_find(&intern->storage, hash, hash_len, (void**)&element) == SUCCESS) {
-		return element;
-	} else {
-		return NULL;
-	}
+	return (spl_SplObjectStorageElement*)zend_hash_find_ptr(&intern->storage, hash);
 } /* }}} */
 
-void spl_object_storage_attach(spl_SplObjectStorage *intern, zval *this, zval *obj, zval *inf TSRMLS_DC) /* {{{ */
+spl_SplObjectStorageElement *spl_object_storage_attach(spl_SplObjectStorage *intern, zval *this, zval *obj, zval *inf TSRMLS_DC) /* {{{ */
 {
 	spl_SplObjectStorageElement *pelement, element;
-	
-	int hash_len;
-	char *hash = spl_object_storage_get_hash(intern, this, obj, &hash_len TSRMLS_CC);
+	zend_string *hash = spl_object_storage_get_hash(intern, this, obj TSRMLS_CC);
+
 	if (!hash) {
-		return;
+		return NULL;
 	}
 
-	pelement = spl_object_storage_get(intern, hash, hash_len TSRMLS_CC);
+	pelement = spl_object_storage_get(intern, hash TSRMLS_CC);
 
-	if (inf) {
-		Z_ADDREF_P(inf);
-	} else {
-		ALLOC_INIT_ZVAL(inf);
-	}
 	if (pelement) {
 		zval_ptr_dtor(&pelement->inf);
-		pelement->inf = inf;
+		if (inf) {
+			ZVAL_COPY(&pelement->inf, inf);
+		} else {
+			ZVAL_NULL(&pelement->inf);
+		}
 		spl_object_storage_free_hash(intern, hash);
-		return;
+		return pelement;
 	}
-	Z_ADDREF_P(obj);
-	element.obj = obj;
-	element.inf = inf;
-	zend_hash_update(&intern->storage, hash, hash_len, &element, sizeof(spl_SplObjectStorageElement), NULL);
+
+	ZVAL_COPY(&element.obj, obj);
+	if (inf) {
+		ZVAL_COPY(&element.inf, inf);
+	} else {
+		ZVAL_NULL(&element.inf);
+	}
+	pelement = zend_hash_update_mem(&intern->storage, hash, &element, sizeof(spl_SplObjectStorageElement));
 	spl_object_storage_free_hash(intern, hash);
+	return pelement;
 } /* }}} */
 
 int spl_object_storage_detach(spl_SplObjectStorage *intern, zval *this, zval *obj TSRMLS_DC) /* {{{ */
 {
-	int hash_len, ret = FAILURE;
-	char *hash = spl_object_storage_get_hash(intern, this, obj, &hash_len TSRMLS_CC);
+	int ret = FAILURE;
+	zend_string *hash = spl_object_storage_get_hash(intern, this, obj TSRMLS_CC);
 	if (!hash) {
 		return ret;
 	}
-	ret = zend_hash_del(&intern->storage, hash, hash_len);
+	ret = zend_hash_del(&intern->storage, hash);
 	spl_object_storage_free_hash(intern, hash);
 	
 	return ret;
@@ -242,8 +246,8 @@ void spl_object_storage_addall(spl_SplObjectStorage *intern, zval *this, spl_Spl
 	spl_SplObjectStorageElement *element;
 
 	zend_hash_internal_pointer_reset_ex(&other->storage, &pos);
-	while (zend_hash_get_current_data_ex(&other->storage, (void **)&element, &pos) == SUCCESS) {
-		spl_object_storage_attach(intern, this, element->obj, element->inf TSRMLS_CC);
+	while ((element = zend_hash_get_current_data_ptr_ex(&other->storage, &pos)) != NULL) {
+		spl_object_storage_attach(intern, this, &element->obj, &element->inf TSRMLS_CC);
 		zend_hash_move_forward_ex(&other->storage, &pos);
 	}
 
@@ -251,33 +255,31 @@ void spl_object_storage_addall(spl_SplObjectStorage *intern, zval *this, spl_Spl
 	intern->index = 0;
 } /* }}} */
 
-static zend_object_value spl_object_storage_new_ex(zend_class_entry *class_type, spl_SplObjectStorage **obj, zval *orig TSRMLS_DC) /* {{{ */
+static zend_object *spl_object_storage_new_ex(zend_class_entry *class_type, zval *orig TSRMLS_DC) /* {{{ */
 {
-	zend_object_value     retval;
 	spl_SplObjectStorage *intern;
-	zend_class_entry     *parent = class_type;
+	zend_class_entry *parent = class_type;
 
-	intern = emalloc(sizeof(spl_SplObjectStorage));
-	memset(intern, 0, sizeof(spl_SplObjectStorage));
-	*obj = intern;
+	intern = emalloc(sizeof(spl_SplObjectStorage) + sizeof(zval) * (parent->default_properties_count - 1));
+	memset(intern, 0, sizeof(spl_SplObjectStorage) - sizeof(zval));
+	intern->pos = INVALID_IDX;
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
 
-	zend_hash_init(&intern->storage, 0, NULL, (void (*)(void *))spl_object_storage_dtor, 0);
+	zend_hash_init(&intern->storage, 0, NULL, spl_object_storage_dtor, 0);
 
-	retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) spl_SplOjectStorage_free_storage, NULL TSRMLS_CC);
-	retval.handlers = &spl_handler_SplObjectStorage;
+	intern->std.handlers = &spl_handler_SplObjectStorage;
 
 	if (orig) {
-		spl_SplObjectStorage *other = (spl_SplObjectStorage*)zend_object_store_get_object(orig TSRMLS_CC);
+		spl_SplObjectStorage *other = Z_SPLOBJSTORAGE_P(orig);
 		spl_object_storage_addall(intern, orig, other TSRMLS_CC);
 	}
 
 	while (parent) {
 		if (parent == spl_ce_SplObjectStorage) {
 			if (class_type != spl_ce_SplObjectStorage) {
-				zend_hash_find(&class_type->function_table, "gethash",    sizeof("gethash"),    (void **) &intern->fptr_get_hash);
+				intern->fptr_get_hash = zend_hash_str_find_ptr(&class_type->function_table, "gethash", sizeof("gethash") - 1);
 				if (intern->fptr_get_hash->common.scope == spl_ce_SplObjectStorage) {
 					intern->fptr_get_hash = NULL;
 				}
@@ -288,73 +290,66 @@ static zend_object_value spl_object_storage_new_ex(zend_class_entry *class_type,
 		parent = parent->parent;
 	}
 
-	return retval;
+	return &intern->std;
 }
 /* }}} */
 
 /* {{{ spl_object_storage_clone */
-static zend_object_value spl_object_storage_clone(zval *zobject TSRMLS_DC)
+static zend_object *spl_object_storage_clone(zval *zobject TSRMLS_DC)
 {
-	zend_object_value new_obj_val;
 	zend_object *old_object;
 	zend_object *new_object;
-	zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
-	spl_SplObjectStorage *intern;
 
-	old_object = zend_objects_get_address(zobject TSRMLS_CC);
-	new_obj_val = spl_object_storage_new_ex(old_object->ce, &intern, zobject TSRMLS_CC);
-	new_object = &intern->std;
+	old_object = Z_OBJ_P(zobject);
+	new_object = spl_object_storage_new_ex(old_object->ce, zobject TSRMLS_CC);
 
-	zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
+	zend_objects_clone_members(new_object, old_object TSRMLS_CC);
 
-	return new_obj_val;
+	return new_object;
 }
 /* }}} */
 
 static HashTable* spl_object_storage_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(obj TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(obj);
 	spl_SplObjectStorageElement *element;
 	HashTable *props;
 	HashPosition pos;
-	zval *tmp, *storage;
+	zval tmp, storage;
 	char md5str[33];
-	int name_len;
-	char *zname;
+	zend_string *zname;
 
 	*is_temp = 0;
 
 	props = Z_OBJPROP_P(obj);
-	zend_hash_del(props, "\x00gcdata", sizeof("\x00gcdata"));
+	zend_hash_str_del(props, "\x00gcdata", sizeof("\x00gcdata") - 1);
 
 	if (intern->debug_info == NULL) {
 		ALLOC_HASHTABLE(intern->debug_info);
 		ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(props) + 1, 0);
 	}
 
-	if (intern->debug_info->nApplyCount == 0) {
-		zend_hash_copy(intern->debug_info, props, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
+	if (intern->debug_info->u.v.nApplyCount == 0) {
+		zend_hash_copy(intern->debug_info, props, (copy_ctor_func_t)zval_add_ref);
 
-		MAKE_STD_ZVAL(storage);
-		array_init(storage);
+		array_init(&storage);
 
 		zend_hash_internal_pointer_reset_ex(&intern->storage, &pos);
-		while (zend_hash_get_current_data_ex(&intern->storage, (void **)&element, &pos) == SUCCESS) {
-				php_spl_object_hash(element->obj, md5str TSRMLS_CC);
-				MAKE_STD_ZVAL(tmp);
-				array_init(tmp);
+		while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &pos)) != NULL) {
+				php_spl_object_hash(&element->obj, md5str TSRMLS_CC);
+				array_init(&tmp);
 				/* Incrementing the refcount of obj and inf would confuse the garbage collector.
 				 * Prefer to null the destructor */
-				Z_ARRVAL_P(tmp)->pDestructor = NULL;
-				add_assoc_zval_ex(tmp, "obj", sizeof("obj"), element->obj);
-				add_assoc_zval_ex(tmp, "inf", sizeof("inf"), element->inf);
-				add_assoc_zval_ex(storage, md5str, 33, tmp);
+				Z_ARRVAL_P(&tmp)->pDestructor = NULL;
+				add_assoc_zval_ex(&tmp, "obj", sizeof("obj") - 1, &element->obj);
+				add_assoc_zval_ex(&tmp, "inf", sizeof("inf") - 1, &element->inf);
+				add_assoc_zval_ex(&storage, md5str, 32, &tmp);
 				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_update(intern->debug_info, zname, name_len+1, &storage, sizeof(zval *), NULL);
-		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;
@@ -363,14 +358,13 @@ static HashTable* spl_object_storage_debug_info(zval *obj, int *is_temp TSRMLS_D
 
 /* overriden for garbage collection
  * This is very hacky */
-static HashTable *spl_object_storage_get_gc(zval *obj, zval ***table, int *n TSRMLS_DC) /* {{{ */
+static HashTable *spl_object_storage_get_gc(zval *obj, zval **table, int *n TSRMLS_DC) /* {{{ */
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(obj TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(obj);
 	spl_SplObjectStorageElement *element;
 	HashTable *props;
 	HashPosition pos;
-	zval *gcdata_arr = NULL,
-		 **gcdata_arr_pp;
+	zval *gcdata_arr, tmp;
 
 	props = std_object_handlers.get_properties(obj TSRMLS_CC);
 	
@@ -378,25 +372,24 @@ static HashTable *spl_object_storage_get_gc(zval *obj, zval ***table, int *n TSR
 	*n = 0;
 
 	/* clean \x00gcdata, as it may be out of date */
-	if (zend_hash_find(props, "\x00gcdata", sizeof("\x00gcdata"), (void**) &gcdata_arr_pp) == SUCCESS) {
-		gcdata_arr = *gcdata_arr_pp;
+	if ((gcdata_arr = zend_hash_str_find(props, "\x00gcdata", sizeof("\x00gcdata") - 1)) != NULL) {
 		zend_hash_clean(Z_ARRVAL_P(gcdata_arr));
 	}
 
 	if (gcdata_arr == NULL) {
-		MAKE_STD_ZVAL(gcdata_arr);
-		array_init(gcdata_arr);
+		array_init(&tmp);
 		/* don't decrease refcount of members when destroying */
-		Z_ARRVAL_P(gcdata_arr)->pDestructor = NULL;
+		Z_ARRVAL_P(&tmp)->pDestructor = NULL;
 
 		/* name starts with \x00 to make tampering in user-land more difficult */
-		zend_hash_add(props, "\x00gcdata", sizeof("\x00gcdata"), &gcdata_arr, sizeof(gcdata_arr), NULL);
+		zend_hash_str_add(props, "\x00gcdata", sizeof("\x00gcdata") - 1, &tmp);
+		gcdata_arr = &tmp;
 	}
 
 	zend_hash_internal_pointer_reset_ex(&intern->storage, &pos);
-	while (zend_hash_get_current_data_ex(&intern->storage, (void **)&element, &pos) == SUCCESS) {
-		add_next_index_zval(gcdata_arr, element->obj);
-		add_next_index_zval(gcdata_arr, element->inf);
+	while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &pos)) != NULL) {
+		add_next_index_zval(gcdata_arr, &element->obj);
+		add_next_index_zval(gcdata_arr, &element->inf);
 		zend_hash_move_forward_ex(&intern->storage, &pos);
 	}
 
@@ -404,11 +397,13 @@ static HashTable *spl_object_storage_get_gc(zval *obj, zval ***table, int *n TSR
 }
 /* }}} */
 
-static int spl_object_storage_compare_info(spl_SplObjectStorageElement *e1, spl_SplObjectStorageElement *e2 TSRMLS_DC) /* {{{ */
+static int spl_object_storage_compare_info(zval *e1, zval *e2 TSRMLS_DC) /* {{{ */
 {
+	spl_SplObjectStorageElement *s1 = (spl_SplObjectStorageElement*)Z_PTR_P(e1);
+	spl_SplObjectStorageElement *s2 = (spl_SplObjectStorageElement*)Z_PTR_P(e2);
 	zval result;
 
-	if (compare_function(&result, e1->inf, e2->inf TSRMLS_CC) == FAILURE) {
+	if (compare_function(&result, &s1->inf, &s2->inf TSRMLS_CC) == FAILURE) {
 		return 1;
 	}
 
@@ -418,34 +413,33 @@ static int spl_object_storage_compare_info(spl_SplObjectStorageElement *e1, spl_
 
 static int spl_object_storage_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
 {
-	zend_object *zo1 = (zend_object *)zend_object_store_get_object(o1 TSRMLS_CC);
-	zend_object *zo2 = (zend_object *)zend_object_store_get_object(o2 TSRMLS_CC);
+	zend_object *zo1 = (zend_object *)Z_OBJ_P(o1);
+	zend_object *zo2 = (zend_object *)Z_OBJ_P(o2);
 
 	if (zo1->ce != spl_ce_SplObjectStorage || zo2->ce != spl_ce_SplObjectStorage) {
 		return 1;
 	}
 
-	return zend_hash_compare(&((spl_SplObjectStorage *)zo1)->storage, &((spl_SplObjectStorage *)zo2)->storage, (compare_func_t) spl_object_storage_compare_info, 0 TSRMLS_CC);
+	return zend_hash_compare(&(Z_SPLOBJSTORAGE_P(o1))->storage, &(Z_SPLOBJSTORAGE_P(o2))->storage, (compare_func_t)spl_object_storage_compare_info, 0 TSRMLS_CC);
 }
 /* }}} */
 
 /* {{{ spl_array_object_new */
-static zend_object_value spl_SplObjectStorage_new(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *spl_SplObjectStorage_new(zend_class_entry *class_type TSRMLS_DC)
 {
-	spl_SplObjectStorage *tmp;
-	return spl_object_storage_new_ex(class_type, &tmp, NULL TSRMLS_CC);
+	return spl_object_storage_new_ex(class_type, NULL TSRMLS_CC);
 }
 /* }}} */
 
 int spl_object_storage_contains(spl_SplObjectStorage *intern, zval *this, zval *obj TSRMLS_DC) /* {{{ */
 {
-	int hash_len, found;
-	char *hash = spl_object_storage_get_hash(intern, this, obj, &hash_len TSRMLS_CC);
+	int found;
+	zend_string *hash = spl_object_storage_get_hash(intern, this, obj TSRMLS_CC);
 	if (!hash) {
 		return 0;
 	}
 
-	found = zend_hash_exists(&intern->storage, hash, hash_len);
+	found = zend_hash_exists(&intern->storage, hash);
 	spl_object_storage_free_hash(intern, hash);
 	return found;
 } /* }}} */
@@ -456,7 +450,7 @@ SPL_METHOD(SplObjectStorage, attach)
 {
 	zval *obj, *inf = NULL;
 
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|z!", &obj, &inf) == FAILURE) {
 		return;
@@ -469,7 +463,7 @@ SPL_METHOD(SplObjectStorage, attach)
 SPL_METHOD(SplObjectStorage, detach)
 {
 	zval *obj;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
 		return;
@@ -494,7 +488,7 @@ SPL_METHOD(SplObjectStorage, getHash)
 	hash = emalloc(33);
 	php_spl_object_hash(obj, hash TSRMLS_CC);
 	
-	RETVAL_STRING(hash, 0);
+	RETVAL_STRING(hash);
 
 } /* }}} */
 
@@ -504,26 +498,25 @@ SPL_METHOD(SplObjectStorage, offsetGet)
 {
 	zval *obj;
 	spl_SplObjectStorageElement *element;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
-	char *hash;
-	int hash_len;
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
+	zend_string *hash;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
 		return;
 	}
 
-	hash = spl_object_storage_get_hash(intern, getThis(), obj, &hash_len TSRMLS_CC);
+	hash = spl_object_storage_get_hash(intern, getThis(), obj TSRMLS_CC);
 	if (!hash) {
 		return;
 	}
 
-	element = spl_object_storage_get(intern, hash, hash_len TSRMLS_CC);
+	element = spl_object_storage_get(intern, hash TSRMLS_CC);
 	spl_object_storage_free_hash(intern, hash);
 
 	if (!element) {
 		zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Object not found");
 	} else {
-		RETURN_ZVAL(element->inf,1, 0);
+		RETURN_ZVAL(&element->inf, 1, 0);
 	}
 } /* }}} */
 
@@ -532,16 +525,16 @@ SPL_METHOD(SplObjectStorage, offsetGet)
 SPL_METHOD(SplObjectStorage, addAll)
 {
 	zval *obj;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	spl_SplObjectStorage *other;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
 		return;
 	}
 
-	other = (spl_SplObjectStorage *)zend_object_store_get_object(obj TSRMLS_CC);
+	other = Z_SPLOBJSTORAGE_P(obj);
 
-	spl_object_storage_addall(intern, getThis(),  other TSRMLS_CC);
+	spl_object_storage_addall(intern, getThis(), other TSRMLS_CC);
 
 	RETURN_LONG(zend_hash_num_elements(&intern->storage));
 } /* }}} */
@@ -551,7 +544,7 @@ SPL_METHOD(SplObjectStorage, addAll)
 SPL_METHOD(SplObjectStorage, removeAll)
 {
 	zval *obj;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	spl_SplObjectStorage *other;
 	spl_SplObjectStorageElement *element;
 
@@ -559,11 +552,11 @@ SPL_METHOD(SplObjectStorage, removeAll)
 		return;
 	}
 
-	other = (spl_SplObjectStorage *)zend_object_store_get_object(obj TSRMLS_CC);
+	other = Z_SPLOBJSTORAGE_P(obj);
 
 	zend_hash_internal_pointer_reset(&other->storage);
-	while (zend_hash_get_current_data(&other->storage, (void **)&element) == SUCCESS) {
-		if (spl_object_storage_detach(intern, getThis(), element->obj TSRMLS_CC) == FAILURE) {
+	while ((element = zend_hash_get_current_data_ptr(&other->storage)) != NULL) {
+		if (spl_object_storage_detach(intern, getThis(), &element->obj TSRMLS_CC) == FAILURE) {
 			zend_hash_move_forward(&other->storage);
 		}
 	}
@@ -579,7 +572,7 @@ SPL_METHOD(SplObjectStorage, removeAll)
 SPL_METHOD(SplObjectStorage, removeAllExcept)
 {
 	zval *obj;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage *)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	spl_SplObjectStorage *other;
 	spl_SplObjectStorageElement *element;
 
@@ -587,12 +580,12 @@ SPL_METHOD(SplObjectStorage, removeAllExcept)
 		return;
 	}
 
-	other = (spl_SplObjectStorage *)zend_object_store_get_object(obj TSRMLS_CC);
+	other = Z_SPLOBJSTORAGE_P(obj);
 
 	zend_hash_internal_pointer_reset(&intern->storage);
-	while (zend_hash_get_current_data(&intern->storage, (void **)&element) == SUCCESS) {
-		if (!spl_object_storage_contains(other, getThis(), element->obj TSRMLS_CC)) {
-			spl_object_storage_detach(intern, getThis(), element->obj TSRMLS_CC);
+	while ((element = zend_hash_get_current_data_ptr(&intern->storage)) != NULL) {
+		if (!spl_object_storage_contains(other, getThis(), &element->obj TSRMLS_CC)) {
+			spl_object_storage_detach(intern, getThis(), &element->obj TSRMLS_CC);
 		}
 		zend_hash_move_forward(&intern->storage);
 	}
@@ -609,7 +602,7 @@ SPL_METHOD(SplObjectStorage, removeAllExcept)
 SPL_METHOD(SplObjectStorage, contains)
 {
 	zval *obj;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
 		return;
@@ -621,7 +614,7 @@ SPL_METHOD(SplObjectStorage, contains)
  Determine number of objects in storage */
 SPL_METHOD(SplObjectStorage, count)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	long mode = COUNT_NORMAL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &mode) == FAILURE) {
@@ -630,14 +623,11 @@ SPL_METHOD(SplObjectStorage, count)
 
 	if (mode == COUNT_RECURSIVE) {
 		long ret = zend_hash_num_elements(&intern->storage);
-		HashPosition position;
 		zval *element;
 
-		for (zend_hash_internal_pointer_reset_ex(&intern->storage, &position);
-		     zend_hash_get_current_data_ex(&intern->storage, (void**) &element, &position) == SUCCESS;
-		     zend_hash_move_forward_ex(&intern->storage, &position)) {
+		ZEND_HASH_FOREACH_VAL(&intern->storage, element) {
 			ret += php_count_recursive(element, mode TSRMLS_CC);
-		}
+		} ZEND_HASH_FOREACH_END();
 
 		RETURN_LONG(ret);
 		return;
@@ -650,7 +640,7 @@ SPL_METHOD(SplObjectStorage, count)
  Rewind to first position */
 SPL_METHOD(SplObjectStorage, rewind)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -664,7 +654,7 @@ SPL_METHOD(SplObjectStorage, rewind)
  Returns whether current position is valid */
 SPL_METHOD(SplObjectStorage, valid)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -677,7 +667,7 @@ SPL_METHOD(SplObjectStorage, valid)
  Returns current key */
 SPL_METHOD(SplObjectStorage, key)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -691,16 +681,16 @@ SPL_METHOD(SplObjectStorage, key)
 SPL_METHOD(SplObjectStorage, current)
 {
 	spl_SplObjectStorageElement *element;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 	
-	if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == FAILURE) {
+	if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) == NULL) {
 		return;
 	}
-	RETVAL_ZVAL(element->obj, 1, 0);
+	RETVAL_ZVAL(&element->obj, 1, 0);
 } /* }}} */
 
 /* {{{ proto mixed SplObjectStorage::getInfo()
@@ -708,16 +698,16 @@ SPL_METHOD(SplObjectStorage, current)
 SPL_METHOD(SplObjectStorage, getInfo)
 {
 	spl_SplObjectStorageElement *element;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 	
-	if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == FAILURE) {
+	if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) == NULL) {
 		return;
 	}
-	RETVAL_ZVAL(element->inf, 1, 0);
+	RETVAL_ZVAL(&element->inf, 1, 0);
 } /* }}} */
 
 /* {{{ proto mixed SplObjectStorage::setInfo(mixed $inf)
@@ -725,26 +715,25 @@ SPL_METHOD(SplObjectStorage, getInfo)
 SPL_METHOD(SplObjectStorage, setInfo)
 {
 	spl_SplObjectStorageElement *element;
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	zval *inf;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &inf) == FAILURE) {
 		return;
 	}
 
-	if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == FAILURE) {
+	if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) == NULL) {
 		return;
 	}
 	zval_ptr_dtor(&element->inf);
-	element->inf = inf;
-	Z_ADDREF_P(inf);
+	ZVAL_ZVAL(&element->inf, inf, 1, 0);
 } /* }}} */
 
 /* {{{ proto void SplObjectStorage::next()
  Moves position forward */
 SPL_METHOD(SplObjectStorage, next)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -758,10 +747,10 @@ SPL_METHOD(SplObjectStorage, next)
  Serializes storage */
 SPL_METHOD(SplObjectStorage, serialize)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	spl_SplObjectStorageElement *element;
-	zval members, *pmembers, *flags;
+	zval members, flags;
 	HashPosition      pos;
 	php_serialize_data_t var_hash;
 	smart_str buf = {0};
@@ -774,15 +763,14 @@ SPL_METHOD(SplObjectStorage, serialize)
 	
 	/* storage */
 	smart_str_appendl(&buf, "x:", 2);
-	MAKE_STD_ZVAL(flags);
-	ZVAL_LONG(flags, zend_hash_num_elements(&intern->storage));
+	ZVAL_LONG(&flags, zend_hash_num_elements(&intern->storage));
 	php_var_serialize(&buf, &flags, &var_hash TSRMLS_CC);
 	zval_ptr_dtor(&flags);
 
 	zend_hash_internal_pointer_reset_ex(&intern->storage, &pos);
 
-	while(zend_hash_has_more_elements_ex(&intern->storage, &pos) == SUCCESS) {
-		if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &pos) == FAILURE) {
+	while (zend_hash_has_more_elements_ex(&intern->storage, &pos) == SUCCESS) {
+		if ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &pos)) == NULL) {
 			smart_str_free(&buf);
 			PHP_VAR_SERIALIZE_DESTROY(var_hash);
 			RETURN_NULL();
@@ -796,17 +784,16 @@ SPL_METHOD(SplObjectStorage, serialize)
 
 	/* members */
 	smart_str_appendl(&buf, "m:", 2);
-	INIT_PZVAL(&members);
-	Z_ARRVAL(members) = zend_std_get_properties(getThis() TSRMLS_CC);
-	Z_TYPE(members) = IS_ARRAY;
-	pmembers = &members;
-	php_var_serialize(&buf, &pmembers, &var_hash TSRMLS_CC); /* finishes the string */
+	array_init(&members);
+	zend_hash_copy(Z_ARRVAL(members), zend_std_get_properties(getThis() TSRMLS_CC), (copy_ctor_func_t) zval_add_ref);
+	php_var_serialize(&buf, &members, &var_hash TSRMLS_CC); /* finishes the string */
+	zval_ptr_dtor(&members);
 
 	/* done */
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
 
-	if (buf.c) {
-		RETURN_STRINGL(buf.c, buf.len, 0);
+	if (buf.s) {
+		RETURN_STR(buf.s);
 	} else {
 		RETURN_NULL();
 	}
@@ -817,13 +804,14 @@ SPL_METHOD(SplObjectStorage, serialize)
  Unserializes storage */
 SPL_METHOD(SplObjectStorage, unserialize)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	char *buf;
 	int buf_len;
 	const unsigned char *p, *s;
 	php_unserialize_data_t var_hash;
-	zval *pentry, *pmembers, *pcount = NULL, *pinf;
+	zval entry, pmembers, pcount, inf;
+	spl_SplObjectStorageElement *element;
 	long count;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
@@ -844,18 +832,20 @@ SPL_METHOD(SplObjectStorage, unserialize)
 	}
 	++p;
 
-	ALLOC_INIT_ZVAL(pcount);
-	if (!php_var_unserialize(&pcount, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE_P(pcount) != IS_LONG) {
+	if (!php_var_unserialize(&pcount, &p, s + buf_len, &var_hash TSRMLS_CC)) {
+		goto outexcept;
+	}
+	if (Z_TYPE(pcount) != IS_LONG) {
+		zval_ptr_dtor(&pcount);
 		goto outexcept;
 	}
 
 	--p; /* for ';' */
-	count = Z_LVAL_P(pcount);
+	count = Z_LVAL(pcount);
 		
-	while(count-- > 0) {
+	while (count-- > 0) {
 		spl_SplObjectStorageElement *pelement;
-		char *hash;
-		int hash_len;
+		zend_string *hash;
 		
 		if (*p != ';') {
 			goto outexcept;
@@ -864,43 +854,43 @@ SPL_METHOD(SplObjectStorage, unserialize)
 		if(*p != 'O' && *p != 'C' && *p != 'r') {
 			goto outexcept;
 		}
-		ALLOC_INIT_ZVAL(pentry);
-		if (!php_var_unserialize(&pentry, &p, s + buf_len, &var_hash TSRMLS_CC)) {
-			zval_ptr_dtor(&pentry);
+		/* sore reference to allow cross-references between different elements */
+		if (!php_var_unserialize(&entry, &p, s + buf_len, &var_hash TSRMLS_CC)) {
 			goto outexcept;
 		}
-		if(Z_TYPE_P(pentry) != IS_OBJECT) {
-			zval_ptr_dtor(&pentry);
+		if (Z_TYPE(entry) != IS_OBJECT) {
+			zval_ptr_dtor(&entry);
 			goto outexcept;
 		}
-		ALLOC_INIT_ZVAL(pinf);
 		if (*p == ',') { /* new version has inf */
 			++p;
-			if (!php_var_unserialize(&pinf, &p, s + buf_len, &var_hash TSRMLS_CC)) {
-				zval_ptr_dtor(&pinf);
+			if (!php_var_unserialize(&inf, &p, s + buf_len, &var_hash TSRMLS_CC)) {
+				zval_ptr_dtor(&entry);
 				goto outexcept;
 			}
 		}
 
-		hash = spl_object_storage_get_hash(intern, getThis(), pentry, &hash_len TSRMLS_CC);
+		hash = spl_object_storage_get_hash(intern, getThis(), &entry TSRMLS_CC);
 		if (!hash) {
-			zval_ptr_dtor(&pentry);
-			zval_ptr_dtor(&pinf);
+			zval_ptr_dtor(&entry);
+			zval_ptr_dtor(&inf);
 			goto outexcept;
 		}
-		pelement = spl_object_storage_get(intern, hash, hash_len TSRMLS_CC);
+		pelement = spl_object_storage_get(intern, hash TSRMLS_CC);
 		spl_object_storage_free_hash(intern, hash);
-		if(pelement) {
-			if(pelement->inf) {
+		if (pelement) {
+			if (!ZVAL_IS_UNDEF(&pelement->inf)) {
 				var_push_dtor(&var_hash, &pelement->inf);
 			}
-			if(pelement->obj) {
+			if (!ZVAL_IS_UNDEF(&pelement->obj)) {
 				var_push_dtor(&var_hash, &pelement->obj);
 			}
 		} 
-		spl_object_storage_attach(intern, getThis(), pentry, pinf TSRMLS_CC);
-		zval_ptr_dtor(&pentry);
-		zval_ptr_dtor(&pinf);
+		element = spl_object_storage_attach(intern, getThis(), &entry, &inf TSRMLS_CC);
+		var_replace(&var_hash, &entry, &element->obj);
+		var_replace(&var_hash, &inf, &element->inf);
+		zval_ptr_dtor(&entry);
+		zval_ptr_dtor(&inf);
 	}
 
 	if (*p != ';') {
@@ -914,9 +904,7 @@ SPL_METHOD(SplObjectStorage, unserialize)
 	}
 	++p;
 
-	ALLOC_INIT_ZVAL(pmembers);
 	if (!php_var_unserialize(&pmembers, &p, s + buf_len, &var_hash TSRMLS_CC)) {
-		zval_ptr_dtor(&pmembers);
 		goto outexcept;
 	}
 
@@ -924,20 +912,13 @@ SPL_METHOD(SplObjectStorage, unserialize)
 	if (!intern->std.properties) {
 		rebuild_object_properties(&intern->std);
 	}
-	zend_hash_copy(intern->std.properties, Z_ARRVAL_P(pmembers), (copy_ctor_func_t) zval_add_ref, (void *) NULL, sizeof(zval *));
+	zend_hash_copy(intern->std.properties, Z_ARRVAL(pmembers), (copy_ctor_func_t) zval_add_ref);
 	zval_ptr_dtor(&pmembers);
 
-	/* done reading $serialized */
-	if (pcount) {
-		zval_ptr_dtor(&pcount);
-	}
 	PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
 	return;
 
 outexcept:
-	if (pcount) {
-		zval_ptr_dtor(&pcount);
-	}
 	PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
 	zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len);
 	return;
@@ -1026,7 +1007,7 @@ SPL_METHOD(MultipleIterator, __construct)
 		return;
 	}
 
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 	intern->flags = flags;
 	zend_restore_error_handling(&error_handling TSRMLS_CC);
 }
@@ -1036,7 +1017,7 @@ SPL_METHOD(MultipleIterator, __construct)
    Return current flags */
 SPL_METHOD(MultipleIterator, getFlags)
 {
-	spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1050,7 +1031,7 @@ SPL_METHOD(MultipleIterator, getFlags)
 SPL_METHOD(MultipleIterator, setFlags)
 {
 	spl_SplObjectStorage *intern;
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &intern->flags) == FAILURE) {
 		return;
@@ -1069,7 +1050,7 @@ SPL_METHOD(MultipleIterator, attachIterator)
 		return;
 	}
 
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 
 	if (info != NULL) {
 		spl_SplObjectStorageElement *element;
@@ -1081,8 +1062,8 @@ SPL_METHOD(MultipleIterator, attachIterator)
 		}
 
 		zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
-		while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS) {
-			is_identical_function(&compare_result, info, element->inf TSRMLS_CC);
+		while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) != NULL) {
+			is_identical_function(&compare_result, info, &element->inf TSRMLS_CC);
 			if (Z_LVAL(compare_result)) {
 				zend_throw_exception(spl_ce_InvalidArgumentException, "Key duplication error", 0 TSRMLS_CC);
 				return;
@@ -1103,16 +1084,16 @@ SPL_METHOD(MultipleIterator, rewind)
 	spl_SplObjectStorageElement *element;
 	zval                        *it;
 
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
-	while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
-		it = element->obj;
-		zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_rewind, "rewind", NULL);
+	while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) != NULL && !EG(exception)) {
+		it = &element->obj;
+		zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_rewind, "rewind", NULL);
 		zend_hash_move_forward_ex(&intern->storage, &intern->pos);
 	}
 }
@@ -1126,16 +1107,16 @@ SPL_METHOD(MultipleIterator, next)
 	spl_SplObjectStorageElement *element;
 	zval                        *it;
 
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
-	while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
-		it = element->obj;
-		zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_next, "next", NULL);
+	while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) != NULL && !EG(exception)) {
+		it = &element->obj;
+		zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_next, "next", NULL);
 		zend_hash_move_forward_ex(&intern->storage, &intern->pos);
 	}
 }
@@ -1147,10 +1128,10 @@ SPL_METHOD(MultipleIterator, valid)
 {
 	spl_SplObjectStorage        *intern;
 	spl_SplObjectStorageElement *element;
-	zval                        *it, *retval = NULL;
+	zval                        *it, retval;
 	long                         expect, valid;
 
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1163,12 +1144,12 @@ SPL_METHOD(MultipleIterator, valid)
 	expect = (intern->flags & MIT_NEED_ALL) ? 1 : 0;
 
 	zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
-	while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
-		it = element->obj;
-		zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
+	while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) != NULL && !EG(exception)) {
+		it = &element->obj;
+		zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
 
-		if (retval) {
-			valid = Z_LVAL_P(retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			valid = Z_LVAL(retval);
 			zval_ptr_dtor(&retval);
 		} else {
 			valid = 0;
@@ -1188,7 +1169,7 @@ SPL_METHOD(MultipleIterator, valid)
 static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_type, zval *return_value TSRMLS_DC) /* {{{ */
 {
 	spl_SplObjectStorageElement *element;
-	zval                        *it, *retval = NULL;
+	zval                        *it, retval;
 	int                          valid = 1, num_elements;
 
 	num_elements = zend_hash_num_elements(&intern->storage);
@@ -1199,12 +1180,12 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_
 	array_init_size(return_value, num_elements);
 	
 	zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
-	while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
-		it = element->obj;
-		zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
+	while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) != NULL && !EG(exception)) {
+		it = &element->obj;
+		zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
 
-		if (retval) {
-			valid = Z_LVAL_P(retval);
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			valid = Z_LVAL(retval);
 			zval_ptr_dtor(&retval);
 		} else {
 			valid = 0;
@@ -1212,11 +1193,11 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_
 
 		if (valid) {
 			if (SPL_MULTIPLE_ITERATOR_GET_ALL_CURRENT == get_type) {
-				zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_current, "current", &retval);
+				zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_current, "current", &retval);
 			} else {
-				zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_key,     "key",     &retval);
+				zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_key, "key", &retval);
 			}
-			if (!retval) {
+			if (ZVAL_IS_UNDEF(&retval)) {
 				zend_throw_exception(spl_ce_RuntimeException, "Failed to call sub iterator method", 0 TSRMLS_CC);
 				return;
 			}
@@ -1228,16 +1209,16 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_
 			}
 			return;
 		} else {
-			ALLOC_INIT_ZVAL(retval);
+			ZVAL_NULL(&retval);
 		}
 
 		if (intern->flags & MIT_KEYS_ASSOC) {
-			switch (Z_TYPE_P(element->inf)) {
+			switch (Z_TYPE(element->inf)) {
 				case IS_LONG:
-					add_index_zval(return_value, Z_LVAL_P(element->inf), retval);
+					add_index_zval(return_value, Z_LVAL(element->inf), &retval);
 					break;
 				case IS_STRING:
-					add_assoc_zval_ex(return_value, Z_STRVAL_P(element->inf), Z_STRLEN_P(element->inf)+1U, retval);
+					zend_hash_update(Z_ARRVAL_P(return_value), Z_STR(element->inf), &retval);
 					break;
 				default:
 					zval_ptr_dtor(&retval);
@@ -1245,7 +1226,7 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_
 					return;
 			}
 		} else {
-			add_next_index_zval(return_value, retval);
+			add_next_index_zval(return_value, &retval);
 		}
 
 		zend_hash_move_forward_ex(&intern->storage, &intern->pos);
@@ -1258,7 +1239,7 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_
 SPL_METHOD(MultipleIterator, current)
 {
 	spl_SplObjectStorage        *intern;
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1272,8 +1253,8 @@ SPL_METHOD(MultipleIterator, current)
    Return an array of all registered Iterator instances key() result */
 SPL_METHOD(MultipleIterator, key)
 {
-	spl_SplObjectStorage        *intern;
-	intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
+	spl_SplObjectStorage *intern;
+	intern = Z_SPLOBJSTORAGE_P(getThis());
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1326,10 +1307,13 @@ PHP_MINIT_FUNCTION(spl_observer)
 	REGISTER_SPL_STD_CLASS_EX(SplObjectStorage, spl_SplObjectStorage_new, spl_funcs_SplObjectStorage);
 	memcpy(&spl_handler_SplObjectStorage, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
 
+	spl_handler_SplObjectStorage.offset          = XtOffsetOf(spl_SplObjectStorage, std);
 	spl_handler_SplObjectStorage.get_debug_info  = spl_object_storage_debug_info;
 	spl_handler_SplObjectStorage.compare_objects = spl_object_storage_compare_objects;
 	spl_handler_SplObjectStorage.clone_obj       = spl_object_storage_clone;
 	spl_handler_SplObjectStorage.get_gc          = spl_object_storage_get_gc;
+	spl_handler_SplObjectStorage.dtor_obj        = zend_objects_destroy_object;
+	spl_handler_SplObjectStorage.free_obj        = spl_SplObjectStorage_free_storage;
 
 	REGISTER_SPL_IMPLEMENTS(SplObjectStorage, Countable);
 	REGISTER_SPL_IMPLEMENTS(SplObjectStorage, Iterator);
diff --git a/ext/spl/tests/bug60201.phpt b/ext/spl/tests/bug60201.phpt
index 68a5daabfd..c77988eb13 100644
--- a/ext/spl/tests/bug60201.phpt
+++ b/ext/spl/tests/bug60201.phpt
@@ -12,17 +12,17 @@ var_dump($params);
 --EXPECTF--
 array(3) {
   [0]=>
-  &object(ReflectionParameter)#%d (1) {
+  object(ReflectionParameter)#%d (1) {
     ["name"]=>
     string(9) "delimiter"
   }
   [1]=>
-  &object(ReflectionParameter)#%d (1) {
+  object(ReflectionParameter)#%d (1) {
     ["name"]=>
     string(9) "enclosure"
   }
   [2]=>
-  &object(ReflectionParameter)#%d (1) {
+  object(ReflectionParameter)#%d (1) {
     ["name"]=>
     string(6) "escape"
   }
diff --git a/ext/spl/tests/fixedarray_002.phpt b/ext/spl/tests/fixedarray_002.phpt
index 534d41f184..2521516c14 100644
--- a/ext/spl/tests/fixedarray_002.phpt
+++ b/ext/spl/tests/fixedarray_002.phpt
@@ -3,6 +3,9 @@ SPL: FixedArray: overloading
 --FILE--
 <?php
 class A extends SplFixedArray {
+	public $prop1 = NULL;
+	public $prop2 = NULL;
+
     public function count() {
         return 2;
     }
diff --git a/ext/spl/tests/fixedarray_003.phpt b/ext/spl/tests/fixedarray_003.phpt
index b6c5eb53e4..69cec7528e 100644
--- a/ext/spl/tests/fixedarray_003.phpt
+++ b/ext/spl/tests/fixedarray_003.phpt
@@ -3,6 +3,8 @@ SPL: FixedArray: Iterators
 --FILE--
 <?php
 class A extends SplFixedArray {
+	public $prop1 = "dummy";
+	public $prop2 = "dummy";
 
     public function current() {
         echo "A::current\n";
diff --git a/ext/spl/tests/iterator_042.phpt b/ext/spl/tests/iterator_042.phpt
index 95fea2f6b8..e2fb167583 100644
--- a/ext/spl/tests/iterator_042.phpt
+++ b/ext/spl/tests/iterator_042.phpt
@@ -83,7 +83,7 @@ object(ArrayIterator)#%d (1) {
       }
     }
     [2]=>
-    object(ArrayIterator)#5 (1) {
+    object(ArrayIterator)#%d (1) {
       %s"storage"%s"ArrayIterator":private]=>
       array(3) {
         [0]=>
diff --git a/ext/sqlite3/php_sqlite3_structs.h b/ext/sqlite3/php_sqlite3_structs.h
index 5336d116fc..e988ac20d0 100644
--- a/ext/sqlite3/php_sqlite3_structs.h
+++ b/ext/sqlite3/php_sqlite3_structs.h
@@ -39,11 +39,9 @@
 /* Structure for SQLite Statement Parameter. */
 struct php_sqlite3_bound_param  {
 	long param_number;
-	char *name;
-	int name_len;
+	zend_string *name;
 	long type;
-
-	zval *parameter;
+	zval parameter;
 };
 
 struct php_sqlite3_fci {
@@ -58,7 +56,7 @@ typedef struct _php_sqlite3_func {
 	const char *func_name;
 	int argc;
 
-	zval *func, *step, *fini;
+	zval func, step, fini;
 	struct php_sqlite3_fci afunc, astep, afini;
 } php_sqlite3_func;
 
@@ -67,13 +65,12 @@ typedef struct _php_sqlite3_collation {
 	struct _php_sqlite3_collation *next;
 
 	const char *collation_name;
-	zval *cmp_func;
+	zval cmp_func;
 	struct php_sqlite3_fci fci;
 } php_sqlite3_collation;
 
 /* Structure for SQLite Database object. */
 typedef struct _php_sqlite3_db_object  {
-	zend_object zo;
 	int initialised;
 	sqlite3 *db;
 	php_sqlite3_func *funcs;
@@ -82,11 +79,18 @@ typedef struct _php_sqlite3_db_object  {
 	zend_bool exception;
 
 	zend_llist free_list;
+	zend_object zo;
 } php_sqlite3_db_object;
 
+static inline php_sqlite3_db_object *php_sqlite3_db_from_obj(zend_object *obj) {
+	return (php_sqlite3_db_object*)((char*)(obj) - XtOffsetOf(php_sqlite3_db_object, zo));
+}
+
+#define Z_SQLITE3_DB_P(zv)  php_sqlite3_db_from_obj(Z_OBJ_P((zv)))
+
 /* Structure for SQLite Database object. */
 typedef struct _php_sqlite3_agg_context  {
-	zval *zval_context;
+	zval zval_context;
 	long row_count;
 } php_sqlite3_agg_context;
 
@@ -95,34 +99,46 @@ typedef struct _php_sqlite3_result_object php_sqlite3_result;
 
 /* sqlite3 objects to be destroyed */
 typedef struct _php_sqlite3_free_list {
-	zval *stmt_obj_zval;
+	zval stmt_obj_zval;
 	php_sqlite3_stmt *stmt_obj;
 } php_sqlite3_free_list;
 
 /* Structure for SQLite Result object. */
 struct _php_sqlite3_result_object  {
-	zend_object zo;
 	php_sqlite3_db_object *db_obj;
 	php_sqlite3_stmt *stmt_obj;
-	zval *stmt_obj_zval;
+	zval stmt_obj_zval;
 	
 	int is_prepared_statement;
 	int complete;
+	zend_object zo;
 };
 
+static inline php_sqlite3_result *php_sqlite3_result_from_obj(zend_object *obj) {
+	return (php_sqlite3_result*)((char*)(obj) - XtOffsetOf(php_sqlite3_result, zo));
+}
+
+#define Z_SQLITE3_RESULT_P(zv)  php_sqlite3_result_from_obj(Z_OBJ_P((zv)))
+
 /* Structure for SQLite Statement object. */
 struct _php_sqlite3_stmt_object  {
-	zend_object zo;
 	sqlite3_stmt *stmt;
 	php_sqlite3_db_object *db_obj;
-	zval *db_obj_zval;
+	zval db_obj_zval;
 
 	int initialised;
 
 	/* Keep track of the zvals for bound parameters */
 	HashTable *bound_params;
+	zend_object zo;
 };
 
+static inline php_sqlite3_stmt *php_sqlite3_stmt_from_obj(zend_object *obj) {
+	return (php_sqlite3_stmt*)((char*)(obj) - XtOffsetOf(php_sqlite3_stmt, zo));
+}
+
+#define Z_SQLITE3_STMT_P(zv)  php_sqlite3_stmt_from_obj(Z_OBJ_P((zv)))
+
 #endif
 
 
diff --git a/ext/sqlite3/sqlite3.c b/ext/sqlite3/sqlite3.c
index 0c9041ebfc..bfbb3fbdd1 100644
--- a/ext/sqlite3/sqlite3.c
+++ b/ext/sqlite3/sqlite3.c
@@ -39,7 +39,7 @@ ZEND_DECLARE_MODULE_GLOBALS(sqlite3)
 
 static PHP_GINIT_FUNCTION(sqlite3);
 static int php_sqlite3_authorizer(void *autharg, int access_type, const char *arg3, const char *arg4, const char *arg5, const char *arg6);
-static void sqlite3_param_dtor(void *data);
+static void sqlite3_param_dtor(zval *data);
 static int php_sqlite3_compare_stmt_zval_free(php_sqlite3_free_list **free_list, zval *statement);
 
 /* {{{ Error Handler
@@ -100,7 +100,7 @@ PHP_METHOD(sqlite3, open)
 	long flags = SQLITE_OPEN_READWRITE | SQLITE_OPEN_CREATE;
 	zend_error_handling error_handling;
 
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 	zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
 
 	if (FAILURE == zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|ls", &filename, &filename_len, &flags, &encryption_key, &encryption_key_len)) {
@@ -184,7 +184,7 @@ PHP_METHOD(sqlite3, close)
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
 	int errcode;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -212,7 +212,7 @@ PHP_METHOD(sqlite3, exec)
 	zval *object = getThis();
 	char *sql, *errtext = NULL;
 	int sql_len;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -240,7 +240,7 @@ PHP_METHOD(sqlite3, version)
 
 	array_init(return_value);
 
-	add_assoc_string(return_value, "versionString", (char*)sqlite3_libversion(), 1);
+	add_assoc_string(return_value, "versionString", (char*)sqlite3_libversion());
 	add_assoc_long(return_value, "versionNumber", sqlite3_libversion_number());
 
 	return;
@@ -253,7 +253,7 @@ PHP_METHOD(sqlite3, lastInsertRowID)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -271,7 +271,7 @@ PHP_METHOD(sqlite3, lastErrorCode)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
 
@@ -289,7 +289,7 @@ PHP_METHOD(sqlite3, lastErrorMsg)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->db, SQLite3)
 
@@ -297,7 +297,7 @@ PHP_METHOD(sqlite3, lastErrorMsg)
 		return;
 	}
 
-	RETVAL_STRING((char *)sqlite3_errmsg(db_obj->db), 1);
+	RETVAL_STRING((char *)sqlite3_errmsg(db_obj->db));
 }
 /* }}} */
 
@@ -309,7 +309,7 @@ PHP_METHOD(sqlite3, busyTimeout)
 	zval *object = getThis();
 	long ms;
 	int return_code;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -338,7 +338,7 @@ PHP_METHOD(sqlite3, loadExtension)
 	char *extension, *lib_path, *extension_dir, *errtext = NULL;
 	char fullpath[MAXPATHLEN];
 	int extension_len, extension_dir_len;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -408,7 +408,7 @@ PHP_METHOD(sqlite3, changes)
 {
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -434,7 +434,7 @@ PHP_METHOD(sqlite3, escapeString)
 	if (sql_len) {
 		ret = sqlite3_mprintf("%q", sql);
 		if (ret) {
-			RETVAL_STRING(ret, 1);
+			RETVAL_STRING(ret);
 			sqlite3_free(ret);
 		}
 	} else {
@@ -454,7 +454,7 @@ PHP_METHOD(sqlite3, prepare)
 	int sql_len, errcode;
 	php_sqlite3_free_list *free_item;
 
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -467,11 +467,9 @@ PHP_METHOD(sqlite3, prepare)
 	}
 
 	object_init_ex(return_value, php_sqlite3_stmt_entry);
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(return_value TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(return_value);
 	stmt_obj->db_obj = db_obj;
-	stmt_obj->db_obj_zval = getThis();
-
-	Z_ADDREF_P(object);
+	ZVAL_COPY(&stmt_obj->db_obj_zval, object);
 
 	errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
 	if (errcode != SQLITE_OK) {
@@ -484,7 +482,7 @@ PHP_METHOD(sqlite3, prepare)
 
 	free_item = emalloc(sizeof(php_sqlite3_free_list));
 	free_item->stmt_obj = stmt_obj;
-	free_item->stmt_obj_zval = return_value;
+	ZVAL_COPY_VALUE(&free_item->stmt_obj_zval, return_value);
 
 	zend_llist_add_element(&(db_obj->free_list), &free_item);
 }
@@ -498,10 +496,10 @@ PHP_METHOD(sqlite3, query)
 	php_sqlite3_result *result;
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
-	zval *stmt = NULL;
+	zval stmt;
 	char *sql, *errtext = NULL;
 	int sql_len, return_code;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -514,7 +512,7 @@ PHP_METHOD(sqlite3, query)
 	}
 
 	/* If there was no return value then just execute the query */
-	if (!return_value_used) {
+	if (!USED_RET()) {
 		if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
 			php_sqlite3_error(db_obj, "%s", errtext);
 			sqlite3_free(errtext);
@@ -522,14 +520,10 @@ PHP_METHOD(sqlite3, query)
 		return;
 	}
 
-	MAKE_STD_ZVAL(stmt);
-
-	object_init_ex(stmt, php_sqlite3_stmt_entry);
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(stmt TSRMLS_CC);
+	object_init_ex(&stmt, php_sqlite3_stmt_entry);
+	stmt_obj = Z_SQLITE3_STMT_P(&stmt);
 	stmt_obj->db_obj = db_obj;
-	stmt_obj->db_obj_zval = getThis();
-
-	Z_ADDREF_P(object);
+	ZVAL_COPY(&stmt_obj->db_obj_zval, object);
 
 	return_code = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
 	if (return_code != SQLITE_OK) {
@@ -541,10 +535,10 @@ PHP_METHOD(sqlite3, query)
 	stmt_obj->initialised = 1;
 
 	object_init_ex(return_value, php_sqlite3_result_entry);
-	result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
+	result = Z_SQLITE3_RESULT_P(return_value);
 	result->db_obj = db_obj;
 	result->stmt_obj = stmt_obj;
-	result->stmt_obj_zval = stmt;
+	ZVAL_COPY_VALUE(&result->stmt_obj_zval, &stmt);
 
 	return_code = sqlite3_step(result->stmt_obj->stmt);
 
@@ -570,14 +564,12 @@ PHP_METHOD(sqlite3, query)
 }
 /* }}} */
 
-static zval* sqlite_value_to_zval(sqlite3_stmt *stmt, int column) /* {{{ */
+static void sqlite_value_to_zval(sqlite3_stmt *stmt, int column, zval *data) /* {{{ */
 {
-	zval *data;
-	MAKE_STD_ZVAL(data);
 	switch (sqlite3_column_type(stmt, column)) {
 		case SQLITE_INTEGER:
 			if ((sqlite3_column_int64(stmt, column)) >= INT_MAX || sqlite3_column_int64(stmt, column) <= INT_MIN) {
-				ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column), 1);
+				ZVAL_STRINGL(data, (char *)sqlite3_column_text(stmt, column), sqlite3_column_bytes(stmt, column));
 			} else {
 				ZVAL_LONG(data, sqlite3_column_int64(stmt, column));
 			}
@@ -592,14 +584,13 @@ static zval* sqlite_value_to_zval(sqlite3_stmt *stmt, int column) /* {{{ */
 			break;
 
 		case SQLITE3_TEXT:
-			ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column), 1);
+			ZVAL_STRING(data, (char*)sqlite3_column_text(stmt, column));
 			break;
 
 		case SQLITE_BLOB:
 		default:
-			ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column), 1);
+			ZVAL_STRINGL(data, (char*)sqlite3_column_blob(stmt, column), sqlite3_column_bytes(stmt, column));
 	}
-	return data;
 }
 /* }}} */
 
@@ -613,7 +604,7 @@ PHP_METHOD(sqlite3, querySingle)
 	int sql_len, return_code;
 	zend_bool entire_row = 0;
 	sqlite3_stmt *stmt;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -626,7 +617,7 @@ PHP_METHOD(sqlite3, querySingle)
 	}
 
 	/* If there was no return value then just execute the query */
-	if (!return_value_used) {
+	if (!USED_RET()) {
 		if (sqlite3_exec(db_obj->db, sql, NULL, NULL, &errtext) != SQLITE_OK) {
 			php_sqlite3_error(db_obj, "%s", errtext);
 			sqlite3_free(errtext);
@@ -646,19 +637,14 @@ PHP_METHOD(sqlite3, querySingle)
 		case SQLITE_ROW: /* Valid Row */
 		{
 			if (!entire_row) {
-				zval *data;
-				data = sqlite_value_to_zval(stmt, 0);
-				*return_value = *data;
-				zval_copy_ctor(return_value);
-				zval_dtor(data);
-				FREE_ZVAL(data);
+				sqlite_value_to_zval(stmt, 0, return_value);
 			} else {
 				int i = 0;
 				array_init(return_value);
 				for (i = 0; i < sqlite3_data_count(stmt); i++) {
-					zval *data;
-					data = sqlite_value_to_zval(stmt, i);
-					add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), data);
+					zval data;
+					sqlite_value_to_zval(stmt, i, &data);
+					add_assoc_zval(return_value, (char*)sqlite3_column_name(stmt, i), &data);
 				}
 			}
 			break;
@@ -682,8 +668,8 @@ PHP_METHOD(sqlite3, querySingle)
 
 static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, sqlite3_value **argv, sqlite3_context *context, int is_agg TSRMLS_DC) /* {{{ */
 {
-	zval ***zargs = NULL;
-	zval *retval = NULL;
+	zval *zargs = NULL;
+	zval retval;
 	int i;
 	int ret;
 	int fake_argc;
@@ -697,58 +683,51 @@ static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, s
 
 	fc->fci.size = sizeof(fc->fci);
 	fc->fci.function_table = EG(function_table);
-	fc->fci.function_name = cb;
+	ZVAL_COPY_VALUE(&fc->fci.function_name, cb);
 	fc->fci.symbol_table = NULL;
-	fc->fci.object_ptr = NULL;
-	fc->fci.retval_ptr_ptr = &retval;
+	fc->fci.object = NULL;
+	fc->fci.retval = &retval;
 	fc->fci.param_count = fake_argc;
 
 	/* build up the params */
 
 	if (fake_argc) {
-		zargs = (zval ***)safe_emalloc(fake_argc, sizeof(zval **), 0);
+		zargs = (zval *)safe_emalloc(fake_argc, sizeof(zval), 0);
 	}
 
 	if (is_agg) {
 		/* summon the aggregation context */
 		agg_context = (php_sqlite3_agg_context *)sqlite3_aggregate_context(context, sizeof(php_sqlite3_agg_context));
 
-		if (!agg_context->zval_context) {
-			MAKE_STD_ZVAL(agg_context->zval_context);
-			ZVAL_NULL(agg_context->zval_context);
+		if (ZVAL_IS_UNDEF(&agg_context->zval_context)) {
+			ZVAL_NULL(&agg_context->zval_context);
 		}
-		zargs[0] = &agg_context->zval_context;
-
-		zargs[1] = emalloc(sizeof(zval*));
-		MAKE_STD_ZVAL(*zargs[1]);
-		ZVAL_LONG(*zargs[1], agg_context->row_count);
+		ZVAL_COPY_VALUE(&zargs[0], &agg_context->zval_context);
+		ZVAL_LONG(&zargs[1], agg_context->row_count);
 	}
 
 	for (i = 0; i < argc; i++) {
-		zargs[i + is_agg] = emalloc(sizeof(zval *));
-		MAKE_STD_ZVAL(*zargs[i + is_agg]);
-
 		switch (sqlite3_value_type(argv[i])) {
 			case SQLITE_INTEGER:
 #if LONG_MAX > 2147483647
-				ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int64(argv[i]));
+				ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int64(argv[i]));
 #else
-				ZVAL_LONG(*zargs[i + is_agg], sqlite3_value_int(argv[i]));
+				ZVAL_LONG(&zargs[i + is_agg], sqlite3_value_int(argv[i]));
 #endif
 				break;
 
 			case SQLITE_FLOAT:
-				ZVAL_DOUBLE(*zargs[i + is_agg], sqlite3_value_double(argv[i]));
+				ZVAL_DOUBLE(&zargs[i + is_agg], sqlite3_value_double(argv[i]));
 				break;
 
 			case SQLITE_NULL:
-				ZVAL_NULL(*zargs[i + is_agg]);
+				ZVAL_NULL(&zargs[i + is_agg]);
 				break;
 
 			case SQLITE_BLOB:
 			case SQLITE3_TEXT:
 			default:
-				ZVAL_STRINGL(*zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]), 1);
+				ZVAL_STRINGL(&zargs[i + is_agg], (char*)sqlite3_value_text(argv[i]), sqlite3_value_bytes(argv[i]));
 				break;
 		}
 	}
@@ -762,12 +741,10 @@ static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, s
 	/* clean up the params */
 	if (fake_argc) {
 		for (i = is_agg; i < argc + is_agg; i++) {
-			zval_ptr_dtor(zargs[i]);
-			efree(zargs[i]);
+			zval_ptr_dtor(&zargs[i]);
 		}
 		if (is_agg) {
-			zval_ptr_dtor(zargs[1]);
-			efree(zargs[1]);
+			zval_ptr_dtor(&zargs[1]);
 		}
 		efree(zargs);
 	}
@@ -775,13 +752,13 @@ static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, s
 	if (!is_agg || !argv) {
 		/* only set the sqlite return value if we are a scalar function,
 		 * or if we are finalizing an aggregate */
-		if (retval) {
-			switch (Z_TYPE_P(retval)) {
+		if (!ZVAL_IS_UNDEF(&retval)) {
+			switch (Z_TYPE(retval)) {
 				case IS_LONG:
 #if LONG_MAX > 2147483647
-					sqlite3_result_int64(context, Z_LVAL_P(retval));
+					sqlite3_result_int64(context, Z_LVAL(retval));
 #else
-					sqlite3_result_int(context, Z_LVAL_P(retval));
+					sqlite3_result_int(context, Z_LVAL(retval));
 #endif
 					break;
 
@@ -790,36 +767,32 @@ static int sqlite3_do_callback(struct php_sqlite3_fci *fc, zval *cb, int argc, s
 					break;
 
 				case IS_DOUBLE:
-					sqlite3_result_double(context, Z_DVAL_P(retval));
+					sqlite3_result_double(context, Z_DVAL(retval));
 					break;
 
 				default:
 					convert_to_string_ex(&retval);
-					sqlite3_result_text(context, Z_STRVAL_P(retval), Z_STRLEN_P(retval), SQLITE_TRANSIENT);
+					sqlite3_result_text(context, Z_STRVAL(retval), Z_STRLEN(retval), SQLITE_TRANSIENT);
 					break;
 			}
 		} else {
 			sqlite3_result_error(context, "failed to invoke callback", 0);
 		}
 
-		if (agg_context && agg_context->zval_context) {
+		if (agg_context && !ZVAL_IS_UNDEF(&agg_context->zval_context)) {
 			zval_ptr_dtor(&agg_context->zval_context);
 		}
 	} else {
 		/* we're stepping in an aggregate; the return value goes into
 		 * the context */
-		if (agg_context && agg_context->zval_context) {
+		if (agg_context && !ZVAL_IS_UNDEF(&agg_context->zval_context)) {
 			zval_ptr_dtor(&agg_context->zval_context);
 		}
-		if (retval) {
-			agg_context->zval_context = retval;
-			retval = NULL;
-		} else {
-			agg_context->zval_context = NULL;
-		}
+		ZVAL_COPY_VALUE(&agg_context->zval_context, &retval);
+		ZVAL_UNDEF(&retval);
 	}
 
-	if (retval) {
+	if (!ZVAL_IS_UNDEF(&retval)) {
 		zval_ptr_dtor(&retval);
 	}
 	return ret;
@@ -831,7 +804,7 @@ static void php_sqlite3_callback_func(sqlite3_context *context, int argc, sqlite
 	php_sqlite3_func *func = (php_sqlite3_func *)sqlite3_user_data(context);
 	TSRMLS_FETCH();
 
-	sqlite3_do_callback(&func->afunc, func->func, argc, argv, context, 0 TSRMLS_CC);
+	sqlite3_do_callback(&func->afunc, &func->func, argc, argv, context, 0 TSRMLS_CC);
 }
 /* }}}*/
 
@@ -843,7 +816,7 @@ static void php_sqlite3_callback_step(sqlite3_context *context, int argc, sqlite
 	TSRMLS_FETCH();
 	agg_context->row_count++;
 
-	sqlite3_do_callback(&func->astep, func->step, argc, argv, context, 1 TSRMLS_CC);
+	sqlite3_do_callback(&func->astep, &func->step, argc, argv, context, 1 TSRMLS_CC);
 }
 /* }}} */
 
@@ -855,36 +828,30 @@ static void php_sqlite3_callback_final(sqlite3_context *context) /* {{{ */
 	TSRMLS_FETCH();
 	agg_context->row_count = 0;
 
-	sqlite3_do_callback(&func->afini, func->fini, 0, NULL, context, 1 TSRMLS_CC);
+	sqlite3_do_callback(&func->afini, &func->fini, 0, NULL, context, 1 TSRMLS_CC);
 }
 /* }}} */
 
 static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, int b_len, const void* b) /* {{{ */
 {
 	php_sqlite3_collation *collation = (php_sqlite3_collation*)coll;
-	zval ***zargs = NULL;
-	zval *retval = NULL;
+	zval *zargs = NULL;
+	zval retval;
 	int ret;
 
 	TSRMLS_FETCH();
 
 	collation->fci.fci.size = (sizeof(collation->fci.fci));
 	collation->fci.fci.function_table = EG(function_table);
-	collation->fci.fci.function_name = collation->cmp_func;
+	ZVAL_COPY_VALUE(&collation->fci.fci.function_name, &collation->cmp_func);
 	collation->fci.fci.symbol_table = NULL;
-	collation->fci.fci.object_ptr = NULL;
-	collation->fci.fci.retval_ptr_ptr = &retval;
+	collation->fci.fci.object = NULL;
+	collation->fci.fci.retval = &retval;
 	collation->fci.fci.param_count = 2;
 
-	zargs = (zval***)safe_emalloc(2, sizeof(zval**), 0);
-	zargs[0] = emalloc(sizeof(zval*));
-	zargs[1] = emalloc(sizeof(zval*));
-
-	MAKE_STD_ZVAL(*zargs[0]);
-	ZVAL_STRINGL(*zargs[0], a, a_len, 1);
-
-	MAKE_STD_ZVAL(*zargs[1]);
-	ZVAL_STRINGL(*zargs[1], b, b_len, 1);
+	zargs = safe_emalloc(2, sizeof(zval), 0);
+	ZVAL_STRINGL(&zargs[0], a, a_len);
+	ZVAL_STRINGL(&zargs[1], b, b_len);
  
 	collation->fci.fci.params = zargs;
 
@@ -892,19 +859,17 @@ static int php_sqlite3_callback_compare(void *coll, int a_len, const void *a, in
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback");
 	}
 
-	zval_ptr_dtor(zargs[0]);
-	zval_ptr_dtor(zargs[1]);
-	efree(zargs[0]);
-	efree(zargs[1]);
+	zval_ptr_dtor(&zargs[0]);
+	zval_ptr_dtor(&zargs[1]);
 	efree(zargs);
 
 	//retval ought to contain a ZVAL_LONG by now
 	// (the result of a comparison, i.e. most likely -1, 0, or 1)
 	//I suppose we could accept any scalar return type, though.
-	if (Z_TYPE_P(retval) != IS_LONG){
+	if (Z_TYPE(retval) != IS_LONG){
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the compare callback (invalid return type).  Collation behaviour is undefined.");
 	}else{
-		ret = Z_LVAL_P(retval);
+		ret = Z_LVAL(retval);
 	}
 
 	zval_ptr_dtor(&retval);
@@ -920,11 +885,12 @@ PHP_METHOD(sqlite3, createFunction)
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
 	php_sqlite3_func *func;
-	char *sql_func, *callback_name;
+	char *sql_func;
 	int sql_func_len;
 	zval *callback_func;
+	zend_string *callback_name;
 	long sql_func_num_args = -1;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -937,19 +903,18 @@ PHP_METHOD(sqlite3, createFunction)
 	}
 
 	if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
-		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
-		efree(callback_name);
+		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+		STR_RELEASE(callback_name);
 		RETURN_FALSE;
 	}
-	efree(callback_name);
+	STR_RELEASE(callback_name);
 
 	func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
 
 	if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, php_sqlite3_callback_func, NULL, NULL) == SQLITE_OK) {
 		func->func_name = estrdup(sql_func);
 
-		MAKE_STD_ZVAL(func->func);
-		MAKE_COPY_ZVAL(&callback_func, func->func);
+		ZVAL_COPY(&func->func, callback_func);
 
 		func->argc = sql_func_num_args;
 		func->next = db_obj->funcs;
@@ -970,11 +935,12 @@ PHP_METHOD(sqlite3, createAggregate)
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
 	php_sqlite3_func *func;
-	char *sql_func, *callback_name;
+	char *sql_func;
+	zend_string *callback_name;
 	int sql_func_len;
 	zval *step_callback, *fini_callback;
 	long sql_func_num_args = -1;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -987,29 +953,26 @@ PHP_METHOD(sqlite3, createAggregate)
 	}
 
 	if (!zend_is_callable(step_callback, 0, &callback_name TSRMLS_CC)) {
-		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
-		efree(callback_name);
+		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+		STR_RELEASE(callback_name);
 		RETURN_FALSE;
 	}
-	efree(callback_name);
+	STR_RELEASE(callback_name);
 
 	if (!zend_is_callable(fini_callback, 0, &callback_name TSRMLS_CC)) {
-		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
-		efree(callback_name);
+		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+		STR_RELEASE(callback_name);
 		RETURN_FALSE;
 	}
-	efree(callback_name);
+	STR_RELEASE(callback_name);
 
 	func = (php_sqlite3_func *)ecalloc(1, sizeof(*func));
 
 	if (sqlite3_create_function(db_obj->db, sql_func, sql_func_num_args, SQLITE_UTF8, func, NULL, php_sqlite3_callback_step, php_sqlite3_callback_final) == SQLITE_OK) {
 		func->func_name = estrdup(sql_func);
 
-		MAKE_STD_ZVAL(func->step);
-		MAKE_COPY_ZVAL(&step_callback, func->step);
-
-		MAKE_STD_ZVAL(func->fini);
-		MAKE_COPY_ZVAL(&fini_callback, func->fini);
+		ZVAL_COPY(&func->step, step_callback);
+		ZVAL_COPY(&func->fini, fini_callback);
 
 		func->argc = sql_func_num_args;
 		func->next = db_obj->funcs;
@@ -1030,10 +993,11 @@ PHP_METHOD(sqlite3, createCollation)
 	php_sqlite3_db_object *db_obj;
 	zval *object = getThis();
 	php_sqlite3_collation *collation;
-	char *collation_name, *callback_name;
+	char *collation_name;
+	zend_string *callback_name;
 	int collation_name_len;
 	zval *callback_func;
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -1046,18 +1010,17 @@ PHP_METHOD(sqlite3, createCollation)
 	}
 
 	if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
-		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name);
-		efree(callback_name);
+		php_sqlite3_error(db_obj, "Not a valid callback function %s", callback_name->val);
+		STR_RELEASE(callback_name);
 		RETURN_FALSE;
 	}
-	efree(callback_name);
+	STR_RELEASE(callback_name);
 
 	collation = (php_sqlite3_collation *)ecalloc(1, sizeof(*collation));
 	if (sqlite3_create_collation(db_obj->db, collation_name, SQLITE_UTF8, collation, php_sqlite3_callback_compare) == SQLITE_OK) {
 		collation->collation_name = estrdup(collation_name);
 
-		MAKE_STD_ZVAL(collation->cmp_func);
-		MAKE_COPY_ZVAL(&callback_func, collation->cmp_func);
+		ZVAL_COPY(&collation->cmp_func, callback_func);
 
 		collation->next = db_obj->collations;
 		db_obj->collations = collation;
@@ -1219,7 +1182,7 @@ PHP_METHOD(sqlite3, openBlob)
 	php_stream_sqlite3_data *sqlite3_stream;
 	php_stream *stream;
 
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -1255,7 +1218,7 @@ PHP_METHOD(sqlite3, enableExceptions)
 	zval *object = getThis();
 	zend_bool enableExceptions = 0;
 
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(object TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(object);
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|b", &enableExceptions) == FAILURE) {
 		return;
@@ -1273,7 +1236,7 @@ PHP_METHOD(sqlite3stmt, paramCount)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1289,7 +1252,7 @@ PHP_METHOD(sqlite3stmt, close)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1307,7 +1270,7 @@ PHP_METHOD(sqlite3stmt, reset)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1327,7 +1290,7 @@ PHP_METHOD(sqlite3stmt, clear)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1348,7 +1311,7 @@ PHP_METHOD(sqlite3stmt, readOnly)
 {
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1376,21 +1339,21 @@ static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *pa
 
 	/* We need a : prefix to resolve a name to a parameter number */
 	if (param->name) {
-		if (param->name[0] != ':') {
+		if (param->name->val[0] != ':') {
 			/* pre-increment for character + 1 for null */
-			char *temp = emalloc(++param->name_len + 1);
-			temp[0] = ':';
-			memmove(temp+1, param->name, param->name_len);
+			zend_string *temp = STR_ALLOC(param->name->len + 1, 0);
+			temp->val[0] = ':';
+			memmove(temp->val + 1, param->name->val, param->name->len + 1);
 			param->name = temp;
 		} else {
-			param->name = estrndup(param->name, param->name_len);
+			param->name = STR_INIT(param->name->val, param->name->len, 0);
 		}
 		/* do lookup*/
-		param->param_number = sqlite3_bind_parameter_index(stmt->stmt, param->name);
+		param->param_number = sqlite3_bind_parameter_index(stmt->stmt, param->name->val);
 	}
 
 	if (param->param_number < 1) {
-		efree(param->name);
+		STR_RELEASE(param->name);
 		return 0;
 	}
 
@@ -1399,9 +1362,9 @@ static int register_bound_parameter_to_sqlite(struct php_sqlite3_bound_param *pa
 	}
 
 	if (param->name) {
-		zend_hash_update(hash, param->name, param->name_len, param, sizeof(*param), NULL);
+		zend_hash_update_mem(hash, param->name, param, sizeof(struct php_sqlite3_bound_param));
 	} else {
-		zend_hash_index_update(hash, param->param_number, param, sizeof(*param), NULL);
+		zend_hash_index_update_mem(hash, param->param_number, param, sizeof(struct php_sqlite3_bound_param));
 	}
 
 	return 1;
@@ -1415,23 +1378,24 @@ PHP_METHOD(sqlite3stmt, bindParam)
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
 	struct php_sqlite3_bound_param param = {0};
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
+	zval *parameter;
 
 	param.param_number = -1;
 	param.type = SQLITE3_TEXT;
 
-	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", &param.param_number, &param.parameter, &param.type) == FAILURE) {
-		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|l", &param.name, &param.name_len, &param.parameter, &param.type) == FAILURE) {
+	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz|l", &param.param_number, &parameter, &param.type) == FAILURE) {
+		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz|l", &param.name, &parameter, &param.type) == FAILURE) {
 			return;
 		}
 	}
 
-	Z_ADDREF_P(param.parameter);
+	ZVAL_COPY(&param.parameter, parameter);
 
 	if (!register_bound_parameter_to_sqlite(&param, stmt_obj TSRMLS_CC)) {
-		if (param.parameter) {
+		if (!ZVAL_IS_UNDEF(&param.parameter)) {
 			zval_ptr_dtor(&(param.parameter));
-			param.parameter = NULL;
+			ZVAL_UNDEF(&param.parameter);
 		}
 		RETURN_FALSE;
 	}
@@ -1446,23 +1410,24 @@ PHP_METHOD(sqlite3stmt, bindValue)
 	php_sqlite3_stmt *stmt_obj;
 	zval *object = getThis();
 	struct php_sqlite3_bound_param param = {0};
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
+	zval *parameter;
 
 	param.param_number = -1;
 	param.type = SQLITE3_TEXT;
 
-	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", &param.param_number, &param.parameter, &param.type) == FAILURE) {
-		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz/|l", &param.name, &param.name_len, &param.parameter, &param.type) == FAILURE) {
+	if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "lz/|l", &param.param_number, &parameter, &param.type) == FAILURE) {
+		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Sz/|l", &param.name, &parameter, &param.type) == FAILURE) {
 			return;
 		}
 	}
 
-	Z_ADDREF_P(param.parameter);
+	ZVAL_COPY(&param.parameter, parameter);
 
 	if (!register_bound_parameter_to_sqlite(&param, stmt_obj TSRMLS_CC)) {
-		if (param.parameter) {
+		if (!ZVAL_IS_UNDEF(&param.parameter)) {
 			zval_ptr_dtor(&(param.parameter));
-			param.parameter = NULL;
+			ZVAL_UNDEF(&param.parameter);
 		}
 		RETURN_FALSE;
 	}
@@ -1480,7 +1445,7 @@ PHP_METHOD(sqlite3stmt, execute)
 	int return_code = 0;
 	struct php_sqlite3_bound_param *param;
 
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1489,59 +1454,63 @@ PHP_METHOD(sqlite3stmt, execute)
 	SQLITE3_CHECK_INITIALIZED(stmt_obj->db_obj, stmt_obj->initialised, SQLite3)
 
 	if (stmt_obj->bound_params) {
-		zend_hash_internal_pointer_reset(stmt_obj->bound_params);
-		while (zend_hash_get_current_data(stmt_obj->bound_params, (void **)&param) == SUCCESS) {
+		ZEND_HASH_FOREACH_PTR(stmt_obj->bound_params, param) {
+			zval *parameter;
+			/* parameter must be a reference? */
+			if (Z_ISREF(param->parameter)) {
+				parameter = Z_REFVAL(param->parameter);
+			} else {
+				parameter = &param->parameter;
+			}
+
 			/* If the ZVAL is null then it should be bound as that */
-			if (Z_TYPE_P(param->parameter) == IS_NULL) {
+			if (Z_TYPE_P(parameter) == IS_NULL) {
 				sqlite3_bind_null(stmt_obj->stmt, param->param_number);
-				zend_hash_move_forward(stmt_obj->bound_params);
 				continue;
 			}
 
 			switch (param->type) {
 				case SQLITE_INTEGER:
-					convert_to_long(param->parameter);
+					convert_to_long(parameter);
 #if LONG_MAX > 2147483647
-					sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
+					sqlite3_bind_int64(stmt_obj->stmt, param->param_number, Z_LVAL_P(parameter));
 #else
-					sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(param->parameter));
+					sqlite3_bind_int(stmt_obj->stmt, param->param_number, Z_LVAL_P(parameter));
 #endif
 					break;
 
 				case SQLITE_FLOAT:
-					/* convert_to_double(param->parameter);*/
-					sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(param->parameter));
+					/* convert_to_double(parameter);*/
+					sqlite3_bind_double(stmt_obj->stmt, param->param_number, Z_DVAL_P(parameter));
 					break;
 
 				case SQLITE_BLOB:
 				{
 					php_stream *stream = NULL;
-					int blength;
-					char *buffer = NULL;
-					if (Z_TYPE_P(param->parameter) == IS_RESOURCE) {
-						php_stream_from_zval_no_verify(stream, &param->parameter);
+					zend_string *buffer;
+					if (Z_TYPE_P(parameter) == IS_RESOURCE) {
+						php_stream_from_zval_no_verify(stream, parameter);
 						if (stream == NULL) {
 							php_sqlite3_error(stmt_obj->db_obj, "Unable to read stream for parameter %ld", param->param_number);
 							RETURN_FALSE;
 						}
-						blength = php_stream_copy_to_mem(stream, (void *)&buffer, PHP_STREAM_COPY_ALL, 0);
+						buffer = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
 					} else {
-						convert_to_string(param->parameter);
-						blength =  Z_STRLEN_P(param->parameter);
-						buffer = Z_STRVAL_P(param->parameter);
+						convert_to_string(parameter);
+						buffer = Z_STR_P(parameter);
 					}
 
-					sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer, blength, SQLITE_TRANSIENT);
+					sqlite3_bind_blob(stmt_obj->stmt, param->param_number, buffer->val, buffer->len, SQLITE_TRANSIENT);
 
 					if (stream) {
-						pefree(buffer, 0);
+						STR_RELEASE(buffer);
 					}
 					break;
 				}
 
 				case SQLITE3_TEXT:
-					convert_to_string(param->parameter);
-					sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(param->parameter), Z_STRLEN_P(param->parameter), SQLITE_STATIC);
+					convert_to_string(parameter);
+					sqlite3_bind_text(stmt_obj->stmt, param->param_number, Z_STRVAL_P(parameter), Z_STRLEN_P(parameter), SQLITE_STATIC);
 					break;
 
 				case SQLITE_NULL:
@@ -1552,8 +1521,7 @@ PHP_METHOD(sqlite3stmt, execute)
 					php_sqlite3_error(stmt_obj->db_obj, "Unknown parameter type: %ld for parameter %ld", param->type, param->param_number);
 					RETURN_FALSE;
 			}
-			zend_hash_move_forward(stmt_obj->bound_params);
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	return_code = sqlite3_step(stmt_obj->stmt);
@@ -1564,14 +1532,12 @@ PHP_METHOD(sqlite3stmt, execute)
 		{
 			sqlite3_reset(stmt_obj->stmt);
 			object_init_ex(return_value, php_sqlite3_result_entry);
-			result = (php_sqlite3_result *)zend_object_store_get_object(return_value TSRMLS_CC);
+			result = Z_SQLITE3_RESULT_P(return_value);
 
-			Z_ADDREF_P(object);
-	
 			result->is_prepared_statement = 1;
 			result->db_obj = stmt_obj->db_obj;
 			result->stmt_obj = stmt_obj;
-			result->stmt_obj_zval = getThis();
+			ZVAL_COPY(&result->stmt_obj_zval, object);
 
 			break;
 		}
@@ -1601,7 +1567,7 @@ PHP_METHOD(sqlite3stmt, __construct)
 	zend_error_handling error_handling;
 	php_sqlite3_free_list *free_item;
 
-	stmt_obj = (php_sqlite3_stmt *)zend_object_store_get_object(object TSRMLS_CC);
+	stmt_obj = Z_SQLITE3_STMT_P(object);
 	zend_replace_error_handling(EH_THROW, NULL, &error_handling TSRMLS_CC);
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Os", &db_zval, php_sqlite3_sc_entry, &sql, &sql_len) == FAILURE) {
@@ -1609,7 +1575,7 @@ PHP_METHOD(sqlite3stmt, __construct)
 		return;
 	}
 
-	db_obj = (php_sqlite3_db_object *)zend_object_store_get_object(db_zval TSRMLS_CC);
+	db_obj = Z_SQLITE3_DB_P(db_zval);
 
 	SQLITE3_CHECK_INITIALIZED(db_obj, db_obj->initialised, SQLite3)
 
@@ -1620,9 +1586,7 @@ PHP_METHOD(sqlite3stmt, __construct)
 	}
 
 	stmt_obj->db_obj = db_obj;
-	stmt_obj->db_obj_zval = db_zval;
-
-	Z_ADDREF_P(db_zval);
+	ZVAL_COPY(&stmt_obj->db_obj_zval, db_zval);
 	
 	errcode = sqlite3_prepare_v2(db_obj->db, sql, sql_len, &(stmt_obj->stmt), NULL);
 	if (errcode != SQLITE_OK) {
@@ -1634,7 +1598,8 @@ PHP_METHOD(sqlite3stmt, __construct)
 
 	free_item = emalloc(sizeof(php_sqlite3_free_list));
 	free_item->stmt_obj = stmt_obj;
-	free_item->stmt_obj_zval = getThis();
+	//??  free_item->stmt_obj_zval = getThis();
+	ZVAL_COPY_VALUE(&free_item->stmt_obj_zval, object);
 
 	zend_llist_add_element(&(db_obj->free_list), &free_item);
 }
@@ -1646,7 +1611,7 @@ PHP_METHOD(sqlite3result, numColumns)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = getThis();
-	result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+	result_obj = Z_SQLITE3_RESULT_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
 
@@ -1666,7 +1631,7 @@ PHP_METHOD(sqlite3result, columnName)
 	zval *object = getThis();
 	long column = 0;
 	char *column_name;
-	result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+	result_obj = Z_SQLITE3_RESULT_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
 
@@ -1679,7 +1644,7 @@ PHP_METHOD(sqlite3result, columnName)
 		RETURN_FALSE;
 	}
 		
-	RETVAL_STRING(column_name, 1);
+	RETVAL_STRING(column_name);
 }
 /* }}} */
 
@@ -1690,7 +1655,7 @@ PHP_METHOD(sqlite3result, columnType)
 	php_sqlite3_result *result_obj;
 	zval *object = getThis();
 	long column = 0;
-	result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+	result_obj = Z_SQLITE3_RESULT_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
 
@@ -1714,7 +1679,7 @@ PHP_METHOD(sqlite3result, fetchArray)
 	zval *object = getThis();
 	int i, ret;
 	long mode = PHP_SQLITE3_BOTH;
-	result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+	result_obj = Z_SQLITE3_RESULT_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
 
@@ -1726,26 +1691,28 @@ PHP_METHOD(sqlite3result, fetchArray)
 	switch (ret) {
 		case SQLITE_ROW:
 			/* If there was no return value then just skip fetching */
-			if (!return_value_used) {
+			if (!USED_RET()) {
 				return;
 			}
 
 			array_init(return_value);
 
 			for (i = 0; i < sqlite3_data_count(result_obj->stmt_obj->stmt); i++) {
-				zval *data;
+				zval data;
 
-				data = sqlite_value_to_zval(result_obj->stmt_obj->stmt, i);
+				sqlite_value_to_zval(result_obj->stmt_obj->stmt, i, &data);
 
 				if (mode & PHP_SQLITE3_NUM) {
-					add_index_zval(return_value, i, data);
+					add_index_zval(return_value, i, &data);
 				}
 
 				if (mode & PHP_SQLITE3_ASSOC) {
 					if (mode & PHP_SQLITE3_NUM) {
-						Z_ADDREF_P(data);
+						if (Z_REFCOUNTED(data)) {
+							Z_ADDREF(data);
+						}
 					}
-					add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->stmt_obj->stmt, i), data);
+					add_assoc_zval(return_value, (char*)sqlite3_column_name(result_obj->stmt_obj->stmt, i), &data);
 				}
 			}
 			break;
@@ -1767,7 +1734,7 @@ PHP_METHOD(sqlite3result, reset)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = getThis();
-	result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+	result_obj = Z_SQLITE3_RESULT_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
 
@@ -1791,7 +1758,7 @@ PHP_METHOD(sqlite3result, finalize)
 {
 	php_sqlite3_result *result_obj;
 	zval *object = getThis();
-	result_obj = (php_sqlite3_result *)zend_object_store_get_object(object TSRMLS_CC);
+	result_obj = Z_SQLITE3_RESULT_P(object);
 
 	SQLITE3_CHECK_INITIALIZED(result_obj->db_obj, result_obj->stmt_obj->initialised, SQLite3Result)
 
@@ -1801,7 +1768,7 @@ PHP_METHOD(sqlite3result, finalize)
 
 	/* We need to finalize an internal statement */
 	if (result_obj->is_prepared_statement == 0) {
-		zend_llist_del_element(&(result_obj->db_obj->free_list), result_obj->stmt_obj_zval,
+		zend_llist_del_element(&(result_obj->db_obj->free_list), &result_obj->stmt_obj_zval,
 			(int (*)(void *, void *)) php_sqlite3_compare_stmt_zval_free);
 	} else {
 		sqlite3_reset(result_obj->stmt_obj->stmt);
@@ -2011,9 +1978,10 @@ static void php_sqlite3_free_list_dtor(void **item)
 }
 /* }}} */
 
-static int php_sqlite3_compare_stmt_zval_free( php_sqlite3_free_list **free_list, zval *statement ) /* {{{ */
+static int php_sqlite3_compare_stmt_zval_free(php_sqlite3_free_list **free_list, zval *statement ) /* {{{ */
 {
-	return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj_zval);
+	//?????  return ((*free_list)->stmt_obj->initialised && statement == (*free_list)->stmt_obj_zval);
+	return  ((*free_list)->stmt_obj->initialised && Z_PTR_P(statement) == Z_PTR((*free_list)->stmt_obj_zval));	
 }
 /* }}} */
 
@@ -2023,9 +1991,9 @@ static int php_sqlite3_compare_stmt_free( php_sqlite3_free_list **free_list, sql
 }
 /* }}} */
 
-static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_sqlite3_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_sqlite3_db_object *intern = (php_sqlite3_db_object *)object;
+	php_sqlite3_db_object *intern = php_sqlite3_db_from_obj(object);
 	php_sqlite3_func *func;
 	php_sqlite3_collation *collation;
 
@@ -2042,13 +2010,13 @@ static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 
 		efree((char*)func->func_name);
 
-		if (func->func) {
+		if (!ZVAL_IS_UNDEF(&func->func)) {
 			zval_ptr_dtor(&func->func);
 		}
-		if (func->step) {
+		if (!ZVAL_IS_UNDEF(&func->step)) {
 			zval_ptr_dtor(&func->step);
 		}
-		if (func->fini) {
+		if (!ZVAL_IS_UNDEF(&func->fini)) {
 			zval_ptr_dtor(&func->fini);
 		}
 		efree(func);
@@ -2061,7 +2029,7 @@ static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 			sqlite3_create_collation(intern->db, collation->collation_name, SQLITE_UTF8, NULL, NULL);
 		}
 		efree((char*)collation->collation_name);
-		if (collation->cmp_func){
+		if (!ZVAL_IS_UNDEF(&collation->cmp_func)) {
 			zval_ptr_dtor(&collation->cmp_func);
 		}
 		efree(collation);
@@ -2073,13 +2041,12 @@ static void php_sqlite3_object_free_storage(void *object TSRMLS_DC) /* {{{ */
 	}
 
 	zend_object_std_dtor(&intern->zo TSRMLS_CC);
-	efree(intern);
 }
 /* }}} */
 
-static void php_sqlite3_stmt_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_sqlite3_stmt_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_sqlite3_stmt *intern = (php_sqlite3_stmt *)object;
+	php_sqlite3_stmt *intern = php_sqlite3_stmt_from_obj(object);
 
 	if (!intern) {
 		return;
@@ -2096,120 +2063,98 @@ static void php_sqlite3_stmt_object_free_storage(void *object TSRMLS_DC) /* {{{
 			(int (*)(void *, void *)) php_sqlite3_compare_stmt_free);
 	}
 
-	if (intern->db_obj_zval) {
+	if (!ZVAL_IS_UNDEF(&intern->db_obj_zval)) {
 		zval_ptr_dtor(&intern->db_obj_zval);
 	}
 
 	zend_object_std_dtor(&intern->zo TSRMLS_CC);
-	efree(intern);
 }
 /* }}} */
 
-static void php_sqlite3_result_object_free_storage(void *object TSRMLS_DC) /* {{{ */
+static void php_sqlite3_result_object_free_storage(zend_object *object TSRMLS_DC) /* {{{ */
 {
-	php_sqlite3_result *intern = (php_sqlite3_result *)object;
+	php_sqlite3_result *intern = php_sqlite3_result_from_obj(object);
 
 	if (!intern) {
 		return;
 	}
 
-	if (intern->stmt_obj_zval) {
+	if (!ZVAL_IS_NULL(&intern->stmt_obj_zval)) {
 		if (intern->stmt_obj->initialised) {
 			sqlite3_reset(intern->stmt_obj->stmt);
 		}
 
-		if (intern->is_prepared_statement == 0) {
-			zval_dtor(intern->stmt_obj_zval);
-			FREE_ZVAL(intern->stmt_obj_zval);
-		} else {
-			zval_ptr_dtor(&intern->stmt_obj_zval);
-		}
+		zval_ptr_dtor(&intern->stmt_obj_zval);
 	}
 
 	zend_object_std_dtor(&intern->zo TSRMLS_CC);
-	efree(intern);
 }
 /* }}} */
 
-static zend_object_value php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_sqlite3_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	zend_object_value retval;
 	php_sqlite3_db_object *intern;
 
 	/* Allocate memory for it */
-	intern = emalloc(sizeof(php_sqlite3_db_object));
-	memset(intern, 0, sizeof(php_sqlite3_db_object));
-	intern->exception = 0;
+	intern = ecalloc(1, sizeof(php_sqlite3_db_object) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	/* Need to keep track of things to free */
-	zend_llist_init(&(intern->free_list),   sizeof(php_sqlite3_free_list *), (llist_dtor_func_t)php_sqlite3_free_list_dtor, 0);
+	zend_llist_init(&(intern->free_list),  sizeof(php_sqlite3_free_list *), (llist_dtor_func_t)php_sqlite3_free_list_dtor, 0);
 
 	zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
 	object_properties_init(&intern->zo, class_type);
 
-	retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_object_free_storage, NULL TSRMLS_CC);
-	retval.handlers = (zend_object_handlers *) &sqlite3_object_handlers;
+	intern->zo.handlers = &sqlite3_object_handlers;
 
-	return retval;
+	return &intern->zo;
 }
 /* }}} */
 
-static zend_object_value php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_sqlite3_stmt_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	zend_object_value retval;
 	php_sqlite3_stmt *intern;
 
 	/* Allocate memory for it */
-	intern = emalloc(sizeof(php_sqlite3_stmt));
-	memset(intern, 0, sizeof(php_sqlite3_stmt));
-
-	intern->db_obj_zval = NULL;
+	intern = ecalloc(1, sizeof(php_sqlite3_stmt) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
 	object_properties_init(&intern->zo, class_type);
 
-	retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_stmt_object_free_storage, NULL TSRMLS_CC);
-	retval.handlers = (zend_object_handlers *) &sqlite3_stmt_object_handlers;
+	intern->zo.handlers = &sqlite3_stmt_object_handlers;
 
-	return retval;
+	return &intern->zo;
 }
 /* }}} */
 
-static zend_object_value php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
+static zend_object *php_sqlite3_result_object_new(zend_class_entry *class_type TSRMLS_DC) /* {{{ */
 {
-	zend_object_value retval;
 	php_sqlite3_result *intern;
 
 	/* Allocate memory for it */
-	intern = emalloc(sizeof(php_sqlite3_result));
-	memset(intern, 0, sizeof(php_sqlite3_result));
-
-	intern->complete = 0;
-	intern->is_prepared_statement = 0;
-	intern->stmt_obj_zval = NULL;
+	intern = ecalloc(1, sizeof(php_sqlite3_result) + sizeof(zval) * (class_type->default_properties_count - 1));
 
 	zend_object_std_init(&intern->zo, class_type TSRMLS_CC);
 	object_properties_init(&intern->zo, class_type);
 
-	retval.handle = zend_objects_store_put(intern, NULL, (zend_objects_free_object_storage_t) php_sqlite3_result_object_free_storage, NULL TSRMLS_CC);
-	retval.handlers = (zend_object_handlers *) &sqlite3_result_object_handlers;
+	intern->zo.handlers = &sqlite3_result_object_handlers;
 
-	return retval;
+	return &intern->zo;
 }
 /* }}} */
 
-static void sqlite3_param_dtor(void *data) /* {{{ */
+static void sqlite3_param_dtor(zval *data) /* {{{ */
 {
-	struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)data;
+	struct php_sqlite3_bound_param *param = (struct php_sqlite3_bound_param*)Z_PTR_P(data);
 
 	if (param->name) {
-		efree(param->name);
+		STR_RELEASE(param->name);
 	}
 
-	if (param->parameter) {
+	if (!ZVAL_IS_NULL(&param->parameter)) {
 		zval_ptr_dtor(&(param->parameter));
-		param->parameter = NULL;
+		ZVAL_UNDEF(&param->parameter);
 	}
+	efree(param);
 }
 /* }}} */
 
@@ -2234,19 +2179,25 @@ PHP_MINIT_FUNCTION(sqlite3)
 	/* Register SQLite 3 Class */
 	INIT_CLASS_ENTRY(ce, "SQLite3", php_sqlite3_class_methods);
 	ce.create_object = php_sqlite3_object_new;
+	sqlite3_object_handlers.offset = XtOffsetOf(php_sqlite3_db_object, zo);
 	sqlite3_object_handlers.clone_obj = NULL;
+	sqlite3_object_handlers.free_obj = php_sqlite3_object_free_storage;
 	php_sqlite3_sc_entry = zend_register_internal_class(&ce TSRMLS_CC);
 
 	/* Register SQLite 3 Prepared Statement Class */
 	INIT_CLASS_ENTRY(ce, "SQLite3Stmt", php_sqlite3_stmt_class_methods);
 	ce.create_object = php_sqlite3_stmt_object_new;
+	sqlite3_stmt_object_handlers.offset = XtOffsetOf(php_sqlite3_stmt, zo);
 	sqlite3_stmt_object_handlers.clone_obj = NULL;
+	sqlite3_stmt_object_handlers.free_obj = php_sqlite3_stmt_object_free_storage;
 	php_sqlite3_stmt_entry = zend_register_internal_class(&ce TSRMLS_CC);
 
 	/* Register SQLite 3 Result Class */
 	INIT_CLASS_ENTRY(ce, "SQLite3Result", php_sqlite3_result_class_methods);
 	ce.create_object = php_sqlite3_result_object_new;
+	sqlite3_result_object_handlers.offset = XtOffsetOf(php_sqlite3_result, zo);
 	sqlite3_result_object_handlers.clone_obj = NULL;
+	sqlite3_result_object_handlers.free_obj = php_sqlite3_result_object_free_storage;
 	php_sqlite3_result_entry = zend_register_internal_class(&ce TSRMLS_CC);
 
 	REGISTER_INI_ENTRIES();
diff --git a/ext/standard/array.c b/ext/standard/array.c
index 450e6995c2..a38c389d93 100644
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -178,25 +178,19 @@ static int php_array_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{
 	zval first;
 	zval second;
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
 
-	if (f->nKeyLength == 0) {
-		Z_TYPE(first) = IS_LONG;
-		Z_LVAL(first) = f->h;
+	if (f->key == NULL) {
+		ZVAL_LONG(&first, f->h);
 	} else {
-		Z_TYPE(first) = IS_STRING;
-		Z_STRVAL(first) = (char*)f->arKey;
-		Z_STRLEN(first) = f->nKeyLength - 1;
+		ZVAL_STR(&first, f->key);
 	}
 
-	if (s->nKeyLength == 0) {
-		Z_TYPE(second) = IS_LONG;
-		Z_LVAL(second) = s->h;
+	if (s->key == 0) {
+		ZVAL_LONG(&second, s->h);
 	} else {
-		Z_TYPE(second) = IS_STRING;
-		Z_STRVAL(second) = (char*)s->arKey;
-		Z_STRLEN(second) = s->nKeyLength - 1;
+		ZVAL_STR(&second, s->key);
 	}
 
 	if (ARRAYG(compare_func)(&result, &first, &second TSRMLS_CC) == FAILURE) {
@@ -274,26 +268,22 @@ PHP_FUNCTION(ksort)
 PHPAPI int php_count_recursive(zval *array, long mode TSRMLS_DC) /* {{{ */
 {
 	long cnt = 0;
-	zval **element;
+	zval *element;
 
 	if (Z_TYPE_P(array) == IS_ARRAY) {
-		if (Z_ARRVAL_P(array)->nApplyCount > 1) {
+		if (Z_ARRVAL_P(array)->u.v.nApplyCount > 1) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
 			return 0;
 		}
 
 		cnt = zend_hash_num_elements(Z_ARRVAL_P(array));
 		if (mode == COUNT_RECURSIVE) {
-			HashPosition pos;
-
-			for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
-				zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **) &element, &pos) == SUCCESS;
-				zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos)
-			) {
-				Z_ARRVAL_P(array)->nApplyCount++;
-				cnt += php_count_recursive(*element, COUNT_RECURSIVE TSRMLS_CC);
-				Z_ARRVAL_P(array)->nApplyCount--;
-			}
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(array), element) {
+				Z_ARRVAL_P(array)->u.v.nApplyCount++;
+				ZVAL_DEREF(element);
+				cnt += php_count_recursive(element, COUNT_RECURSIVE TSRMLS_CC);
+				Z_ARRVAL_P(array)->u.v.nApplyCount--;
+			} ZEND_HASH_FOREACH_END();
 		}
 	}
 
@@ -321,7 +311,7 @@ PHP_FUNCTION(count)
 			break;
 		case IS_OBJECT: {
 #ifdef HAVE_SPL
-			zval *retval;
+			zval retval;
 #endif
 			/* first, we check if the handler is defined */
 			if (Z_OBJ_HT_P(array)->count_elements) {
@@ -333,17 +323,15 @@ PHP_FUNCTION(count)
 #ifdef HAVE_SPL
 			/* if not and the object implements Countable we call its count() method */
 			if (Z_OBJ_HT_P(array)->get_class_entry && instanceof_function(Z_OBJCE_P(array), spl_ce_Countable TSRMLS_CC)) {
-				zval *mode_zv;
-				MAKE_STD_ZVAL(mode_zv);
-				ZVAL_LONG(mode_zv, mode);
-				zend_call_method_with_1_params(&array, NULL, NULL, "count", &retval, mode_zv);
-				if (retval) {
+				zval mode_zv;
+				ZVAL_LONG(&mode_zv, mode);
+				zend_call_method_with_1_params(array, NULL, NULL, "count", &retval, &mode_zv);
+				if (Z_TYPE(retval) != IS_UNDEF) {
 					convert_to_long_ex(&retval);
-					RETVAL_LONG(Z_LVAL_P(retval));
+					RETVAL_LONG(Z_LVAL(retval));
 					zval_ptr_dtor(&retval);
 				}
-				zval_dtor(mode_zv);
-				efree(mode_zv);
+				zval_dtor(&mode_zv);
 				return;
 			}
 #endif
@@ -369,12 +357,18 @@ static int php_array_data_compare(const void *a, const void *b TSRMLS_DC) /* {{{
 	zval *first;
 	zval *second;
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
 
-	first = *((zval **) f->pData);
-	second = *((zval **) s->pData);
+	first = &f->val;
+	second = &s->val;
 
+	if (Z_TYPE_P(first) == IS_INDIRECT) {
+		first = Z_INDIRECT_P(first);
+	}
+	if (Z_TYPE_P(second) == IS_INDIRECT) {
+		second = Z_INDIRECT_P(second);
+	}
 	if (ARRAYG(compare_func)(&result, first, second TSRMLS_CC) == FAILURE) {
 		return 0;
 	}
@@ -414,13 +408,16 @@ static int php_array_natural_general_compare(const void *a, const void *b, int f
 	zval first, second;
 	int result;
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
+
+	fval = &f->val;
+	sval = &s->val;
 
-	fval = *((zval **) f->pData);
-	sval = *((zval **) s->pData);
-	first = *fval;
-	second = *sval;
+	ZVAL_DEREF(fval);
+	ZVAL_DEREF(sval);
+	ZVAL_COPY_VALUE(&first, fval);
+	ZVAL_COPY_VALUE(&second, sval);
 
 	if (Z_TYPE_P(fval) != IS_STRING) {
 		zval_copy_ctor(&first);
@@ -580,27 +577,31 @@ static int php_array_user_compare(const void *a, const void *b TSRMLS_DC) /* {{{
 {
 	Bucket *f;
 	Bucket *s;
-	zval **args[2];
-	zval *retval_ptr = NULL;
+	zval args[2];
+	zval retval;
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
 
-	args[0] = (zval **) f->pData;
-	args[1] = (zval **) s->pData;
+	ZVAL_COPY(&args[0], &f->val);
+	ZVAL_COPY(&args[1], &s->val);
 
 	BG(user_compare_fci).param_count = 2;
 	BG(user_compare_fci).params = args;
-	BG(user_compare_fci).retval_ptr_ptr = &retval_ptr;
+	BG(user_compare_fci).retval = &retval;
 	BG(user_compare_fci).no_separation = 0;
-	if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && retval_ptr) {
-		long retval;
-
-		convert_to_long_ex(&retval_ptr);
-		retval = Z_LVAL_P(retval_ptr);
-		zval_ptr_dtor(&retval_ptr);
-		return retval < 0 ? -1 : retval > 0 ? 1 : 0;
+	if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		long ret;
+
+		convert_to_long_ex(&retval);
+		ret = Z_LVAL(retval);
+		zval_ptr_dtor(&retval);
+		zval_ptr_dtor(&args[1]);
+		zval_ptr_dtor(&args[0]);
+		return ret < 0 ? -1 : ret > 0 ? 1 : 0;
 	} else {
+		zval_ptr_dtor(&args[1]);
+		zval_ptr_dtor(&args[0]);
 		return 0;
 	}
 }
@@ -656,7 +657,7 @@ PHP_FUNCTION(usort)
 	 * comparison. The result of sorting in such case is undefined and the
 	 * function returns FALSE.
 	 */
-	Z_UNSET_ISREF_P(array);
+//???	Z_UNSET_ISREF_P(array);
 	refcount = Z_REFCOUNT_P(array);
 
 	if (zend_hash_sort(Z_ARRVAL_P(array), zend_qsort, php_array_user_compare, 1 TSRMLS_CC) == FAILURE) {
@@ -671,7 +672,7 @@ PHP_FUNCTION(usort)
 	}
 	
 	if (Z_REFCOUNT_P(array) > 1) {
-		Z_SET_ISREF_P(array);
+//???		Z_SET_ISREF_P(array);
 	}
 
 	PHP_ARRAY_CMP_FUNC_RESTORE();
@@ -699,7 +700,7 @@ PHP_FUNCTION(uasort)
 	 * comparison. The result of sorting in such case is undefined and the
 	 * function returns FALSE.
 	 */
-	Z_UNSET_ISREF_P(array);
+//???	Z_UNSET_ISREF_P(array);
 	refcount = Z_REFCOUNT_P(array);
 
 	if (zend_hash_sort(Z_ARRVAL_P(array), zend_qsort, php_array_user_compare, 0 TSRMLS_CC) == FAILURE) {
@@ -714,7 +715,7 @@ PHP_FUNCTION(uasort)
 	}
 
 	if (Z_REFCOUNT_P(array) > 1) {
-		Z_SET_ISREF_P(array);
+//???		Z_SET_ISREF_P(array);
 	}
 
 	PHP_ARRAY_CMP_FUNC_RESTORE();
@@ -725,50 +726,41 @@ static int php_array_user_key_compare(const void *a, const void *b TSRMLS_DC) /*
 {
 	Bucket *f;
 	Bucket *s;
-	zval *key1, *key2;
-	zval **args[2];
-	zval *retval_ptr = NULL;
+	zval args[2];
+	zval retval;
 	long result;
 
-	ALLOC_INIT_ZVAL(key1);
-	ALLOC_INIT_ZVAL(key2);
-	args[0] = &key1;
-	args[1] = &key2;
+	ZVAL_NULL(&args[0]);
+	ZVAL_NULL(&args[1]);
 
-	f = *((Bucket **) a);
-	s = *((Bucket **) b);
+	f = (Bucket *) a;
+	s = (Bucket *) b;
 
-	if (f->nKeyLength == 0) {
-		Z_LVAL_P(key1) = f->h;
-		Z_TYPE_P(key1) = IS_LONG;
+	if (f->key == NULL) {
+		ZVAL_LONG(&args[0], f->h);
 	} else {
-		Z_STRVAL_P(key1) = estrndup(f->arKey, f->nKeyLength - 1);
-		Z_STRLEN_P(key1) = f->nKeyLength - 1;
-		Z_TYPE_P(key1) = IS_STRING;
+		ZVAL_STR(&args[0], STR_COPY(f->key));
 	}
-	if (s->nKeyLength == 0) {
-		Z_LVAL_P(key2) = s->h;
-		Z_TYPE_P(key2) = IS_LONG;
+	if (s->key == NULL) {
+		ZVAL_LONG(&args[1], s->h);
 	} else {
-		Z_STRVAL_P(key2) = estrndup(s->arKey, s->nKeyLength - 1);
-		Z_STRLEN_P(key2) = s->nKeyLength - 1;
-		Z_TYPE_P(key2) = IS_STRING;
+		ZVAL_STR(&args[1], STR_COPY(s->key));
 	}
 
 	BG(user_compare_fci).param_count = 2;
 	BG(user_compare_fci).params = args;
-	BG(user_compare_fci).retval_ptr_ptr = &retval_ptr;
+	BG(user_compare_fci).retval = &retval;
 	BG(user_compare_fci).no_separation = 0;
-	if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && retval_ptr) {
-		convert_to_long_ex(&retval_ptr);
-		result = Z_LVAL_P(retval_ptr);
-		zval_ptr_dtor(&retval_ptr);
+	if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		convert_to_long_ex(&retval);
+		result = Z_LVAL(retval);
+		zval_ptr_dtor(&retval);
 	} else {
 		result = 0;
 	}
 
-	zval_ptr_dtor(&key1);
-	zval_ptr_dtor(&key2);
+	zval_ptr_dtor(&args[0]);
+	zval_ptr_dtor(&args[1]);
 
 	return result;
 }
@@ -795,7 +787,7 @@ PHP_FUNCTION(uksort)
 	 * comparison. The result of sorting in such case is undefined and the
 	 * function returns FALSE.
 	 */
-	Z_UNSET_ISREF_P(array);
+//???	Z_UNSET_ISREF_P(array);
 	refcount = Z_REFCOUNT_P(array);
 
 	if (zend_hash_sort(Z_ARRVAL_P(array), zend_qsort, php_array_user_key_compare, 0 TSRMLS_CC) == FAILURE) {
@@ -810,7 +802,7 @@ PHP_FUNCTION(uksort)
 	}
 
 	if (Z_REFCOUNT_P(array) > 1) {
-		Z_SET_ISREF_P(array);
+//???		Z_SET_ISREF_P(array);
 	}
 
 	PHP_ARRAY_CMP_FUNC_RESTORE();
@@ -822,7 +814,7 @@ PHP_FUNCTION(uksort)
 PHP_FUNCTION(end)
 {
 	HashTable *array;
-	zval **entry;
+	zval *entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
 		return;
@@ -830,12 +822,16 @@ PHP_FUNCTION(end)
 
 	zend_hash_internal_pointer_end(array);
 
-	if (return_value_used) {
-		if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+	if (USED_RET()) {
+		if ((entry = zend_hash_get_current_data(array)) == NULL) {
 			RETURN_FALSE;
 		}
 
-		RETURN_ZVAL_FAST(*entry);
+		if (Z_TYPE_P(entry) == IS_INDIRECT) {
+			entry = Z_INDIRECT_P(entry);
+		}
+
+		RETURN_ZVAL_FAST(entry);
 	}
 }
 /* }}} */
@@ -845,7 +841,7 @@ PHP_FUNCTION(end)
 PHP_FUNCTION(prev)
 {
 	HashTable *array;
-	zval **entry;
+	zval *entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
 		return;
@@ -853,12 +849,16 @@ PHP_FUNCTION(prev)
 
 	zend_hash_move_backwards(array);
 
-	if (return_value_used) {
-		if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+	if (USED_RET()) {
+		if ((entry = zend_hash_get_current_data(array)) == NULL) {
 			RETURN_FALSE;
 		}
 
-		RETURN_ZVAL_FAST(*entry);
+		if (Z_TYPE_P(entry) == IS_INDIRECT) {
+			entry = Z_INDIRECT_P(entry);
+		}
+
+		RETURN_ZVAL_FAST(entry);
 	}
 }
 /* }}} */
@@ -868,7 +868,7 @@ PHP_FUNCTION(prev)
 PHP_FUNCTION(next)
 {
 	HashTable *array;
-	zval **entry;
+	zval *entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
 		return;
@@ -876,12 +876,16 @@ PHP_FUNCTION(next)
 
 	zend_hash_move_forward(array);
 
-	if (return_value_used) {
-		if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+	if (USED_RET()) {
+		if ((entry = zend_hash_get_current_data(array)) == NULL) {
 			RETURN_FALSE;
 		}
 
-		RETURN_ZVAL_FAST(*entry);
+		if (Z_TYPE_P(entry) == IS_INDIRECT) {
+			entry = Z_INDIRECT_P(entry);
+		}
+
+		RETURN_ZVAL_FAST(entry);
 	}
 }
 /* }}} */
@@ -891,7 +895,7 @@ PHP_FUNCTION(next)
 PHP_FUNCTION(reset)
 {
 	HashTable *array;
-	zval **entry;
+	zval *entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
 		return;
@@ -899,12 +903,16 @@ PHP_FUNCTION(reset)
 
 	zend_hash_internal_pointer_reset(array);
 
-	if (return_value_used) {
-		if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+	if (USED_RET()) {
+		if ((entry = zend_hash_get_current_data(array)) == NULL) {
 			RETURN_FALSE;
 		}
 
-		RETURN_ZVAL_FAST(*entry);
+		if (Z_TYPE_P(entry) == IS_INDIRECT) {
+			entry = Z_INDIRECT_P(entry);
+		}
+
+		RETURN_ZVAL_FAST(entry);
 	}
 }
 /* }}} */
@@ -914,17 +922,21 @@ PHP_FUNCTION(reset)
 PHP_FUNCTION(current)
 {
 	HashTable *array;
-	zval **entry;
+	zval *entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "H", &array) == FAILURE) {
 		return;
 	}
 
-	if (zend_hash_get_current_data(array, (void **) &entry) == FAILURE) {
+	if ((entry = zend_hash_get_current_data(array)) == NULL) {
 		RETURN_FALSE;
 	}
 
-	RETURN_ZVAL_FAST(*entry);
+	if (Z_TYPE_P(entry) == IS_INDIRECT) {
+		entry = Z_INDIRECT_P(entry);
+	}
+
+	RETURN_ZVAL_FAST(entry);
 }
 /* }}} */
 
@@ -947,7 +959,7 @@ PHP_FUNCTION(key)
 PHP_FUNCTION(min)
 {
 	int argc;
-	zval ***args = NULL;
+	zval *args = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
 		return;
@@ -957,14 +969,14 @@ PHP_FUNCTION(min)
 	
 	/* mixed min ( array $values ) */
 	if (argc == 1) {
-		zval **result;
+		zval *result;
 		
-		if (Z_TYPE_PP(args[0]) != IS_ARRAY) {
+		if (Z_TYPE(args[0]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "When only one parameter is given, it must be an array");
 			RETVAL_NULL();
 		} else {
-			if (zend_hash_minmax(Z_ARRVAL_PP(args[0]), php_array_data_compare, 0, (void **) &result TSRMLS_CC) == SUCCESS) {
-				RETVAL_ZVAL_FAST(*result);
+			if ((result = zend_hash_minmax(Z_ARRVAL(args[0]), php_array_data_compare, 0 TSRMLS_CC)) != NULL) {
+				RETVAL_ZVAL_FAST(result);
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array must contain at least one element");
 				RETVAL_FALSE;
@@ -972,23 +984,19 @@ PHP_FUNCTION(min)
 		}
 	} else {
 		/* mixed min ( mixed $value1 , mixed $value2 [, mixed $value3... ] ) */
-		zval **min, result;
+		zval *min, result;
 		int i;
 
-		min = args[0];
+		min = &args[0];
 
 		for (i = 1; i < argc; i++) {
-			is_smaller_function(&result, *args[i], *min TSRMLS_CC);
+			is_smaller_function(&result, &args[i], min TSRMLS_CC);
 			if (Z_LVAL(result) == 1) {
-				min = args[i];
+				min = &args[i];
 			}
 		}
 
-		RETVAL_ZVAL_FAST(*min);
-	}
-
-	if (args) {
-		efree(args);
+		RETVAL_ZVAL_FAST(min);
 	}
 }
 /* }}} */
@@ -997,7 +1005,7 @@ PHP_FUNCTION(min)
    Return the highest value in an array or a series of arguments */
 PHP_FUNCTION(max)
 {
-	zval ***args = NULL;
+	zval *args = NULL;
 	int argc;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
@@ -1008,14 +1016,14 @@ PHP_FUNCTION(max)
 	
 	/* mixed max ( array $values ) */
 	if (argc == 1) {
-		zval **result;
+		zval *result;
 
-		if (Z_TYPE_PP(args[0]) != IS_ARRAY) {
+		if (Z_TYPE(args[0]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "When only one parameter is given, it must be an array");
 			RETVAL_NULL();
 		} else {
-			if (zend_hash_minmax(Z_ARRVAL_PP(args[0]), php_array_data_compare, 1, (void **) &result TSRMLS_CC) == SUCCESS) {
-				RETVAL_ZVAL_FAST(*result);
+			if ((result = zend_hash_minmax(Z_ARRVAL(args[0]), php_array_data_compare, 1 TSRMLS_CC)) != NULL) {
+				RETVAL_ZVAL_FAST(result);
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array must contain at least one element");
 				RETVAL_FALSE;
@@ -1023,59 +1031,68 @@ PHP_FUNCTION(max)
 		}
 	} else {
 		/* mixed max ( mixed $value1 , mixed $value2 [, mixed $value3... ] ) */
-		zval **max, result;
+		zval *max, result;
 		int i;
 
-		max = args[0];
+		max = &args[0];
 
 		for (i = 1; i < argc; i++) {
-			is_smaller_or_equal_function(&result, *args[i], *max TSRMLS_CC);
+			is_smaller_or_equal_function(&result, &args[i], max TSRMLS_CC);
 			if (Z_LVAL(result) == 0) {
-				max = args[i];
+				max = &args[i];
 			}
 		}
 
-		RETVAL_ZVAL_FAST(*max);
-	}
-	
-	if (args) {
-		efree(args);
+		RETVAL_ZVAL_FAST(max);
 	}
 }
 /* }}} */
 
 static int php_array_walk(HashTable *target_hash, zval *userdata, int recursive TSRMLS_DC) /* {{{ */
 {
-	zval **args[3],			/* Arguments to userland function */
-		  *retval_ptr = NULL,		/* Return value - unused */
-		  *key=NULL;		/* Entry key */
+	zval args[3],		/* Arguments to userland function */
+		 retval,		/* Return value - unused */
+		 *zv;
 
 	/* Set up known arguments */
-	args[1] = &key;
-	args[2] = &userdata;
+	ZVAL_UNDEF(&retval);
+	ZVAL_UNDEF(&args[1]);
 	if (userdata) {
-		Z_ADDREF_P(userdata);
+		ZVAL_COPY(&args[2], userdata);
 	}
 
-	BG(array_walk_fci).retval_ptr_ptr = &retval_ptr;
+	BG(array_walk_fci).retval = &retval;
 	BG(array_walk_fci).param_count = userdata ? 3 : 2;
 	BG(array_walk_fci).params = args;
 	BG(array_walk_fci).no_separation = 0;
 	
 	/* Iterate through hash */
 	zend_hash_internal_pointer_reset(target_hash);
-	while (!EG(exception) && zend_hash_get_current_data(target_hash, (void **)&args[0]) == SUCCESS) {
-		if (recursive && Z_TYPE_PP(args[0]) == IS_ARRAY) {
+	while (!EG(exception) && (zv = zend_hash_get_current_data(target_hash)) != NULL) {
+		if (Z_TYPE_P(zv) == IS_INDIRECT) {
+			zv = Z_INDIRECT_P(zv);
+			if (Z_TYPE_P(zv) == IS_UNDEF) {
+				zend_hash_move_forward(target_hash);
+				continue;
+			}
+		}
+		if (recursive &&
+		    (Z_TYPE_P(zv) == IS_ARRAY ||
+		     (Z_ISREF_P(zv) && Z_TYPE_P(Z_REFVAL_P(zv)) == IS_ARRAY))) {
 			HashTable *thash;
 			zend_fcall_info orig_array_walk_fci;
 			zend_fcall_info_cache orig_array_walk_fci_cache;
 
-			SEPARATE_ZVAL_IF_NOT_REF(args[0]);
-			thash = Z_ARRVAL_PP(args[0]);
-			if (thash->nApplyCount > 1) {
+			if (Z_ISREF_P(zv)) {
+				thash = Z_ARRVAL_P(Z_REFVAL_P(zv));
+			} else {
+				SEPARATE_ZVAL(zv);
+				thash = Z_ARRVAL_P(zv);
+			}
+			if (thash->u.v.nApplyCount > 1) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
 				if (userdata) {
-					zval_ptr_dtor(&userdata);
+					zval_ptr_dtor(&args[2]);
 				}
 				return 0;
 			}
@@ -1084,41 +1101,53 @@ static int php_array_walk(HashTable *target_hash, zval *userdata, int recursive
 			orig_array_walk_fci = BG(array_walk_fci);
 			orig_array_walk_fci_cache = BG(array_walk_fci_cache);
 
-			thash->nApplyCount++;
+			thash->u.v.nApplyCount++;
 			php_array_walk(thash, userdata, recursive TSRMLS_CC);
-			thash->nApplyCount--;
+			thash->u.v.nApplyCount--;
 
 			/* restore the fcall info and cache */
 			BG(array_walk_fci) = orig_array_walk_fci;
 			BG(array_walk_fci_cache) = orig_array_walk_fci_cache;
 		} else {
+			int was_ref = Z_ISREF_P(zv);
+
+			ZVAL_COPY(&args[0], zv);
+
 			/* Allocate space for key */
-			MAKE_STD_ZVAL(key);
-			zend_hash_get_current_key_zval(target_hash, key);
+			zend_hash_get_current_key_zval(target_hash, &args[1]);
 
 			/* Call the userland function */
 			if (zend_call_function(&BG(array_walk_fci), &BG(array_walk_fci_cache) TSRMLS_CC) == SUCCESS) {
-				if (retval_ptr) {
-					zval_ptr_dtor(&retval_ptr);
+				if (!was_ref && Z_ISREF(args[0])) {
+					/* copy reference back */
+					zval garbage;
+
+					ZVAL_COPY_VALUE(&garbage, zv);
+					ZVAL_COPY_VALUE(zv, &args[0]);
+					zval_ptr_dtor(&garbage);
+				} else {
+					zval_ptr_dtor(&args[0]);
 				}
+				zval_ptr_dtor(&retval);
 			} else {
-				if (key) {
-					zval_ptr_dtor(&key);
-					key = NULL;
+				zval_ptr_dtor(&args[0]);
+				if (Z_TYPE(args[1]) != IS_UNDEF) {
+					zval_ptr_dtor(&args[1]);
+					ZVAL_UNDEF(&args[1]);
 				}
 				break;
 			}
 		}
 
-		if (key) {
-			zval_ptr_dtor(&key);
-			key = NULL;
+		if (Z_TYPE(args[1]) != IS_UNDEF) {
+			zval_ptr_dtor(&args[1]);
+			ZVAL_UNDEF(&args[1]);
 		}
 		zend_hash_move_forward(target_hash);
 	}
 
 	if (userdata) {
-		zval_ptr_dtor(&userdata);
+		zval_ptr_dtor(&args[2]);
 	}
 	return 0;
 }
@@ -1182,32 +1211,47 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{
 {
 	zval *value,				/* value to check for */
 		 *array,				/* array to check in */
-		 **entry,				/* pointer to array entry */
+		 *entry,				/* pointer to array entry */
 		  res;					/* comparison result */
-	HashPosition pos;			/* hash iterator */
+	ulong num_idx;
+	zend_string *str_idx;
 	zend_bool strict = 0;		/* strict comparison or not */
-	int (*is_equal_func)(zval *, zval *, zval * TSRMLS_DC) = is_equal_function;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "za|b", &value, &array, &strict) == FAILURE) {
 		return;
 	}
 
 	if (strict) {
-		is_equal_func = is_identical_function;
-	}
-
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
-		is_equal_func(&res, value, *entry TSRMLS_CC);
-		if (Z_LVAL(res)) {
-			if (behavior == 0) {
-				RETURN_TRUE;
-			} else {
-				zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(array), return_value, &pos);
-				return;
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
+			is_identical_function(&res, value, entry TSRMLS_CC);
+			if (Z_LVAL(res)) {
+				if (behavior == 0) {
+					RETURN_TRUE;
+				} else {
+					if (str_idx) {
+						RETVAL_STR(STR_COPY(str_idx));
+					} else {
+						RETVAL_LONG(num_idx);
+					}
+					return;
+				}
 			}
-		}
-		zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
+		} ZEND_HASH_FOREACH_END();
+	} else {
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
+			if (fast_equal_function(&res, value, entry TSRMLS_CC)) {
+				if (behavior == 0) {
+					RETURN_TRUE;
+				} else {
+					if (str_idx) {
+						RETVAL_STR(STR_COPY(str_idx));
+					} else {
+						RETVAL_LONG(num_idx);
+					}
+					return;
+				}
+			}
+		} ZEND_HASH_FOREACH_END();
 	}
 
 	RETURN_FALSE;
@@ -1268,9 +1312,7 @@ static int php_valid_var_name(char *var_name, int var_name_len) /* {{{ */
 
 PHPAPI int php_prefix_varname(zval *result, zval *prefix, char *var_name, int var_name_len, zend_bool add_underscore TSRMLS_DC) /* {{{ */
 {
-	Z_STRLEN_P(result) = Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len;
-	Z_TYPE_P(result) = IS_STRING;
-	Z_STRVAL_P(result) = emalloc(Z_STRLEN_P(result) + 1);
+	ZVAL_NEW_STR(result, STR_ALLOC(Z_STRLEN_P(prefix) + (add_underscore ? 1 : 0) + var_name_len, 0));
 	memcpy(Z_STRVAL_P(result), Z_STRVAL_P(prefix), Z_STRLEN_P(prefix));
 
 	if (add_underscore) {
@@ -1289,13 +1331,11 @@ PHP_FUNCTION(extract)
 {
 	zval *var_array, *prefix = NULL;
 	long extract_type = EXTR_OVERWRITE;
-	zval **entry, *data;
-	char *var_name;
+	zval *entry, data;
+	zend_string *var_name;
 	ulong num_key;
-	uint var_name_len;
-	int var_exists, key_type, count = 0;
+	int var_exists, count = 0;
 	int extract_refs = 0;
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|lz/", &var_array, &extract_type, &prefix) == FAILURE) {
 		return;
@@ -1333,19 +1373,15 @@ PHP_FUNCTION(extract)
 		SEPARATE_ARG_IF_REF(var_array);
 	}
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(var_array), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(var_array), (void **)&entry, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_KEY_VAL_IND(Z_ARRVAL_P(var_array), num_key, var_name, entry) {
 		zval final_name;
 
 		ZVAL_NULL(&final_name);
-
-		key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(var_array), &var_name, &var_name_len, &num_key, 0, &pos);
 		var_exists = 0;
 
-		if (key_type == HASH_KEY_IS_STRING) {
-			var_name_len--;
-			var_exists = zend_hash_exists(EG(active_symbol_table), var_name, var_name_len + 1);
-		} else if (key_type == HASH_KEY_IS_LONG && (extract_type == EXTR_PREFIX_ALL || extract_type == EXTR_PREFIX_INVALID)) {
+		if (var_name) {
+			var_exists = zend_hash_exists_ind(&EG(active_symbol_table)->ht, var_name);
+		} else if (extract_type == EXTR_PREFIX_ALL || extract_type == EXTR_PREFIX_INVALID) {
 			zval num;
 
 			ZVAL_LONG(&num, num_key);
@@ -1353,7 +1389,6 @@ PHP_FUNCTION(extract)
 			php_prefix_varname(&final_name, prefix, Z_STRVAL(num), Z_STRLEN(num), 1 TSRMLS_CC);
 			zval_dtor(&num);
 		} else {
-			zend_hash_move_forward_ex(Z_ARRVAL_P(var_array), &pos);
 			continue;
 		}
 
@@ -1364,79 +1399,77 @@ PHP_FUNCTION(extract)
 
 			case EXTR_OVERWRITE:
 				/* GLOBALS protection */
-				if (var_exists && var_name_len == sizeof("GLOBALS")-1 && !strcmp(var_name, "GLOBALS")) {
+				if (var_exists && var_name->len == sizeof("GLOBALS")-1 && !strcmp(var_name->val, "GLOBALS")) {
 					break;
 				}
-				if (var_exists && var_name_len == sizeof("this")-1  && !strcmp(var_name, "this") && EG(scope) && EG(scope)->name_length != 0) {
+				if (var_exists && var_name->len == sizeof("this")-1  && !strcmp(var_name->val, "this") && EG(scope) && EG(scope)->name->len != 0) {
 					break;
 				}
-				ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+				ZVAL_STR(&final_name, STR_COPY(var_name));
 				break;
 
 			case EXTR_PREFIX_IF_EXISTS:
 				if (var_exists) {
-					php_prefix_varname(&final_name, prefix, var_name, var_name_len, 1 TSRMLS_CC);
+					php_prefix_varname(&final_name, prefix, var_name->val, var_name->len, 1 TSRMLS_CC);
 				}
 				break;
 
 			case EXTR_PREFIX_SAME:
-				if (!var_exists && var_name_len != 0) {
-					ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+				if (!var_exists && var_name->len != 0) {
+					ZVAL_STR(&final_name, STR_COPY(var_name));
 				}
 				/* break omitted intentionally */
 
 			case EXTR_PREFIX_ALL:
-				if (Z_TYPE(final_name) == IS_NULL && var_name_len != 0) {
-					php_prefix_varname(&final_name, prefix, var_name, var_name_len, 1 TSRMLS_CC);
+				if (Z_TYPE(final_name) == IS_NULL && var_name->len != 0) {
+					php_prefix_varname(&final_name, prefix, var_name->val, var_name->len, 1 TSRMLS_CC);
 				}
 				break;
 
 			case EXTR_PREFIX_INVALID:
 				if (Z_TYPE(final_name) == IS_NULL) {
-					if (!php_valid_var_name(var_name, var_name_len)) {
-						php_prefix_varname(&final_name, prefix, var_name, var_name_len, 1 TSRMLS_CC);
+					if (!php_valid_var_name(var_name->val, var_name->len)) {
+						php_prefix_varname(&final_name, prefix, var_name->val, var_name->len, 1 TSRMLS_CC);
 					} else {
-						ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+						ZVAL_STR(&final_name, STR_COPY(var_name));
 					}
 				}
 				break;
 
 			default:
 				if (!var_exists) {
-					ZVAL_STRINGL(&final_name, var_name, var_name_len, 1);
+					ZVAL_STR(&final_name, STR_COPY(var_name));
 				}
 				break;
 		}
 
 		if (Z_TYPE(final_name) != IS_NULL && php_valid_var_name(Z_STRVAL(final_name), Z_STRLEN(final_name))) {
 			if (extract_refs) {
-				zval **orig_var;
+				zval *orig_var;
 
 				SEPARATE_ZVAL_TO_MAKE_IS_REF(entry);
-				zval_add_ref(entry);
+				Z_ADDREF_P(entry);
 
-				if (zend_hash_find(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, (void **) &orig_var) == SUCCESS) {
+				if ((orig_var = zend_hash_find(&EG(active_symbol_table)->ht, Z_STR(final_name))) != NULL) {
+					if (Z_TYPE_P(orig_var) == IS_INDIRECT) {
+						orig_var = Z_INDIRECT_P(orig_var);
+					}
 					zval_ptr_dtor(orig_var);
-					*orig_var = *entry;
+					ZVAL_COPY_VALUE(orig_var, entry);
 				} else {
-					zend_hash_update(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, (void **) entry, sizeof(zval *), NULL);
+					zend_hash_update(&EG(active_symbol_table)->ht, Z_STR(final_name), entry);
 				}
 			} else {
-				MAKE_STD_ZVAL(data);
-				*data = **entry;
-				zval_copy_ctor(data);
-
-				ZEND_SET_SYMBOL_WITH_LENGTH(EG(active_symbol_table), Z_STRVAL(final_name), Z_STRLEN(final_name) + 1, data, 1, 0);
+				ZVAL_DUP(&data, entry);
+				zend_set_local_var(Z_STR(final_name), &data, 1 TSRMLS_CC);
 			}
 			count++;
 		}
 		zval_dtor(&final_name);
-
-		zend_hash_move_forward_ex(Z_ARRVAL_P(var_array), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	if (!extract_refs) {
-		zval_ptr_dtor(&var_array);
+		zval_ptr_dtor(var_array);
 	}
 
 	RETURN_LONG(count);
@@ -1445,35 +1478,26 @@ PHP_FUNCTION(extract)
 
 static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_value, zval *entry TSRMLS_DC) /* {{{ */
 {
-	zval **value_ptr, *value, *data;
+	zval *value_ptr, data;
 
+	ZVAL_DEREF(entry);
 	if (Z_TYPE_P(entry) == IS_STRING) {
-		if (zend_hash_find(eg_active_symbol_table, Z_STRVAL_P(entry), Z_STRLEN_P(entry) + 1, (void **)&value_ptr) != FAILURE) {
-			value = *value_ptr;
-			ALLOC_ZVAL(data);
-			MAKE_COPY_ZVAL(&value, data);
-
-			zend_hash_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(entry), Z_STRLEN_P(entry) + 1, &data, sizeof(zval *), NULL);
+		if ((value_ptr = zend_hash_find_ind(eg_active_symbol_table, Z_STR_P(entry))) != NULL) {
+			ZVAL_DUP(&data, value_ptr);
+			zend_hash_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
 		}
-	}
-	else if (Z_TYPE_P(entry) == IS_ARRAY) {
-		HashPosition pos;
-
-		if ((Z_ARRVAL_P(entry)->nApplyCount > 1)) {
+	} else if (Z_TYPE_P(entry) == IS_ARRAY) {
+		if ((Z_ARRVAL_P(entry)->u.v.nApplyCount > 1)) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
 			return;
 		}
 
-		Z_ARRVAL_P(entry)->nApplyCount++;
+		Z_ARRVAL_P(entry)->u.v.nApplyCount++;
 
-		zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(entry), &pos);
-		while (zend_hash_get_current_data_ex(Z_ARRVAL_P(entry), (void**)&value_ptr, &pos) == SUCCESS) {
-			value = *value_ptr;
-
-			php_compact_var(eg_active_symbol_table, return_value, value TSRMLS_CC);
-			zend_hash_move_forward_ex(Z_ARRVAL_P(entry), &pos);
-		}
-		Z_ARRVAL_P(entry)->nApplyCount--;
+		ZEND_HASH_FOREACH_VAL_IND(Z_ARRVAL_P(entry), value_ptr) {
+			php_compact_var(eg_active_symbol_table, return_value, value_ptr TSRMLS_CC);
+		} ZEND_HASH_FOREACH_END();
+		Z_ARRVAL_P(entry)->u.v.nApplyCount--;
 	}
 }
 /* }}} */
@@ -1482,7 +1506,7 @@ static void php_compact_var(HashTable *eg_active_symbol_table, zval *return_valu
    Creates a hash containing variables and their values */
 PHP_FUNCTION(compact)
 {
-	zval ***args = NULL;	/* function arguments array */
+	zval *args = NULL;	/* function arguments array */
 	int num_args, i;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &num_args) == FAILURE) {
@@ -1496,18 +1520,14 @@ PHP_FUNCTION(compact)
 	/* compact() is probably most used with a single array of var_names
 	   or multiple string names, rather than a combination of both.
 	   So quickly guess a minimum result size based on that */
-	if (ZEND_NUM_ARGS() == 1 && Z_TYPE_PP(args[0]) == IS_ARRAY) {
-		array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_PP(args[0])));
+	if (ZEND_NUM_ARGS() == 1 && Z_TYPE(args[0]) == IS_ARRAY) {
+		array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL(args[0])));
 	} else {
 		array_init_size(return_value, ZEND_NUM_ARGS());
 	}
 
 	for (i=0; i<ZEND_NUM_ARGS(); i++) {
-		php_compact_var(EG(active_symbol_table), return_value, *args[i] TSRMLS_CC);
-	}
-
-	if (args) {
-		efree(args);
+		php_compact_var(&EG(active_symbol_table)->ht, return_value, &args[i] TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -1536,12 +1556,12 @@ PHP_FUNCTION(array_fill)
 	}
 
 	num--;
-	zend_hash_index_update(Z_ARRVAL_P(return_value), start_key, &val, sizeof(zval *), NULL);
-	zval_add_ref(&val);
+	zend_hash_index_update(Z_ARRVAL_P(return_value), start_key, val);
+	zval_add_ref(val);
 
 	while (num--) {
-		if (zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &val, sizeof(zval *), NULL) == SUCCESS) {
-			zval_add_ref(&val);
+		if (zend_hash_next_index_insert(Z_ARRVAL_P(return_value), val) != NULL) {
+			zval_add_ref(val);
 		} else {
 			zval_dtor(return_value);
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to the array as the next element is already occupied");
@@ -1555,8 +1575,7 @@ PHP_FUNCTION(array_fill)
    Create an array using the elements of the first parameter as keys each initialized to val */
 PHP_FUNCTION(array_fill_keys)
 {
-	zval *keys, *val, **entry;
-	HashPosition pos;
+	zval *keys, *val, *entry;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "az", &keys, &val) == FAILURE) {
 		return;
@@ -1565,32 +1584,28 @@ PHP_FUNCTION(array_fill_keys)
 	/* Initialize return array */
 	array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(keys)));
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(keys), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), (void **)&entry, &pos) == SUCCESS) {
-
-		if (Z_TYPE_PP(entry) == IS_LONG) {
-			zval_add_ref(&val);
-			zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &val, sizeof(zval *), NULL);
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(keys), entry) {
+		ZVAL_DEREF(entry);
+		if (Z_TYPE_P(entry) == IS_LONG) {
+			zval_add_ref(val);
+			zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), val);
 		} else {
-			zval key, *key_ptr = *entry;
+			zval key, *key_ptr = entry;
 
-			if (Z_TYPE_PP(entry) != IS_STRING) {
-				key = **entry;
-				zval_copy_ctor(&key);
+			if (Z_TYPE_P(entry) != IS_STRING) {
+				ZVAL_DUP(&key, entry);
 				convert_to_string(&key);
 				key_ptr = &key;
 			}
 
-			zval_add_ref(&val);
-			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STRVAL_P(key_ptr), Z_STRLEN_P(key_ptr) + 1, &val, sizeof(zval *), NULL);
+			zval_add_ref(val);
+			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(key_ptr), val);
 
-			if (key_ptr != *entry) {
+			if (key_ptr != entry) {
 				zval_dtor(&key);
 			}
 		}
-
-		zend_hash_move_forward_ex(Z_ARRVAL_P(keys), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -1613,7 +1628,7 @@ PHP_FUNCTION(range)
 			is_step_double = 1;
 		}
 
-		convert_to_double_ex(&zstep);
+		convert_to_double_ex(zstep);
 		step = Z_DVAL_P(zstep);
 
 		/* We only want positive step values. */
@@ -1653,7 +1668,7 @@ PHP_FUNCTION(range)
 				goto err;
 			}
 			for (; ch >= *high; ch -= (unsigned int)lstep) {
-				add_next_index_stringl(return_value, (const char *)&ch, 1, 1);
+				add_next_index_stringl(return_value, (const char *)&ch, 1);
 				if (((signed int)ch - lstep) < 0) {
 					break;
 				}
@@ -1666,13 +1681,13 @@ PHP_FUNCTION(range)
 				goto err;
 			}
 			for (; ch <= *high; ch += (unsigned int)lstep) {
-				add_next_index_stringl(return_value, (const char *)&ch, 1, 1);
+				add_next_index_stringl(return_value, (const char *)&ch, 1);
 				if (((signed int)ch + lstep) > 255) {
 					break;
 				}
 			}
 		} else {
-			add_next_index_stringl(return_value, (const char *)low, 1, 1);
+			add_next_index_stringl(return_value, (const char *)low, 1);
 		}
 
 	} else if (Z_TYPE_P(zlow) == IS_DOUBLE || Z_TYPE_P(zhigh) == IS_DOUBLE || is_step_double) {
@@ -1747,7 +1762,8 @@ err:
 
 static void php_array_data_shuffle(zval *array TSRMLS_DC) /* {{{ */
 {
-	Bucket **elems, *temp;
+	uint idx;
+	Bucket *p, temp;
 	HashTable *hash;
 	int j, n_elems, rnd_idx, n_left;
 
@@ -1757,41 +1773,46 @@ static void php_array_data_shuffle(zval *array TSRMLS_DC) /* {{{ */
 		return;
 	}
 
-	elems = (Bucket **)safe_emalloc(n_elems, sizeof(Bucket *), 0);
 	hash = Z_ARRVAL_P(array);
 	n_left = n_elems;
 
-	for (j = 0, temp = hash->pListHead; temp; temp = temp->pListNext)
-		elems[j++] = temp;
+	if (hash->nNumUsed != hash->nNumOfElements) {
+		for (j = 0, idx = 0; idx < hash->nNumUsed; idx++) {
+			p = hash->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			if (j != idx) {
+				hash->arData[j] = *p;
+			}
+			j++;
+		}
+	}
 	while (--n_left) {
 		rnd_idx = php_rand(TSRMLS_C);
 		RAND_RANGE(rnd_idx, 0, n_left, PHP_RAND_MAX);
 		if (rnd_idx != n_left) {
-			temp = elems[n_left];
-			elems[n_left] = elems[rnd_idx];
-			elems[rnd_idx] = temp;
+			temp = hash->arData[n_left];
+			hash->arData[n_left] = hash->arData[rnd_idx];
+			hash->arData[rnd_idx] = temp;
 		}
 	}
 
 	HANDLE_BLOCK_INTERRUPTIONS();
-	hash->pListHead = elems[0];
-	hash->pListTail = NULL;
-	hash->pInternalPointer = hash->pListHead;
+	hash->nNumUsed = n_elems;
+	hash->nInternalPointer = 0;
 
 	for (j = 0; j < n_elems; j++) {
-		if (hash->pListTail) {
-			hash->pListTail->pListNext = elems[j];
+		p = hash->arData + j;
+		if (p->key && !IS_INTERNED(p->key)) {
+			STR_RELEASE(p->key);
 		}
-		elems[j]->pListLast = hash->pListTail;
-		elems[j]->pListNext = NULL;
-		hash->pListTail = elems[j];
+		p->h = j;
+		p->key = NULL;
+	}
+	hash->nNextFreeElement = n_elems;
+	if (!(hash->u.flags & HASH_FLAG_PACKED)) {
+		zend_hash_to_packed(hash);
 	}
-	temp = hash->pListHead;
-	j = 0;
-	zend_hash_reindex(hash, 0);
 	HANDLE_UNBLOCK_INTERRUPTIONS();
-
-	efree(elems);
 }
 /* }}} */
 
@@ -1811,15 +1832,108 @@ PHP_FUNCTION(shuffle)
 }
 /* }}} */
 
-PHPAPI void php_splice(HashTable *ht, zend_uint offset, zend_uint length, zval ***list, zend_uint list_count, HashTable *removed TSRMLS_DC) /* {{{ */
+PHPAPI HashTable* php_splice(HashTable *in_hash, int offset, int length, zval *list, int list_count, HashTable *removed) /* {{{ */
 {
-	zend_hash_splice(ht, sizeof(zval *), (copy_ctor_func_t) zval_add_ref, offset, length, (void **) list, list_count, removed);
+	HashTable 	*out_hash = NULL;	/* Output hashtable */
+	int			 num_in,			/* Number of entries in the input hashtable */
+				 pos,				/* Current position in the hashtable */
+				 i;					/* Loop counter */
+	uint         idx;
+	Bucket		*p;					/* Pointer to hash bucket */
+	zval		*entry;				/* Hash entry */
 
-	zend_hash_internal_pointer_reset(ht);
+	/* If input hash doesn't exist, we have nothing to do */
+	if (!in_hash) {
+		return NULL;
+	}
+
+	/* Get number of entries in the input hash */
+	num_in = zend_hash_num_elements(in_hash);
 
-	if (ht == &EG(symbol_table)) {
-		zend_reset_all_cv(&EG(symbol_table) TSRMLS_CC);
+	/* Clamp the offset.. */
+	if (offset > num_in) {
+		offset = num_in;
+	} else if (offset < 0 && (offset = (num_in + offset)) < 0) {
+		offset = 0;
 	}
+
+	/* ..and the length */
+	if (length < 0) {
+		length = num_in - offset + length;
+	} else if (((unsigned)offset + (unsigned)length) > (unsigned)num_in) {
+		length = num_in - offset;
+	}
+
+	/* Create and initialize output hash */
+	ALLOC_HASHTABLE(out_hash);
+	zend_hash_init(out_hash, (length > 0 ? num_in - length : 0) + list_count, NULL, ZVAL_PTR_DTOR, 0);
+
+	/* Start at the beginning of the input hash and copy entries to output hash until offset is reached */
+	for (pos = 0, idx = 0; pos < offset && idx < in_hash->nNumUsed; idx++) {
+		p = in_hash->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		pos++;
+		/* Get entry and increase reference count */
+		entry = &p->val;
+		if (Z_REFCOUNTED_P(entry)) {
+			Z_ADDREF_P(entry);
+		}
+
+		/* Update output hash depending on key type */
+		if (p->key == NULL) {
+			zend_hash_next_index_insert(out_hash, entry);
+		} else {
+			zend_hash_update(out_hash, p->key, entry);
+		}
+	}
+
+	/* If hash for removed entries exists, go until offset+length and copy the entries to it */
+	if (removed != NULL) {
+		for ( ; pos < offset + length && idx < in_hash->nNumUsed; idx++) {
+			p = in_hash->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			pos++;
+			entry = &p->val;
+			if (Z_REFCOUNTED_P(entry)) {
+				Z_ADDREF_P(entry);
+			}
+			if (p->key == NULL) {
+				zend_hash_next_index_insert(removed, entry);
+			} else {
+				zend_hash_update(removed, p->key, entry);
+			}
+		}
+	} else { /* otherwise just skip those entries */
+		for ( ; pos < offset + length && idx < in_hash->nNumUsed; pos++, idx++);
+	}
+
+	/* If there are entries to insert.. */
+	if (list != NULL) {
+		/* ..for each one, create a new zval, copy entry into it and copy it into the output hash */
+		for (i = 0; i < list_count; i++) {
+			entry = &list[i];
+			if (Z_REFCOUNTED_P(entry)) Z_ADDREF_P(entry);
+			zend_hash_next_index_insert(out_hash, entry);
+		}
+	}
+
+	/* Copy the remaining input hash entries to the output hash */
+	for ( ; idx < in_hash->nNumUsed ; idx++) {
+		p = in_hash->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		entry = &p->val;
+		if (Z_REFCOUNTED_P(entry)) {
+			Z_ADDREF_P(entry);
+		}
+		if (p->key == NULL) {
+			zend_hash_next_index_insert(out_hash, entry);
+		} else {
+			zend_hash_update(out_hash, p->key, entry);
+		}
+	}
+
+	zend_hash_internal_pointer_reset(out_hash);
+	return out_hash;
 }
 /* }}} */
 
@@ -1827,9 +1941,9 @@ PHPAPI void php_splice(HashTable *ht, zend_uint offset, zend_uint length, zval *
    Pushes elements onto the end of the array */
 PHP_FUNCTION(array_push)
 {
-	zval ***args,		/* Function arguments array */
+	zval   *args,		/* Function arguments array */
 		   *stack,		/* Input array */
-		   *new_var;	/* Variable to be pushed */
+		    new_var;	/* Variable to be pushed */
 	int i,				/* Loop counter */
 		argc;			/* Number of function arguments */
 
@@ -1840,19 +1954,16 @@ PHP_FUNCTION(array_push)
 
 	/* For each subsequent argument, make it a reference, increase refcount, and add it to the end of the array */
 	for (i = 0; i < argc; i++) {
-		new_var = *args[i];
-		Z_ADDREF_P(new_var);
+		ZVAL_COPY(&new_var, &args[i]);
 
-		if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), &new_var, sizeof(zval *), NULL) == FAILURE) {
-			Z_DELREF_P(new_var);
+		if (zend_hash_next_index_insert(Z_ARRVAL_P(stack), &new_var) == NULL) {
+			if (Z_REFCOUNTED(new_var)) Z_DELREF(new_var);
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot add element to the array as the next element is already occupied");
-			efree(args);
 			RETURN_FALSE;
 		}
 	}
 
 	/* Clean up and return the number of values in the stack */
-	efree(args);
 	RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack)));
 }
 /* }}} */
@@ -1861,9 +1972,8 @@ PHP_FUNCTION(array_push)
 static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
 {
 	zval *stack,	/* Input stack */
-		 **val;		/* Value to be popped */
-	char *key = NULL;
-	uint key_len = 0;
+		 *val;		/* Value to be popped */
+	zend_string *key = NULL;
 	ulong index;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &stack) == FAILURE) {
@@ -1877,24 +1987,75 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
 	/* Get the first or last value and copy it into the return value */
 	if (off_the_end) {
 		zend_hash_internal_pointer_end(Z_ARRVAL_P(stack));
+		while (1) {
+			val = zend_hash_get_current_data(Z_ARRVAL_P(stack));
+			if (!val) {
+				return;
+			} else if (Z_TYPE_P(val) == IS_INDIRECT) {
+				val = Z_INDIRECT_P(val);
+				if (Z_TYPE_P(val) == IS_UNDEF) {
+					zend_hash_move_backwards(Z_ARRVAL_P(stack));
+					continue;
+				}
+			}
+			break;
+		}
 	} else {
 		zend_hash_internal_pointer_reset(Z_ARRVAL_P(stack));
+		while (1) {
+			val = zend_hash_get_current_data(Z_ARRVAL_P(stack));
+			if (!val) {
+				return;
+			} else if (Z_TYPE_P(val) == IS_INDIRECT) {
+				val = Z_INDIRECT_P(val);
+				if (Z_TYPE_P(val) == IS_UNDEF) {
+					zend_hash_move_forward(Z_ARRVAL_P(stack));
+					continue;
+				}
+			}
+			break;
+		}
 	}
-	zend_hash_get_current_data(Z_ARRVAL_P(stack), (void **)&val);
-	RETVAL_ZVAL_FAST(*val);
+	RETVAL_ZVAL_FAST(val);
 
 	/* Delete the first or last value */
-	zend_hash_get_current_key_ex(Z_ARRVAL_P(stack), &key, &key_len, &index, 0, NULL);
-	if (key && Z_ARRVAL_P(stack) == &EG(symbol_table)) {
-		zend_delete_global_variable(key, key_len - 1 TSRMLS_CC);
+	zend_hash_get_current_key(Z_ARRVAL_P(stack), &key, &index, 0);
+	if (key && Z_ARRVAL_P(stack) == &EG(symbol_table).ht) {
+		zend_delete_global_variable(key TSRMLS_CC);
+	} else if (key) {
+		zend_hash_del(Z_ARRVAL_P(stack), key);
 	} else {
-		zend_hash_del_key_or_index(Z_ARRVAL_P(stack), key, key_len, index, (key) ? HASH_DEL_KEY : HASH_DEL_INDEX);
+		zend_hash_index_del(Z_ARRVAL_P(stack), index);
 	}
 
 	/* If we did a shift... re-index like it did before */
 	if (!off_the_end) {
-		zend_hash_reindex(Z_ARRVAL_P(stack), 1);
-	} else if (!key_len && index >= Z_ARRVAL_P(stack)->nNextFreeElement - 1) {
+		unsigned int k = 0;
+		int should_rehash = 0;
+		uint idx;
+		Bucket *p;
+
+		for (idx = 0; idx < Z_ARRVAL_P(stack)->nNumUsed; idx++) {
+			p = Z_ARRVAL_P(stack)->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			if (p->key == NULL) {
+				if (p->h != k) {
+					p->h = k++;
+					should_rehash = 1;
+				} else {
+					k++;
+				}
+			}
+		}
+		Z_ARRVAL_P(stack)->nNextFreeElement = k;
+		if (should_rehash) {
+			if (Z_ARRVAL_P(stack)->u.flags & HASH_FLAG_PACKED) {
+				zend_hash_packed_to_hash(Z_ARRVAL_P(stack));
+			} else {
+				zend_hash_rehash(Z_ARRVAL_P(stack));
+			}
+		}
+	} else if (!key && index >= Z_ARRVAL_P(stack)->nNextFreeElement - 1) {
 		Z_ARRVAL_P(stack)->nNextFreeElement = Z_ARRVAL_P(stack)->nNextFreeElement - 1;
 	}
 
@@ -1922,19 +2083,25 @@ PHP_FUNCTION(array_shift)
    Pushes elements onto the beginning of the array */
 PHP_FUNCTION(array_unshift)
 {
-	zval ***args,			/* Function arguments array */
+	zval   *args,			/* Function arguments array */
 		   *stack;			/* Input stack */
+	HashTable *new_hash;	/* New hashtable for the stack */
+	HashTable  old_hash;
 	int argc;				/* Number of function arguments */
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a+", &stack, &args, &argc) == FAILURE) {
 		return;
 	}
 
-	/* Use splice to insert the elements at the beginning. */
-	php_splice(Z_ARRVAL_P(stack), 0, 0, args, argc, NULL TSRMLS_CC);
+	/* Use splice to insert the elements at the beginning. Destroy old
+	 * hashtable and replace it with new one */
+	new_hash = php_splice(Z_ARRVAL_P(stack), 0, 0, &args[0], argc, NULL);
+	old_hash = *Z_ARRVAL_P(stack);
+	*Z_ARRVAL_P(stack) = *new_hash;
+	FREE_HASHTABLE(new_hash);
+	zend_hash_destroy(&old_hash);
 
 	/* Clean up and return the number of elements in the stack */
-	efree(args);
 	RETVAL_LONG(zend_hash_num_elements(Z_ARRVAL_P(stack)));
 }
 /* }}} */
@@ -1944,9 +2111,12 @@ PHP_FUNCTION(array_unshift)
 PHP_FUNCTION(array_splice)
 {
 	zval *array,				/* Input array */
-		 **repl_array = NULL,	/* Replacement array */
-		 ***repl = NULL;		/* Replacement elements */
-	HashTable *rem_hash = NULL;	/* Removed elements' hash */
+		 *repl_array = NULL,	/* Replacement array */
+		 *repl = NULL;			/* Replacement elements */
+	HashTable *new_hash = NULL,	/* Output array's hash */
+	          *rem_hash = NULL;	/* Removed elements' hash */
+	HashTable  old_hash;
+	uint    idx;
 	Bucket *p;					/* Bucket used for traversing hash */
 	long	i,
 			offset,
@@ -1954,7 +2124,7 @@ PHP_FUNCTION(array_splice)
 			repl_num = 0;		/* Number of replacement elements */
 	int		num_in;				/* Number of elements in the input array */
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|lZ", &array, &offset, &length, &repl_array) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|lz/", &array, &offset, &length, &repl_array) == FAILURE) {
 		return;
 	}
 
@@ -1964,44 +2134,55 @@ PHP_FUNCTION(array_splice)
 		length = num_in;
 	}
 
-	if (repl_array) {
+	if (ZEND_NUM_ARGS() == 4) {
 		/* Make sure the last argument, if passed, is an array */
-		convert_to_array_ex(repl_array);
+		convert_to_array(repl_array);
 
 		/* Create the array of replacement elements */
-		repl_num = zend_hash_num_elements(Z_ARRVAL_PP(repl_array));
-		repl = (zval ***)safe_emalloc(repl_num, sizeof(zval **), 0);
-		for (p = Z_ARRVAL_PP(repl_array)->pListHead, i = 0; p; p = p->pListNext, i++) {
-			repl[i] = ((zval **)p->pData);
+		repl_num = zend_hash_num_elements(Z_ARRVAL_P(repl_array));
+		repl = (zval *)safe_emalloc(repl_num, sizeof(zval), 0);
+		for (idx = 0, i = 0; idx < Z_ARRVAL_P(repl_array)->nNumUsed; idx++) {
+			p = Z_ARRVAL_P(repl_array)->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			ZVAL_COPY_VALUE(&repl[i++], &p->val);
 		}
 	}
 
-	/* Clamp the offset */
-	if (offset < 0 && (offset = num_in + offset) < 0) {
-		offset = 0;
-	} else if (offset > num_in) {
-		offset = num_in;
-	}
-
-	/* Clamp the length */
-	if (length < 0 && (length = num_in - offset + length) < 0) {
-		length = 0;
-	} else if ((unsigned long) offset + (unsigned long) length > (unsigned) num_in) {
-		length = num_in - offset;
-	}
-
 	/* Don't create the array of removed elements if it's not going
 	 * to be used; e.g. only removing and/or replacing elements */
-	if (return_value_used) {
-		array_init_size(return_value, length);
+	if (USED_RET()) {
+		int size = length;
+
+		/* Clamp the offset.. */
+		if (offset > num_in) {
+			offset = num_in;
+		} else if (offset < 0 && (offset = (num_in + offset)) < 0) {
+			offset = 0;
+		}
+
+		/* ..and the length */
+		if (length < 0) {
+			size = num_in - offset + length;
+		} else if (((unsigned long) offset + (unsigned long) length) > (unsigned) num_in) {
+			size = num_in - offset;
+		}
+
+		/* Initialize return value */
+		array_init_size(return_value, size > 0 ? size : 0);
 		rem_hash = Z_ARRVAL_P(return_value);
 	}
 
 	/* Perform splice */
-	php_splice(Z_ARRVAL_P(array), offset, length, repl, repl_num, rem_hash TSRMLS_CC);
+	new_hash = php_splice(Z_ARRVAL_P(array), offset, length, repl, repl_num, rem_hash);
+
+	/* Replace input array's hashtable with the new one */
+	old_hash = *Z_ARRVAL_P(array);
+	*Z_ARRVAL_P(array) = *new_hash;
+	FREE_HASHTABLE(new_hash);
+	zend_hash_destroy(&old_hash);
 
 	/* Clean up */
-	if (repl) {
+	if (ZEND_NUM_ARGS() == 4) {
 		efree(repl);
 	}
 }
@@ -2012,19 +2193,17 @@ PHP_FUNCTION(array_splice)
 PHP_FUNCTION(array_slice)
 {
 	zval	 *input,		/* Input array */
-			**z_length = NULL, /* How many elements to get */ 
-			**entry;		/* An array entry */
+			 *z_length = NULL, /* How many elements to get */ 
+			 *entry;		/* An array entry */
 	long	 offset,		/* Offset to get elements from */
 			 length = 0;	
 	zend_bool preserve_keys = 0; /* Whether to preserve keys while copying to the new array or not */
 	int		 num_in,		/* Number of elements in the input array */
 			 pos;			/* Current position in the array */
-	char *string_key;
-	uint string_key_len;
+	zend_string *string_key;
 	ulong num_key;
-	HashPosition hpos;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|Zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "al|zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) {
 		return;
 	}
 
@@ -2032,11 +2211,11 @@ PHP_FUNCTION(array_slice)
 	num_in = zend_hash_num_elements(Z_ARRVAL_P(input));
 
 	/* We want all entries from offset to the end if length is not passed or is null */
-	if (ZEND_NUM_ARGS() < 3 || Z_TYPE_PP(z_length) == IS_NULL) {
+	if (ZEND_NUM_ARGS() < 3 || Z_TYPE_P(z_length) == IS_NULL) {
 		length = num_in;
 	} else {
 		convert_to_long_ex(z_length);
-		length = Z_LVAL_PP(z_length);
+		length = Z_LVAL_P(z_length);
 	}
 
 	/* Clamp the offset.. */
@@ -2063,165 +2242,171 @@ PHP_FUNCTION(array_slice)
 
 	/* Start at the beginning and go until we hit offset */
 	pos = 0;
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &hpos);
-	while (pos < offset && zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &hpos) == SUCCESS) {
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(input), num_key, string_key, entry) {
 		pos++;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &hpos);
-	}
-
-	/* Copy elements from input array to the one that's returned */
-	while (pos < offset + length && zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &hpos) == SUCCESS) {
+		if (pos <= offset) {
+			continue;
+		}
+		if (pos > offset + length) {
+			break;
+		}
 
+		/* Copy elements from input array to the one that's returned */
 		zval_add_ref(entry);
 
-		switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, &hpos)) {
-			case HASH_KEY_IS_STRING:
-				zend_hash_update(Z_ARRVAL_P(return_value), string_key, string_key_len, entry, sizeof(zval *), NULL);
-				break;
-
-			case HASH_KEY_IS_LONG:
-				if (preserve_keys) {
-					zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry, sizeof(zval *), NULL);
-				} else {
-					zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, sizeof(zval *), NULL);
-				}
-				break;
+		if (string_key) {
+			zend_hash_update(Z_ARRVAL_P(return_value), string_key, entry);
+		} else {
+			if (preserve_keys) {
+				zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry);
+			} else {
+				zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry);
+			}
 		}
-		pos++;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &hpos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
 PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS_DC) /* {{{ */
 {
-	zval **src_entry, **dest_entry;
-	char *string_key;
-	uint string_key_len;
-	ulong num_key;
-	HashPosition pos;
-
-	zend_hash_internal_pointer_reset_ex(src, &pos);
-	while (zend_hash_get_current_data_ex(src, (void **)&src_entry, &pos) == SUCCESS) {
-		switch (zend_hash_get_current_key_ex(src, &string_key, &string_key_len, &num_key, 0, &pos)) {
-			case HASH_KEY_IS_STRING:
-				if (recursive && zend_hash_find(dest, string_key, string_key_len, (void **)&dest_entry) == SUCCESS) {
-					HashTable *thash = Z_TYPE_PP(dest_entry) == IS_ARRAY ? Z_ARRVAL_PP(dest_entry) : NULL;
-					zval *src_zval;
-					zval *tmp = NULL;
-
-					if ((thash && thash->nApplyCount > 1) || (*src_entry == *dest_entry && Z_ISREF_PP(dest_entry) && (Z_REFCOUNT_PP(dest_entry) % 2))) {
-						php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
-						return 0;
-					}
-					SEPARATE_ZVAL(dest_entry);
-
-					if (Z_TYPE_PP(dest_entry) == IS_NULL) {
-						convert_to_array_ex(dest_entry);
-						add_next_index_null(*dest_entry);
+	zval *src_entry, *dest_entry;
+	zend_string *string_key;
+
+	ZEND_HASH_FOREACH_STR_KEY_VAL(src, string_key, src_entry) {
+		if (string_key) {
+			if (recursive && (dest_entry = zend_hash_find(dest, string_key)) != NULL) {
+				zval *src_zval = src_entry;
+				zval *dest_zval = dest_entry;
+				HashTable *thash;
+				zval tmp;
+					
+				ZVAL_DEREF(src_zval);
+				ZVAL_DEREF(dest_zval);
+				thash = Z_TYPE_P(dest_zval) == IS_ARRAY ? Z_ARRVAL_P(dest_zval) : NULL;
+				if ((thash && thash->u.v.nApplyCount > 1) || (src_entry == dest_entry && Z_ISREF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) {
+					php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
+					return 0;
+				}
+					
+				if (Z_ISREF_P(dest_entry)) {
+					if (Z_REFCOUNT_P(dest_entry) == 1) {
+						ZVAL_UNREF(dest_entry);
 					} else {
-						convert_to_array_ex(dest_entry);
+						Z_DELREF_P(dest_entry);
+						ZVAL_DUP(dest_entry, dest_zval);
 					}
-					if (Z_TYPE_PP(src_entry) == IS_OBJECT) {
-						ALLOC_ZVAL(src_zval);
-						INIT_PZVAL_COPY(src_zval, *src_entry);
-						zval_copy_ctor(src_zval);
-						convert_to_array(src_zval);
-						tmp = src_zval;
-					} else {
-						src_zval = *src_entry;
+					dest_zval = dest_entry;
+				} else {
+					SEPARATE_ZVAL(dest_zval);
+				}
+
+				if (Z_TYPE_P(dest_zval) == IS_NULL) {
+					convert_to_array_ex(dest_zval);
+					add_next_index_null(dest_zval);
+				} else {
+					convert_to_array_ex(dest_zval);
+				}
+				ZVAL_UNDEF(&tmp);
+				if (Z_TYPE_P(src_zval) == IS_OBJECT) {
+					ZVAL_DUP(&tmp, src_zval);
+					convert_to_array(&tmp);
+					src_zval = &tmp;
+				}
+				if (Z_TYPE_P(src_zval) == IS_ARRAY) {
+					if (thash) {
+						thash->u.v.nApplyCount++;
 					}
-					if (Z_TYPE_P(src_zval) == IS_ARRAY) {
+					if (!php_array_merge(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval), recursive TSRMLS_CC)) {
 						if (thash) {
-							thash->nApplyCount++;
+							thash->u.v.nApplyCount--;
 						}
-						if (!php_array_merge(Z_ARRVAL_PP(dest_entry), Z_ARRVAL_P(src_zval), recursive TSRMLS_CC)) {
-							if (thash) {
-								thash->nApplyCount--;
-							}
-							return 0;
-						}
-						if (thash) {
-							thash->nApplyCount--;
-						}
-					} else {
-						Z_ADDREF_PP(src_entry);
-						zend_hash_next_index_insert(Z_ARRVAL_PP(dest_entry), &src_zval, sizeof(zval *), NULL);
+						return 0;
 					}
-					if (tmp) {
-						zval_ptr_dtor(&tmp);
+					if (thash) {
+						thash->u.v.nApplyCount--;
 					}
 				} else {
-					Z_ADDREF_PP(src_entry);
-					zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
+					if (Z_REFCOUNTED_P(src_entry)) {
+						Z_ADDREF_P(src_entry);
+					}
+					zend_hash_next_index_insert(Z_ARRVAL_P(dest_zval), src_zval);
 				}
-				break;
-
-			case HASH_KEY_IS_LONG:
-				Z_ADDREF_PP(src_entry);
-				zend_hash_next_index_insert(dest, src_entry, sizeof(zval *), NULL);
-				break;
+				zval_ptr_dtor(&tmp);
+			} else {
+				if (Z_REFCOUNTED_P(src_entry)) {
+					Z_ADDREF_P(src_entry);
+				}
+				zend_hash_update(dest, string_key, src_entry);
+			}
+		} else {
+			if (Z_REFCOUNTED_P(src_entry)) {
+				Z_ADDREF_P(src_entry);
+			}
+			zend_hash_next_index_insert(dest, src_entry);
 		}
-		zend_hash_move_forward_ex(src, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 	return 1;
 }
 /* }}} */
 
 PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC) /* {{{ */
 {
-	zval **src_entry, **dest_entry;
-	char *string_key;
-	uint string_key_len;
+	zval *src_entry, *dest_entry, *src_zval, *dest_zval;
+	zend_string *string_key;
 	ulong num_key;
-	HashPosition pos;
-
-	for (zend_hash_internal_pointer_reset_ex(src, &pos);
-	     zend_hash_get_current_data_ex(src, (void **)&src_entry, &pos) == SUCCESS;
-	     zend_hash_move_forward_ex(src, &pos)) {
-		switch (zend_hash_get_current_key_ex(src, &string_key, &string_key_len, &num_key, 0, &pos)) {
-			case HASH_KEY_IS_STRING:
-				if (Z_TYPE_PP(src_entry) != IS_ARRAY ||
-					zend_hash_find(dest, string_key, string_key_len, (void **)&dest_entry) == FAILURE ||
-					Z_TYPE_PP(dest_entry) != IS_ARRAY) {
-
-					Z_ADDREF_PP(src_entry);
-					zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
 
-					continue;
+	ZEND_HASH_FOREACH_KEY_VAL(src, num_key, string_key, src_entry) {
+		src_zval = src_entry;
+		ZVAL_DEREF(src_zval);
+		if (string_key) {
+			if (Z_TYPE_P(src_zval) != IS_ARRAY ||
+				(dest_entry = zend_hash_find(dest, string_key)) == NULL ||
+				(Z_TYPE_P(dest_entry) != IS_ARRAY &&
+				 (!Z_ISREF_P(dest_entry) || Z_TYPE_P(Z_REFVAL_P(dest_entry)) != IS_ARRAY))) {
+
+				if (Z_REFCOUNTED_P(src_entry)) {
+					Z_ADDREF_P(src_entry);
 				}
-				break;
-
-			case HASH_KEY_IS_LONG:
-				if (Z_TYPE_PP(src_entry) != IS_ARRAY ||
-					zend_hash_index_find(dest, num_key, (void **)&dest_entry) == FAILURE ||
-					Z_TYPE_PP(dest_entry) != IS_ARRAY) {
+				zend_hash_update(dest, string_key, src_entry);
 
-					Z_ADDREF_PP(src_entry);
-					zend_hash_index_update(dest, num_key, src_entry, sizeof(zval *), NULL);
+				continue;
+			}
+		} else {
+			if (Z_TYPE_P(src_zval) != IS_ARRAY ||
+				(dest_entry = zend_hash_index_find(dest, num_key)) == NULL ||
+				(Z_TYPE_P(dest_entry) != IS_ARRAY &&
+				 (!Z_ISREF_P(dest_entry) || Z_TYPE_P(Z_REFVAL_P(dest_entry)) != IS_ARRAY))) {
 
-					continue;
+				if (Z_REFCOUNTED_P(src_entry)) {
+					Z_ADDREF_P(src_entry);
 				}
-				break;
+				zend_hash_index_update(dest, num_key, src_entry);
+
+				continue;
+			}
 		}
 
-		if (Z_ARRVAL_PP(dest_entry)->nApplyCount > 1 || Z_ARRVAL_PP(src_entry)->nApplyCount > 1 || (*src_entry == *dest_entry && Z_ISREF_PP(dest_entry) && (Z_REFCOUNT_PP(dest_entry) % 2))) {
+		dest_zval = dest_entry;
+		ZVAL_DEREF(dest_zval);
+		if (Z_ARRVAL_P(dest_zval)->u.v.nApplyCount > 1 ||
+		    Z_ARRVAL_P(src_zval)->u.v.nApplyCount > 1 ||
+		    (Z_ISREF_P(src_entry) && Z_ISREF_P(dest_entry) && Z_REF_P(src_entry) == Z_REF_P(dest_entry) && (Z_REFCOUNT_P(dest_entry) % 2))) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "recursion detected");
 			return 0;
 		}
-		SEPARATE_ZVAL(dest_entry);
-		Z_ARRVAL_PP(dest_entry)->nApplyCount++;
-		Z_ARRVAL_PP(src_entry)->nApplyCount++;
+		SEPARATE_ZVAL(dest_zval);
+		Z_ARRVAL_P(dest_zval)->u.v.nApplyCount++;
+		Z_ARRVAL_P(src_zval)->u.v.nApplyCount++;
 		
 
-		if (!php_array_replace_recursive(Z_ARRVAL_PP(dest_entry), Z_ARRVAL_PP(src_entry) TSRMLS_CC)) {
-			Z_ARRVAL_PP(dest_entry)->nApplyCount--;
-			Z_ARRVAL_PP(src_entry)->nApplyCount--;
+		if (!php_array_replace_recursive(Z_ARRVAL_P(dest_zval), Z_ARRVAL_P(src_zval) TSRMLS_CC)) {
+			Z_ARRVAL_P(dest_zval)->u.v.nApplyCount--;
+			Z_ARRVAL_P(src_zval)->u.v.nApplyCount--;
 			return 0;
 		}
-		Z_ARRVAL_PP(dest_entry)->nApplyCount--;
-		Z_ARRVAL_PP(src_entry)->nApplyCount--;
-	}
+		Z_ARRVAL_P(dest_zval)->u.v.nApplyCount--;
+		Z_ARRVAL_P(src_zval)->u.v.nApplyCount--;
+	} ZEND_HASH_FOREACH_END();
 
 	return 1;
 }
@@ -2229,7 +2414,7 @@ PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC
 
 static void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETERS, int recursive, int replace) /* {{{ */
 {
-	zval ***args = NULL;
+	zval *args = NULL;
 	int argc, i, init_size = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
@@ -2237,12 +2422,14 @@ static void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETERS, int
 	}
 
 	for (i = 0; i < argc; i++) {
-		if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+		zval *arg = args + i;
+
+		ZVAL_DEREF(arg);
+		if (Z_TYPE_P(arg) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
-			efree(args);
 			RETURN_NULL();
 		} else {
-			int num = zend_hash_num_elements(Z_ARRVAL_PP(args[i]));
+			int num = zend_hash_num_elements(Z_ARRVAL_P(arg));
 
 			if (num > init_size) {
 				init_size = num;
@@ -2253,16 +2440,17 @@ static void php_array_merge_or_replace_wrapper(INTERNAL_FUNCTION_PARAMETERS, int
 	array_init_size(return_value, init_size);
 
 	for (i = 0; i < argc; i++) {
+		zval *arg = args + i;
+
+		ZVAL_DEREF(arg);
 		if (!replace) {
-			php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(args[i]), recursive TSRMLS_CC);
+			php_array_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg), recursive TSRMLS_CC);
 		} else if (recursive && i > 0) { /* First array will be copied directly instead */
-			php_array_replace_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(args[i]) TSRMLS_CC);
+			php_array_replace_recursive(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg) TSRMLS_CC);
 		} else {
-			zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(args[i]), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval *), 1);
+			zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(arg), zval_add_ref, 1);
 		}
 	}
-
-	efree(args);
 }
 /* }}} */
 
@@ -2304,12 +2492,13 @@ PHP_FUNCTION(array_keys)
 {
 	zval *input,				/* Input array */
 	     *search_value = NULL,	/* Value to search for */
-	     **entry,				/* An entry in the input array */
+	     *entry,				/* An entry in the input array */
 	       res,					/* Result of comparison */
-	      *new_val;				/* New value */
+	       new_val;				/* New value */
 	int    add_key;				/* Flag to indicate whether a key should be added */
 	zend_bool strict = 0;		/* do strict comparison */
-	HashPosition pos;
+	ulong num_idx;
+	zend_string *str_idx;
 	int (*is_equal_func)(zval *, zval *, zval * TSRMLS_DC) = is_equal_function;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|zb", &input, &search_value, &strict) == FAILURE) {
@@ -2329,21 +2518,21 @@ PHP_FUNCTION(array_keys)
 	add_key = 1;
 
 	/* Go through input array and add keys to the return array */
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(input), num_idx, str_idx, entry) {
 		if (search_value != NULL) {
-			is_equal_func(&res, search_value, *entry TSRMLS_CC);
+			is_equal_func(&res, search_value, entry TSRMLS_CC);
 			add_key = zval_is_true(&res);
 		}
 
 		if (add_key) {
-			MAKE_STD_ZVAL(new_val);
-			zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(input), new_val, &pos);
-			zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &new_val, sizeof(zval *), NULL);
+			if (str_idx) {
+				ZVAL_STR(&new_val, STR_COPY(str_idx));
+			} else {
+				ZVAL_LONG(&new_val, num_idx);
+			}
+			zend_hash_next_index_insert(Z_ARRVAL_P(return_value), &new_val);
 		}
-
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2352,8 +2541,7 @@ PHP_FUNCTION(array_keys)
 PHP_FUNCTION(array_values)
 {
 	zval	 *input,		/* Input array */
-			**entry;		/* An entry in the input array */
-	HashPosition pos;
+			 *entry;		/* An entry in the input array */
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &input) == FAILURE) {
 		return;
@@ -2363,12 +2551,10 @@ PHP_FUNCTION(array_values)
 	array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(input)));
 
 	/* Go through input array and add values to the return array */
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), entry) {
 		zval_add_ref(entry);
-		zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, sizeof(zval *), NULL);
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
-	}
+		zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry);
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2376,11 +2562,10 @@ PHP_FUNCTION(array_values)
    Return the value as key and the frequency of that value in input as value */
 PHP_FUNCTION(array_count_values)
 {
-	zval	*input,			/* Input array */
-			**entry,		/* An entry in the input array */
-			**tmp;
+	zval	*input,		/* Input array */
+			*entry,		/* An entry in the input array */
+			*tmp;
 	HashTable *myht;
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &input) == FAILURE) {
 		return;
@@ -2391,32 +2576,27 @@ PHP_FUNCTION(array_count_values)
 
 	/* Go through input array and add values to the return array */
 	myht = Z_ARRVAL_P(input);
-	zend_hash_internal_pointer_reset_ex(myht, &pos);
-	while (zend_hash_get_current_data_ex(myht, (void **)&entry, &pos) == SUCCESS) {
-		if (Z_TYPE_PP(entry) == IS_LONG) {
-			if (zend_hash_index_find(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), (void **)&tmp) == FAILURE) {
-				zval *data;
-				MAKE_STD_ZVAL(data);
-				ZVAL_LONG(data, 1);
-				zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &data, sizeof(data), NULL);
+	ZEND_HASH_FOREACH_VAL(myht, entry) {
+		if (Z_TYPE_P(entry) == IS_LONG) {
+			if ((tmp = zend_hash_index_find(Z_ARRVAL_P(return_value), Z_LVAL_P(entry))) == NULL) {
+				zval data;
+				ZVAL_LONG(&data, 1);
+				zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data);
 			} else {
-				Z_LVAL_PP(tmp)++;
+				Z_LVAL_P(tmp)++;
 			}
-		} else if (Z_TYPE_PP(entry) == IS_STRING) {
-			if (zend_symtable_find(Z_ARRVAL_P(return_value), Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, (void**)&tmp) == FAILURE) {
-				zval *data;
-				MAKE_STD_ZVAL(data);
-				ZVAL_LONG(data, 1);
-				zend_symtable_update(Z_ARRVAL_P(return_value), Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, &data, sizeof(data), NULL);
+		} else if (Z_TYPE_P(entry) == IS_STRING) {
+			if ((tmp = zend_symtable_find(Z_ARRVAL_P(return_value), Z_STR_P(entry))) == NULL) {
+				zval data;
+				ZVAL_LONG(&data, 1);
+				zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
 			} else {
-				Z_LVAL_PP(tmp)++;
+				Z_LVAL_P(tmp)++;
 			}
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only count STRING and INTEGER values!");
 		}
-
-		zend_hash_move_forward_ex(myht, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2424,9 +2604,9 @@ PHP_FUNCTION(array_count_values)
  * Specialized conversion rules for array_column() function
  */
 static inline
-zend_bool array_column_param_helper(zval **param,
+zend_bool array_column_param_helper(zval *param,
                                     const char *name TSRMLS_DC) {
-	switch (Z_TYPE_PP(param)) {
+	switch (Z_TYPE_P(param)) {
 		case IS_DOUBLE:
 			convert_to_long_ex(param);
 			/* fallthrough */
@@ -2450,11 +2630,12 @@ zend_bool array_column_param_helper(zval **param,
    value_key and optionally indexed by the index_key */
 PHP_FUNCTION(array_column)
 {
-	zval **zcolumn = NULL, **zkey = NULL, **data;
+	zval *zcolumn = NULL, *zkey = NULL, *data;
 	HashTable *arr_hash;
-	HashPosition pointer;
+	zval *zcolval = NULL, *zkeyval = NULL;
+	HashTable *ht;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hZ!|Z!", &arr_hash, &zcolumn, &zkey) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "hz!|z!", &arr_hash, &zcolumn, &zkey) == FAILURE) {
 		return;
 	}
 
@@ -2464,53 +2645,50 @@ PHP_FUNCTION(array_column)
 	}
 
 	array_init(return_value);
-	for (zend_hash_internal_pointer_reset_ex(arr_hash, &pointer);
-			zend_hash_get_current_data_ex(arr_hash, (void**)&data, &pointer) == SUCCESS;
-			zend_hash_move_forward_ex(arr_hash, &pointer)) {
-		zval **zcolval, **zkeyval = NULL;
-		HashTable *ht;
-
-		if (Z_TYPE_PP(data) != IS_ARRAY) {
+	ZEND_HASH_FOREACH_VAL(arr_hash, data) {
+		if (Z_TYPE_P(data) != IS_ARRAY) {
 			/* Skip elemens which are not sub-arrays */
 			continue;
 		}
-		ht = Z_ARRVAL_PP(data);
+		ht = Z_ARRVAL_P(data);
 
 		if (!zcolumn) {
 			/* NULL column ID means use entire subarray as data */
 			zcolval = data;
 
 			/* Otherwise, skip if the value doesn't exist in our subarray */
-		} else if ((Z_TYPE_PP(zcolumn) == IS_STRING) &&
-		    (zend_hash_find(ht, Z_STRVAL_PP(zcolumn), Z_STRLEN_PP(zcolumn) + 1, (void**)&zcolval) == FAILURE)) {
+		} else if ((Z_TYPE_P(zcolumn) == IS_STRING) &&
+		    ((zcolval = zend_hash_find(ht, Z_STR_P(zcolumn))) == NULL)) {
 			continue;
-		} else if ((Z_TYPE_PP(zcolumn) == IS_LONG) &&
-		    (zend_hash_index_find(ht, Z_LVAL_PP(zcolumn), (void**)&zcolval) == FAILURE)) {
+		} else if ((Z_TYPE_P(zcolumn) == IS_LONG) &&
+		    ((zcolval = zend_hash_index_find(ht, Z_LVAL_P(zcolumn))) == NULL)) {
 			continue;
 		}
 
 		/* Failure will leave zkeyval alone which will land us on the final else block below
 		 * which is to append the value as next_index
 		 */
-		if (zkey && (Z_TYPE_PP(zkey) == IS_STRING)) {
-			zend_hash_find(ht, Z_STRVAL_PP(zkey), Z_STRLEN_PP(zkey) + 1, (void**)&zkeyval);
-		} else if (zkey && (Z_TYPE_PP(zkey) == IS_LONG)) {
-			zend_hash_index_find(ht, Z_LVAL_PP(zkey), (void**)&zkeyval);
-		}
-
-		Z_ADDREF_PP(zcolval);
-		if (zkeyval && Z_TYPE_PP(zkeyval) == IS_STRING) {
-			add_assoc_zval(return_value, Z_STRVAL_PP(zkeyval), *zcolval);
-		} else if (zkeyval && Z_TYPE_PP(zkeyval) == IS_LONG) {
-			add_index_zval(return_value, Z_LVAL_PP(zkeyval), *zcolval);
-		} else if (zkeyval && Z_TYPE_PP(zkeyval) == IS_OBJECT) {
+		if (zkey && (Z_TYPE_P(zkey) == IS_STRING)) {
+			zkeyval = zend_hash_find(ht, Z_STR_P(zkey));
+		} else if (zkey && (Z_TYPE_P(zkey) == IS_LONG)) {
+			zkeyval = zend_hash_index_find(ht, Z_LVAL_P(zkey));
+		}
+
+		if (Z_REFCOUNTED_P(zcolval)) {
+			Z_ADDREF_P(zcolval);
+		}
+		if (zkeyval && Z_TYPE_P(zkeyval) == IS_STRING) {
+			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(zkeyval), zcolval);
+		} else if (zkeyval && Z_TYPE_P(zkeyval) == IS_LONG) {
+			add_index_zval(return_value, Z_LVAL_P(zkeyval), zcolval);
+		} else if (zkeyval && Z_TYPE_P(zkeyval) == IS_OBJECT) {
 			SEPARATE_ZVAL(zkeyval);
-			convert_to_string(*zkeyval);
-			add_assoc_zval(return_value, Z_STRVAL_PP(zkeyval), *zcolval);
+			convert_to_string(zkeyval);
+			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(zkeyval), zcolval);
 		} else {
-			add_next_index_zval(return_value, *zcolval);
+			add_next_index_zval(return_value, zcolval);
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2519,12 +2697,10 @@ PHP_FUNCTION(array_column)
 PHP_FUNCTION(array_reverse)
 {
 	zval	 *input,				/* Input array */
-			**entry;				/* An entry in the input array */
-	char	 *string_key;
-	uint	  string_key_len;
+			 *entry;				/* An entry in the input array */
+	zend_string *string_key;
 	ulong	  num_key;
 	zend_bool preserve_keys = 0;	/* whether to preserve keys */
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|b", &input, &preserve_keys) == FAILURE) {
 		return;
@@ -2533,26 +2709,19 @@ PHP_FUNCTION(array_reverse)
 	/* Initialize return array */
 	array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(input)));
 
-	zend_hash_internal_pointer_end_ex(Z_ARRVAL_P(input), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS) {
+	ZEND_HASH_REVERSE_FOREACH_KEY_VAL(Z_ARRVAL_P(input), num_key, string_key, entry) {
 		zval_add_ref(entry);
 
-		switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, &pos)) {
-			case HASH_KEY_IS_STRING:
-				zend_hash_update(Z_ARRVAL_P(return_value), string_key, string_key_len, entry, sizeof(zval *), NULL);
-				break;
-
-			case HASH_KEY_IS_LONG:
-				if (preserve_keys) {
-					zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry, sizeof(zval *), NULL);
-				} else {
-					zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry, sizeof(zval *), NULL);
-				}
-				break;
+		if (string_key) {
+			zend_hash_update(Z_ARRVAL_P(return_value), string_key, entry);
+		} else {
+			if (preserve_keys) {
+				zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry);
+			} else {
+				zend_hash_next_index_insert(Z_ARRVAL_P(return_value), entry);
+			}
 		}
-
-		zend_hash_move_backwards_ex(Z_ARRVAL_P(input), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2562,7 +2731,9 @@ PHP_FUNCTION(array_pad)
 {
 	zval  *input;		/* Input array */
 	zval  *pad_value;	/* Padding value obviously */
-	zval ***pads;		/* Array to pass to splice */
+	zval  *pads;		/* Array to pass to splice */
+	HashTable *new_hash;/* Return value from splice */
+	HashTable  old_hash;
 	long pad_size;		/* Size to pad to */
 	long pad_size_abs;	/* Absolute value of pad_size */
 	int	input_size;		/* Size of the input array */
@@ -2599,18 +2770,24 @@ PHP_FUNCTION(array_pad)
 		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
-	pads = (zval ***)safe_emalloc(num_pads, sizeof(zval **), 0);
+	pads = (zval *)safe_emalloc(num_pads, sizeof(zval), 0);
 	for (i = 0; i < num_pads; i++) {
-		pads[i] = &pad_value;
+		ZVAL_COPY_VALUE(&pads[i], pad_value);
 	}
 
 	/* Pad on the right or on the left */
 	if (pad_size > 0) {
-		php_splice(Z_ARRVAL_P(return_value), input_size, 0, pads, num_pads, NULL TSRMLS_CC);
+		new_hash = php_splice(Z_ARRVAL_P(return_value), input_size, 0, pads, num_pads, NULL);
 	} else {
-		php_splice(Z_ARRVAL_P(return_value), 0, 0, pads, num_pads, NULL TSRMLS_CC);
+		new_hash = php_splice(Z_ARRVAL_P(return_value), 0, 0, pads, num_pads, NULL);
 	}
 
+	/* Copy the result hash into return value */
+	old_hash = *Z_ARRVAL_P(return_value);
+	*Z_ARRVAL_P(return_value) = *new_hash;
+	FREE_HASHTABLE(new_hash);
+	zend_hash_destroy(&old_hash);
+
 	/* Clean up */
 	efree(pads);
 }
@@ -2620,8 +2797,9 @@ PHP_FUNCTION(array_pad)
    Return array with key <-> value flipped */
 PHP_FUNCTION(array_flip)
 {
-	zval *array, **entry, *data;
-	HashPosition pos;
+	zval *array, *entry, data;
+	ulong num_idx;
+	zend_string *str_idx;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &array) == FAILURE) {
 		return;
@@ -2629,22 +2807,25 @@ PHP_FUNCTION(array_flip)
 
 	array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array)));
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
-		MAKE_STD_ZVAL(data);
-		zend_hash_get_current_key_zval_ex(Z_ARRVAL_P(array), data, &pos);
-
-		if (Z_TYPE_PP(entry) == IS_LONG) {
-			zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_PP(entry), &data, sizeof(data), NULL);
-		} else if (Z_TYPE_PP(entry) == IS_STRING) {
-			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STRVAL_PP(entry), Z_STRLEN_PP(entry) + 1, &data, sizeof(data), NULL);
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
+		if (Z_TYPE_P(entry) == IS_LONG) {
+			if (str_idx) {
+				ZVAL_STR(&data, STR_COPY(str_idx));
+			} else {
+				ZVAL_LONG(&data, num_idx);
+			}
+			zend_hash_index_update(Z_ARRVAL_P(return_value), Z_LVAL_P(entry), &data);
+		} else if (Z_TYPE_P(entry) == IS_STRING) {
+			if (str_idx) {
+				ZVAL_STR(&data, STR_COPY(str_idx));
+			} else {
+				ZVAL_LONG(&data, num_idx);
+			}
+			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(entry), &data);
 		} else {
-			zval_ptr_dtor(&data); /* will free also zval structure */
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can only flip STRING and INTEGER values!");
 		}
-
-		zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2652,13 +2833,11 @@ PHP_FUNCTION(array_flip)
    Retuns an array with all string keys lowercased [or uppercased] */
 PHP_FUNCTION(array_change_key_case)
 {
-	zval *array, **entry;
-	char *string_key;
-	char *new_key;
-	uint str_key_len;
+	zval *array, *entry;
+	zend_string *string_key;
+	zend_string *new_key;
 	ulong num_key;
 	long change_to_upper=0;
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &array, &change_to_upper) == FAILURE) {
 		return;
@@ -2666,28 +2845,22 @@ PHP_FUNCTION(array_change_key_case)
 
 	array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array)));
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&entry, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_key, string_key, entry) {
 		zval_add_ref(entry);
 
-		switch (zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &str_key_len, &num_key, 0, &pos)) {
-			case HASH_KEY_IS_LONG:
-				zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry, sizeof(entry), NULL);
-				break;
-			case HASH_KEY_IS_STRING:
-				new_key = estrndup(string_key, str_key_len - 1);
-				if (change_to_upper) {
-					php_strtoupper(new_key, str_key_len - 1);
-				} else {
-					php_strtolower(new_key, str_key_len - 1);
-				}
-				zend_hash_update(Z_ARRVAL_P(return_value), new_key, str_key_len, entry, sizeof(entry), NULL);
-				efree(new_key);
-				break;
+		if (!string_key) {
+			zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, entry);
+		} else {
+			new_key = STR_INIT(string_key->val, string_key->len, 0);
+			if (change_to_upper) {
+				php_strtoupper(new_key->val, new_key->len);
+			} else {
+				php_strtolower(new_key->val, new_key->len);
+			}
+			zend_hash_update(Z_ARRVAL_P(return_value), new_key, entry);
+			STR_RELEASE(new_key);
 		}
-
-		zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -2695,10 +2868,11 @@ PHP_FUNCTION(array_change_key_case)
    Removes duplicate values from array */
 PHP_FUNCTION(array_unique)
 {
-	zval *array, *tmp;
+	zval *array;
+	uint idx;
 	Bucket *p;
 	struct bucketindex {
-		Bucket *b;
+		Bucket b;
 		unsigned int i;
 	};
 	struct bucketindex *arTmp, *cmpdata, *lastkept;
@@ -2712,61 +2886,71 @@ PHP_FUNCTION(array_unique)
 	php_set_compare_func(sort_type TSRMLS_CC);
 
 	array_init_size(return_value, zend_hash_num_elements(Z_ARRVAL_P(array)));
-	zend_hash_copy(Z_ARRVAL_P(return_value), Z_ARRVAL_P(array), (copy_ctor_func_t) zval_add_ref, (void *)&tmp, sizeof(zval*));
+	zend_hash_copy(Z_ARRVAL_P(return_value), Z_ARRVAL_P(array), zval_add_ref);
 
 	if (Z_ARRVAL_P(array)->nNumOfElements <= 1) {	/* nothing to do */
 		return;
 	}
 
 	/* create and sort array with pointers to the target_hash buckets */
-	arTmp = (struct bucketindex *) pemalloc((Z_ARRVAL_P(array)->nNumOfElements + 1) * sizeof(struct bucketindex), Z_ARRVAL_P(array)->persistent);
+	arTmp = (struct bucketindex *) pemalloc((Z_ARRVAL_P(array)->nNumOfElements + 1) * sizeof(struct bucketindex), Z_ARRVAL_P(array)->u.flags & HASH_FLAG_PERSISTENT);
 	if (!arTmp) {
 		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
-	for (i = 0, p = Z_ARRVAL_P(array)->pListHead; p; i++, p = p->pListNext) {
-		arTmp[i].b = p;
+	for (i = 0, idx = 0; idx < Z_ARRVAL_P(array)->nNumUsed; idx++) {
+		p = Z_ARRVAL_P(array)->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (Z_TYPE(p->val) == IS_INDIRECT && Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF) continue;
+		arTmp[i].b = *p;
 		arTmp[i].i = i;
+		i++;
 	}
-	arTmp[i].b = NULL;
+	ZVAL_UNDEF(&arTmp[i].b.val);
 	zend_qsort((void *) arTmp, i, sizeof(struct bucketindex), php_array_data_compare TSRMLS_CC);
 
 	/* go through the sorted array and delete duplicates from the copy */
 	lastkept = arTmp;
-	for (cmpdata = arTmp + 1; cmpdata->b; cmpdata++) {
+	for (cmpdata = arTmp + 1; Z_TYPE(cmpdata->b.val) != IS_UNDEF; cmpdata++) {
 		if (php_array_data_compare(lastkept, cmpdata TSRMLS_CC)) {
 			lastkept = cmpdata;
 		} else {
 			if (lastkept->i > cmpdata->i) {
-				p = lastkept->b;
+				p = &lastkept->b;
 				lastkept = cmpdata;
 			} else {
-				p = cmpdata->b;
+				p = &cmpdata->b;
 			}
-			if (p->nKeyLength == 0) {
+			if (p->key == NULL) {
 				zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
 			} else {
-				if (Z_ARRVAL_P(return_value) == &EG(symbol_table)) {
-					zend_delete_global_variable(p->arKey, p->nKeyLength - 1 TSRMLS_CC);
+				if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
+					zend_delete_global_variable(p->key TSRMLS_CC);
 				} else {
-					zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+					zend_hash_del(Z_ARRVAL_P(return_value), p->key);
 				}
 			}
 		}
 	}
-	pefree(arTmp, Z_ARRVAL_P(array)->persistent);
+	pefree(arTmp, Z_ARRVAL_P(array)->u.flags & HASH_FLAG_PERSISTENT);
 }
 /* }}} */
 
-static int zval_compare(zval **a, zval **b TSRMLS_DC) /* {{{ */
+static int zval_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */
 {
 	zval result;
 	zval *first;
 	zval *second;
 
-	first = *((zval **) a);
-	second = *((zval **) b);
+	first = a;
+	second = b;
 
+	if (Z_TYPE_P(first) == IS_INDIRECT) {
+		first = Z_INDIRECT_P(first);
+	}
+	if (Z_TYPE_P(second) == IS_INDIRECT) {
+		second = Z_INDIRECT_P(second);
+	}
 	if (string_compare_function(&result, first, second TSRMLS_CC) == FAILURE) {
 		return 0;
 	}
@@ -2793,26 +2977,33 @@ static int zval_compare(zval **a, zval **b TSRMLS_DC) /* {{{ */
 }
 /* }}} */
 
-static int zval_user_compare(zval **a, zval **b TSRMLS_DC) /* {{{ */
+static int zval_user_compare(zval *a, zval *b TSRMLS_DC) /* {{{ */
 {
-	zval **args[2];
-	zval *retval_ptr = NULL;
+	zval args[2];
+	zval retval;
 
-	args[0] = (zval **) a;
-	args[1] = (zval **) b;
+	if (Z_TYPE_P(a) == IS_INDIRECT) {
+		a = Z_INDIRECT_P(a);
+	}
+	if (Z_TYPE_P(b) == IS_INDIRECT) {
+		b = Z_INDIRECT_P(b);
+	}
+
+	ZVAL_COPY_VALUE(&args[0], a);
+	ZVAL_COPY_VALUE(&args[1], b);
 
 	BG(user_compare_fci).param_count = 2;
 	BG(user_compare_fci).params = args;
-	BG(user_compare_fci).retval_ptr_ptr = &retval_ptr;
+	BG(user_compare_fci).retval = &retval;
 	BG(user_compare_fci).no_separation = 0;
 
-	if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && retval_ptr) {
-		long retval;
+	if (zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache) TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		long ret;
 
-		convert_to_long_ex(&retval_ptr);
-		retval = Z_LVAL_P(retval_ptr);
-		zval_ptr_dtor(&retval_ptr);
-		return retval < 0 ? -1 : retval > 0 ? 1 : 0;;
+		convert_to_long_ex(&retval);
+		ret = Z_LVAL(retval);
+		zval_ptr_dtor(&retval);
+		return ret < 0 ? -1 : ret > 0 ? 1 : 0;;
 	} else {
 		return 0;
 	}
@@ -2821,12 +3012,13 @@ static int zval_user_compare(zval **a, zval **b TSRMLS_DC) /* {{{ */
 
 static void php_array_intersect_key(INTERNAL_FUNCTION_PARAMETERS, int data_compare_type) /* {{{ */
 {
+    uint idx;
 	Bucket *p;
 	int argc, i;
-	zval ***args;
-	int (*intersect_data_compare_func)(zval **, zval ** TSRMLS_DC) = NULL;
+	zval *args;
+	int (*intersect_data_compare_func)(zval *, zval * TSRMLS_DC) = NULL;
 	zend_bool ok;
-	zval **data;
+	zval *data;
 	int req_args;
 	char *param_spec;
 
@@ -2858,59 +3050,63 @@ static void php_array_intersect_key(INTERNAL_FUNCTION_PARAMETERS, int data_compa
 	}
 
 	for (i = 0; i < argc; i++) {
-		if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+		if (Z_TYPE(args[i]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
-			RETVAL_NULL();
-			goto out;
+			RETURN_NULL();
 		}
 	}
 
 	array_init(return_value);
 
-	for (p = Z_ARRVAL_PP(args[0])->pListHead; p != NULL; p = p->pListNext) {
-		if (p->nKeyLength == 0) {
+	for (idx = 0; idx < Z_ARRVAL(args[0])->nNumUsed; idx++) {
+		p = Z_ARRVAL(args[0])->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key == NULL) {
 			ok = 1;
 			for (i = 1; i < argc; i++) {
-				if (zend_hash_index_find(Z_ARRVAL_PP(args[i]), p->h, (void**)&data) == FAILURE ||
+				if ((data = zend_hash_index_find(Z_ARRVAL(args[i]), p->h)) == NULL ||
 					(intersect_data_compare_func &&
-					intersect_data_compare_func((zval**)p->pData, data TSRMLS_CC) != 0)
+					intersect_data_compare_func(&p->val, data TSRMLS_CC) != 0)
 				) {
 					ok = 0;
 					break;
 				}
 			}
 			if (ok) {
-				Z_ADDREF_PP((zval**)p->pData);
-				zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL);
+				if (Z_REFCOUNTED(p->val)) {
+					Z_ADDREF(p->val);
+				}
+				zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->val);
 			}
 		} else {
 			ok = 1;
 			for (i = 1; i < argc; i++) {
-				if (zend_hash_quick_find(Z_ARRVAL_PP(args[i]), p->arKey, p->nKeyLength, p->h, (void**)&data) == FAILURE ||
+				if ((data = zend_hash_find(Z_ARRVAL(args[i]), p->key)) == NULL ||
 					(intersect_data_compare_func &&
-					intersect_data_compare_func((zval**)p->pData, data TSRMLS_CC) != 0)
+					intersect_data_compare_func(&p->val, data TSRMLS_CC) != 0)
 				) {
 					ok = 0;
 					break;
 				}
 			}
 			if (ok) {
-				Z_ADDREF_PP((zval**)p->pData);
-				zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL);
+				if (Z_REFCOUNTED(p->val)) {
+					Z_ADDREF(p->val);
+				}
+				zend_hash_update(Z_ARRVAL_P(return_value), p->key, &p->val);
 			}
 		}
 	}
-out:
-	efree(args);
 }
 /* }}} */
 
 static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_compare_type, int key_compare_type) /* {{{ */
 {
-	zval ***args = NULL;
+	zval *args = NULL;
 	HashTable *hash;
 	int arr_argc, i, c = 0;
-	Bucket ***lists, **list, ***ptrs, *p;
+	uint idx;
+	Bucket **lists, *list, **ptrs, *p;
 	int req_args;
 	char *param_spec;
 	zend_fcall_info fci1, fci2;
@@ -3010,8 +3206,8 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 	PHP_ARRAY_CMP_FUNC_BACKUP();
 
 	/* for each argument, create and sort list with pointers to the hash buckets */
-	lists = (Bucket ***)safe_emalloc(arr_argc, sizeof(Bucket **), 0);
-	ptrs = (Bucket ***)safe_emalloc(arr_argc, sizeof(Bucket **), 0);
+	lists = (Bucket **)safe_emalloc(arr_argc, sizeof(Bucket *), 0);
+	ptrs = (Bucket **)safe_emalloc(arr_argc, sizeof(Bucket *), 0);
 	php_set_compare_func(PHP_SORT_STRING TSRMLS_CC);
 
 	if (behavior == INTERSECT_NORMAL && data_compare_type == INTERSECT_COMP_DATA_USER) {
@@ -3023,48 +3219,47 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 	}
 
 	for (i = 0; i < arr_argc; i++) {
-		if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+		if (Z_TYPE(args[i]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
 			arr_argc = i; /* only free up to i - 1 */
 			goto out;
 		}
-		hash = Z_ARRVAL_PP(args[i]);
-		list = (Bucket **) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket *), hash->persistent);
+		hash = Z_ARRVAL(args[i]);
+		list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->u.flags & HASH_FLAG_PERSISTENT);
 		if (!list) {
 			PHP_ARRAY_CMP_FUNC_RESTORE();
 
 			efree(ptrs);
 			efree(lists);
-			efree(args);
 			RETURN_FALSE;
 		}
 		lists[i] = list;
 		ptrs[i] = list;
-		for (p = hash->pListHead; p; p = p->pListNext) {
-			*list++ = p;
+		for (idx = 0; idx < hash->nNumUsed; idx++) {
+			p = hash->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			*list++ = *p;
 		}
-		*list = NULL;
+		ZVAL_UNDEF(&list->val);
 		if (behavior == INTERSECT_NORMAL) {
-			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket *), intersect_data_compare_func TSRMLS_CC);
+			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket), intersect_data_compare_func TSRMLS_CC);
 		} else if (behavior & INTERSECT_ASSOC) { /* triggered also when INTERSECT_KEY */
-			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket *), intersect_key_compare_func TSRMLS_CC);
+			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket), intersect_key_compare_func TSRMLS_CC);
 		}
 	}
 
 	/* copy the argument array */
-	RETVAL_ZVAL(*args[0], 1, 0);
-	if (return_value->value.ht == &EG(symbol_table)) {
-		HashTable *ht;
-		zval *tmp;
+	RETVAL_ZVAL(&args[0], 1, 0);
+	if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {		
+		HashTable *old_ht = Z_ARRVAL_P(return_value);
 
-		ALLOC_HASHTABLE(ht);
-		zend_hash_init(ht, zend_hash_num_elements(return_value->value.ht), NULL, ZVAL_PTR_DTOR, 0);
-		zend_hash_copy(ht, return_value->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
-		return_value->value.ht = ht;
+		ZVAL_NEW_ARR(return_value);
+		zend_hash_init(Z_ARRVAL_P(return_value), zend_hash_num_elements(old_ht), NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_copy(Z_ARRVAL_P(return_value), old_ht, zval_add_ref);
 	}
 
 	/* go through the lists and look for common values */
-	while (*ptrs[0]) {
+	while (Z_TYPE(ptrs[0]->val) != IS_UNDEF) {
 		if ((behavior & INTERSECT_ASSOC) /* triggered also when INTERSECT_KEY */
 			&&
 			key_compare_type == INTERSECT_COMP_KEY_USER) {
@@ -3075,14 +3270,14 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 
 		for (i = 1; i < arr_argc; i++) {
 			if (behavior & INTERSECT_NORMAL) {
-				while (*ptrs[i] && (0 < (c = intersect_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
+				while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = intersect_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
 					ptrs[i]++;
 				}
 			} else if (behavior & INTERSECT_ASSOC) { /* triggered also when INTERSECT_KEY */
-				while (*ptrs[i] && (0 < (c = intersect_key_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
+				while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = intersect_key_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
 					ptrs[i]++;
 				}
-				if ((!c && *ptrs[i]) && (behavior == INTERSECT_ASSOC)) { /* only when INTERSECT_ASSOC */
+				if ((!c && Z_TYPE(ptrs[i]->val) != IS_UNDEF) && (behavior == INTERSECT_ASSOC)) { /* only when INTERSECT_ASSOC */
 					/* this means that ptrs[i] is not NULL so we can compare
 					 * and "c==0" is from last operation
 					 * in this branch of code we enter only when INTERSECT_ASSOC
@@ -3104,19 +3299,19 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 					}
 				}
 			}
-			if (!*ptrs[i]) {
+			if (Z_TYPE(ptrs[i]->val) == IS_UNDEF) {
 				/* delete any values corresponding to remains of ptrs[0] */
 				/* and exit because they do not present in at least one of */
 				/* the other arguments */
 				for (;;) {
-					p = *ptrs[0]++;
-					if (!p) {
+					p = ptrs[0]++;
+					if (Z_TYPE(p->val) == IS_UNDEF) {
 						goto out;
 					}
-					if (p->nKeyLength == 0) {
+					if (p->key == NULL) {
 						zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
 					} else {
-						zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+						zend_hash_del(Z_ARRVAL_P(return_value), p->key);
 					}
 				}
 			}
@@ -3128,13 +3323,13 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 			/* Value of ptrs[0] not in all arguments, delete all entries */
 			/* with value < value of ptrs[i] */
 			for (;;) {
-				p = *ptrs[0];
-				if (p->nKeyLength == 0) {
+				p = ptrs[0];
+				if (p->key == NULL) {
 					zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
 				} else {
-					zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+					zend_hash_del(Z_ARRVAL_P(return_value), p->key);
 				}
-				if (!*++ptrs[0]) {
+				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
 					goto out;
 				}
 				if (behavior == INTERSECT_NORMAL) {
@@ -3150,7 +3345,7 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 			/* ptrs[0] is present in all the arguments */
 			/* Skip all entries with same value as ptrs[0] */
 			for (;;) {
-				if (!*++ptrs[0]) {
+				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
 					goto out;
 				}
 				if (behavior == INTERSECT_NORMAL) {
@@ -3166,15 +3361,14 @@ static void php_array_intersect(INTERNAL_FUNCTION_PARAMETERS, int behavior, int
 	}
 out:
 	for (i = 0; i < arr_argc; i++) {
-		hash = Z_ARRVAL_PP(args[i]);
-		pefree(lists[i], hash->persistent);
+		hash = Z_ARRVAL(args[i]);
+		pefree(lists[i], hash->u.flags & HASH_FLAG_PERSISTENT);
 	}
 
 	PHP_ARRAY_CMP_FUNC_RESTORE();
 
 	efree(ptrs);
 	efree(lists);
-	efree(args);
 }
 /* }}} */
 
@@ -3244,12 +3438,13 @@ PHP_FUNCTION(array_uintersect_uassoc)
 
 static void php_array_diff_key(INTERNAL_FUNCTION_PARAMETERS, int data_compare_type) /* {{{ */
 {
+    uint idx;
 	Bucket *p;
 	int argc, i;
-	zval ***args;
-	int (*diff_data_compare_func)(zval **, zval ** TSRMLS_DC) = NULL;
+	zval *args;
+	int (*diff_data_compare_func)(zval *, zval * TSRMLS_DC) = NULL;
 	zend_bool ok;
-	zval **data;
+	zval *data;
 
 	/* Get the argument count */
 	argc = ZEND_NUM_ARGS();
@@ -3276,59 +3471,63 @@ static void php_array_diff_key(INTERNAL_FUNCTION_PARAMETERS, int data_compare_ty
 	}
 
 	for (i = 0; i < argc; i++) {
-		if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+		if (Z_TYPE(args[i]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
-			RETVAL_NULL();
-			goto out;
+			RETURN_NULL();
 		}
 	}
 
 	array_init(return_value);
 
-	for (p = Z_ARRVAL_PP(args[0])->pListHead; p != NULL; p = p->pListNext) {
-		if (p->nKeyLength == 0) {
+	for (idx = 0; idx < Z_ARRVAL(args[0])->nNumUsed; idx++) {
+		p = Z_ARRVAL(args[0])->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (p->key == NULL) {
 			ok = 1;
 			for (i = 1; i < argc; i++) {
-				if (zend_hash_index_find(Z_ARRVAL_PP(args[i]), p->h, (void**)&data) == SUCCESS &&
+				if ((data = zend_hash_index_find(Z_ARRVAL(args[i]), p->h)) != NULL &&
 					(!diff_data_compare_func ||
-					diff_data_compare_func((zval**)p->pData, data TSRMLS_CC) == 0)
+					diff_data_compare_func(&p->val, data TSRMLS_CC) == 0)
 				) {
 					ok = 0;
 					break;
 				}
 			}
 			if (ok) {
-				Z_ADDREF_PP((zval**)p->pData);
-				zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, p->pData, sizeof(zval*), NULL);
+				if (Z_REFCOUNTED(p->val)) {
+					Z_ADDREF(p->val);
+				}
+				zend_hash_index_update(Z_ARRVAL_P(return_value), p->h, &p->val);
 			}
 		} else {
 			ok = 1;
 			for (i = 1; i < argc; i++) {
-				if (zend_hash_quick_find(Z_ARRVAL_PP(args[i]), p->arKey, p->nKeyLength, p->h, (void**)&data) == SUCCESS &&
+				if ((data = zend_hash_find(Z_ARRVAL(args[i]), p->key)) != NULL &&
 					(!diff_data_compare_func ||
-					diff_data_compare_func((zval**)p->pData, data TSRMLS_CC) == 0)
+					diff_data_compare_func(&p->val, data TSRMLS_CC) == 0)
 				) {
 					ok = 0;
 					break;
 				}
 			}
 			if (ok) {
-				Z_ADDREF_PP((zval**)p->pData);
-				zend_hash_quick_update(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h, p->pData, sizeof(zval*), NULL);
+				if (Z_REFCOUNTED(p->val)) {
+					Z_ADDREF(p->val);
+				}
+				zend_hash_update(Z_ARRVAL_P(return_value), p->key, &p->val);
 			}
 		}
 	}
-out:
-	efree(args);
 }
 /* }}} */
 
 static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_compare_type, int key_compare_type) /* {{{ */
 {
-	zval ***args = NULL;
+	zval *args = NULL;
 	HashTable *hash;
 	int arr_argc, i, c;
-	Bucket ***lists, **list, ***ptrs, *p;
+	uint idx;
+	Bucket **lists, *list, **ptrs, *p;
 	int req_args;
 	char *param_spec;
 	zend_fcall_info fci1, fci2;
@@ -3427,8 +3626,8 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 	PHP_ARRAY_CMP_FUNC_BACKUP();
 
 	/* for each argument, create and sort list with pointers to the hash buckets */
-	lists = (Bucket ***)safe_emalloc(arr_argc, sizeof(Bucket **), 0);
-	ptrs = (Bucket ***)safe_emalloc(arr_argc, sizeof(Bucket **), 0);
+	lists = (Bucket **)safe_emalloc(arr_argc, sizeof(Bucket *), 0);
+	ptrs = (Bucket **)safe_emalloc(arr_argc, sizeof(Bucket *), 0);
 	php_set_compare_func(PHP_SORT_STRING TSRMLS_CC);
 
 	if (behavior == DIFF_NORMAL && data_compare_type == DIFF_COMP_DATA_USER) {
@@ -3440,48 +3639,47 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 	}
 
 	for (i = 0; i < arr_argc; i++) {
-		if (Z_TYPE_PP(args[i]) != IS_ARRAY) {
+		if (Z_TYPE(args[i]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is not an array", i + 1);
 			arr_argc = i; /* only free up to i - 1 */
 			goto out;
 		}
-		hash = Z_ARRVAL_PP(args[i]);
-		list = (Bucket **) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket *), hash->persistent);
+		hash = Z_ARRVAL(args[i]);
+		list = (Bucket *) pemalloc((hash->nNumOfElements + 1) * sizeof(Bucket), hash->u.flags & HASH_FLAG_PERSISTENT);
 		if (!list) {
 			PHP_ARRAY_CMP_FUNC_RESTORE();
 
 			efree(ptrs);
 			efree(lists);
-			efree(args);
 			RETURN_FALSE;
 		}
 		lists[i] = list;
 		ptrs[i] = list;
-		for (p = hash->pListHead; p; p = p->pListNext) {
-			*list++ = p;
+		for (idx = 0; idx < hash->nNumUsed; idx++) {
+			p = hash->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			*list++ = *p;
 		}
-		*list = NULL;
+		ZVAL_UNDEF(&list->val);
 		if (behavior == DIFF_NORMAL) {
-			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket *), diff_data_compare_func TSRMLS_CC);
+			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket), diff_data_compare_func TSRMLS_CC);
 		} else if (behavior & DIFF_ASSOC) { /* triggered also when DIFF_KEY */
-			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket *), diff_key_compare_func TSRMLS_CC);
+			zend_qsort((void *) lists[i], hash->nNumOfElements, sizeof(Bucket), diff_key_compare_func TSRMLS_CC);
 		}
 	}
 
 	/* copy the argument array */
-	RETVAL_ZVAL(*args[0], 1, 0);
-	if (return_value->value.ht == &EG(symbol_table)) {
-		HashTable *ht;
-		zval *tmp;
+	RETVAL_ZVAL(&args[0], 1, 0);
+	if (Z_ARRVAL_P(return_value) == &EG(symbol_table).ht) {
+		HashTable *old_ht = Z_ARRVAL_P(return_value);
 
-		ALLOC_HASHTABLE(ht);
-		zend_hash_init(ht, zend_hash_num_elements(return_value->value.ht), NULL, ZVAL_PTR_DTOR, 0);
-		zend_hash_copy(ht, return_value->value.ht, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
-		return_value->value.ht = ht;
+		ZVAL_NEW_ARR(return_value);
+		zend_hash_init(Z_ARRVAL_P(return_value), zend_hash_num_elements(old_ht), NULL, ZVAL_PTR_DTOR, 0);
+		zend_hash_copy(Z_ARRVAL_P(return_value), old_ht, zval_add_ref);
 	}
 
 	/* go through the lists and look for values of ptr[0] that are not in the others */
-	while (*ptrs[0]) {
+	while (Z_TYPE(ptrs[0]->val) != IS_UNDEF) {
 		if ((behavior & DIFF_ASSOC) /* triggered also when DIFF_KEY */
 			&&
 			key_compare_type == DIFF_COMP_KEY_USER
@@ -3491,26 +3689,26 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 		}
 		c = 1;
 		for (i = 1; i < arr_argc; i++) {
-			Bucket **ptr = ptrs[i];
+			Bucket *ptr = ptrs[i];
 			if (behavior == DIFF_NORMAL) {
-				while (*ptrs[i] && (0 < (c = diff_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
+				while (Z_TYPE(ptrs[i]->val) != IS_UNDEF && (0 < (c = diff_data_compare_func(ptrs[0], ptrs[i] TSRMLS_CC)))) {
 					ptrs[i]++;
 				}
 			} else if (behavior & DIFF_ASSOC) { /* triggered also when DIFF_KEY */
-				while (*ptr && (0 != (c = diff_key_compare_func(ptrs[0], ptr TSRMLS_CC)))) {
+				while (Z_TYPE(ptr->val) != IS_UNDEF && (0 != (c = diff_key_compare_func(ptrs[0], ptr TSRMLS_CC)))) {
 					ptr++;
 				}
 			}
 			if (!c) {
 				if (behavior == DIFF_NORMAL) {
-					if (*ptrs[i]) {
+					if (Z_TYPE(ptrs[i]->val) != IS_UNDEF) {
 						ptrs[i]++;
 					}
 					break;
 				} else if (behavior == DIFF_ASSOC) {  /* only when DIFF_ASSOC */
 					/* In this branch is execute only when DIFF_ASSOC. If behavior == DIFF_KEY
 					 * data comparison is not needed - skipped. */
-					if (*ptr) {
+					if (Z_TYPE(ptr->val) != IS_UNDEF) {
 						if (data_compare_type == DIFF_COMP_DATA_USER) {
 							BG(user_compare_fci) = *fci_data;
 							BG(user_compare_fci_cache) = *fci_data_cache;
@@ -3541,13 +3739,13 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 			/* ptrs[0] in one of the other arguments */
 			/* delete all entries with value as ptrs[0] */
 			for (;;) {
-				p = *ptrs[0];
-				if (p->nKeyLength == 0) {
+				p = ptrs[0];
+				if (p->key == NULL) {
 					zend_hash_index_del(Z_ARRVAL_P(return_value), p->h);
 				} else {
-					zend_hash_quick_del(Z_ARRVAL_P(return_value), p->arKey, p->nKeyLength, p->h);
+					zend_hash_del(Z_ARRVAL_P(return_value), p->key);
 				}
-				if (!*++ptrs[0]) {
+				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
 					goto out;
 				}
 				if (behavior == DIFF_NORMAL) {
@@ -3563,7 +3761,7 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 			/* ptrs[0] in none of the other arguments */
 			/* skip all entries with value as ptrs[0] */
 			for (;;) {
-				if (!*++ptrs[0]) {
+				if (Z_TYPE((++ptrs[0])->val) == IS_UNDEF) {
 					goto out;
 				}
 				if (behavior == DIFF_NORMAL) {
@@ -3579,15 +3777,14 @@ static void php_array_diff(INTERNAL_FUNCTION_PARAMETERS, int behavior, int data_
 	}
 out:
 	for (i = 0; i < arr_argc; i++) {
-		hash = Z_ARRVAL_PP(args[i]);
-		pefree(lists[i], hash->persistent);
+		hash = Z_ARRVAL(args[i]);
+		pefree(lists[i], hash->u.flags & HASH_FLAG_PERSISTENT);
 	}
 
 	PHP_ARRAY_CMP_FUNC_RESTORE();
 
 	efree(ptrs);
 	efree(lists);
-	efree(args);
 }
 /* }}} */
 
@@ -3661,8 +3858,8 @@ PHP_FUNCTION(array_udiff_uassoc)
 
 PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
 {
-	Bucket **ab = *(Bucket ***)a;
-	Bucket **bb = *(Bucket ***)b;
+	Bucket *ab = *(Bucket **)a;
+	Bucket *bb = *(Bucket **)b;
 	int r;
 	int result = 0;
 	zval temp;
@@ -3671,13 +3868,13 @@ PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC) /* {{{
 	do {
 		php_set_compare_func(ARRAYG(multisort_flags)[MULTISORT_TYPE][r] TSRMLS_CC);
 
-		ARRAYG(compare_func)(&temp, *((zval **)ab[r]->pData), *((zval **)bb[r]->pData) TSRMLS_CC);
+		ARRAYG(compare_func)(&temp, &ab[r].val, &bb[r].val TSRMLS_CC);
 		result = ARRAYG(multisort_flags)[MULTISORT_ORDER][r] * Z_LVAL(temp);
 		if (result != 0) {
 			return result;
 		}
 		r++;
-	} while (ab[r] != NULL);
+	} while (Z_TYPE(ab[r].val) != IS_UNDEF);
 
 	return result;
 }
@@ -3687,16 +3884,16 @@ PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC) /* {{{
 	for (k = 0; k < MULTISORT_LAST; k++)	\
 		efree(ARRAYG(multisort_flags)[k]);	\
 	efree(arrays);							\
-	efree(args);							\
 	RETURN_FALSE;
 
 /* {{{ proto bool array_multisort(array ar1 [, SORT_ASC|SORT_DESC [, SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_NATURAL|SORT_FLAG_CASE]] [, array ar2 [, SORT_ASC|SORT_DESC [, SORT_REGULAR|SORT_NUMERIC|SORT_STRING|SORT_NATURAL|SORT_FLAG_CASE]], ...])
    Sort multiple arrays at once similar to how ORDER BY clause works in SQL */
 PHP_FUNCTION(array_multisort)
 {
-	zval***			args;
-	zval***			arrays;
-	Bucket***		indirect;
+	zval*			args;
+	zval**			arrays;
+	Bucket**		indirect;
+	uint            idx;
 	Bucket*			p;
 	HashTable*		hash;
 	int				argc;
@@ -3705,14 +3902,14 @@ PHP_FUNCTION(array_multisort)
 	int				parse_state[MULTISORT_LAST];   /* 0 - flag not allowed 1 - flag allowed */
 	int				sort_order = PHP_SORT_ASC;
 	int				sort_type  = PHP_SORT_REGULAR;
-	int				i, k;
+	int				i, k, n;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
 		return;
 	}
 
 	/* Allocate space for storing pointers to input arrays and sort flags. */
-	arrays = (zval ***)ecalloc(argc, sizeof(zval **));
+	arrays = (zval **)ecalloc(argc, sizeof(zval *));
 	for (i = 0; i < MULTISORT_LAST; i++) {
 		parse_state[i] = 0;
 		ARRAYG(multisort_flags)[i] = (int *)ecalloc(argc, sizeof(int));
@@ -3724,7 +3921,10 @@ PHP_FUNCTION(array_multisort)
 	 * accordingly. There can't be two sort flags of the same type after an
 	 * array, and the very first argument has to be an array. */
 	for (i = 0; i < argc; i++) {
-		if (Z_TYPE_PP(args[i]) == IS_ARRAY) {
+		zval *arg = &args[i];
+
+		ZVAL_DEREF(arg);
+		if (Z_TYPE_P(arg) == IS_ARRAY) {
 			/* We see the next array, so we update the sort flags of
 			 * the previous array and reset the sort flags. */
 			if (i > 0) {
@@ -3733,20 +3933,20 @@ PHP_FUNCTION(array_multisort)
 				sort_order = PHP_SORT_ASC;
 				sort_type = PHP_SORT_REGULAR;
 			}
-			arrays[num_arrays++] = args[i];
+			arrays[num_arrays++] = arg;
 
 			/* Next one may be an array or a list of sort flags. */
 			for (k = 0; k < MULTISORT_LAST; k++) {
 				parse_state[k] = 1;
 			}
-		} else if (Z_TYPE_PP(args[i]) == IS_LONG) {
-			switch (Z_LVAL_PP(args[i]) & ~PHP_SORT_FLAG_CASE) {
+		} else if (Z_TYPE_P(arg) == IS_LONG) {
+			switch (Z_LVAL_P(arg) & ~PHP_SORT_FLAG_CASE) {
 				case PHP_SORT_ASC:
 				case PHP_SORT_DESC:
 					/* flag allowed here */
 					if (parse_state[MULTISORT_ORDER] == 1) {
 						/* Save the flag and make sure then next arg is not the current flag. */
-						sort_order = Z_LVAL_PP(args[i]) == PHP_SORT_DESC ? -1 : 1;
+						sort_order = Z_LVAL(args[i]) == PHP_SORT_DESC ? -1 : 1;
 						parse_state[MULTISORT_ORDER] = 0;
 					} else {
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1);
@@ -3764,7 +3964,7 @@ PHP_FUNCTION(array_multisort)
 					/* flag allowed here */
 					if (parse_state[MULTISORT_TYPE] == 1) {
 						/* Save the flag and make sure then next arg is not the current flag. */
-						sort_type = Z_LVAL_PP(args[i]);
+						sort_type = Z_LVAL(args[i]);
 						parse_state[MULTISORT_TYPE] = 0;
 					} else {
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d is expected to be an array or sorting flag that has not already been specified", i + 1);
@@ -3788,9 +3988,9 @@ PHP_FUNCTION(array_multisort)
 	ARRAYG(multisort_flags)[MULTISORT_TYPE][num_arrays - 1] = sort_type;
 
 	/* Make sure the arrays are of the same size. */
-	array_size = zend_hash_num_elements(Z_ARRVAL_PP(arrays[0]));
+	array_size = zend_hash_num_elements(Z_ARRVAL_P(arrays[0]));
 	for (i = 0; i < num_arrays; i++) {
-		if (zend_hash_num_elements(Z_ARRVAL_PP(arrays[i])) != array_size) {
+		if (zend_hash_num_elements(Z_ARRVAL_P(arrays[i])) != array_size) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Array sizes are inconsistent");
 			MULTISORT_ABORT;
 		}
@@ -3802,7 +4002,6 @@ PHP_FUNCTION(array_multisort)
 			efree(ARRAYG(multisort_flags)[k]);
 		}
 		efree(arrays);
-		efree(args);
 		RETURN_TRUE;
 	}
 
@@ -3810,41 +4009,42 @@ PHP_FUNCTION(array_multisort)
 	 * M is the number of entries in each input array and N is the number
 	 * of the input arrays + 1. The last column is NULL to indicate the end
 	 * of the row. */
-	indirect = (Bucket ***)safe_emalloc(array_size, sizeof(Bucket **), 0);
+	indirect = (Bucket **)safe_emalloc(array_size, sizeof(Bucket *), 0);
 	for (i = 0; i < array_size; i++) {
-		indirect[i] = (Bucket **)safe_emalloc((num_arrays + 1), sizeof(Bucket *), 0);
+		indirect[i] = (Bucket *)safe_emalloc((num_arrays + 1), sizeof(Bucket), 0);
 	}
 	for (i = 0; i < num_arrays; i++) {
 		k = 0;
-		for (p = Z_ARRVAL_PP(arrays[i])->pListHead; p; p = p->pListNext, k++) {
-			indirect[k][i] = p;
+		for (idx = 0; idx < Z_ARRVAL_P(arrays[i])->nNumUsed; idx++) {
+			p = Z_ARRVAL_P(arrays[i])->arData + idx;
+			if (Z_TYPE(p->val) == IS_UNDEF) continue;
+			indirect[k][i] = *p;
+			k++;
 		}
 	}
 	for (k = 0; k < array_size; k++) {
-		indirect[k][num_arrays] = NULL;
+		ZVAL_UNDEF(&indirect[k][num_arrays].val);
 	}
 
 	/* Do the actual sort magic - bada-bim, bada-boom. */
-	zend_qsort(indirect, array_size, sizeof(Bucket **), php_multisort_compare TSRMLS_CC);
+	zend_qsort(indirect, array_size, sizeof(Bucket *), php_multisort_compare TSRMLS_CC);
 
 	/* Restructure the arrays based on sorted indirect - this is mostly taken from zend_hash_sort() function. */
 	HANDLE_BLOCK_INTERRUPTIONS();
 	for (i = 0; i < num_arrays; i++) {
-		hash = Z_ARRVAL_PP(arrays[i]);
-		hash->pListHead = indirect[0][i];;
-		hash->pListTail = NULL;
-		hash->pInternalPointer = hash->pListHead;
-
-		for (k = 0; k < array_size; k++) {
-			if (hash->pListTail) {
-				hash->pListTail->pListNext = indirect[k][i];
-			}
-			indirect[k][i]->pListLast = hash->pListTail;
-			indirect[k][i]->pListNext = NULL;
-			hash->pListTail = indirect[k][i];
+		hash = Z_ARRVAL_P(arrays[i]);
+		hash->nNumUsed = array_size;
+		hash->nInternalPointer = 0;
+
+		for (n = 0, k = 0; k < array_size; k++) {
+			hash->arData[k] = indirect[k][i];
+			if (hash->arData[k].key == NULL)
+				hash->arData[k].h = n++;
+		}
+		hash->nNextFreeElement = array_size;
+		if (!(hash->u.flags & HASH_FLAG_PACKED)) {
+			zend_hash_to_packed(hash);
 		}
-
-		zend_hash_reindex(hash, 1);
 	}
 	HANDLE_UNBLOCK_INTERRUPTIONS();
 
@@ -3857,7 +4057,6 @@ PHP_FUNCTION(array_multisort)
 		efree(ARRAYG(multisort_flags)[k]);
 	}
 	efree(arrays);
-	efree(args);
 	RETURN_TRUE;
 }
 /* }}} */
@@ -3868,11 +4067,9 @@ PHP_FUNCTION(array_rand)
 {
 	zval *input;
 	long randval, num_req = 1;
-	int num_avail, key_type;
-	char *string_key;
-	uint string_key_len;
+	int num_avail;
+	zend_string *string_key;
 	ulong num_key;
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|l", &input, &num_req) == FAILURE) {
 		return;
@@ -3893,23 +4090,25 @@ PHP_FUNCTION(array_rand)
 	}
 
 	/* We can't use zend_hash_index_find() because the array may have string keys or gaps. */
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
-	while (num_req && (key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &string_key, &string_key_len, &num_key, 0, &pos)) != HASH_KEY_NON_EXISTENT) {
+	ZEND_HASH_FOREACH_KEY(Z_ARRVAL_P(input), num_key, string_key) {
+		if (!num_req) {
+			break;
+		}
 
 		randval = php_rand(TSRMLS_C);
 
 		if ((double) (randval / (PHP_RAND_MAX + 1.0)) < (double) num_req / (double) num_avail) {
 			/* If we are returning a single result, just do it. */
 			if (Z_TYPE_P(return_value) != IS_ARRAY) {
-				if (key_type == HASH_KEY_IS_STRING) {
-					RETURN_STRINGL(string_key, string_key_len - 1, 1);
+				if (string_key) {
+					RETURN_STR(STR_COPY(string_key));
 				} else {
 					RETURN_LONG(num_key);
 				}
 			} else {
 				/* Append the result to the return value. */
-				if (key_type == HASH_KEY_IS_STRING) {
-					add_next_index_stringl(return_value, string_key, string_key_len - 1, 1);
+				if (string_key) {
+					add_next_index_str(return_value, STR_COPY(string_key));
 				} else {
 					add_next_index_long(return_value, num_key);
 				}
@@ -3917,8 +4116,7 @@ PHP_FUNCTION(array_rand)
 			num_req--;
 		}
 		num_avail--;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -3927,9 +4125,8 @@ PHP_FUNCTION(array_rand)
 PHP_FUNCTION(array_sum)
 {
 	zval *input,
-		 **entry,
+		 *entry,
 		 entry_n;
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &input) == FAILURE) {
 		return;
@@ -3937,18 +4134,14 @@ PHP_FUNCTION(array_sum)
 
 	ZVAL_LONG(return_value, 0);
 
-	for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
-		zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos)
-	) {
-		if (Z_TYPE_PP(entry) == IS_ARRAY || Z_TYPE_PP(entry) == IS_OBJECT) {
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), entry) {
+		if (Z_TYPE_P(entry) == IS_ARRAY || Z_TYPE_P(entry) == IS_OBJECT) {
 			continue;
 		}
-		entry_n = **entry;
-		zval_copy_ctor(&entry_n);
+		ZVAL_DUP(&entry_n, entry);
 		convert_scalar_to_number(&entry_n TSRMLS_CC);
 		fast_add_function(return_value, return_value, &entry_n TSRMLS_CC);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -3957,9 +4150,8 @@ PHP_FUNCTION(array_sum)
 PHP_FUNCTION(array_product)
 {
 	zval *input,
-		 **entry,
+		 *entry,
 		 entry_n;
-	HashPosition pos;
 	double dval;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &input) == FAILURE) {
@@ -3971,15 +4163,11 @@ PHP_FUNCTION(array_product)
 		return;
 	}
 
-	for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
-		zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void **)&entry, &pos) == SUCCESS;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos)
-	) {
-		if (Z_TYPE_PP(entry) == IS_ARRAY || Z_TYPE_PP(entry) == IS_OBJECT) {
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(input), entry) {
+		if (Z_TYPE_P(entry) == IS_ARRAY || Z_TYPE_P(entry) == IS_OBJECT) {
 			continue;
 		}
-		entry_n = **entry;
-		zval_copy_ctor(&entry_n);
+		ZVAL_DUP(&entry_n, entry);
 		convert_scalar_to_number(&entry_n TSRMLS_CC);
 
 		if (Z_TYPE(entry_n) == IS_LONG && Z_TYPE_P(return_value) == IS_LONG) {
@@ -3992,7 +4180,7 @@ PHP_FUNCTION(array_product)
 		convert_to_double(return_value);
 		convert_to_double(&entry_n);
 		Z_DVAL_P(return_value) *= Z_DVAL(entry_n);
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -4001,26 +4189,24 @@ PHP_FUNCTION(array_product)
 PHP_FUNCTION(array_reduce)
 {
 	zval *input;
-	zval **args[2];
-	zval **operand;
-	zval *result = NULL;
-	zval *retval;
+	zval args[2];
+	zval *operand;
+	zval result;
+	zval retval;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
 	zval *initial = NULL;
-	HashPosition pos;
 	HashTable *htbl;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "af|z", &input, &fci, &fci_cache, &initial) == FAILURE) {
 		return;
 	}
 
+
 	if (ZEND_NUM_ARGS() > 2) {
-		ALLOC_ZVAL(result);
-		MAKE_COPY_ZVAL(&initial, result);
+		ZVAL_DUP(&result, initial);
 	} else {
-		MAKE_STD_ZVAL(result);
-		ZVAL_NULL(result);
+		ZVAL_NULL(&result);
 	}
 
 	/* (zval **)input points to an element of argument stack
@@ -4029,38 +4215,28 @@ PHP_FUNCTION(array_reduce)
 	htbl = Z_ARRVAL_P(input);
 
 	if (zend_hash_num_elements(htbl) == 0) {
-		if (result) {
-			RETVAL_ZVAL(result, 1, 1);
-		}
-		return;
+		RETURN_ZVAL(&result, 1, 1);
 	}
 
-	fci.retval_ptr_ptr = &retval;
+	fci.retval = &retval;
 	fci.param_count = 2;
 	fci.no_separation = 0;
 
-	zend_hash_internal_pointer_reset_ex(htbl, &pos);
-	while (zend_hash_get_current_data_ex(htbl, (void **)&operand, &pos) == SUCCESS) {
+	ZEND_HASH_FOREACH_VAL(htbl, operand) {
+		ZVAL_COPY_VALUE(&args[0], &result);
+		ZVAL_COPY_VALUE(&args[1], operand);
+		fci.params = args;
 
-		if (result) {
-			args[0] = &result;
-			args[1] = operand;
-			fci.params = args;
-
-			if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && retval) {
-				zval_ptr_dtor(&result);
-				result = retval;
-			} else {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the reduction callback");
-				return;
-			}
+		if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+			zval_ptr_dtor(&result);
+			ZVAL_COPY_VALUE(&result, &retval);
 		} else {
-			result = *operand;
-			zval_add_ref(&result);
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the reduction callback");
+			return;
 		}
-		zend_hash_move_forward_ex(htbl, &pos);
-	}
-	RETVAL_ZVAL(result, 1, 1);
+	} ZEND_HASH_FOREACH_END();
+
+	RETVAL_ZVAL(&result, 1, 1);
 }
 /* }}} */
 
@@ -4069,18 +4245,15 @@ PHP_FUNCTION(array_reduce)
 PHP_FUNCTION(array_filter)
 {
 	zval *array;
-	zval **operand;
-	zval **args[2];
-	zval *retval = NULL;
-    zval *key = NULL;
+	zval *operand;
+	zval args[2];
+	zval retval;
 	zend_bool have_callback = 0;
 	long use_type = 0;
-	char *string_key;
+	zend_string *string_key;
 	zend_fcall_info fci = empty_fcall_info;
 	zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
-	uint string_key_len;
 	ulong num_key;
-	HashPosition pos;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|fl", &array, &fci, &fci_cache, &use_type) == FAILURE) {
 		return;
@@ -4094,75 +4267,68 @@ PHP_FUNCTION(array_filter)
 	if (ZEND_NUM_ARGS() > 1) {
 		have_callback = 1;
 		fci.no_separation = 0;
-		fci.retval_ptr_ptr = &retval;
-
-		if (use_type == ARRAY_FILTER_USE_BOTH) {
-			fci.param_count = 2;
-			args[1] = &key;
-		} else {
-			fci.param_count = 1;
-			if (use_type == ARRAY_FILTER_USE_KEY) {
-				args[0] = &key;
-			}
-		}
+		fci.retval = &retval;
+		fci.param_count = 1;
 	}
 
-	for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(array), &pos);
-		zend_hash_get_current_data_ex(Z_ARRVAL_P(array), (void **)&operand, &pos) == SUCCESS;
-		zend_hash_move_forward_ex(Z_ARRVAL_P(array), &pos)
-	) {
-		int key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(array), &string_key, &string_key_len, &num_key, 0, &pos);
-
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_key, string_key, operand) {
 		if (have_callback) {
 			if (use_type) {
-				MAKE_STD_ZVAL(key);
 				/* Set up the key */
-				switch (key_type) {
-					case HASH_KEY_IS_LONG:
-						Z_TYPE_P(key) = IS_LONG;
-						Z_LVAL_P(key) = num_key;
-						break;
-
-					case HASH_KEY_IS_STRING:
-						ZVAL_STRINGL(key, string_key, string_key_len - 1, 1);
-						break;
+				if (!string_key) {
+					if (use_type == ARRAY_FILTER_USE_BOTH) {
+						fci.param_count = 2;
+						ZVAL_LONG(&args[1], num_key);
+					} else if (use_type == ARRAY_FILTER_USE_KEY) {
+						ZVAL_LONG(&args[0], num_key);
+					}
+				} else {
+					if (use_type == ARRAY_FILTER_USE_BOTH) {
+						ZVAL_STR(&args[1], STR_COPY(string_key));
+					} else if (use_type == ARRAY_FILTER_USE_KEY) {
+						ZVAL_STR(&args[0], STR_COPY(string_key));
+					}
 				}
 			}
-
 			if (use_type != ARRAY_FILTER_USE_KEY) {
-				args[0] = operand;
+				ZVAL_COPY(&args[0], operand);
 			}
 			fci.params = args;
 
-			if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && retval) {
-				int retval_true = zend_is_true(retval TSRMLS_CC);
-
-				zval_ptr_dtor(&retval);
-				if (use_type) {
-					zval_ptr_dtor(&key);
+			if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS) {
+				zval_ptr_dtor(&args[0]);
+				if (use_type == ARRAY_FILTER_USE_BOTH) {
+					zval_ptr_dtor(&args[1]);						
 				}
-				if (!retval_true) {
+				if (!ZVAL_IS_UNDEF(&retval)) {
+					int retval_true = zend_is_true(&retval TSRMLS_CC);
+
+					zval_ptr_dtor(&retval);
+					if (!retval_true) {
+						continue;
+					}
+				} else {
 					continue;
 				}
 			} else {
+				zval_ptr_dtor(&args[0]);
+				if (use_type == ARRAY_FILTER_USE_BOTH) {
+					zval_ptr_dtor(&args[1]);						
+				}
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the filter callback");
 				return;
 			}
-		} else if (!zend_is_true(*operand TSRMLS_CC)) {
+		} else if (!zend_is_true(operand TSRMLS_CC)) {
 			continue;
 		}
 
 		zval_add_ref(operand);
-		switch (key_type) {
-			case HASH_KEY_IS_STRING:
-				zend_hash_update(Z_ARRVAL_P(return_value), string_key, string_key_len, operand, sizeof(zval *), NULL);
-				break;
-
-			case HASH_KEY_IS_LONG:
-				zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, operand, sizeof(zval *), NULL);
-				break;
+		if (string_key) {
+			zend_hash_update(Z_ARRVAL_P(return_value), string_key, operand);
+		} else {
+			zend_hash_index_update(Z_ARRVAL_P(return_value), num_key, operand);
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 }
 /* }}} */
 
@@ -4170,10 +4336,10 @@ PHP_FUNCTION(array_filter)
    Applies the callback to the elements in given arrays. */
 PHP_FUNCTION(array_map)
 {
-	zval ***arrays = NULL;
+	zval *arrays = NULL;
 	int n_arrays = 0;
-	zval ***params;
-	zval *result, *null;
+	zval *params;
+	zval result;
 	HashPosition *array_pos;
 	zval **args;
 	zend_fcall_info fci = empty_fcall_info;
@@ -4192,24 +4358,22 @@ PHP_FUNCTION(array_map)
 	array_pos = (HashPosition *)safe_emalloc(n_arrays, sizeof(HashPosition), 0);
 
 	for (i = 0; i < n_arrays; i++) {
-		if (Z_TYPE_PP(arrays[i]) != IS_ARRAY) {
+		if (Z_TYPE(arrays[i]) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument #%d should be an array", i + 2);
-			efree(arrays);
 			efree(args);
 			efree(array_len);
 			efree(array_pos);
 			return;
 		}
-		SEPARATE_ZVAL_IF_NOT_REF(arrays[i]);
-		args[i] = *arrays[i];
-		array_len[i] = zend_hash_num_elements(Z_ARRVAL_PP(arrays[i]));
+		SEPARATE_ZVAL_IF_NOT_REF(&arrays[i]);
+		args[i] = &arrays[i];
+		array_len[i] = zend_hash_num_elements(Z_ARRVAL(arrays[i]));
 		if (array_len[i] > maxlen) {
 			maxlen = array_len[i];
 		}
-		zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(arrays[i]), &array_pos[i]);
+		zend_hash_internal_pointer_reset_ex(Z_ARRVAL(arrays[i]), &array_pos[i]);
 	}
 
-	efree(arrays);
 
 	/* Short-circuit: if no callback and only one array, just return it. */
 	if (!ZEND_FCI_INITIALIZED(fci) && n_arrays == 1) {
@@ -4221,76 +4385,78 @@ PHP_FUNCTION(array_map)
 	}
 
 	array_init_size(return_value, maxlen);
-	params = (zval ***)safe_emalloc(n_arrays, sizeof(zval **), 0);
-	MAKE_STD_ZVAL(null);
-	ZVAL_NULL(null);
+	params = (zval *)safe_emalloc(n_arrays, sizeof(zval), 0);
 
 	/* We iterate through all the arrays at once. */
 	for (k = 0; k < maxlen; k++) {
-		uint str_key_len;
 		ulong num_key;
-		char *str_key;
+		zend_string *str_key;
 		int key_type = 0;
 
 		/* If no callback, the result will be an array, consisting of current
 		 * entries from all arrays. */
 		if (!ZEND_FCI_INITIALIZED(fci)) {
-			MAKE_STD_ZVAL(result);
-			array_init_size(result, n_arrays);
+			array_init_size(&result, n_arrays);
 		}
 
 		for (i = 0; i < n_arrays; i++) {
 			/* If this array still has elements, add the current one to the
 			 * parameter list, otherwise use null value. */
 			if (k < array_len[i]) {
-				zend_hash_get_current_data_ex(Z_ARRVAL_P(args[i]), (void **)&params[i], &array_pos[i]);
+				zval *zv = zend_hash_get_current_data_ex(Z_ARRVAL_P(args[i]), &array_pos[i]);
+
+				ZVAL_COPY(&params[i], zv);
 
 				/* It is safe to store only last value of key type, because
 				 * this loop will run just once if there is only 1 array. */
 				if (n_arrays == 1) {
-					key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(args[0]), &str_key, &str_key_len, &num_key, 0, &array_pos[i]);
+					key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(args[0]), &str_key, &num_key, 0, &array_pos[i]);
 				}
 				zend_hash_move_forward_ex(Z_ARRVAL_P(args[i]), &array_pos[i]);
 			} else {
-				params[i] = &null;
+				ZVAL_NULL(&params[i]);
 			}
 
 			if (!ZEND_FCI_INITIALIZED(fci)) {
-				zval_add_ref(params[i]);
-				add_next_index_zval(result, *params[i]);
+				add_next_index_zval(&result, &params[i]);
 			}
 		}
 
 		if (ZEND_FCI_INITIALIZED(fci)) {
-			fci.retval_ptr_ptr = &result;
+			fci.retval = &result;
 			fci.param_count = n_arrays;
 			fci.params = params;
 			fci.no_separation = 0;
 
-			if (zend_call_function(&fci, &fci_cache TSRMLS_CC) != SUCCESS || !result) {
+			if (zend_call_function(&fci, &fci_cache TSRMLS_CC) != SUCCESS || Z_TYPE(result) == IS_UNDEF) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "An error occurred while invoking the map callback");
 				efree(array_len);
 				efree(args);
 				efree(array_pos);
 				zval_dtor(return_value);
-				zval_ptr_dtor(&null);
+				for (i = 0; i < n_arrays; i++) {
+					zval_ptr_dtor(&params[i]);
+				}
 				efree(params);
 				RETURN_NULL();
+			} else {
+				for (i = 0; i < n_arrays; i++) {
+					zval_ptr_dtor(&params[i]);
+				}
 			}
 		}
 
 		if (n_arrays > 1) {
-			add_next_index_zval(return_value, result);
+			add_next_index_zval(return_value, &result);
 		} else {
 			if (key_type == HASH_KEY_IS_STRING) {
-				add_assoc_zval_ex(return_value, str_key, str_key_len, result);
+				zend_hash_update(Z_ARRVAL_P(return_value), str_key, &result);
 			} else {
-				add_index_zval(return_value, num_key, result);
+				add_index_zval(return_value, num_key, &result);
 			}
 		}
 	}
 
-	zval_ptr_dtor(&null);
 	efree(params);
 	efree(array_len);
 	efree(array_pos);
@@ -4311,7 +4477,7 @@ PHP_FUNCTION(array_key_exists)
 
 	switch (Z_TYPE_P(key)) {
 		case IS_STRING:
-			if (zend_symtable_exists(array, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1)) {
+			if (zend_symtable_exists(array, Z_STR_P(key))) {
 				RETURN_TRUE;
 			}
 			RETURN_FALSE;
@@ -4321,7 +4487,7 @@ PHP_FUNCTION(array_key_exists)
 			}
 			RETURN_FALSE;
 		case IS_NULL:
-			if (zend_hash_exists(array, "", 1)) {
+			if (zend_hash_exists(array, STR_EMPTY_ALLOC())) {
 				RETURN_TRUE;
 			}
 			RETURN_FALSE;
@@ -4337,16 +4503,14 @@ PHP_FUNCTION(array_key_exists)
    Split array into chunks */
 PHP_FUNCTION(array_chunk)
 {
-	int argc = ZEND_NUM_ARGS(), key_type, num_in;
+	int argc = ZEND_NUM_ARGS(), num_in;
 	long size, current = 0;
-	char *str_key;
-	uint str_key_len;
+	zend_string *str_key;
 	ulong num_key;
 	zend_bool preserve_keys = 0;
 	zval *input = NULL;
-	zval *chunk = NULL;
-	zval **entry;
-	HashPosition pos;
+	zval chunk;
+	zval *entry;
 
 	if (zend_parse_parameters(argc TSRMLS_CC, "al|b", &input, &size, &preserve_keys) == FAILURE) {
 		return;
@@ -4365,44 +4529,38 @@ PHP_FUNCTION(array_chunk)
 
 	array_init_size(return_value, ((num_in - 1) / size) + 1);
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(input), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(input), (void**)&entry, &pos) == SUCCESS) {
+	ZVAL_UNDEF(&chunk);
+
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(input), num_key, str_key, entry) {
 		/* If new chunk, create and initialize it. */
-		if (!chunk) {
-			MAKE_STD_ZVAL(chunk);
-			array_init_size(chunk, size);
+		if (Z_TYPE(chunk) == IS_UNDEF) {
+			array_init_size(&chunk, size);
 		}
 
 		/* Add entry to the chunk, preserving keys if necessary. */
 		zval_add_ref(entry);
 
 		if (preserve_keys) {
-			key_type = zend_hash_get_current_key_ex(Z_ARRVAL_P(input), &str_key, &str_key_len, &num_key, 0, &pos);
-			switch (key_type) {
-				case HASH_KEY_IS_STRING:
-					add_assoc_zval_ex(chunk, str_key, str_key_len, *entry);
-					break;
-				default:
-					add_index_zval(chunk, num_key, *entry);
-					break;
+			if (str_key) {
+				zend_hash_update(Z_ARRVAL(chunk), str_key, entry);
+			} else {
+				add_index_zval(&chunk, num_key, entry);
 			}
 		} else {
-			add_next_index_zval(chunk, *entry);
+			add_next_index_zval(&chunk, entry);
 		}
 
 		/* If reached the chunk size, add it to the result array, and reset the
 		 * pointer. */
 		if (!(++current % size)) {
-			add_next_index_zval(return_value, chunk);
-			chunk = NULL;
+			add_next_index_zval(return_value, &chunk);
+			ZVAL_UNDEF(&chunk);
 		}
-
-		zend_hash_move_forward_ex(Z_ARRVAL_P(input), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	/* Add the final chunk if there is one. */
-	if (chunk) {
-		add_next_index_zval(return_value, chunk);
+	if (Z_TYPE(chunk) != IS_UNDEF) {
+		add_next_index_zval(return_value, &chunk);
 	}
 }
 /* }}} */
@@ -4413,7 +4571,7 @@ PHP_FUNCTION(array_combine)
 {
 	zval *values, *keys;
 	HashPosition pos_values, pos_keys;
-	zval **entry_keys, **entry_values;
+	zval *entry_keys, *entry_values;
 	int num_keys, num_values;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "aa", &keys, &values) == FAILURE) {
@@ -4436,26 +4594,25 @@ PHP_FUNCTION(array_combine)
 
 	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(keys), &pos_keys);
 	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(values), &pos_values);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), (void **)&entry_keys, &pos_keys) == SUCCESS &&
-		zend_hash_get_current_data_ex(Z_ARRVAL_P(values), (void **)&entry_values, &pos_values) == SUCCESS
+	while ((entry_keys = zend_hash_get_current_data_ex(Z_ARRVAL_P(keys), &pos_keys)) != NULL &&
+		(entry_values = zend_hash_get_current_data_ex(Z_ARRVAL_P(values), &pos_values)) != NULL
 	) {
-		if (Z_TYPE_PP(entry_keys) == IS_LONG) {
+		if (Z_TYPE_P(entry_keys) == IS_LONG) {
 			zval_add_ref(entry_values);
-			add_index_zval(return_value, Z_LVAL_PP(entry_keys), *entry_values);
+			add_index_zval(return_value, Z_LVAL_P(entry_keys), entry_values);
 		} else {
-			zval key, *key_ptr = *entry_keys;
+			zval key, *key_ptr = entry_keys;
 
-			if (Z_TYPE_PP(entry_keys) != IS_STRING) {
-				key = **entry_keys;
-				zval_copy_ctor(&key);
+			if (Z_TYPE_P(entry_keys) != IS_STRING) {
+				ZVAL_DUP(&key, entry_keys);
 				convert_to_string(&key);
 				key_ptr = &key;
 			}
 
 			zval_add_ref(entry_values);
-			add_assoc_zval_ex(return_value, Z_STRVAL_P(key_ptr), Z_STRLEN_P(key_ptr) + 1, *entry_values);
+			zend_symtable_update(Z_ARRVAL_P(return_value), Z_STR_P(key_ptr), entry_values);
 
-			if (key_ptr != *entry_keys) {
+			if (key_ptr != entry_keys) {
 				zval_dtor(&key);
 			}
 		}
diff --git a/ext/standard/assert.c b/ext/standard/assert.c
index a9567f3b0a..7791dafd43 100644
--- a/ext/standard/assert.c
+++ b/ext/standard/assert.c
@@ -29,7 +29,7 @@ ZEND_BEGIN_MODULE_GLOBALS(assert)
 	long bail;
 	long warning;
 	long quiet_eval;
-	zval *callback;
+	zval callback;
 	char *cb;
 ZEND_END_MODULE_GLOBALS(assert)
 
@@ -54,13 +54,12 @@ enum {
 static PHP_INI_MH(OnChangeCallback) /* {{{ */
 {
 	if (EG(in_execution)) {
-		if (ASSERTG(callback)) {
+		if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {
 			zval_ptr_dtor(&ASSERTG(callback));
-			ASSERTG(callback) = NULL;
+			ZVAL_UNDEF(&ASSERTG(callback));
 		}
-		if (new_value && (ASSERTG(callback) || new_value_length)) {
-			MAKE_STD_ZVAL(ASSERTG(callback));
-			ZVAL_STRINGL(ASSERTG(callback), new_value, new_value_length, 1);
+		if (new_value && (Z_TYPE(ASSERTG(callback)) != IS_UNDEF || new_value_length)) {
+			ZVAL_STRINGL(&ASSERTG(callback), new_value, new_value_length);
 		}
 	} else {
 		if (ASSERTG(cb)) {
@@ -88,7 +87,7 @@ PHP_INI_END()
 
 static void php_assert_init_globals(zend_assert_globals *assert_globals_p TSRMLS_DC) /* {{{ */
 {
-	assert_globals_p->callback = NULL;
+	ZVAL_UNDEF(&assert_globals_p->callback);
 	assert_globals_p->cb = NULL;
 }
 /* }}} */
@@ -121,9 +120,9 @@ PHP_MSHUTDOWN_FUNCTION(assert) /* {{{ */
 
 PHP_RSHUTDOWN_FUNCTION(assert) /* {{{ */
 {
-	if (ASSERTG(callback)) {
+	if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {
 		zval_ptr_dtor(&ASSERTG(callback));
-		ASSERTG(callback) = NULL;
+		ZVAL_UNDEF(&ASSERTG(callback));
 	}
 
 	return SUCCESS;
@@ -140,7 +139,7 @@ PHP_MINFO_FUNCTION(assert) /* {{{ */
    Checks if assertion is false */
 PHP_FUNCTION(assert)
 {
-	zval **assertion;
+	zval *assertion;
 	int val, description_len = 0;
 	char *myeval = NULL;
 	char *compiled_string_description, *description = NULL;
@@ -149,15 +148,15 @@ PHP_FUNCTION(assert)
 		RETURN_TRUE;
 	}
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|s", &assertion, &description, &description_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|s", &assertion, &description, &description_len) == FAILURE) {
 		return;
 	}
 
-	if (Z_TYPE_PP(assertion) == IS_STRING) {
+	if (Z_TYPE_P(assertion) == IS_STRING) {
 		zval retval;
 		int old_error_reporting = 0; /* shut up gcc! */
 
-		myeval = Z_STRVAL_PP(assertion);
+		myeval = Z_STRVAL_P(assertion);
 
 		if (ASSERTG(quiet_eval)) {
 			old_error_reporting = EG(error_reporting);
@@ -165,7 +164,7 @@ PHP_FUNCTION(assert)
 		}
 
 		compiled_string_description = zend_make_compiled_string_description("assert code" TSRMLS_CC);
-		if (zend_eval_stringl(myeval, Z_STRLEN_PP(assertion), &retval, compiled_string_description TSRMLS_CC) == FAILURE) {
+		if (zend_eval_stringl(myeval, Z_STRLEN_P(assertion), &retval, compiled_string_description TSRMLS_CC) == FAILURE) {
 			efree(compiled_string_description);
 			if (description_len == 0) {
 				php_error_docref(NULL TSRMLS_CC, E_RECOVERABLE_ERROR, "Failure evaluating code: %s%s", PHP_EOL, myeval);
@@ -187,47 +186,40 @@ PHP_FUNCTION(assert)
 		val = Z_LVAL(retval);
 	} else {
 		convert_to_boolean_ex(assertion);
-		val = Z_LVAL_PP(assertion);
+		val = Z_LVAL_P(assertion);
 	}
 
 	if (val) {
 		RETURN_TRUE;
 	}
 
-	if (!ASSERTG(callback) && ASSERTG(cb)) {
-		MAKE_STD_ZVAL(ASSERTG(callback));
-		ZVAL_STRING(ASSERTG(callback), ASSERTG(cb), 1);
+	if (Z_TYPE(ASSERTG(callback)) == IS_UNDEF && ASSERTG(cb)) {
+		ZVAL_STRING(&ASSERTG(callback), ASSERTG(cb));
 	}
 
-	if (ASSERTG(callback)) {
-		zval **args = safe_emalloc(description_len == 0 ? 3 : 4, sizeof(zval *), 0);
-		zval *retval;
+	if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {
+		zval *args = safe_emalloc(description_len == 0 ? 3 : 4, sizeof(zval), 0);
+		zval retval;
 		int i;
 		uint lineno = zend_get_executed_lineno(TSRMLS_C);
 		const char *filename = zend_get_executed_filename(TSRMLS_C);
 
-		MAKE_STD_ZVAL(args[0]);
-		MAKE_STD_ZVAL(args[1]);
-		MAKE_STD_ZVAL(args[2]);
-
-		ZVAL_STRING(args[0], SAFE_STRING(filename), 1);
-		ZVAL_LONG (args[1], lineno);
-		ZVAL_STRING(args[2], SAFE_STRING(myeval), 1);
+		ZVAL_STRING(&args[0], SAFE_STRING(filename));
+		ZVAL_LONG (&args[1], lineno);
+		ZVAL_STRING(&args[2], SAFE_STRING(myeval));
 
-		MAKE_STD_ZVAL(retval);
-		ZVAL_FALSE(retval);
+		ZVAL_FALSE(&retval);
 
 		/* XXX do we want to check for error here? */
 		if (description_len == 0) {
-			call_user_function(CG(function_table), NULL, ASSERTG(callback), retval, 3, args TSRMLS_CC);
+			call_user_function(CG(function_table), NULL, &ASSERTG(callback), &retval, 3, args TSRMLS_CC);
 			for (i = 0; i <= 2; i++) {
 				zval_ptr_dtor(&(args[i]));
 			}
 		} else {
-			MAKE_STD_ZVAL(args[3]);
-			ZVAL_STRINGL(args[3], SAFE_STRING(description), description_len, 1);
+			ZVAL_STRINGL(&args[3], SAFE_STRING(description), description_len);
 
-			call_user_function(CG(function_table), NULL, ASSERTG(callback), retval, 4, args TSRMLS_CC);
+			call_user_function(CG(function_table), NULL, &ASSERTG(callback), &retval, 4, args TSRMLS_CC);
 			for (i = 0; i <= 3; i++) {
 				zval_ptr_dtor(&(args[i]));
 			}
@@ -263,12 +255,13 @@ PHP_FUNCTION(assert)
    Set/get the various assert flags */
 PHP_FUNCTION(assert_options)
 {
-	zval **value = NULL;
+	zval *value = NULL;
 	long what;
 	int oldint;
 	int ac = ZEND_NUM_ARGS();
+	zend_string *key;
 
-	if (zend_parse_parameters(ac TSRMLS_CC, "l|Z", &what, &value) == FAILURE) {
+	if (zend_parse_parameters(ac TSRMLS_CC, "l|z", &what, &value) == FAILURE) {
 		return;
 	}
 
@@ -277,7 +270,9 @@ PHP_FUNCTION(assert_options)
 		oldint = ASSERTG(active);
 		if (ac == 2) {
 			convert_to_string_ex(value);
-			zend_alter_ini_entry_ex("assert.active", sizeof("assert.active"), Z_STRVAL_PP(value), Z_STRLEN_PP(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			key = STR_INIT("assert.active", sizeof("assert.active")-1, 0);
+			zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			STR_RELEASE(key);
 		}
 		RETURN_LONG(oldint);
 		break;
@@ -286,7 +281,9 @@ PHP_FUNCTION(assert_options)
 		oldint = ASSERTG(bail);
 		if (ac == 2) {
 			convert_to_string_ex(value);
-			zend_alter_ini_entry_ex("assert.bail", sizeof("assert.bail"), Z_STRVAL_PP(value), Z_STRLEN_PP(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			key = STR_INIT("assert.bail", sizeof("assert.bail")-1, 0);
+			zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			STR_RELEASE(key);
 		}
 		RETURN_LONG(oldint);
 		break;
@@ -295,7 +292,9 @@ PHP_FUNCTION(assert_options)
 		oldint = ASSERTG(quiet_eval);
 		if (ac == 2) {
 			convert_to_string_ex(value);
-			zend_alter_ini_entry_ex("assert.quiet_eval", sizeof("assert.quiet_eval"), Z_STRVAL_PP(value), Z_STRLEN_PP(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			key = STR_INIT("assert.quiet_eval", sizeof("assert.quiet_eval")-1, 0);
+			zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			STR_RELEASE(key);
 		}
 		RETURN_LONG(oldint);
 		break;
@@ -304,23 +303,23 @@ PHP_FUNCTION(assert_options)
 		oldint = ASSERTG(warning);
 		if (ac == 2) {
 			convert_to_string_ex(value);
-			zend_alter_ini_entry_ex("assert.warning", sizeof("assert.warning"), Z_STRVAL_PP(value), Z_STRLEN_PP(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			key = STR_INIT("assert.warning", sizeof("assert.warning")-1, 0);
+			zend_alter_ini_entry_ex(key, Z_STRVAL_P(value), Z_STRLEN_P(value), PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+			STR_RELEASE(key);
 		}
 		RETURN_LONG(oldint);
 		break;
 
 	case ASSERT_CALLBACK:
-		if (ASSERTG(callback) != NULL) {
-			RETVAL_ZVAL(ASSERTG(callback), 1, 0);
+		if (Z_TYPE(ASSERTG(callback)) != IS_UNDEF) {
+			RETVAL_ZVAL(&ASSERTG(callback), 1, 0);
 		} else if (ASSERTG(cb)) {
-			RETVAL_STRING(ASSERTG(cb), 1);
+			RETVAL_STRING(ASSERTG(cb));
 		} else {
 			RETVAL_NULL();
 		}
 		if (ac == 2) {
-			if (ASSERTG(callback)) {
-				zval_ptr_dtor(&ASSERTG(callback));
-			}
+			zval_ptr_dtor(&ASSERTG(callback));
 			ASSERTG(callback) = *value;
 			zval_add_ref(value);
 		}
diff --git a/ext/standard/base64.c b/ext/standard/base64.c
index 0df7826642..3bc96267b2 100644
--- a/ext/standard/base64.c
+++ b/ext/standard/base64.c
@@ -53,21 +53,18 @@ static const short base64_reverse_table[256] = {
 };
 /* }}} */
 
-PHPAPI unsigned char *php_base64_encode(const unsigned char *str, int length, int *ret_length) /* {{{ */
+PHPAPI zend_string *php_base64_encode(const unsigned char *str, int length) /* {{{ */
 {
 	const unsigned char *current = str;
 	unsigned char *p;
-	unsigned char *result;
+	zend_string *result;
 
 	if (length < 0) {
-		if (ret_length != NULL) {
-			*ret_length = 0;
-		}
 		return NULL;
 	}
 
-	result = (unsigned char *) safe_emalloc((length + 2) / 3, 4 * sizeof(char), 1);
-	p = result;
+	result = STR_ALLOC(((length + 2) / 3) * 4 * sizeof(char), 0);
+	p = (unsigned char *)result->val;
 
 	while (length > 2) { /* keep going until we have less than 24 bits */
 		*p++ = base64_table[current[0] >> 2];
@@ -92,10 +89,10 @@ PHPAPI unsigned char *php_base64_encode(const unsigned char *str, int length, in
 			*p++ = base64_pad;
 		}
 	}
-	if (ret_length != NULL) {
-		*ret_length = (int)(p - result);
-	}
 	*p = '\0';
+
+	result->len = (p - (unsigned char *)result->val);
+
 	return result;
 }
 /* }}} */
@@ -134,20 +131,20 @@ void php_base64_init(void)
 */
 /* }}} */
 
-PHPAPI unsigned char *php_base64_decode(const unsigned char *str, int length, int *ret_length) /* {{{ */
+PHPAPI zend_string *php_base64_decode(const unsigned char *str, int length) /* {{{ */
 {
-	return php_base64_decode_ex(str, length, ret_length, 0);
+	return php_base64_decode_ex(str, length, 0);
 }
 /* }}} */
 
-PHPAPI unsigned char *php_base64_decode_ex(const unsigned char *str, int length, int *ret_length, zend_bool strict) /* {{{ */
+PHPAPI zend_string *php_base64_decode_ex(const unsigned char *str, int length, zend_bool strict) /* {{{ */
 {
 	const unsigned char *current = str;
 	int ch, i = 0, j = 0, k;
 	/* this sucks for threaded environments */
-	unsigned char *result;
+	zend_string *result;
 
-	result = (unsigned char *)safe_emalloc(length, 1, 1);
+	result = STR_ALLOC(length, 0);
 
 	/* run through the whole string, converting as we go */
 	while ((ch = *current++) != '\0' && length-- > 0) {
@@ -161,7 +158,7 @@ PHPAPI unsigned char *php_base64_decode_ex(const unsigned char *str, int length,
 						continue;
 					}
 				}
-				efree(result);
+				STR_FREE(result);
 				return NULL;
 			}
 			continue;
@@ -171,24 +168,24 @@ PHPAPI unsigned char *php_base64_decode_ex(const unsigned char *str, int length,
 		if ((!strict && ch < 0) || ch == -1) { /* a space or some other separator character, we simply skip over */
 			continue;
 		} else if (ch == -2) {
-			efree(result);
+			STR_FREE(result);
 			return NULL;
 		}
 
 		switch(i % 4) {
 		case 0:
-			result[j] = ch << 2;
+			result->val[j] = ch << 2;
 			break;
 		case 1:
-			result[j++] |= ch >> 4;
-			result[j] = (ch & 0x0f) << 4;
+			result->val[j++] |= ch >> 4;
+			result->val[j] = (ch & 0x0f) << 4;
 			break;
 		case 2:
-			result[j++] |= ch >>2;
-			result[j] = (ch & 0x03) << 6;
+			result->val[j++] |= ch >>2;
+			result->val[j] = (ch & 0x03) << 6;
 			break;
 		case 3:
-			result[j++] |= ch;
+			result->val[j++] |= ch;
 			break;
 		}
 		i++;
@@ -199,18 +196,17 @@ PHPAPI unsigned char *php_base64_decode_ex(const unsigned char *str, int length,
 	if (ch == base64_pad) {
 		switch(i % 4) {
 		case 1:
-			efree(result);
+			STR_FREE(result);
 			return NULL;
 		case 2:
 			k++;
 		case 3:
-			result[k] = 0;
+			result->val[k] = 0;
 		}
 	}
-	if(ret_length) {
-		*ret_length = j;
-	}
-	result[j] = '\0';
+	result->len = j;
+	result->val[result->len] = '\0';
+
 	return result;
 }
 /* }}} */
@@ -220,15 +216,15 @@ PHPAPI unsigned char *php_base64_decode_ex(const unsigned char *str, int length,
 PHP_FUNCTION(base64_encode)
 {
 	char *str;
-	unsigned char *result;
-	int str_len, ret_length;
+	int str_len;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
 		return;
 	}
-	result = php_base64_encode((unsigned char*)str, str_len, &ret_length);
+	result = php_base64_encode((unsigned char*)str, str_len);
 	if (result != NULL) {
-		RETVAL_STRINGL((char*)result, ret_length, 0);
+		RETURN_STR(result);
 	} else {
 		RETURN_FALSE;
 	}
@@ -240,16 +236,16 @@ PHP_FUNCTION(base64_encode)
 PHP_FUNCTION(base64_decode)
 {
 	char *str;
-	unsigned char *result;
 	zend_bool strict = 0;
-	int str_len, ret_length;
+	int str_len;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &str, &str_len, &strict) == FAILURE) {
 		return;
 	}
-	result = php_base64_decode_ex((unsigned char*)str, str_len, &ret_length, strict);
+	result = php_base64_decode_ex((unsigned char*)str, str_len, strict);
 	if (result != NULL) {
-		RETVAL_STRINGL((char*)result, ret_length, 0);
+		RETURN_STR(result);
 	} else {
 		RETURN_FALSE;
 	}
diff --git a/ext/standard/base64.h b/ext/standard/base64.h
index 2358c58951..e58565702a 100644
--- a/ext/standard/base64.h
+++ b/ext/standard/base64.h
@@ -24,9 +24,9 @@
 PHP_FUNCTION(base64_decode);
 PHP_FUNCTION(base64_encode);
 
-PHPAPI extern unsigned char *php_base64_encode(const unsigned char *, int, int *);
-PHPAPI extern unsigned char *php_base64_decode_ex(const unsigned char *, int, int *, zend_bool);
-PHPAPI extern unsigned char *php_base64_decode(const unsigned char *, int, int *);
+PHPAPI extern zend_string *php_base64_encode(const unsigned char *, int);
+PHPAPI extern zend_string *php_base64_decode_ex(const unsigned char *, int, zend_bool);
+PHPAPI extern zend_string *php_base64_decode(const unsigned char *, int);
 
 #endif /* BASE64_H */
 
diff --git a/ext/standard/basic_functions.c b/ext/standard/basic_functions.c
index de3719e1e9..537ca17731 100644
--- a/ext/standard/basic_functions.c
+++ b/ext/standard/basic_functions.c
@@ -119,13 +119,13 @@ PHPAPI php_basic_globals basic_globals;
 static zend_class_entry *incomplete_class_entry = NULL;
 
 typedef struct _user_tick_function_entry {
-	zval **arguments;
+	zval *arguments;
 	int arg_count;
 	int calling;
 } user_tick_function_entry;
 
 /* some prototypes for local functions */
-static void user_shutdown_function_dtor(php_shutdown_function_entry *shutdown_function_entry);
+static void user_shutdown_function_dtor(zval *zv);
 static void user_tick_function_dtor(user_tick_function_entry *tick_function_entry);
 
 static HashTable basic_submodules;
@@ -3374,8 +3374,10 @@ zend_module_entry basic_functions_module = { /* {{{ */
 /* }}} */
 
 #if defined(HAVE_PUTENV)
-static void php_putenv_destructor(putenv_entry *pe) /* {{{ */
+static void php_putenv_destructor(zval *zv) /* {{{ */
 {
+	putenv_entry *pe = Z_PTR_P(zv);
+
 	if (pe->previous_value) {
 #if _MSC_VER >= 1300
 		/* VS.Net has a bug in putenv() when setting a variable that
@@ -3414,6 +3416,7 @@ static void php_putenv_destructor(putenv_entry *pe) /* {{{ */
 
 	efree(pe->putenv_string);
 	efree(pe->key);
+	efree(pe);
 }
 /* }}} */
 #endif
@@ -3496,25 +3499,25 @@ PHPAPI double php_get_inf(void) /* {{{ */
 	}
 
 #define BASIC_ADD_SUBMODULE(module) \
-	zend_hash_add_empty_element(&basic_submodules, #module, strlen(#module));
+	zend_hash_str_add_empty_element(&basic_submodules, #module, strlen(#module));
 	
 #define BASIC_RINIT_SUBMODULE(module) \
-	if (zend_hash_exists(&basic_submodules, #module, strlen(#module))) { \
+	if (zend_hash_str_exists(&basic_submodules, #module, strlen(#module))) { \
 		PHP_RINIT(module)(INIT_FUNC_ARGS_PASSTHRU); \
 	}
 
 #define BASIC_MINFO_SUBMODULE(module) \
-	if (zend_hash_exists(&basic_submodules, #module, strlen(#module))) { \
+	if (zend_hash_str_exists(&basic_submodules, #module, strlen(#module))) { \
 		PHP_MINFO(module)(ZEND_MODULE_INFO_FUNC_ARGS_PASSTHRU); \
 	}
 
 #define BASIC_RSHUTDOWN_SUBMODULE(module) \
-	if (zend_hash_exists(&basic_submodules, #module, strlen(#module))) { \
+	if (zend_hash_str_exists(&basic_submodules, #module, strlen(#module))) { \
 		PHP_RSHUTDOWN(module)(SHUTDOWN_FUNC_ARGS_PASSTHRU); \
 	}
 
 #define BASIC_MSHUTDOWN_SUBMODULE(module) \
-	if (zend_hash_exists(&basic_submodules, #module, strlen(#module))) { \
+	if (zend_hash_str_exists(&basic_submodules, #module, strlen(#module))) { \
 		PHP_MSHUTDOWN(module)(SHUTDOWN_FUNC_ARGS_PASSTHRU); \
 	}
 
@@ -3698,7 +3701,7 @@ PHP_RINIT_FUNCTION(basic) /* {{{ */
 	memset(&BG(unserialize), 0, sizeof(BG(unserialize)));
 
 	BG(strtok_string) = NULL;
-	BG(strtok_zval) = NULL;
+	ZVAL_UNDEF(&BG(strtok_zval));
 	BG(strtok_last) = NULL;
 	BG(locale_string) = NULL;
 	BG(array_walk_fci) = empty_fcall_info;
@@ -3710,9 +3713,7 @@ PHP_RINIT_FUNCTION(basic) /* {{{ */
 	BG(page_inode) = -1;
 	BG(page_mtime) = -1;
 #ifdef HAVE_PUTENV
-	if (zend_hash_init(&BG(putenv_ht), 1, NULL, (void (*)(void *)) php_putenv_destructor, 0) == FAILURE) {
-		return FAILURE;
-	}
+	zend_hash_init(&BG(putenv_ht), 1, NULL, php_putenv_destructor, 0);
 #endif
 	BG(user_shutdown_function_names) = NULL;
 
@@ -3738,11 +3739,9 @@ PHP_RINIT_FUNCTION(basic) /* {{{ */
 
 PHP_RSHUTDOWN_FUNCTION(basic) /* {{{ */
 {
-	if (BG(strtok_zval)) {
-		zval_ptr_dtor(&BG(strtok_zval));
-	}
+	zval_ptr_dtor(&BG(strtok_zval));
+	ZVAL_UNDEF(&BG(strtok_zval));
 	BG(strtok_string) = NULL;
-	BG(strtok_zval) = NULL;
 #ifdef HAVE_PUTENV
 	zend_hash_destroy(&BG(putenv_ht));
 #endif
@@ -3758,8 +3757,10 @@ PHP_RSHUTDOWN_FUNCTION(basic) /* {{{ */
 		setlocale(LC_CTYPE, "");
 		zend_update_current_locale();
 	}
-	STR_FREE(BG(locale_string));
-	BG(locale_string) = NULL;
+	if (BG(locale_string)) {
+		efree(BG(locale_string));
+		BG(locale_string) = NULL;
+	}
 
 	/* FG(stream_wrappers) and FG(stream_filters) are destroyed
 	 * during php_request_shutdown() */
@@ -3806,15 +3807,22 @@ PHP_MINFO_FUNCTION(basic) /* {{{ */
    Given the name of a constant this function will return the constant's associated value */
 PHP_FUNCTION(constant)
 {
-	char *const_name;
-	int const_name_len;
+	zend_string *const_name;
+	zval *c;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &const_name, &const_name_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &const_name) == FAILURE) {
 		return;
 	}
 
-	if (!zend_get_constant_ex(const_name, const_name_len, return_value, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't find constant %s", const_name);
+	c = zend_get_constant_ex(const_name, NULL, ZEND_FETCH_CLASS_SILENT TSRMLS_CC);
+	if (c) {
+		ZVAL_COPY_VALUE(return_value, c);
+		if (Z_CONSTANT_P(return_value)) {
+			zval_update_constant_ex(return_value, 1, NULL TSRMLS_CC);
+		}
+		zval_copy_ctor(return_value);
+	} else {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Couldn't find constant %s", const_name->val);
 		RETURN_NULL();
 	}
 }
@@ -3848,7 +3856,7 @@ PHP_NAMED_FUNCTION(php_inet_ntop)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(buffer, 1);
+	RETURN_STRING(buffer);
 }
 /* }}} */
 #endif /* HAVE_INET_NTOP */
@@ -3886,7 +3894,7 @@ PHP_NAMED_FUNCTION(php_inet_pton)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL(buffer, af == AF_INET ? 4 : 16, 1);
+	RETURN_STRINGL(buffer, af == AF_INET ? 4 : 16);
 }
 /* }}} */
 #endif /* HAVE_INET_PTON */
@@ -3951,12 +3959,12 @@ PHP_FUNCTION(long2ip)
 	myaddr.s_addr = htonl(n);
 #ifdef HAVE_INET_PTON
 	if (inet_ntop(AF_INET, &myaddr, str, sizeof(str))) {
-		RETURN_STRING(str, 1);
+		RETURN_STRING(str);
 	} else {
 		RETURN_FALSE;
 	}
 #else
-	RETURN_STRING(inet_ntoa(myaddr), 1);
+	RETURN_STRING(inet_ntoa(myaddr));
 #endif
 }
 /* }}} */
@@ -3979,7 +3987,10 @@ PHP_FUNCTION(getenv)
 	/* SAPI method returns an emalloc()'d string */
 	ptr = sapi_getenv(str, str_len TSRMLS_CC);
 	if (ptr) {
-		RETURN_STRING(ptr, 0);
+		// TODO: avoid realocation ???
+		RETVAL_STRING(ptr);
+		efree(ptr);
+		return;
 	}
 #ifdef PHP_WIN32
 	{
@@ -4015,7 +4026,7 @@ PHP_FUNCTION(getenv)
 	/* system method returns a const */
 	ptr = getenv(str);
 	if (ptr) {
-		RETURN_STRING(ptr, 1);
+		RETURN_STRING(ptr);
 	}
 #endif
 	RETURN_FALSE;
@@ -4064,7 +4075,7 @@ PHP_FUNCTION(putenv)
 		}
 #endif
 
-		zend_hash_del(&BG(putenv_ht), pe.key, pe.key_len+1);
+		zend_hash_str_del(&BG(putenv_ht), pe.key, pe.key_len);
 
 		/* find previous value */
 		pe.previous_value = NULL;
@@ -4099,7 +4110,7 @@ PHP_FUNCTION(putenv)
 #  endif
 # endif
 #endif
-			zend_hash_add(&BG(putenv_ht), pe.key, pe.key_len + 1, (void **) &pe, sizeof(putenv_entry), NULL);
+			zend_hash_str_add_mem(&BG(putenv_ht), pe.key, pe.key_len, &pe, sizeof(putenv_entry));
 #ifdef HAVE_TZSET
 			if (!strncmp(pe.key, "TZ", pe.key_len)) {
 				tzset();
@@ -4201,7 +4212,7 @@ PHP_FUNCTION(getopt)
 	int argc = 0, options_len = 0, len, o;
 	char *php_optarg = NULL;
 	int php_optind = 1;
-	zval *val, **args = NULL, *p_longopts = NULL;
+	zval val, *args = NULL, *p_longopts = NULL;
 	int optname_len = 0;
 	opt_struct *opts, *orig_opts;
 
@@ -4212,41 +4223,38 @@ PHP_FUNCTION(getopt)
 	/* Get argv from the global symbol table. We calculate argc ourselves
 	 * in order to be on the safe side, even though it is also available
 	 * from the symbol table. */
-	if (PG(http_globals)[TRACK_VARS_SERVER] &&
-		(zend_hash_find(HASH_OF(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), (void **) &args) != FAILURE ||
-		zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void **) &args) != FAILURE) && Z_TYPE_PP(args) == IS_ARRAY
+	if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) != IS_UNDEF &&
+		((args = zend_hash_str_find_ind(HASH_OF(&PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv")-1)) != NULL ||
+		(args = zend_hash_str_find_ind(&EG(symbol_table).ht, "argv", sizeof("argv")-1)) != NULL)
 	) {
 		int pos = 0;
-		zval **entry;
+		zval *entry;
 
-		argc = zend_hash_num_elements(Z_ARRVAL_PP(args));
+ 		if (Z_TYPE_P(args) != IS_ARRAY) {
+ 			RETURN_FALSE;
+ 		}
+ 		argc = zend_hash_num_elements(Z_ARRVAL_P(args));
 
 		/* Attempt to allocate enough memory to hold all of the arguments
 		 * and a trailing NULL */
 		argv = (char **) safe_emalloc(sizeof(char *), (argc + 1), 0);
 
-		/* Reset the array indexes. */
-		zend_hash_internal_pointer_reset(Z_ARRVAL_PP(args));
-
 		/* Iterate over the hash to construct the argv array. */
-		while (zend_hash_get_current_data(Z_ARRVAL_PP(args), (void **)&entry) == SUCCESS) {
-			zval arg, *arg_ptr = *entry;
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(args), entry) {
+			zval arg, *arg_ptr = entry;
 
-			if (Z_TYPE_PP(entry) != IS_STRING) {
-				arg = **entry;
-				zval_copy_ctor(&arg);
+			if (Z_TYPE_P(entry) != IS_STRING) {
+				ZVAL_DUP(&arg, entry);
 				convert_to_string(&arg);
 				arg_ptr = &arg;
 			}
 
 			argv[pos++] = estrdup(Z_STRVAL_P(arg_ptr));
 
-			if (arg_ptr != *entry) {
+			if (arg_ptr != entry) {
 				zval_dtor(&arg);
 			}
-
-			zend_hash_move_forward(Z_ARRVAL_PP(args));
-		}
+		} ZEND_HASH_FOREACH_END();
 
 		/* The C Standard requires argv[argc] to be NULL - this might
 		 * keep some getopt implementations happy. */
@@ -4260,7 +4268,7 @@ PHP_FUNCTION(getopt)
 
 	if (p_longopts) {
 		int count;
-		zval **entry;
+		zval *entry;
 
 		count = zend_hash_num_elements(Z_ARRVAL_P(p_longopts));
 
@@ -4272,16 +4280,12 @@ PHP_FUNCTION(getopt)
 
 		memset(opts, 0, count * sizeof(opt_struct));
 
-		/* Reset the array indexes. */
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(p_longopts));
-
 		/* Iterate over the hash to construct the argv array. */
-		while (zend_hash_get_current_data(Z_ARRVAL_P(p_longopts), (void **)&entry) == SUCCESS) {
-			zval arg, *arg_ptr = *entry;
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(p_longopts), entry) {
+			zval arg, *arg_ptr = entry;
 
-			if (Z_TYPE_PP(entry) != IS_STRING) {
-				arg = **entry;
-				zval_copy_ctor(&arg);
+			if (Z_TYPE_P(entry) != IS_STRING) {
+				ZVAL_DUP(&arg, entry);
 				convert_to_string(&arg);
 				arg_ptr = &arg;
 			}
@@ -4300,12 +4304,10 @@ PHP_FUNCTION(getopt)
 			opts->opt_char = 0;
 			opts++;
 
-			if (arg_ptr != *entry) {
+			if (arg_ptr != entry) {
 				zval_dtor(&arg);
 			}
-
-			zend_hash_move_forward(Z_ARRVAL_P(p_longopts));
-		}
+		} ZEND_HASH_FOREACH_END();
 	} else {
 		opts = (opt_struct*) erealloc(opts, sizeof(opt_struct) * (len + 1));
 		orig_opts = opts;
@@ -4340,12 +4342,11 @@ PHP_FUNCTION(getopt)
 			optname = opt;
 		}
 
-		MAKE_STD_ZVAL(val);
 		if (php_optarg != NULL) {
 			/* keep the arg as binary, since the encoding is not known */
-			ZVAL_STRING(val, php_optarg, 1);
+			ZVAL_STRING(&val, php_optarg);
 		} else {
-			ZVAL_FALSE(val);
+			ZVAL_FALSE(&val);
 		}
 
 		/* Add this option / argument pair to the result hash. */
@@ -4353,23 +4354,23 @@ PHP_FUNCTION(getopt)
 		if (!(optname_len > 1 && optname[0] == '0') && is_numeric_string(optname, optname_len, NULL, NULL, 0) == IS_LONG) {
 			/* numeric string */
 			int optname_int = atoi(optname);
-			if (zend_hash_index_find(HASH_OF(return_value), optname_int, (void **)&args) != FAILURE) {
-				if (Z_TYPE_PP(args) != IS_ARRAY) {
+			if ((args = zend_hash_index_find(HASH_OF(return_value), optname_int)) != NULL) {
+				if (Z_TYPE_P(args) != IS_ARRAY) {
 					convert_to_array_ex(args);
 				}
-				zend_hash_next_index_insert(HASH_OF(*args), (void *)&val, sizeof(zval *), NULL);
+				zend_hash_next_index_insert(HASH_OF(args), &val);
 			} else {
-				zend_hash_index_update(HASH_OF(return_value), optname_int, &val, sizeof(zval *), NULL);
+				zend_hash_index_update(HASH_OF(return_value), optname_int, &val);
 			}
 		} else {
 			/* other strings */
-			if (zend_hash_find(HASH_OF(return_value), optname, strlen(optname)+1, (void **)&args) != FAILURE) {
-				if (Z_TYPE_PP(args) != IS_ARRAY) {
+			if ((args = zend_hash_str_find(HASH_OF(return_value), optname, strlen(optname))) != NULL) {
+				if (Z_TYPE_P(args) != IS_ARRAY) {
 					convert_to_array_ex(args);
 				}
-				zend_hash_next_index_insert(HASH_OF(*args), (void *)&val, sizeof(zval *), NULL);
+				zend_hash_next_index_insert(HASH_OF(args), &val);
 			} else {
-				zend_hash_add(HASH_OF(return_value), optname, strlen(optname)+1, (void *)&val, sizeof(zval *), NULL);
+				zend_hash_str_add(HASH_OF(return_value), optname, strlen(optname), &val);
 			}
 		}
 
@@ -4520,7 +4521,7 @@ PHP_FUNCTION(get_current_user)
 		return;
 	}
 
-	RETURN_STRING(php_get_current_user(TSRMLS_C), 1);
+	RETURN_STRING(php_get_current_user(TSRMLS_C));
 }
 /* }}} */
 
@@ -4529,19 +4530,18 @@ PHP_FUNCTION(get_current_user)
 static int add_config_entry_cb(zval *entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key)
 {
 	zval *retval = (zval *)va_arg(args, zval*);
-	zval *tmp;
+	zval tmp;
 
 	if (Z_TYPE_P(entry) == IS_STRING) {
-		if (hash_key->nKeyLength > 0) {
-			add_assoc_stringl_ex(retval, hash_key->arKey, hash_key->nKeyLength, Z_STRVAL_P(entry), Z_STRLEN_P(entry), 1);
+		if (hash_key->key) {
+			add_assoc_str_ex(retval, hash_key->key->val, hash_key->key->len, STR_COPY(Z_STR_P(entry)));
 		} else {
-			add_index_stringl(retval, hash_key->h, Z_STRVAL_P(entry), Z_STRLEN_P(entry), 1);
+			add_index_str(retval, hash_key->h, STR_COPY(Z_STR_P(entry)));
 		}
 	} else if (Z_TYPE_P(entry) == IS_ARRAY) {
-		MAKE_STD_ZVAL(tmp);
-		array_init(tmp);
+		array_init(&tmp);
 		zend_hash_apply_with_arguments(Z_ARRVAL_P(entry) TSRMLS_CC, (apply_func_args_t) add_config_entry_cb, 1, tmp);
-		add_assoc_zval_ex(retval, hash_key->arKey, hash_key->nKeyLength, tmp);
+		zend_hash_update(Z_ARRVAL_P(retval), hash_key->key, &tmp);
 	}
 	return 0;
 }
@@ -4559,7 +4559,7 @@ PHP_FUNCTION(get_cfg_var)
 		return;
 	}
 
-	retval = cfg_get_entry(varname, varname_len + 1);
+	retval = cfg_get_entry(varname, varname_len);
 
 	if (retval) {
 		if (Z_TYPE_P(retval) == IS_ARRAY) {
@@ -4567,7 +4567,7 @@ PHP_FUNCTION(get_cfg_var)
 			zend_hash_apply_with_arguments(Z_ARRVAL_P(retval) TSRMLS_CC, (apply_func_args_t) add_config_entry_cb, 1, return_value);
 			return;
 		} else {
-			RETURN_STRING(Z_STRVAL_P(retval), 1);
+			RETURN_STRING(Z_STRVAL_P(retval));
 		}
 	} else {
 		RETURN_FALSE;
@@ -4712,10 +4712,10 @@ PHP_FUNCTION(error_get_last)
 
 	if (PG(last_error_message)) {
 		array_init(return_value);
-		add_assoc_long_ex(return_value, "type", sizeof("type"), PG(last_error_type));
-		add_assoc_string_ex(return_value, "message", sizeof("message"), PG(last_error_message), 1);
-		add_assoc_string_ex(return_value, "file", sizeof("file"), PG(last_error_file)?PG(last_error_file):"-", 1 );
-		add_assoc_long_ex(return_value, "line", sizeof("line"), PG(last_error_lineno));
+		add_assoc_long_ex(return_value, "type", sizeof("type")-1, PG(last_error_type));
+		add_assoc_string_ex(return_value, "message", sizeof("message")-1, PG(last_error_message));
+		add_assoc_string_ex(return_value, "file", sizeof("file")-1, PG(last_error_file)?PG(last_error_file):"-");
+		add_assoc_long_ex(return_value, "line", sizeof("line")-1, PG(last_error_lineno));
 	}
 }
 /* }}} */
@@ -4724,7 +4724,7 @@ PHP_FUNCTION(error_get_last)
    Call a user function which is the first parameter */
 PHP_FUNCTION(call_user_func)
 {
-	zval *retval_ptr = NULL;
+	zval retval;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fci_cache;
 
@@ -4732,14 +4732,10 @@ PHP_FUNCTION(call_user_func)
 		return;
 	}
 
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.retval = &retval;
 
-	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
-	}
-
-	if (fci.params) {
-		efree(fci.params);
+	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 }
 /* }}} */
@@ -4748,7 +4744,7 @@ PHP_FUNCTION(call_user_func)
    Call a user function which is the first parameter with the arguments contained in array */
 PHP_FUNCTION(call_user_func_array)
 {
-	zval *params, *retval_ptr = NULL;
+	zval *params, retval;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fci_cache;
 
@@ -4757,10 +4753,10 @@ PHP_FUNCTION(call_user_func_array)
 	}
 
 	zend_fcall_info_args(&fci, params TSRMLS_CC);
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.retval = &retval;
 
-	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
+	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 
 	zend_fcall_info_args_clear(&fci, 1);
@@ -4771,7 +4767,7 @@ PHP_FUNCTION(call_user_func_array)
    Call a user function which is the first parameter */
 PHP_FUNCTION(forward_static_call)
 {
-	zval *retval_ptr = NULL;
+	zval retval;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fci_cache;
 
@@ -4783,19 +4779,15 @@ PHP_FUNCTION(forward_static_call)
 		zend_error(E_ERROR, "Cannot call forward_static_call() when no class scope is active");
 	}
 
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.retval = &retval;
 
 	if (EG(called_scope) &&
 		instanceof_function(EG(called_scope), fci_cache.calling_scope TSRMLS_CC)) {
 			fci_cache.called_scope = EG(called_scope);
 	}
 	
-	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
-	}
-
-	if (fci.params) {
-		efree(fci.params);
+	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 }
 /* }}} */
@@ -4804,7 +4796,7 @@ PHP_FUNCTION(forward_static_call)
    Call a user function which is the first parameter with the arguments contained in array */
 PHP_FUNCTION(forward_static_call_array)
 {
-	zval *params, *retval_ptr = NULL;
+	zval *params, retval;
 	zend_fcall_info fci;
 	zend_fcall_info_cache fci_cache;
 
@@ -4813,29 +4805,31 @@ PHP_FUNCTION(forward_static_call_array)
 	}
 
 	zend_fcall_info_args(&fci, params TSRMLS_CC);
-	fci.retval_ptr_ptr = &retval_ptr;
+	fci.retval = &retval;
 
 	if (EG(called_scope) &&
 		instanceof_function(EG(called_scope), fci_cache.calling_scope TSRMLS_CC)) {
 			fci_cache.called_scope = EG(called_scope);
 	}
 
-	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && fci.retval_ptr_ptr && *fci.retval_ptr_ptr) {
-		COPY_PZVAL_TO_ZVAL(*return_value, *fci.retval_ptr_ptr);
+	if (zend_call_function(&fci, &fci_cache TSRMLS_CC) == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		ZVAL_COPY_VALUE(return_value, &retval);
 	}
 
 	zend_fcall_info_args_clear(&fci, 1);
 }
 /* }}} */
 
-void user_shutdown_function_dtor(php_shutdown_function_entry *shutdown_function_entry) /* {{{ */
+void user_shutdown_function_dtor(zval *zv) /* {{{ */
 {
 	int i;
+	php_shutdown_function_entry *shutdown_function_entry = Z_PTR_P(zv);
 
 	for (i = 0; i < shutdown_function_entry->arg_count; i++) {
 		zval_ptr_dtor(&shutdown_function_entry->arguments[i]);
 	}
 	efree(shutdown_function_entry->arguments);
+	efree(shutdown_function_entry);
 }
 /* }}} */
 
@@ -4850,24 +4844,25 @@ void user_tick_function_dtor(user_tick_function_entry *tick_function_entry) /* {
 }
 /* }}} */
 
-static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_function_entry TSRMLS_DC) /* {{{ */
+static int user_shutdown_function_call(zval *zv TSRMLS_DC) /* {{{ */
 {
+    php_shutdown_function_entry *shutdown_function_entry = Z_PTR_P(zv);
 	zval retval;
-	char *function_name;
+	zend_string *function_name;
 
-	if (!zend_is_callable(shutdown_function_entry->arguments[0], 0, &function_name TSRMLS_CC)) {
-		php_error(E_WARNING, "(Registered shutdown functions) Unable to call %s() - function does not exist", function_name);
+	if (!zend_is_callable(&shutdown_function_entry->arguments[0], 0, &function_name TSRMLS_CC)) {
+		php_error(E_WARNING, "(Registered shutdown functions) Unable to call %s() - function does not exist", function_name->val);
 		if (function_name) {
-			efree(function_name);
+			STR_RELEASE(function_name);
 		}
 		return 0;
 	}
 	if (function_name) {
-		efree(function_name);
+		STR_RELEASE(function_name);
 	}
 
 	if (call_user_function(EG(function_table), NULL,
-				shutdown_function_entry->arguments[0],
+				&shutdown_function_entry->arguments[0],
 				&retval,
 				shutdown_function_entry->arg_count - 1,
 				shutdown_function_entry->arguments + 1
@@ -4882,7 +4877,7 @@ static int user_shutdown_function_call(php_shutdown_function_entry *shutdown_fun
 static void user_tick_function_call(user_tick_function_entry *tick_fe TSRMLS_DC) /* {{{ */
 {
 	zval retval;
-	zval *function = tick_fe->arguments[0];
+	zval *function = &tick_fe->arguments[0];
 
 	/* Prevent reentrant calls to the same user ticks function */
 	if (! tick_fe->calling) {
@@ -4897,16 +4892,16 @@ static void user_tick_function_call(user_tick_function_entry *tick_fe TSRMLS_DC)
 			zval_dtor(&retval);
 
 		} else {
-			zval **obj, **method;
+			zval *obj, *method;
 
 			if (Z_TYPE_P(function) == IS_STRING) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s() - function does not exist", Z_STRVAL_P(function));
 			} else if (	Z_TYPE_P(function) == IS_ARRAY
-						&& zend_hash_index_find(Z_ARRVAL_P(function), 0, (void **) &obj) == SUCCESS
-						&& zend_hash_index_find(Z_ARRVAL_P(function), 1, (void **) &method) == SUCCESS
-						&& Z_TYPE_PP(obj) == IS_OBJECT
-						&& Z_TYPE_PP(method) == IS_STRING) {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s::%s() - function does not exist", Z_OBJCE_PP(obj)->name, Z_STRVAL_PP(method));
+						&& (obj = zend_hash_index_find(Z_ARRVAL_P(function), 0)) != NULL
+						&& (method = zend_hash_index_find(Z_ARRVAL_P(function), 1)) != NULL
+						&& Z_TYPE_P(obj) == IS_OBJECT
+						&& Z_TYPE_P(method) == IS_STRING) {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call %s::%s() - function does not exist", Z_OBJCE_P(obj)->name->val, Z_STRVAL_P(method));
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to call tick function");
 			}
@@ -4927,8 +4922,8 @@ static void run_user_tick_functions(int tick_count) /* {{{ */
 
 static int user_tick_function_compare(user_tick_function_entry * tick_fe1, user_tick_function_entry * tick_fe2) /* {{{ */
 {
-	zval *func1 = tick_fe1->arguments[0];
-	zval *func2 = tick_fe2->arguments[0];
+	zval *func1 = &tick_fe1->arguments[0];
+	zval *func2 = &tick_fe2->arguments[0];
 	int ret;
 	TSRMLS_FETCH();
 
@@ -4986,7 +4981,7 @@ void php_free_shutdown_functions(TSRMLS_D) /* {{{ */
 PHP_FUNCTION(register_shutdown_function)
 {
 	php_shutdown_function_entry shutdown_function_entry;
-	char *callback_name = NULL;
+	zend_string *callback_name = NULL;
 	int i;
 
 	shutdown_function_entry.arg_count = ZEND_NUM_ARGS();
@@ -4995,31 +4990,31 @@ PHP_FUNCTION(register_shutdown_function)
 		WRONG_PARAM_COUNT;
 	}
 
-	shutdown_function_entry.arguments = (zval **) safe_emalloc(sizeof(zval *), shutdown_function_entry.arg_count, 0);
+	shutdown_function_entry.arguments = (zval *) safe_emalloc(sizeof(zval), shutdown_function_entry.arg_count, 0);
 
-	if (zend_get_parameters_array(ht, shutdown_function_entry.arg_count, shutdown_function_entry.arguments) == FAILURE) {
+	if (zend_get_parameters_array(ZEND_NUM_ARGS(), shutdown_function_entry.arg_count, shutdown_function_entry.arguments) == FAILURE) {
 		efree(shutdown_function_entry.arguments);
 		RETURN_FALSE;
 	}
 
 	/* Prevent entering of anything but valid callback (syntax check only!) */
-	if (!zend_is_callable(shutdown_function_entry.arguments[0], 0, &callback_name TSRMLS_CC)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid shutdown callback '%s' passed", callback_name);
+	if (!zend_is_callable(&shutdown_function_entry.arguments[0], 0, &callback_name TSRMLS_CC)) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid shutdown callback '%s' passed", callback_name->val);
 		efree(shutdown_function_entry.arguments);
 		RETVAL_FALSE;
 	} else {
 		if (!BG(user_shutdown_function_names)) {
 			ALLOC_HASHTABLE(BG(user_shutdown_function_names));
-			zend_hash_init(BG(user_shutdown_function_names), 0, NULL, (void (*)(void *)) user_shutdown_function_dtor, 0);
+			zend_hash_init(BG(user_shutdown_function_names), 0, NULL, user_shutdown_function_dtor, 0);
 		}
 
 		for (i = 0; i < shutdown_function_entry.arg_count; i++) {
-			Z_ADDREF_P(shutdown_function_entry.arguments[i]);
+			if (Z_REFCOUNTED(shutdown_function_entry.arguments[i])) Z_ADDREF(shutdown_function_entry.arguments[i]);
 		}
-		zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL);
+		zend_hash_next_index_insert_mem(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry));
 	}
 	if (callback_name) {
-		efree(callback_name);
+		STR_RELEASE(callback_name);
 	}
 }
 /* }}} */
@@ -5028,17 +5023,17 @@ PHPAPI zend_bool register_user_shutdown_function(char *function_name, size_t fun
 {
 	if (!BG(user_shutdown_function_names)) {
 		ALLOC_HASHTABLE(BG(user_shutdown_function_names));
-		zend_hash_init(BG(user_shutdown_function_names), 0, NULL, (void (*)(void *)) user_shutdown_function_dtor, 0);
+		zend_hash_init(BG(user_shutdown_function_names), 0, NULL, user_shutdown_function_dtor, 0);
 	}
 
-	return zend_hash_update(BG(user_shutdown_function_names), function_name, function_len, shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL) != FAILURE;
+	return zend_hash_str_update_mem(BG(user_shutdown_function_names), function_name, function_len, shutdown_function_entry, sizeof(php_shutdown_function_entry)) != NULL;
 }
 /* }}} */
 
 PHPAPI zend_bool remove_user_shutdown_function(char *function_name, size_t function_len TSRMLS_DC) /* {{{ */
 {
 	if (BG(user_shutdown_function_names)) {
-		return zend_hash_del_key_or_index(BG(user_shutdown_function_names), function_name, function_len, 0, HASH_DEL_KEY) != FAILURE;
+		return zend_hash_str_del(BG(user_shutdown_function_names), function_name, function_len) != FAILURE;
 	}
 
 	return 0;
@@ -5049,10 +5044,10 @@ PHPAPI zend_bool append_user_shutdown_function(php_shutdown_function_entry shutd
 {
 	if (!BG(user_shutdown_function_names)) {
 		ALLOC_HASHTABLE(BG(user_shutdown_function_names));
-		zend_hash_init(BG(user_shutdown_function_names), 0, NULL, (void (*)(void *)) user_shutdown_function_dtor, 0);
+		zend_hash_init(BG(user_shutdown_function_names), 0, NULL, user_shutdown_function_dtor, 0);
 	}
 
-	return zend_hash_next_index_insert(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry), NULL) != FAILURE;
+	return zend_hash_next_index_insert_mem(BG(user_shutdown_function_names), &shutdown_function_entry, sizeof(php_shutdown_function_entry)) != NULL;
 }
 /* }}} */
 
@@ -5147,13 +5142,13 @@ PHP_FUNCTION(php_strip_whitespace)
    Syntax highlight a string or optionally return it */
 PHP_FUNCTION(highlight_string)
 {
-	zval **expr;
+	zval *expr;
 	zend_syntax_highlighter_ini syntax_highlighter_ini;
 	char *hicompiled_string_description;
 	zend_bool i = 0;
 	int old_error_reporting = EG(error_reporting);
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|b", &expr, &i) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|b", &expr, &i) == FAILURE) {
 		RETURN_FALSE;
 	}
 	convert_to_string_ex(expr);
@@ -5168,7 +5163,7 @@ PHP_FUNCTION(highlight_string)
 
 	hicompiled_string_description = zend_make_compiled_string_description("highlighted code" TSRMLS_CC);
 
-	if (highlight_string(*expr, &syntax_highlighter_ini, hicompiled_string_description TSRMLS_CC) == FAILURE) {
+	if (highlight_string(expr, &syntax_highlighter_ini, hicompiled_string_description TSRMLS_CC) == FAILURE) {
 		efree(hicompiled_string_description);
 		EG(error_reporting) = old_error_reporting;
 		if (i) {
@@ -5200,54 +5195,54 @@ PHP_FUNCTION(ini_get)
 		return;
 	}
 
-	str = zend_ini_string(varname, varname_len + 1, 0);
+	str = zend_ini_string(varname, varname_len, 0);
 
 	if (!str) {
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(str, 1);
+	RETURN_STRING(str);
 }
 /* }}} */
 
-static int php_ini_get_option(zend_ini_entry *ini_entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int php_ini_get_option(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
+	zend_ini_entry *ini_entry = Z_PTR_P(zv);
 	zval *ini_array = va_arg(args, zval *);
 	int module_number = va_arg(args, int);
 	int details = va_arg(args, int);
-	zval *option;
+	zval option;
 
 	if (module_number != 0 && ini_entry->module_number != module_number) {
 		return 0;
 	}
 
-	if (hash_key->nKeyLength == 0 ||
-		hash_key->arKey[0] != 0
+	if (hash_key->key == NULL ||
+		hash_key->key->val[0] != 0
 	) {
 		if (details) {
-			MAKE_STD_ZVAL(option);
-			array_init(option);
+			array_init(&option);
 
 			if (ini_entry->orig_value) {
-				add_assoc_stringl(option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length, 1);
+				add_assoc_stringl(&option, "global_value", ini_entry->orig_value, ini_entry->orig_value_length);
 			} else if (ini_entry->value) {
-				add_assoc_stringl(option, "global_value", ini_entry->value, ini_entry->value_length, 1);
+				add_assoc_stringl(&option, "global_value", ini_entry->value, ini_entry->value_length);
 			} else {
-				add_assoc_null(option, "global_value");
+				add_assoc_null(&option, "global_value");
 			}
 
 			if (ini_entry->value) {
-				add_assoc_stringl(option, "local_value", ini_entry->value, ini_entry->value_length, 1);
+				add_assoc_stringl(&option, "local_value", ini_entry->value, ini_entry->value_length);
 			} else {
-				add_assoc_null(option, "local_value");
+				add_assoc_null(&option, "local_value");
 			}
 
-			add_assoc_long(option, "access", ini_entry->modifiable);
+			add_assoc_long(&option, "access", ini_entry->modifiable);
 
-			add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, option);
+			add_assoc_zval_ex(ini_array, ini_entry->name, ini_entry->name_length, &option);
 		} else {
 			if (ini_entry->value) {
-				add_assoc_stringl(ini_array, ini_entry->name, ini_entry->value, ini_entry->value_length, 1);
+				add_assoc_stringl(ini_array, ini_entry->name, ini_entry->value, ini_entry->value_length);
 			} else {
 				add_assoc_null(ini_array, ini_entry->name);
 			}
@@ -5273,7 +5268,7 @@ PHP_FUNCTION(ini_get_all)
 	zend_ini_sort_entries(TSRMLS_C);
 
 	if (extname) {
-		if (zend_hash_find(&module_registry, extname, extname_len+1, (void **) &module) == FAILURE) {
+		if ((module = zend_hash_str_find_ptr(&module_registry, extname, extname_len)) == NULL) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find extension '%s'", extname);
 			RETURN_FALSE;
 		}
@@ -5299,19 +5294,20 @@ static int php_ini_check_path(char *option_name, int option_len, char *new_optio
    Set a configuration option, returns false on error and the old value of the configuration option on success */
 PHP_FUNCTION(ini_set)
 {
-	char *varname, *new_value;
-	int varname_len, new_value_len;
+	zend_string *varname;
+	char *new_value;
+	int new_value_len;
 	char *old_value;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &varname, &varname_len, &new_value, &new_value_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Ss", &varname, &new_value, &new_value_len) == FAILURE) {
 		return;
 	}
 
-	old_value = zend_ini_string(varname, varname_len + 1, 0);
+	old_value = zend_ini_string(varname->val, varname->len, 0);
 
 	/* copy to return here, because alter might free it! */
 	if (old_value) {
-		RETVAL_STRING(old_value, 1);
+		RETVAL_STRING(old_value);
 	} else {
 		RETVAL_FALSE;
 	}
@@ -5319,12 +5315,12 @@ PHP_FUNCTION(ini_set)
 #define _CHECK_PATH(var, var_len, ini) php_ini_check_path(var, var_len, ini, sizeof(ini))
 	/* open basedir check */
 	if (PG(open_basedir)) {
-		if (_CHECK_PATH(varname, varname_len, "error_log") ||
-			_CHECK_PATH(varname, varname_len, "java.class.path") ||
-			_CHECK_PATH(varname, varname_len, "java.home") ||
-			_CHECK_PATH(varname, varname_len, "mail.log") ||
-			_CHECK_PATH(varname, varname_len, "java.library.path") ||
-			_CHECK_PATH(varname, varname_len, "vpopmail.directory")) {
+		if (_CHECK_PATH(varname->val, varname->len, "error_log") ||
+			_CHECK_PATH(varname->val, varname->len, "java.class.path") ||
+			_CHECK_PATH(varname->val, varname->len, "java.home") ||
+			_CHECK_PATH(varname->val, varname->len, "mail.log") ||
+			_CHECK_PATH(varname->val, varname->len, "java.library.path") ||
+			_CHECK_PATH(varname->val, varname->len, "vpopmail.directory")) {
 			if (php_check_open_basedir(new_value TSRMLS_CC)) {
 				zval_dtor(return_value);
 				RETURN_FALSE;
@@ -5332,7 +5328,7 @@ PHP_FUNCTION(ini_set)
 		}
 	}
 
-	if (zend_alter_ini_entry_ex(varname, varname_len + 1, new_value, new_value_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == FAILURE) {
+	if (zend_alter_ini_entry_ex(varname, new_value, new_value_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == FAILURE) {
 		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
@@ -5343,14 +5339,13 @@ PHP_FUNCTION(ini_set)
    Restore the value of a configuration option specified by varname */
 PHP_FUNCTION(ini_restore)
 {
-	char *varname;
-	int varname_len;
+	zend_string *varname;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &varname, &varname_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &varname) == FAILURE) {
 		return;
 	}
 
-	zend_restore_ini_entry(varname, varname_len+1, PHP_INI_STAGE_RUNTIME);
+	zend_restore_ini_entry(varname, PHP_INI_STAGE_RUNTIME);
 }
 /* }}} */
 
@@ -5361,23 +5356,27 @@ PHP_FUNCTION(set_include_path)
 	char *new_value;
 	int new_value_len;
 	char *old_value;
+	zend_string *key;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &new_value, &new_value_len) == FAILURE) {
 		return;
 	}
 
-	old_value = zend_ini_string("include_path", sizeof("include_path"), 0);
+	old_value = zend_ini_string("include_path", sizeof("include_path") - 1, 0);
 	/* copy to return here, because alter might free it! */
 	if (old_value) {
-		RETVAL_STRING(old_value, 1);
+		RETVAL_STRING(old_value);
 	} else {
 		RETVAL_FALSE;
 	}
 
-	if (zend_alter_ini_entry_ex("include_path", sizeof("include_path"), new_value, new_value_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == FAILURE) {
+	key = STR_INIT("include_path", sizeof("include_path") - 1, 0);
+	if (zend_alter_ini_entry_ex(key, new_value, new_value_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == FAILURE) {
+		STR_RELEASE(key);
 		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
+	STR_RELEASE(key);
 }
 /* }}} */
 
@@ -5391,13 +5390,13 @@ PHP_FUNCTION(get_include_path)
 		return;
 	}
 
-	str = zend_ini_string("include_path", sizeof("include_path"), 0);
+	str = zend_ini_string("include_path", sizeof("include_path") - 1, 0);
 
 	if (str == NULL) {
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(str, 1);
+	RETURN_STRING(str);
 }
 /* }}} */
 
@@ -5405,10 +5404,14 @@ PHP_FUNCTION(get_include_path)
    Restore the value of the include_path configuration option */
 PHP_FUNCTION(restore_include_path)
 {
+	zend_string *key;
+
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "") == FAILURE) {
 		return;
 	}
-	zend_restore_ini_entry("include_path", sizeof("include_path"), PHP_INI_STAGE_RUNTIME);
+	key = STR_INIT("include_path", sizeof("include_path")-1, 0);
+	zend_restore_ini_entry(key, PHP_INI_STAGE_RUNTIME);
+	STR_FREE(key);
 }
 /* }}} */
 
@@ -5469,7 +5472,9 @@ PHP_FUNCTION(ignore_user_abort)
 	old_setting = PG(ignore_user_abort);
 
 	if (arg) {
-		zend_alter_ini_entry_ex("ignore_user_abort", sizeof("ignore_user_abort"), arg, arg_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+		zend_string *key = STR_INIT("ignore_user_abort", sizeof("ignore_user_abort"), 0);
+		zend_alter_ini_entry_ex(key, arg, arg_len, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC);
+		STR_RELEASE(key);
 	}
 
 	RETURN_LONG(old_setting);
@@ -5529,7 +5534,7 @@ PHP_FUNCTION(getservbyport)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(serv->s_name, 1);
+	RETURN_STRING(serv->s_name);
 }
 /* }}} */
 #endif
@@ -5576,7 +5581,7 @@ PHP_FUNCTION(getprotobynumber)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(ent->p_name, 1);
+	RETURN_STRING(ent->p_name);
 }
 /* }}} */
 #endif
@@ -5587,7 +5592,7 @@ PHP_FUNCTION(register_tick_function)
 {
 	user_tick_function_entry tick_fe;
 	int i;
-	char *function_name = NULL;
+	zend_string *function_name = NULL;
 
 	tick_fe.calling = 0;
 	tick_fe.arg_count = ZEND_NUM_ARGS();
@@ -5596,23 +5601,23 @@ PHP_FUNCTION(register_tick_function)
 		WRONG_PARAM_COUNT;
 	}
 
-	tick_fe.arguments = (zval **) safe_emalloc(sizeof(zval *), tick_fe.arg_count, 0);
+	tick_fe.arguments = (zval *) safe_emalloc(sizeof(zval), tick_fe.arg_count, 0);
 
-	if (zend_get_parameters_array(ht, tick_fe.arg_count, tick_fe.arguments) == FAILURE) {
+	if (zend_get_parameters_array(ZEND_NUM_ARGS(), tick_fe.arg_count, tick_fe.arguments) == FAILURE) {
 		efree(tick_fe.arguments);
 		RETURN_FALSE;
 	}
 
-	if (!zend_is_callable(tick_fe.arguments[0], 0, &function_name TSRMLS_CC)) {
+	if (!zend_is_callable(&tick_fe.arguments[0], 0, &function_name TSRMLS_CC)) {
 		efree(tick_fe.arguments);
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid tick callback '%s' passed", function_name);
-		efree(function_name);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid tick callback '%s' passed", function_name->val);
+		STR_RELEASE(function_name);
 		RETURN_FALSE;
 	} else if (function_name) {
-		efree(function_name);
+		STR_RELEASE(function_name);
 	}
 
-	if (Z_TYPE_P(tick_fe.arguments[0]) != IS_ARRAY && Z_TYPE_P(tick_fe.arguments[0]) != IS_OBJECT) {
+	if (Z_TYPE(tick_fe.arguments[0]) != IS_ARRAY && Z_TYPE(tick_fe.arguments[0]) != IS_OBJECT) {
 		convert_to_string_ex(&tick_fe.arguments[0]);
 	}
 
@@ -5625,7 +5630,9 @@ PHP_FUNCTION(register_tick_function)
 	}
 
 	for (i = 0; i < tick_fe.arg_count; i++) {
-		Z_ADDREF_P(tick_fe.arguments[i]);
+		if (Z_REFCOUNTED(tick_fe.arguments[i])) {
+			Z_ADDREF(tick_fe.arguments[i]);
+		}
 	}
 
 	zend_llist_add_element(BG(user_tick_functions), &tick_fe);
@@ -5653,8 +5660,8 @@ PHP_FUNCTION(unregister_tick_function)
 		convert_to_string(function);
 	}
 
-	tick_fe.arguments = (zval **) emalloc(sizeof(zval *));
-	tick_fe.arguments[0] = function;
+	tick_fe.arguments = (zval *) emalloc(sizeof(zval));
+	ZVAL_COPY_VALUE(&tick_fe.arguments[0], function);
 	tick_fe.arg_count = 1;
 	zend_llist_del_element(BG(user_tick_functions), &tick_fe, (int (*)(void *, void *)) user_tick_function_compare);
 	efree(tick_fe.arguments);
@@ -5676,7 +5683,7 @@ PHP_FUNCTION(is_uploaded_file)
 		return;
 	}
 
-	if (zend_hash_exists(SG(rfc1867_uploaded_files), path, path_len + 1)) {
+	if (zend_hash_str_exists(SG(rfc1867_uploaded_files), path, path_len)) {
 		RETURN_TRUE;
 	} else {
 		RETURN_FALSE;
@@ -5704,7 +5711,7 @@ PHP_FUNCTION(move_uploaded_file)
 		return;
 	}
 
-	if (!zend_hash_exists(SG(rfc1867_uploaded_files), path, path_len + 1)) {
+	if (!zend_hash_str_exists(SG(rfc1867_uploaded_files), path, path_len)) {
 		RETURN_FALSE;
 	}
 
@@ -5730,7 +5737,7 @@ PHP_FUNCTION(move_uploaded_file)
 	}
 
 	if (successful) {
-		zend_hash_del(SG(rfc1867_uploaded_files), path, path_len + 1);
+		zend_hash_str_del(SG(rfc1867_uploaded_files), path, path_len);
 	} else {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to move '%s' to '%s'", path, new_path);
 	}
@@ -5743,7 +5750,7 @@ PHP_FUNCTION(move_uploaded_file)
  */
 static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_type, zval *arr TSRMLS_DC)
 {
-	zval *element;
+	zval element;
 
 	switch (callback_type) {
 
@@ -5752,14 +5759,13 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal
 				/* bare string - nothing to do */
 				break;
 			}
-			ALLOC_ZVAL(element);
-			MAKE_COPY_ZVAL(&arg2, element);
-			zend_symtable_update(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, &element, sizeof(zval *), NULL);
+			ZVAL_DUP(&element, arg2);
+			zend_symtable_update(Z_ARRVAL_P(arr), Z_STR_P(arg1), &element);
 			break;
 
 		case ZEND_INI_PARSER_POP_ENTRY:
 		{
-			zval *hash, **find_hash;
+			zval hash, *find_hash;
 
 			if (!arg2) {
 				/* bare string - nothing to do */
@@ -5768,40 +5774,28 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal
 
 			if (!(Z_STRLEN_P(arg1) > 1 && Z_STRVAL_P(arg1)[0] == '0') && is_numeric_string(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), NULL, NULL, 0) == IS_LONG) {
 				ulong key = (ulong) zend_atol(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1));
-				if (zend_hash_index_find(Z_ARRVAL_P(arr), key, (void **) &find_hash) == FAILURE) {
-					ALLOC_ZVAL(hash);
-					INIT_PZVAL(hash);
-					array_init(hash);
-
-					zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash, sizeof(zval *), NULL);
-				} else {
-					hash = *find_hash;
-				}
+				if ((find_hash = zend_hash_index_find(Z_ARRVAL_P(arr), key)) == NULL) {
+					array_init(&hash);
+					find_hash = zend_hash_index_update(Z_ARRVAL_P(arr), key, &hash);
+				} 
 			} else {
-				if (zend_hash_find(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, (void **) &find_hash) == FAILURE) {
-					ALLOC_ZVAL(hash);
-					INIT_PZVAL(hash);
-					array_init(hash);
-
-					zend_hash_update(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, &hash, sizeof(zval *), NULL);
-				} else {
-					hash = *find_hash;
-				}
+				if ((find_hash = zend_hash_find(Z_ARRVAL_P(arr), Z_STR_P(arg1))) == NULL) {
+					array_init(&hash);
+					find_hash = zend_hash_update(Z_ARRVAL_P(arr), Z_STR_P(arg1), &hash);
+				} 
 			}
 
-			if (Z_TYPE_P(hash) != IS_ARRAY) {
-				zval_dtor(hash);
-				INIT_PZVAL(hash);
-				array_init(hash);
+			if (Z_TYPE_P(find_hash) != IS_ARRAY) {
+				zval_dtor(find_hash);
+				array_init(find_hash);
 			}
 
-			ALLOC_ZVAL(element);
-			MAKE_COPY_ZVAL(&arg2, element);
+			ZVAL_DUP(&element, arg2);
 
 			if (arg3 && Z_STRLEN_P(arg3) > 0) {
-				add_assoc_zval_ex(hash, Z_STRVAL_P(arg3), Z_STRLEN_P(arg3) + 1, element);
+				zend_symtable_update(Z_ARRVAL_P(find_hash), Z_STR_P(arg3), &element);
 			} else {
-				add_next_index_zval(hash, element);
+				add_next_index_zval(find_hash, &element);
 			}
 		}
 		break;
@@ -5817,14 +5811,13 @@ static void php_simple_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int cal
 static void php_ini_parser_cb_with_sections(zval *arg1, zval *arg2, zval *arg3, int callback_type, zval *arr TSRMLS_DC)
 {
 	if (callback_type == ZEND_INI_PARSER_SECTION) {
-		MAKE_STD_ZVAL(BG(active_ini_file_section));
-		array_init(BG(active_ini_file_section));
-		zend_symtable_update(Z_ARRVAL_P(arr), Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, &BG(active_ini_file_section), sizeof(zval *), NULL);
+		array_init(&BG(active_ini_file_section));
+		zend_symtable_update(Z_ARRVAL_P(arr), Z_STR_P(arg1), &BG(active_ini_file_section));
 	} else if (arg2) {
 		zval *active_arr;
 
-		if (BG(active_ini_file_section)) {
-			active_arr = BG(active_ini_file_section);
+		if (Z_TYPE(BG(active_ini_file_section)) != IS_UNDEF) {
+			active_arr = &BG(active_ini_file_section);
 		} else {
 			active_arr = arr;
 		}
@@ -5856,7 +5849,7 @@ PHP_FUNCTION(parse_ini_file)
 
 	/* Set callback function */
 	if (process_sections) {
-		BG(active_ini_file_section) = NULL;
+		ZVAL_UNDEF(&BG(active_ini_file_section));
 		ini_parser_cb = (zend_ini_parser_cb_t) php_ini_parser_cb_with_sections;
 	} else {
 		ini_parser_cb = (zend_ini_parser_cb_t) php_simple_ini_parser_cb;
@@ -5869,8 +5862,7 @@ PHP_FUNCTION(parse_ini_file)
 
 	array_init(return_value);
 	if (zend_parse_ini_file(&fh, 0, scanner_mode, ini_parser_cb, return_value TSRMLS_CC) == FAILURE) {
-		zend_hash_destroy(Z_ARRVAL_P(return_value));
-		efree(Z_ARRVAL_P(return_value));
+		zval_dtor(return_value);
 		RETURN_FALSE;
 	}
 }
@@ -5896,7 +5888,7 @@ PHP_FUNCTION(parse_ini_string)
 
 	/* Set callback function */
 	if (process_sections) {
-		BG(active_ini_file_section) = NULL;
+		ZVAL_UNDEF(&BG(active_ini_file_section));
 		ini_parser_cb = (zend_ini_parser_cb_t) php_ini_parser_cb_with_sections;
 	} else {
 		ini_parser_cb = (zend_ini_parser_cb_t) php_simple_ini_parser_cb;
@@ -5909,8 +5901,7 @@ PHP_FUNCTION(parse_ini_string)
 
 	array_init(return_value);
 	if (zend_parse_ini_string(string, 0, scanner_mode, ini_parser_cb, return_value TSRMLS_CC) == FAILURE) {
-		zend_hash_destroy(Z_ARRVAL_P(return_value));
-		efree(Z_ARRVAL_P(return_value));
+		zval_dtor(return_value);
 		RETVAL_FALSE;
 	}
 	efree(string);
diff --git a/ext/standard/basic_functions.h b/ext/standard/basic_functions.h
index 3324427088..3cabf87d1a 100644
--- a/ext/standard/basic_functions.h
+++ b/ext/standard/basic_functions.h
@@ -162,7 +162,7 @@ typedef signed long php_int32;
 typedef struct _php_basic_globals {
 	HashTable *user_shutdown_function_names;
 	HashTable putenv_ht;
-	zval *strtok_zval;
+	zval  strtok_zval;
 	char *strtok_string;
 	char *locale_string;
 	char *strtok_last;
@@ -175,7 +175,7 @@ typedef struct _php_basic_globals {
 	zend_fcall_info_cache user_compare_fci_cache;
 	zend_llist *user_tick_functions;
 
-	zval *active_ini_file_section;
+	zval active_ini_file_section;
 	
 	/* pageinfo.c */
 	long page_uid;
@@ -251,7 +251,7 @@ PHPAPI double php_get_nan(void);
 PHPAPI double php_get_inf(void);
 
 typedef struct _php_shutdown_function_entry {
-	zval **arguments;
+	zval *arguments;
 	int arg_count;
 } php_shutdown_function_entry;
 
diff --git a/ext/standard/browscap.c b/ext/standard/browscap.c
index a2ff691e8f..186c30cc90 100644
--- a/ext/standard/browscap.c
+++ b/ext/standard/browscap.c
@@ -29,7 +29,7 @@
 
 typedef struct {
 	HashTable *htab;
-	zval *current_section;
+	zval current_section;
 	char *current_section_name;
 	char filename[MAXPATHLEN];
 } browser_data;
@@ -55,30 +55,24 @@ ZEND_DECLARE_MODULE_GLOBALS(browscap)
 
 /* OBJECTS_FIXME: This whole extension needs going through. The use of objects looks pretty broken here */
 
-static void browscap_entry_dtor_request(zval **zvalue) /* {{{ */
+static void browscap_entry_dtor_request(zval *zvalue) /* {{{ */
 {
-	if (Z_TYPE_PP(zvalue) == IS_ARRAY) {
-		zend_hash_destroy(Z_ARRVAL_PP(zvalue));
-		efree(Z_ARRVAL_PP(zvalue));
-	} else if (Z_TYPE_PP(zvalue) == IS_STRING) {
-		if (Z_STRVAL_PP(zvalue)) {
-			efree(Z_STRVAL_PP(zvalue));
-		}
+	if (Z_TYPE_P(zvalue) == IS_ARRAY) {
+		zend_hash_destroy(Z_ARRVAL_P(zvalue));
+		efree(Z_ARR_P(zvalue));
+	} else if (Z_TYPE_P(zvalue) == IS_STRING) {
+		STR_RELEASE(Z_STR_P(zvalue));
 	}
-	efree(*zvalue);
 }
 /* }}} */
 
-static void browscap_entry_dtor_persistent(zval **zvalue) /* {{{ */ {
-	if (Z_TYPE_PP(zvalue) == IS_ARRAY) {
-		zend_hash_destroy(Z_ARRVAL_PP(zvalue));
-		free(Z_ARRVAL_PP(zvalue));
-	} else if (Z_TYPE_PP(zvalue) == IS_STRING) {
-		if (Z_STRVAL_PP(zvalue)) {
-			free(Z_STRVAL_PP(zvalue));
-		}
+static void browscap_entry_dtor_persistent(zval *zvalue) /* {{{ */ {
+	if (Z_TYPE_P(zvalue) == IS_ARRAY) {
+		zend_hash_destroy(Z_ARRVAL_P(zvalue));
+		free(Z_ARR_P(zvalue));
+	} else if (Z_TYPE_P(zvalue) == IS_STRING) {
+		STR_RELEASE(Z_STR_P(zvalue));
 	}
-	free(*zvalue);
 }
 /* }}} */
 
@@ -86,16 +80,19 @@ static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */
 {
 	int i, j=0;
 	char *t;
+	zend_string *res;
+	char *lc_pattern;
 
-	php_strtolower(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern));
+	res = STR_SAFE_ALLOC(Z_STRLEN_P(pattern), 2, 4, persistent);
+	t = res->val;
 
-	t = (char *) safe_pemalloc(Z_STRLEN_P(pattern), 2, 5, persistent);
+	lc_pattern = zend_str_tolower_dup(Z_STRVAL_P(pattern), Z_STRLEN_P(pattern));
 
 	t[j++] = '\xA7'; /* section sign */
 	t[j++] = '^';
 
 	for (i=0; i<Z_STRLEN_P(pattern); i++, j++) {
-		switch (Z_STRVAL_P(pattern)[i]) {
+		switch (lc_pattern[i]) {
 			case '?':
 				t[j] = '.';
 				break;
@@ -124,7 +121,7 @@ static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */
 				t[j] = '\xA7';
 				break;
 			default:
-				t[j] = Z_STRVAL_P(pattern)[i];
+				t[j] = lc_pattern[i];
 				break;
 		}
 	}
@@ -133,15 +130,16 @@ static void convert_browscap_pattern(zval *pattern, int persistent) /* {{{ */
 	t[j++] = '\xA7';
 
 	t[j]=0;
-	Z_STRVAL_P(pattern) = t;
-	Z_STRLEN_P(pattern) = j;
+	res->len = j;
+	Z_STR_P(pattern) = res;
+	efree(lc_pattern);
 }
 /* }}} */
 
 static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_type, void *arg TSRMLS_DC) /* {{{ */
 {
 	browser_data *bdata = arg;
-	int persistent = bdata->htab->persistent;
+	int persistent = bdata->htab->u.flags & HASH_FLAG_PERSISTENT;
 	
 	if (!arg1) {
 		return;
@@ -149,9 +147,9 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb
 
 	switch (callback_type) {
 		case ZEND_INI_PARSER_ENTRY:
-			if (bdata->current_section && arg2) {
-				zval *new_property;
-				char *new_key;
+			if (Z_TYPE(bdata->current_section) != IS_UNDEF && arg2) {
+				zval new_property;
+				zend_string *new_key;
 
 				/* parent entry can not be same as current section -> causes infinite loop! */
 				if (!strcasecmp(Z_STRVAL_P(arg1), "parent") && 
@@ -164,75 +162,57 @@ static void php_browscap_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callb
 					return;
 				}
 
-				new_property = (zval *) pemalloc(sizeof(zval), persistent);
-				INIT_PZVAL(new_property);
-				Z_TYPE_P(new_property) = IS_STRING;
-
 				/* Set proper value for true/false settings */
 				if ((Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "on", sizeof("on") - 1)) ||
 					(Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "yes", sizeof("yes") - 1)) ||
 					(Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "true", sizeof("true") - 1))
 				) {
-					Z_STRVAL_P(new_property) = pestrndup("1", 1, persistent);
-					Z_STRLEN_P(new_property) = 1;
+					ZVAL_NEW_STR(&new_property, STR_INIT("1", sizeof("1")-1, persistent));
 				} else if (
 					(Z_STRLEN_P(arg2) == 2 && !strncasecmp(Z_STRVAL_P(arg2), "no", sizeof("no") - 1)) ||
 					(Z_STRLEN_P(arg2) == 3 && !strncasecmp(Z_STRVAL_P(arg2), "off", sizeof("off") - 1)) ||
 					(Z_STRLEN_P(arg2) == 4 && !strncasecmp(Z_STRVAL_P(arg2), "none", sizeof("none") - 1)) ||
 					(Z_STRLEN_P(arg2) == 5 && !strncasecmp(Z_STRVAL_P(arg2), "false", sizeof("false") - 1))
 				) {
-					Z_STRVAL_P(new_property) = pestrndup("", 0, persistent);
-					Z_STRLEN_P(new_property) = 0;
+					// TODO: USE STR_EMPTY_ALLOC()?
+					ZVAL_NEW_STR(&new_property, STR_INIT("", sizeof("")-1, persistent));
 				} else { /* Other than true/false setting */
-					Z_STRVAL_P(new_property) = pestrndup(Z_STRVAL_P(arg2),
-							Z_STRLEN_P(arg2), persistent);
-					Z_STRLEN_P(new_property) = Z_STRLEN_P(arg2);
+					ZVAL_STR(&new_property, STR_DUP(Z_STR_P(arg2), persistent));
 				}
-				new_key = pestrndup(Z_STRVAL_P(arg1), Z_STRLEN_P(arg1), persistent);
-				zend_str_tolower(new_key, Z_STRLEN_P(arg1));
-				zend_hash_update(Z_ARRVAL_P(bdata->current_section), new_key, Z_STRLEN_P(arg1) + 1, &new_property, sizeof(zval *), NULL);
-				pefree(new_key, persistent);
+				new_key = STR_DUP(Z_STR_P(arg1), persistent);
+				zend_str_tolower(new_key->val, new_key->len);
+				zend_hash_update(Z_ARRVAL(bdata->current_section), new_key, &new_property);
+				STR_RELEASE(new_key);
 			}
 			break;
 		case ZEND_INI_PARSER_SECTION: {
-				zval *processed;
-				zval *unprocessed;
-				HashTable *section_properties;
+				zval processed;
+				zval unprocessed;
 
 				/*printf("'%s' (%d)\n",$1.value.str.val,$1.value.str.len + 1);*/
-				bdata->current_section = (zval *) pemalloc(sizeof(zval), persistent);
-				INIT_PZVAL(bdata->current_section);
-				processed = (zval *) pemalloc(sizeof(zval), persistent);
-				INIT_PZVAL(processed);
-				unprocessed = (zval *) pemalloc(sizeof(zval), persistent);
-				INIT_PZVAL(unprocessed);
-
-				section_properties = (HashTable *) pemalloc(sizeof(HashTable), persistent);
-				zend_hash_init(section_properties, 0, NULL,
+				if (persistent) {
+					ZVAL_NEW_PERSISTENT_ARR(&bdata->current_section);
+				} else {
+					ZVAL_NEW_ARR(&bdata->current_section);
+				}
+				zend_hash_init(Z_ARRVAL(bdata->current_section), 0, NULL,
 						(dtor_func_t) (persistent?browscap_entry_dtor_persistent
 												 :browscap_entry_dtor_request),
 						persistent);
-				Z_ARRVAL_P(bdata->current_section) = section_properties;
-				Z_TYPE_P(bdata->current_section) = IS_ARRAY;
 				if (bdata->current_section_name) {
 					pefree(bdata->current_section_name, persistent);
 				}
 				bdata->current_section_name = pestrndup(Z_STRVAL_P(arg1),
 						Z_STRLEN_P(arg1), persistent);
 
-				zend_hash_update(bdata->htab, Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, (void *) &bdata->current_section, sizeof(zval *), NULL);
+				zend_hash_update(bdata->htab, Z_STR_P(arg1), &bdata->current_section);
 
-				Z_STRVAL_P(processed) = Z_STRVAL_P(arg1);
-				Z_STRLEN_P(processed) = Z_STRLEN_P(arg1);
-				Z_TYPE_P(processed) = IS_STRING;
-				Z_STRVAL_P(unprocessed) = Z_STRVAL_P(arg1);
-				Z_STRLEN_P(unprocessed) = Z_STRLEN_P(arg1);
-				Z_TYPE_P(unprocessed) = IS_STRING;
-				Z_STRVAL_P(unprocessed) = pestrndup(Z_STRVAL_P(unprocessed), Z_STRLEN_P(unprocessed), persistent);
+				ZVAL_STR(&processed, Z_STR_P(arg1));
+				ZVAL_STR(&unprocessed, STR_DUP(Z_STR_P(arg1), persistent));
 
-				convert_browscap_pattern(processed, persistent);
-				zend_hash_update(section_properties, "browser_name_regex", sizeof("browser_name_regex"), (void *) &processed, sizeof(zval *), NULL);
-				zend_hash_update(section_properties, "browser_name_pattern", sizeof("browser_name_pattern"), (void *) &unprocessed, sizeof(zval *), NULL);
+				convert_browscap_pattern(&processed, persistent);
+				zend_hash_str_update(Z_ARRVAL(bdata->current_section), "browser_name_regex", sizeof("browser_name_regex")-1, &processed);
+				zend_hash_str_update(Z_ARRVAL(bdata->current_section), "browser_name_pattern", sizeof("browser_name_pattern")-1, &unprocessed);
 			}
 			break;
 	}
@@ -252,14 +232,10 @@ static int browscap_read_file(char *filename, browser_data *browdata, int persis
 		return FAILURE;
 	}
 
-	if (zend_hash_init_ex(browdata->htab, 0, NULL,
+	zend_hash_init_ex(browdata->htab, 0, NULL,
 			(dtor_func_t) (persistent?browscap_entry_dtor_persistent
 									 :browscap_entry_dtor_request),
-			persistent, 0) == FAILURE) {
-		pefree(browdata->htab, persistent);
-		browdata->htab = NULL;
-		return FAILURE;
-	}
+			persistent, 0);
 
 	fh.handle.fp = VCWD_FOPEN(filename, "r");
 	fh.opened_path = NULL;
@@ -272,7 +248,7 @@ static int browscap_read_file(char *filename, browser_data *browdata, int persis
 		return FAILURE;
 	}
 	fh.filename = filename;
-	Z_TYPE(fh) = ZEND_HANDLE_FP;
+	fh.type = ZEND_HANDLE_FP;
 	browdata->current_section_name = NULL;
 	zend_parse_ini_file(&fh, 1, ZEND_INI_SCANNER_RAW,
 			(zend_ini_parser_cb_t) php_browscap_parser_cb, browdata TSRMLS_CC);
@@ -289,7 +265,7 @@ static int browscap_read_file(char *filename, browser_data *browdata, int persis
 static void browscap_globals_ctor(zend_browscap_globals *browscap_globals TSRMLS_DC) /* {{{ */
 {
 	browscap_globals->activation_bdata.htab = NULL;
-	browscap_globals->activation_bdata.current_section = NULL;
+	ZVAL_UNDEF(&browscap_globals->activation_bdata.current_section);
 	browscap_globals->activation_bdata.current_section_name = NULL;
 	browscap_globals->activation_bdata.filename[0] = '\0';
 }
@@ -369,31 +345,31 @@ PHP_MSHUTDOWN_FUNCTION(browscap) /* {{{ */
 }
 /* }}} */
 
-static int browser_reg_compare(zval **browser TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
+static int browser_reg_compare(zval *browser TSRMLS_DC, int num_args, va_list args, zend_hash_key *key) /* {{{ */
 {
-	zval **browser_regex, **previous_match;
+	zval *browser_regex, *previous_match;
 	pcre *re;
 	int re_options;
 	pcre_extra *re_extra;
 	char *lookup_browser_name = va_arg(args, char *);
 	int lookup_browser_length = va_arg(args, int);
-	zval **found_browser_entry = va_arg(args, zval **);
+	zval *found_browser_entry = va_arg(args, zval *);
 
 	/* See if we have an exact match, if so, we're done... */
-	if (*found_browser_entry) {
-		if (zend_hash_find(Z_ARRVAL_PP(found_browser_entry), "browser_name_pattern", sizeof("browser_name_pattern"), (void**) &previous_match) == FAILURE) {
+	if (Z_TYPE_P(found_browser_entry) == IS_ARRAY) {
+		if ((previous_match = zend_hash_str_find(Z_ARRVAL_P(found_browser_entry), "browser_name_pattern", sizeof("browser_name_pattern")-1)) == NULL) {
 			return 0;
 		}
-		else if (!strcasecmp(Z_STRVAL_PP(previous_match), lookup_browser_name)) {
+		else if (!strcasecmp(Z_STRVAL_P(previous_match), lookup_browser_name)) {
 			return 0;
 		}
 	}
 
-	if (zend_hash_find(Z_ARRVAL_PP(browser), "browser_name_regex", sizeof("browser_name_regex"), (void **) &browser_regex) == FAILURE) {
+	if ((browser_regex = zend_hash_str_find(Z_ARRVAL_P(browser), "browser_name_regex", sizeof("browser_name_regex")-1)) == NULL) {
 		return 0;
 	}
 
-	re = pcre_get_compiled_regex(Z_STRVAL_PP(browser_regex), &re_extra, &re_options TSRMLS_CC);
+	re = pcre_get_compiled_regex(Z_STR_P(browser_regex), &re_extra, &re_options TSRMLS_CC);
 	if (re == NULL) {
 		return 0;
 	}
@@ -402,18 +378,18 @@ static int browser_reg_compare(zval **browser TSRMLS_DC, int num_args, va_list a
 		/* If we've found a possible browser, we need to do a comparison of the
 		   number of characters changed in the user agent being checked versus
 		   the previous match found and the current match. */
-		if (*found_browser_entry) {
+		if (Z_TYPE_P(found_browser_entry) == IS_ARRAY) {
 			int i, prev_len = 0, curr_len = 0, ua_len;
-			zval **current_match;
+			zval *current_match;
 
-			if (zend_hash_find(Z_ARRVAL_PP(browser), "browser_name_pattern", sizeof("browser_name_pattern"), (void**) &current_match) == FAILURE) {
+			if ((current_match = zend_hash_str_find(Z_ARRVAL_P(browser), "browser_name_pattern", sizeof("browser_name_pattern")-1)) == NULL) {
 				return 0;
 			}
 
 			ua_len = lookup_browser_length;
 
-			for (i = 0; i < Z_STRLEN_PP(previous_match); i++) {
-				switch (Z_STRVAL_PP(previous_match)[i]) {
+			for (i = 0; i < Z_STRLEN_P(previous_match); i++) {
+				switch (Z_STRVAL_P(previous_match)[i]) {
 					case '?':
 					case '*':
 						/* do nothing, ignore these characters in the count */
@@ -424,8 +400,8 @@ static int browser_reg_compare(zval **browser TSRMLS_DC, int num_args, va_list a
 				}
 			}
 
-			for (i = 0; i < Z_STRLEN_PP(current_match); i++) {
-				switch (Z_STRVAL_PP(current_match)[i]) {
+			for (i = 0; i < Z_STRLEN_P(current_match); i++) {
+				switch (Z_STRVAL_P(current_match)[i]) {
 					case '?':
 					case '*':
 						/* do nothing, ignore these characters in the count */
@@ -439,11 +415,11 @@ static int browser_reg_compare(zval **browser TSRMLS_DC, int num_args, va_list a
 			/* Pick which browser pattern replaces the least amount of
 			   characters when compared to the original user agent string... */
 			if (ua_len - prev_len > ua_len - curr_len) {
-				*found_browser_entry = *browser;
+				ZVAL_COPY_VALUE(found_browser_entry, browser);
 			}
 		}
 		else {
-			*found_browser_entry = *browser;
+			ZVAL_COPY_VALUE(found_browser_entry, browser);
 		}
 	}
 
@@ -451,18 +427,11 @@ static int browser_reg_compare(zval **browser TSRMLS_DC, int num_args, va_list a
 }
 /* }}} */
 
-static void browscap_zval_copy_ctor(zval **p) /* {{{ */
+static void browscap_zval_copy_ctor(zval *p) /* {{{ */
 {
-	zval *new;
-
-	ALLOC_ZVAL(new);
-	*new = **p;
-
-	zval_copy_ctor(new);
-
-	INIT_PZVAL(new);
-	*p = new;
-} /* }}} */
+	zval_copy_ctor(p);
+}
+/* }}} */
 
 /* {{{ proto mixed get_browser([string browser_name [, bool return_array]])
    Get information about the capabilities of a browser. If browser_name is omitted or null, HTTP_USER_AGENT is used. Returns an object by default; if return_array is true, returns an array. */
@@ -471,8 +440,8 @@ PHP_FUNCTION(get_browser)
 	char *agent_name = NULL;
 	int agent_name_len = 0;
 	zend_bool return_array = 0;
-	zval **agent, **z_agent_name, **http_user_agent;
-	zval *found_browser_entry, *tmp_copy;
+	zval *agent, *z_agent_name, *http_user_agent;
+	zval found_browser_entry;
 	char *lookup_browser_name;
 	browser_data *bdata;
 
@@ -496,27 +465,29 @@ PHP_FUNCTION(get_browser)
 	}
 
 	if (agent_name == NULL) {
-		zend_is_auto_global("_SERVER", sizeof("_SERVER") - 1 TSRMLS_CC);
-		if (!PG(http_globals)[TRACK_VARS_SERVER] ||
-			zend_hash_find(HASH_OF(PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_USER_AGENT", sizeof("HTTP_USER_AGENT"), (void **) &http_user_agent) == FAILURE
+		zend_string *key = STR_INIT("_SERVER", sizeof("_SERVER") - 1, 0);
+		zend_is_auto_global(key TSRMLS_CC);
+		STR_RELEASE(key);
+		if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) != IS_UNDEF ||
+			(http_user_agent = zend_hash_str_find(HASH_OF(&PG(http_globals)[TRACK_VARS_SERVER]), "HTTP_USER_AGENT", sizeof("HTTP_USER_AGENT")-1)) == NULL
 		) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "HTTP_USER_AGENT variable is not set, cannot determine user agent name");
 			RETURN_FALSE;
 		}
-		agent_name = Z_STRVAL_PP(http_user_agent);
-		agent_name_len = Z_STRLEN_PP(http_user_agent);
+		agent_name = Z_STRVAL_P(http_user_agent);
+		agent_name_len = Z_STRLEN_P(http_user_agent);
 	}
 
 	lookup_browser_name = estrndup(agent_name, agent_name_len);
 	php_strtolower(lookup_browser_name, agent_name_len);
 
-	if (zend_hash_find(bdata->htab, lookup_browser_name, agent_name_len + 1, (void **) &agent) == FAILURE) {
-		found_browser_entry = NULL;
+	if ((agent = zend_hash_str_find(bdata->htab, lookup_browser_name, agent_name_len)) == NULL) {
+		ZVAL_UNDEF(&found_browser_entry);
 		zend_hash_apply_with_arguments(bdata->htab TSRMLS_CC, (apply_func_args_t) browser_reg_compare, 3, lookup_browser_name, agent_name_len, &found_browser_entry);
 
-		if (found_browser_entry) {
+		if (Z_TYPE(found_browser_entry) != IS_UNDEF) {
 			agent = &found_browser_entry;
-		} else if (zend_hash_find(bdata->htab, DEFAULT_SECTION_NAME, sizeof(DEFAULT_SECTION_NAME), (void **) &agent) == FAILURE) {
+		} else if ((agent = zend_hash_str_find(bdata->htab, DEFAULT_SECTION_NAME, sizeof(DEFAULT_SECTION_NAME)-1)) == NULL) {
 			efree(lookup_browser_name);
 			RETURN_FALSE;
 		}
@@ -524,23 +495,23 @@ PHP_FUNCTION(get_browser)
 
 	if (return_array) {
 		array_init(return_value);
-		zend_hash_copy(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(agent), (copy_ctor_func_t) browscap_zval_copy_ctor, (void *) &tmp_copy, sizeof(zval *));
+		zend_hash_copy(Z_ARRVAL_P(return_value), Z_ARRVAL_P(agent), (copy_ctor_func_t) browscap_zval_copy_ctor);
 	}
 	else {
 		object_init(return_value);
-		zend_hash_copy(Z_OBJPROP_P(return_value), Z_ARRVAL_PP(agent), (copy_ctor_func_t) browscap_zval_copy_ctor, (void *) &tmp_copy, sizeof(zval *));
+		zend_hash_copy(Z_OBJPROP_P(return_value), Z_ARRVAL_P(agent), (copy_ctor_func_t) browscap_zval_copy_ctor);
 	}
 
-	while (zend_hash_find(Z_ARRVAL_PP(agent), "parent", sizeof("parent"), (void **) &z_agent_name) == SUCCESS) {
-		if (zend_hash_find(bdata->htab, Z_STRVAL_PP(z_agent_name), Z_STRLEN_PP(z_agent_name) + 1, (void **)&agent) == FAILURE) {
+	while ((z_agent_name = zend_hash_str_find(Z_ARRVAL_P(agent), "parent", sizeof("parent")-1)) != NULL) {
+		if ((agent = zend_hash_find(bdata->htab, Z_STR_P(z_agent_name))) == NULL) {
 			break;
 		}
 
 		if (return_array) {
-			zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_PP(agent), (copy_ctor_func_t) browscap_zval_copy_ctor, (void *) &tmp_copy, sizeof(zval *), 0);
+			zend_hash_merge(Z_ARRVAL_P(return_value), Z_ARRVAL_P(agent), (copy_ctor_func_t) browscap_zval_copy_ctor, 0);
 		}
 		else {
-			zend_hash_merge(Z_OBJPROP_P(return_value), Z_ARRVAL_PP(agent), (copy_ctor_func_t) browscap_zval_copy_ctor, (void *) &tmp_copy, sizeof(zval *), 0);
+			zend_hash_merge(Z_OBJPROP_P(return_value), Z_ARRVAL_P(agent), (copy_ctor_func_t) browscap_zval_copy_ctor, 0);
 		}
 	}
 
diff --git a/ext/standard/crc32.c b/ext/standard/crc32.c
index 3ce355a45f..e9176e84da 100644
--- a/ext/standard/crc32.c
+++ b/ext/standard/crc32.c
@@ -27,7 +27,7 @@
 PHP_NAMED_FUNCTION(php_if_crc32)
 {
 	char *p;
-	int len, nr;
+	int nr;
 	php_uint32 crcinit = 0;
 	register php_uint32 crc;
 
@@ -36,7 +36,7 @@ PHP_NAMED_FUNCTION(php_if_crc32)
 	}
 	crc = crcinit^0xFFFFFFFF;
 
-	for (len =+nr; nr--; ++p) {
+	for (; nr--; ++p) {
 		crc = ((crc >> 8) & 0x00FFFFFF) ^ crc32tab[(crc ^ (*p)) & 0xFF ];
 	}
 	RETVAL_LONG(crc^0xFFFFFFFF);
diff --git a/ext/standard/crypt.c b/ext/standard/crypt.c
index 3419f09dd7..f7696cf551 100644
--- a/ext/standard/crypt.c
+++ b/ext/standard/crypt.c
@@ -145,9 +145,10 @@ static void php_to64(char *s, long v, int n) /* {{{ */
 }
 /* }}} */
 
-PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt, int salt_len, char **result)
+PHPAPI zend_string *php_crypt(const char *password, const int pass_len, const char *salt, int salt_len)
 {
 	char *crypt_res;
+	zend_string *result;
 /* Windows (win32/crypt) has a stripped down version of libxcrypt and 
 	a CryptoApi md5_crypt implementation */
 #if PHP_USE_PHP_CRYPT_R
@@ -159,10 +160,9 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 
 			out = php_md5_crypt_r(password, salt, output);
 			if (out) {
-				*result = estrdup(out);
-				return SUCCESS;
+				return STR_INIT(out, strlen(out), 0);
 			}
-			return FAILURE;
+			return NULL;
 		} else if (salt[0]=='$' && salt[1]=='6' && salt[2]=='$') {
 			char *output;
 			output = emalloc(PHP_MAX_SALT_LEN);
@@ -171,12 +171,12 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 			if (!crypt_res) {
 				memset(output, 0, PHP_MAX_SALT_LEN);
 				efree(output);
-				return FAILURE;
+				return NULL;
 			} else {
-				*result = estrdup(output);
+				result = STR_INIT(output, strlen(output), 0);
 				memset(output, 0, PHP_MAX_SALT_LEN);
 				efree(output);
-				return SUCCESS;
+				return result;
 			}
 		} else if (salt[0]=='$' && salt[1]=='5' && salt[2]=='$') {
 			char *output;
@@ -186,12 +186,12 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 			if (!crypt_res) {
 				memset(output, 0, PHP_MAX_SALT_LEN);
 				efree(output);
-				return FAILURE;
+				return NULL;
 			} else {
-				*result = estrdup(output);
+				result = STR_INIT(output, strlen(output), 0);
 				memset(output, 0, PHP_MAX_SALT_LEN);
 				efree(output);
-				return SUCCESS;
+				return result;
 			}
 		} else if (
 				salt[0] == '$' &&
@@ -208,11 +208,11 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 			crypt_res = php_crypt_blowfish_rn(password, salt, output, sizeof(output));
 			if (!crypt_res) {
 				memset(output, 0, PHP_MAX_SALT_LEN + 1);
-				return FAILURE;
+				return NULL;
 			} else {
-				*result = estrdup(output);
+				result = STR_INIT(output, strlen(output), 0);
 				memset(output, 0, PHP_MAX_SALT_LEN + 1);
-				return SUCCESS;
+				return result;
 			}
 		} else {
 			memset(&buffer, 0, sizeof(buffer));
@@ -220,10 +220,10 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 
 			crypt_res = _crypt_extended_r(password, salt, &buffer);
 			if (!crypt_res) {
-				return FAILURE;
+				return NULL;
 			} else {
-				*result = estrdup(crypt_res);
-				return SUCCESS;
+				result = STR_INIT(crypt_res, strlen(crypt_res), 0);
+				return result;
 			}
 		}
 	}
@@ -243,8 +243,8 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 		if (!crypt_res) {
 			return FAILURE;
 		} else {
-			*result = estrdup(crypt_res);
-			return SUCCESS;
+			result = STR_INIT(crypt_res, strlen(crypt_res), 0);
+			return result;
 		}
 	}
 # endif
@@ -258,9 +258,10 @@ PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt,
 PHP_FUNCTION(crypt)
 {
 	char salt[PHP_MAX_SALT_LEN + 1];
-	char *str, *salt_in = NULL, *result = NULL;
+	char *str, *salt_in = NULL;
 	int str_len, salt_in_len = 0;
 	salt[0] = salt[PHP_MAX_SALT_LEN] = '\0';
+	zend_string *result;
 
 	/* This will produce suitable results if people depend on DES-encryption
 	 * available (passing always 2-character salt). At least for glibc6.1 */
@@ -293,14 +294,14 @@ PHP_FUNCTION(crypt)
 	}
 	salt[salt_in_len] = '\0';
 
-	if (php_crypt(str, str_len, salt, salt_in_len, &result) == FAILURE) {
+	if ((result = php_crypt(str, str_len, salt, salt_in_len)) == NULL) {
 		if (salt[0] == '*' && salt[1] == '0') {
-			RETURN_STRING("*1", 1);
+			RETURN_STRING("*1");
 		} else {
-			RETURN_STRING("*0", 1);
+			RETURN_STRING("*0");
 		}
 	}
-	RETURN_STRING(result, 0);
+	RETURN_STR(result);
 }
 /* }}} */
 #endif
diff --git a/ext/standard/cyr_convert.c b/ext/standard/cyr_convert.c
index d8d40cb10f..326e9e21b8 100644
--- a/ext/standard/cyr_convert.c
+++ b/ext/standard/cyr_convert.c
@@ -273,16 +273,16 @@ PHP_FUNCTION(convert_cyr_string)
 {
 	char *input, *fr_cs, *to_cs;
 	int input_len, fr_cs_len, to_cs_len;
-	unsigned char *str;
+	zend_string *str;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss", &input, &input_len, &fr_cs, &fr_cs_len, &to_cs, &to_cs_len) == FAILURE) {
 		return;
 	}
 
-	str = (unsigned char*) estrndup(input, input_len);
+	str = STR_INIT(input, input_len, 0);
 
-	php_convert_cyr_string(str, input_len, fr_cs[0], to_cs[0] TSRMLS_CC);
-	RETVAL_STRING((char *)str, 0);
+	php_convert_cyr_string(str->val, str->len, fr_cs[0], to_cs[0] TSRMLS_CC);
+	RETVAL_NEW_STR(str);
 }
 /* }}} */
 
diff --git a/ext/standard/datetime.c b/ext/standard/datetime.c
index 69e17240a7..80a34a4548 100644
--- a/ext/standard/datetime.c
+++ b/ext/standard/datetime.c
@@ -112,7 +112,7 @@ PHP_FUNCTION(strptime)
 	add_assoc_long(return_value, "tm_year",  parsed_time.tm_year);
 	add_assoc_long(return_value, "tm_wday",  parsed_time.tm_wday);
 	add_assoc_long(return_value, "tm_yday",  parsed_time.tm_yday);
-	add_assoc_string(return_value, "unparsed", unparsed_part, 1);
+	add_assoc_string(return_value, "unparsed", unparsed_part);
 }
 /* }}} */
 
diff --git a/ext/standard/dir.c b/ext/standard/dir.c
index c64f37c2d6..16cc8db054 100644
--- a/ext/standard/dir.c
+++ b/ext/standard/dir.c
@@ -52,7 +52,7 @@
 #endif
 
 typedef struct {
-	int default_dir;
+	zend_resource *default_dir;
 } php_dir_globals;
 
 #ifdef ZTS
@@ -81,16 +81,16 @@ static zend_class_entry *dir_class_entry_ptr;
 	if (ZEND_NUM_ARGS() == 0) { \
 		myself = getThis(); \
 		if (myself) { \
-			if (zend_hash_find(Z_OBJPROP_P(myself), "handle", sizeof("handle"), (void **)&tmp) == FAILURE) { \
+			if ((tmp = zend_hash_str_find(Z_OBJPROP_P(myself), "handle", sizeof("handle")-1)) == NULL) { \
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find my handle property"); \
 				RETURN_FALSE; \
 			} \
 			ZEND_FETCH_RESOURCE(dirp, php_stream *, tmp, -1, "Directory", php_file_le_stream()); \
 		} else { \
-			ZEND_FETCH_RESOURCE(dirp, php_stream *, 0, DIRG(default_dir), "Directory", php_file_le_stream()); \
+			ZEND_FETCH_RESOURCE(dirp, php_stream *, 0, DIRG(default_dir)->handle, "Directory", php_file_le_stream()); \
 		} \
 	} else { \
-		dirp = (php_stream *) zend_fetch_resource(&id TSRMLS_CC, -1, "Directory", NULL, 1, php_file_le_stream()); \
+		dirp = (php_stream *) zend_fetch_resource(id TSRMLS_CC, -1, "Directory", NULL, 1, php_file_le_stream()); \
 		if (!dirp) \
 			RETURN_FALSE; \
 	} 
@@ -109,22 +109,22 @@ static const zend_function_entry php_dir_class_functions[] = {
 };
 
 
-static void php_set_default_dir(int id TSRMLS_DC)
+static void php_set_default_dir(zend_resource *res TSRMLS_DC)
 {
-	if (DIRG(default_dir)!=-1) {
+	if (DIRG(default_dir)) {
 		zend_list_delete(DIRG(default_dir));
 	}
 
-	if (id != -1) {
-		zend_list_addref(id);
+	if (res) {
+		GC_REFCOUNT(res)++;
 	}
 	
-	DIRG(default_dir) = id;
+	DIRG(default_dir) = res;
 }
 
 PHP_RINIT_FUNCTION(dir)
 {
-	DIRG(default_dir) = -1;
+	DIRG(default_dir) = NULL;
 	return SUCCESS;
 }
 
@@ -233,12 +233,12 @@ static void _php_do_opendir(INTERNAL_FUNCTION_PARAMETERS, int createobject)
 
 	dirp->flags |= PHP_STREAM_FLAG_NO_FCLOSE;
 		
-	php_set_default_dir(dirp->rsrc_id TSRMLS_CC);
+	php_set_default_dir(dirp->res TSRMLS_CC);
 
 	if (createobject) {
 		object_init_ex(return_value, dir_class_entry_ptr);
-		add_property_stringl(return_value, "path", dirname, dir_len, 1);
-		add_property_resource(return_value, "handle", dirp->rsrc_id);
+		add_property_stringl(return_value, "path", dirname, dir_len);
+		add_property_resource(return_value, "handle", dirp->res);
 		php_stream_auto_cleanup(dirp); /* so we don't get warnings under debug */
 	} else {
 		php_stream_to_zval(dirp, return_value);
@@ -266,22 +266,22 @@ PHP_FUNCTION(getdir)
    Close directory connection identified by the dir_handle */
 PHP_FUNCTION(closedir)
 {
-	zval *id = NULL, **tmp, *myself;
+	zval *id = NULL, *tmp, *myself;
 	php_stream *dirp;
-	int rsrc_id;
+	zend_resource *res;
 
 	FETCH_DIRP();
 
 	if (!(dirp->flags & PHP_STREAM_FLAG_IS_DIR)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%d is not a valid Directory resource", dirp->rsrc_id);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld is not a valid Directory resource", dirp->res->handle);
 		RETURN_FALSE;
 	}
 
-	rsrc_id = dirp->rsrc_id;
-	zend_list_delete(dirp->rsrc_id);
+	res = dirp->res;
+	zend_list_close(dirp->res);
 
-	if (rsrc_id == DIRG(default_dir)) {
-		php_set_default_dir(-1 TSRMLS_CC);
+	if (res == DIRG(default_dir)) {
+		php_set_default_dir(NULL TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -370,7 +370,7 @@ PHP_FUNCTION(getcwd)
 #endif
 
 	if (ret) {
-		RETURN_STRING(path, 1);
+		RETURN_STRING(path);
 	} else {
 		RETURN_FALSE;
 	}
@@ -381,13 +381,13 @@ PHP_FUNCTION(getcwd)
    Rewind dir_handle back to the start */
 PHP_FUNCTION(rewinddir)
 {
-	zval *id = NULL, **tmp, *myself;
+	zval *id = NULL, *tmp, *myself;
 	php_stream *dirp;
 	
 	FETCH_DIRP();
 
 	if (!(dirp->flags & PHP_STREAM_FLAG_IS_DIR)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%d is not a valid Directory resource", dirp->rsrc_id);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld is not a valid Directory resource", dirp->res->handle);
 		RETURN_FALSE;
 	}
 
@@ -399,19 +399,19 @@ PHP_FUNCTION(rewinddir)
    Read directory entry from dir_handle */
 PHP_NAMED_FUNCTION(php_if_readdir)
 {
-	zval *id = NULL, **tmp, *myself;
+	zval *id = NULL, *tmp, *myself;
 	php_stream *dirp;
 	php_stream_dirent entry;
 
 	FETCH_DIRP();
 
 	if (!(dirp->flags & PHP_STREAM_FLAG_IS_DIR)) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%d is not a valid Directory resource", dirp->rsrc_id);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld is not a valid Directory resource", dirp->res->handle);
 		RETURN_FALSE;
 	}
 
 	if (php_stream_readdir(dirp, &entry)) {
-		RETURN_STRINGL(entry.d_name, strlen(entry.d_name), 1);
+		RETURN_STRINGL(entry.d_name, strlen(entry.d_name));
 	}
 	RETURN_FALSE;
 }
@@ -534,7 +534,7 @@ no_results:
 				continue;
 			}
 		}
-		add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip, 1);
+		add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip);
 	}
 
 	globfree(&globbuf);
@@ -554,7 +554,7 @@ PHP_FUNCTION(scandir)
 	char *dirn;
 	int dirn_len;
 	long flags = 0;
-	char **namelist;
+	zend_string **namelist;
 	int n, i;
 	zval *zcontext = NULL;
 	php_stream_context *context = NULL;
@@ -587,7 +587,7 @@ PHP_FUNCTION(scandir)
 	array_init(return_value);
 
 	for (i = 0; i < n; i++) {
-		add_next_index_string(return_value, namelist[i], 0);
+		add_next_index_str(return_value, namelist[i]);
 	}
 
 	if (n) {
diff --git a/ext/standard/dns.c b/ext/standard/dns.c
index 6a894467ff..de0e24a2d7 100644
--- a/ext/standard/dns.c
+++ b/ext/standard/dns.c
@@ -120,8 +120,8 @@
 #endif
 /* }}} */
 
-static char *php_gethostbyaddr(char *ip);
-static char *php_gethostbyname(char *name);
+static zend_string *php_gethostbyaddr(char *ip);
+static zend_string *php_gethostbyname(char *name);
 
 #ifdef HAVE_GETHOSTNAME
 /* {{{ proto string gethostname()
@@ -139,7 +139,7 @@ PHP_FUNCTION(gethostname)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(buf, 1);
+	RETURN_STRING(buf);
 }
 /* }}} */
 #endif
@@ -154,7 +154,7 @@ PHP_FUNCTION(gethostbyaddr)
 {
 	char *addr;
 	int addr_len;
-	char *hostname;
+	zend_string *hostname;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &addr, &addr_len) == FAILURE) {
 		return;
@@ -170,13 +170,13 @@ PHP_FUNCTION(gethostbyaddr)
 #endif
 		RETVAL_FALSE;
 	} else {
-		RETVAL_STRING(hostname, 0);
+		RETVAL_STR(hostname);
 	}
 }
 /* }}} */
 
 /* {{{ php_gethostbyaddr */
-static char *php_gethostbyaddr(char *ip)
+static zend_string *php_gethostbyaddr(char *ip)
 {
 #if HAVE_IPV6 && HAVE_INET_PTON
 	struct in6_addr addr6;
@@ -203,10 +203,10 @@ static char *php_gethostbyaddr(char *ip)
 #endif
 
 	if (!hp || hp->h_name == NULL || hp->h_name[0] == '\0') {
-		return estrdup(ip);
+		return STR_INIT(ip, strlen(ip), 0);
 	}
 
-	return estrdup(hp->h_name);
+	return STR_INIT(hp->h_name, strlen(hp->h_name), 0);
 }
 /* }}} */
 
@@ -216,15 +216,12 @@ PHP_FUNCTION(gethostbyname)
 {
 	char *hostname;
 	int hostname_len;
-	char *addr;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &hostname, &hostname_len) == FAILURE) {
 		return;
 	}
 
-	addr = php_gethostbyname(hostname);
-
-	RETVAL_STRING(addr, 0);
+	RETURN_STR(php_gethostbyname(hostname));
 }
 /* }}} */
 
@@ -251,26 +248,28 @@ PHP_FUNCTION(gethostbynamel)
 
 	for (i = 0 ; hp->h_addr_list[i] != 0 ; i++) {
 		in = *(struct in_addr *) hp->h_addr_list[i];
-		add_next_index_string(return_value, inet_ntoa(in), 1);
+		add_next_index_string(return_value, inet_ntoa(in));
 	}
 }
 /* }}} */
 
 /* {{{ php_gethostbyname */
-static char *php_gethostbyname(char *name)
+static zend_string *php_gethostbyname(char *name)
 {
 	struct hostent *hp;
 	struct in_addr in;
+	char *address;
 
 	hp = gethostbyname(name);
 
 	if (!hp || !*(hp->h_addr_list)) {
-		return estrdup(name);
+		return STR_INIT(name, strlen(name), 0);
 	}
 
 	memcpy(&in.s_addr, *(hp->h_addr_list), sizeof(in.s_addr));
 
-	return estrdup(inet_ntoa(in));
+	address = inet_ntoa(in);
+	return STR_INIT(address, strlen(address), 0);
 }
 /* }}} */
 
@@ -413,7 +412,7 @@ PHP_FUNCTION(dns_check_record)
 #if HAVE_FULL_DNS_FUNCS
 
 /* {{{ php_parserr */
-static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int store, int raw, zval **subarray)
+static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int store, int raw, zval *subarray)
 {
 	u_short type, class, dlen;
 	u_long ttl;
@@ -423,7 +422,7 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int
 	char name[MAXHOSTNAMELEN];
 	int have_v6_break = 0, in_v6_break = 0;
 
-	*subarray = NULL;
+	ZVAL_UNDEF(subarray);
 
 	n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, sizeof(name) - 2);
 	if (n < 0) {
@@ -445,113 +444,113 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int
 		return cp;
 	}
 
-	ALLOC_INIT_ZVAL(*subarray);
-	array_init(*subarray);
+	array_init(subarray);
 
-	add_assoc_string(*subarray, "host", name, 1);
-	add_assoc_string(*subarray, "class", "IN", 1);
-	add_assoc_long(*subarray, "ttl", ttl);
+	add_assoc_string(subarray, "host", name);
+	add_assoc_string(subarray, "class", "IN");
+	add_assoc_long(subarray, "ttl", ttl);
 
 	if (raw) {
-		add_assoc_long(*subarray, "type", type);
-		add_assoc_stringl(*subarray, "data", (char*) cp, (uint) dlen, 1);
+		add_assoc_long(subarray, "type", type);
+		add_assoc_stringl(subarray, "data", (char*) cp, (uint) dlen);
 		cp += dlen;
 		return cp;
 	}
 
 	switch (type) {
 		case DNS_T_A:
-			add_assoc_string(*subarray, "type", "A", 1);
+			add_assoc_string(subarray, "type", "A");
 			snprintf(name, sizeof(name), "%d.%d.%d.%d", cp[0], cp[1], cp[2], cp[3]);
-			add_assoc_string(*subarray, "ip", name, 1);
+			add_assoc_string(subarray, "ip", name);
 			cp += dlen;
 			break;
 		case DNS_T_MX:
-			add_assoc_string(*subarray, "type", "MX", 1);
+			add_assoc_string(subarray, "type", "MX");
 			GETSHORT(n, cp);
-			add_assoc_long(*subarray, "pri", n);
+			add_assoc_long(subarray, "pri", n);
 			/* no break; */
 		case DNS_T_CNAME:
 			if (type == DNS_T_CNAME) {
-				add_assoc_string(*subarray, "type", "CNAME", 1);
+				add_assoc_string(subarray, "type", "CNAME");
 			}
 			/* no break; */
 		case DNS_T_NS:
 			if (type == DNS_T_NS) {
-				add_assoc_string(*subarray, "type", "NS", 1);
+				add_assoc_string(subarray, "type", "NS");
 			}
 			/* no break; */
 		case DNS_T_PTR:
 			if (type == DNS_T_PTR) {
-				add_assoc_string(*subarray, "type", "PTR", 1);
+				add_assoc_string(subarray, "type", "PTR");
 			}
 			n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
 			if (n < 0) {
 				return NULL;
 			}
 			cp += n;
-			add_assoc_string(*subarray, "target", name, 1);
+			add_assoc_string(subarray, "target", name);
 			break;
 		case DNS_T_HINFO:
 			/* See RFC 1010 for values */
-			add_assoc_string(*subarray, "type", "HINFO", 1);
+			add_assoc_string(subarray, "type", "HINFO");
 			n = *cp & 0xFF;
 			cp++;
-			add_assoc_stringl(*subarray, "cpu", (char*)cp, n, 1);
+			add_assoc_stringl(subarray, "cpu", (char*)cp, n);
 			cp += n;
 			n = *cp & 0xFF;
 			cp++;
-			add_assoc_stringl(*subarray, "os", (char*)cp, n, 1);
+			add_assoc_stringl(subarray, "os", (char*)cp, n);
 			cp += n;
 			break;
 		case DNS_T_TXT:
 			{
 				int ll = 0;
-				zval *entries = NULL;
+				zval entries;
+				zend_string *tp;
 
-				add_assoc_string(*subarray, "type", "TXT", 1);
-				tp = emalloc(dlen + 1);
+				add_assoc_string(subarray, "type", "TXT");
+				tp = STR_ALLOC(dlen, 0);
 				
-				MAKE_STD_ZVAL(entries);
-				array_init(entries);
+				array_init(&entries);
 				
 				while (ll < dlen) {
 					n = cp[ll];
-					memcpy(tp + ll , cp + ll + 1, n);
-					add_next_index_stringl(entries, cp + ll + 1, n, 1);
+					memcpy(tp->val + ll , cp + ll + 1, n);
+					add_next_index_stringl(&entries, (char*)cp + ll + 1, n);
 					ll = ll + n + 1;
 				}
-				tp[dlen] = '\0';
+				tp->val[dlen] = '\0';
+				tp->len = dlen;
 				cp += dlen;
 
-				add_assoc_stringl(*subarray, "txt", tp, (dlen>0)?dlen - 1:0, 0);
-				add_assoc_zval(*subarray, "entries", entries);
+				add_assoc_str(subarray, "txt", tp);
+				add_assoc_zval(subarray, "entries", &entries);
 			}
 			break;
 		case DNS_T_SOA:
-			add_assoc_string(*subarray, "type", "SOA", 1);
+			add_assoc_string(subarray, "type", "SOA");
 			n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2);
 			if (n < 0) {
 				return NULL;
 			}
 			cp += n;
-			add_assoc_string(*subarray, "mname", name, 1);
+			add_assoc_string(subarray, "mname", name);
 			n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) -2);
 			if (n < 0) {
 				return NULL;
 			}
 			cp += n;
-			add_assoc_string(*subarray, "rname", name, 1);
+			add_assoc_string(subarray, "rname", name);
 			GETLONG(n, cp);
-			add_assoc_long(*subarray, "serial", n);
+			add_assoc_long(subarray, "serial", n);
 			GETLONG(n, cp);
-			add_assoc_long(*subarray, "refresh", n);
+			add_assoc_long(subarray, "refresh", n);
 			GETLONG(n, cp);
-			add_assoc_long(*subarray, "retry", n);
+			add_assoc_long(subarray, "retry", n);
 			GETLONG(n, cp);
-			add_assoc_long(*subarray, "expire", n);
+			add_assoc_long(subarray, "expire", n);
 			GETLONG(n, cp);
-			add_assoc_long(*subarray, "minimum-ttl", n);
+			add_assoc_long(subarray, "minimum-ttl", n);
 			break;
 		case DNS_T_AAAA:
 			tp = (u_char*)name;
@@ -583,15 +582,15 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int
 				tp++;
 			}
 			tp[0] = '\0';
-			add_assoc_string(*subarray, "type", "AAAA", 1);
-			add_assoc_string(*subarray, "ipv6", name, 1);
+			add_assoc_string(subarray, "type", "AAAA");
+			add_assoc_string(subarray, "ipv6", name);
 			break;
 		case DNS_T_A6:
 			p = cp;
-			add_assoc_string(*subarray, "type", "A6", 1);
+			add_assoc_string(subarray, "type", "A6");
 			n = ((int)cp[0]) & 0xFF;
 			cp++;
-			add_assoc_long(*subarray, "masklen", n);
+			add_assoc_long(subarray, "masklen", n);
 			tp = (u_char*)name;
 			if (n > 15) {
 				have_v6_break = 1;
@@ -651,56 +650,56 @@ static u_char *php_parserr(u_char *cp, querybuf *answer, int type_to_fetch, int
 				tp++;
 			}
 			tp[0] = '\0';
-			add_assoc_string(*subarray, "ipv6", name, 1);
+			add_assoc_string(subarray, "ipv6", name);
 			if (cp < p + dlen) {
 				n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
 				if (n < 0) {
 					return NULL;
 				}
 				cp += n;
-				add_assoc_string(*subarray, "chain", name, 1);
+				add_assoc_string(subarray, "chain", name);
 			}
 			break;
 		case DNS_T_SRV:
-			add_assoc_string(*subarray, "type", "SRV", 1);
+			add_assoc_string(subarray, "type", "SRV");
 			GETSHORT(n, cp);
-			add_assoc_long(*subarray, "pri", n);
+			add_assoc_long(subarray, "pri", n);
 			GETSHORT(n, cp);
-			add_assoc_long(*subarray, "weight", n);
+			add_assoc_long(subarray, "weight", n);
 			GETSHORT(n, cp);
-			add_assoc_long(*subarray, "port", n);
+			add_assoc_long(subarray, "port", n);
 			n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
 			if (n < 0) {
 				return NULL;
 			}
 			cp += n;
-			add_assoc_string(*subarray, "target", name, 1);
+			add_assoc_string(subarray, "target", name);
 			break;
 		case DNS_T_NAPTR:
-			add_assoc_string(*subarray, "type", "NAPTR", 1);
+			add_assoc_string(subarray, "type", "NAPTR");
 			GETSHORT(n, cp);
-			add_assoc_long(*subarray, "order", n);
+			add_assoc_long(subarray, "order", n);
 			GETSHORT(n, cp);
-			add_assoc_long(*subarray, "pref", n);
+			add_assoc_long(subarray, "pref", n);
 			n = (cp[0] & 0xFF);
-			add_assoc_stringl(*subarray, "flags", (char*)++cp, n, 1);
+			add_assoc_stringl(subarray, "flags", (char*)++cp, n);
 			cp += n;
 			n = (cp[0] & 0xFF);
-			add_assoc_stringl(*subarray, "services", (char*)++cp, n, 1);
+			add_assoc_stringl(subarray, "services", (char*)++cp, n);
 			cp += n;
 			n = (cp[0] & 0xFF);
-			add_assoc_stringl(*subarray, "regex", (char*)++cp, n, 1);
+			add_assoc_stringl(subarray, "regex", (char*)++cp, n);
 			cp += n;
 			n = dn_expand(answer->qb2, answer->qb2+65536, cp, name, (sizeof name) - 2);
 			if (n < 0) {
 				return NULL;
 			}
 			cp += n;
-			add_assoc_string(*subarray, "replacement", name, 1);
+			add_assoc_string(subarray, "replacement", name);
 			break;
 		default:
 			zval_ptr_dtor(subarray);
-			*subarray = NULL;
+			ZVAL_UNDEF(subarray);
 			cp += dlen;
 			break;
 	}
@@ -882,11 +881,11 @@ PHP_FUNCTION(dns_get_record)
 
 			/* YAY! Our real answers! */
 			while (an-- && cp && cp < end) {
-				zval *retval;
+				zval retval;
 
 				cp = php_parserr(cp, &answer, type_to_fetch, store_results, raw, &retval);
-				if (retval != NULL && store_results) {
-					add_next_index_zval(return_value, retval);
+				if (Z_TYPE(retval) != IS_UNDEF && store_results) {
+					add_next_index_zval(return_value, &retval);
 				}
 			}
 
@@ -895,11 +894,11 @@ PHP_FUNCTION(dns_get_record)
 				 * Process when only requesting addtl so that we can skip through the section
 				 */
 				while (ns-- > 0 && cp && cp < end) {
-					zval *retval = NULL;
+					zval retval;
 
 					cp = php_parserr(cp, &answer, DNS_T_ANY, authns != NULL, raw, &retval);
-					if (retval != NULL) {
-						add_next_index_zval(authns, retval);
+					if (Z_TYPE(retval) != IS_UNDEF) {
+						add_next_index_zval(authns, &retval);
 					}
 				}
 			}
@@ -907,11 +906,11 @@ PHP_FUNCTION(dns_get_record)
 			if (addtl) {
 				/* Additional records associated with authoritative name servers */
 				while (ar-- > 0 && cp && cp < end) {
-					zval *retval = NULL;
+					zval retval;
 
 					cp = php_parserr(cp, &answer, DNS_T_ANY, 1, raw, &retval);
-					if (retval != NULL) {
-						add_next_index_zval(addtl, retval);
+					if (Z_TYPE(retval) != IS_UNDEF) {
+						add_next_index_zval(addtl, &retval);
 					}
 				}
 			}
@@ -948,10 +947,12 @@ PHP_FUNCTION(dns_get_mx)
 		return;
 	}
 
+	mx_list = Z_REFVAL_P(mx_list);
 	zval_dtor(mx_list);
 	array_init(mx_list);
 
 	if (weight_list) {
+		weight_list = Z_REFVAL_P(weight_list);
 		zval_dtor(weight_list);
 		array_init(weight_list);
 	}
@@ -1006,7 +1007,7 @@ PHP_FUNCTION(dns_get_mx)
 			RETURN_FALSE;
 		}
 		cp += i;
-		add_next_index_string(mx_list, buf, 1);
+		add_next_index_string(mx_list, buf);
 		if (weight_list) {
 			add_next_index_long(weight_list, weight);
 		}
diff --git a/ext/standard/dns_win32.c b/ext/standard/dns_win32.c
index a784823dd3..0aa23599d2 100644
--- a/ext/standard/dns_win32.c
+++ b/ext/standard/dns_win32.c
@@ -75,7 +75,7 @@ PHP_FUNCTION(dns_get_mx) /* {{{ */
 			continue;
 		}
 
-		add_next_index_string(mx_list, pRec->Data.MX.pNameExchange, 1);
+		add_next_index_string(mx_list, pRec->Data.MX.pNameExchange);
 		if (weight_list) {
 			add_next_index_long(weight_list, srv->wPriority);
 		}
@@ -157,13 +157,13 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 	ALLOC_INIT_ZVAL(*subarray);
 	array_init(*subarray);
 
-	add_assoc_string(*subarray, "host", pRec->pName, 1);
-	add_assoc_string(*subarray, "class", "IN", 1);
+	add_assoc_string(*subarray, "host", pRec->pName);
+	add_assoc_string(*subarray, "class", "IN");
 	add_assoc_long(*subarray, "ttl", ttl);
 
 	if (raw) {
 		add_assoc_long(*subarray, "type", type);
-		add_assoc_stringl(*subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength, 1);
+		add_assoc_stringl(*subarray, "data", (char*) &pRec->Data, (uint) pRec->wDataLength);
 		return;
 	}
 
@@ -171,33 +171,33 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 		case DNS_TYPE_A: {
 			IN_ADDR ipaddr;
 			ipaddr.S_un.S_addr = (pRec->Data.A.IpAddress);
-			add_assoc_string(*subarray, "type", "A", 1);
-			add_assoc_string(*subarray, "ip", inet_ntoa(ipaddr), 1);
+			add_assoc_string(*subarray, "type", "A");
+			add_assoc_string(*subarray, "ip", inet_ntoa(ipaddr));
 			break;
 		}
 
 		case DNS_TYPE_MX:
-			add_assoc_string(*subarray, "type", "MX", 1);
+			add_assoc_string(*subarray, "type", "MX");
 			add_assoc_long(*subarray, "pri", pRec->Data.Srv.wPriority);
 			/* no break; */
 
 		case DNS_TYPE_CNAME:
 			if (type == DNS_TYPE_CNAME) {
-				add_assoc_string(*subarray, "type", "CNAME", 1);
+				add_assoc_string(*subarray, "type", "CNAME");
 			}
 			/* no break; */
 
 		case DNS_TYPE_NS:
 			if (type == DNS_TYPE_NS) {
-				add_assoc_string(*subarray, "type", "NS", 1);
+				add_assoc_string(*subarray, "type", "NS");
 			}
 			/* no break; */
 
 		case DNS_TYPE_PTR:
 			if (type == DNS_TYPE_PTR) {
-				add_assoc_string(*subarray, "type", "PTR", 1);
+				add_assoc_string(*subarray, "type", "PTR");
 			}
-			add_assoc_string(*subarray, "target", pRec->Data.MX.pNameExchange, 1);
+			add_assoc_string(*subarray, "target", pRec->Data.MX.pNameExchange);
 			break;
 
 		/* Not available on windows, the query is possible but there is no DNS_HINFO_DATA structure */
@@ -207,11 +207,12 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 				DWORD i = 0;
 				DNS_TXT_DATA *data_txt = &pRec->Data.TXT;
 				DWORD count = data_txt->dwStringCount;
-				char *txt, *txt_dst;
+				zend_string *txt;
+				char *txt_dst;
 				long txt_len = 0;
 				zval *entries;
 
-				add_assoc_string(*subarray, "type", "TXT", 1);
+				add_assoc_string(*subarray, "type", "TXT");
 				
 				ALLOC_INIT_ZVAL(entries);
 				array_init(entries);
@@ -220,16 +221,16 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 					txt_len += strlen(data_txt->pStringArray[i]) + 1;
 				}
 
-				txt = ecalloc(txt_len * 2, 1);
-				txt_dst = txt;
+				txt = STR_SAFE_ALLOC(txt_len, 2, 0, 0);
+				txt_dst = txt->val;
 				for (i = 0; i < count; i++) {
 					int len = strlen(data_txt->pStringArray[i]);
 					memcpy(txt_dst, data_txt->pStringArray[i], len);
-					add_next_index_stringl(entries, data_txt->pStringArray[i], len, 1);
+					add_next_index_stringl(entries, data_txt->pStringArray[i], len);
 					txt_dst += len;
 				}
-
-				add_assoc_string(*subarray, "txt", txt, 0);
+				tct->len = txt_dst - txt->val;
+				add_assoc_str(*subarray, "txt", txt);
 				add_assoc_zval(*subarray, "entries", entries);
 			}
 			break;
@@ -238,10 +239,10 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 			{
 				DNS_SOA_DATA *data_soa = &pRec->Data.Soa;
 
-				add_assoc_string(*subarray, "type", "SOA", 1);
+				add_assoc_string(*subarray, "type", "SOA");
 
-				add_assoc_string(*subarray, "mname", data_soa->pNamePrimaryServer, 1);
-				add_assoc_string(*subarray, "rname", data_soa->pNameAdministrator, 1);
+				add_assoc_string(*subarray, "mname", data_soa->pNamePrimaryServer);
+				add_assoc_string(*subarray, "rname", data_soa->pNameAdministrator);
 				add_assoc_long(*subarray, "serial", data_soa->dwSerialNo);
 				add_assoc_long(*subarray, "refresh", data_soa->dwRefresh);
 				add_assoc_long(*subarray, "retry", data_soa->dwRetry);
@@ -294,8 +295,8 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 				}
 				tp[0] = '\0';
 
-				add_assoc_string(*subarray, "type", "AAAA", 1);
-				add_assoc_string(*subarray, "ipv6", buf, 1);
+				add_assoc_string(*subarray, "type", "AAAA");
+				add_assoc_string(*subarray, "ipv6", buf);
 			}
 			break;
 
@@ -309,11 +310,11 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 			{
 				DNS_SRV_DATA *data_srv = &pRec->Data.Srv;
 
-				add_assoc_string(*subarray, "type", "SRV", 1);
+				add_assoc_string(*subarray, "type", "SRV");
 				add_assoc_long(*subarray, "pri", data_srv->wPriority);
 				add_assoc_long(*subarray, "weight", data_srv->wWeight);
 				add_assoc_long(*subarray, "port", data_srv->wPort);
-				add_assoc_string(*subarray, "target", data_srv->pNameTarget, 1);
+				add_assoc_string(*subarray, "target", data_srv->pNameTarget);
 			}
 			break;
 
@@ -322,13 +323,13 @@ static void php_parserr(PDNS_RECORD pRec, int type_to_fetch, int store, int raw,
 			{
 				DNS_NAPTR_DATA * data_naptr = &pRec->Data.Naptr;
 
-				add_assoc_string(*subarray, "type", "NAPTR", 1);
+				add_assoc_string(*subarray, "type", "NAPTR");
 				add_assoc_long(*subarray, "order", data_naptr->wOrder);
 				add_assoc_long(*subarray, "pref", data_naptr->wPreference);
-				add_assoc_string(*subarray, "flags", data_naptr->pFlags, 1);
-				add_assoc_string(*subarray, "services", data_naptr->pService, 1);
-				add_assoc_string(*subarray, "regex", data_naptr->pRegularExpression, 1);
-				add_assoc_string(*subarray, "replacement", data_naptr->pReplacement, 1);
+				add_assoc_string(*subarray, "flags", data_naptr->pFlags);
+				add_assoc_string(*subarray, "services", data_naptr->pService);
+				add_assoc_string(*subarray, "regex", data_naptr->pRegularExpression);
+				add_assoc_string(*subarray, "replacement", data_naptr->pReplacement);
 			}
 			break;
 #endif
diff --git a/ext/standard/exec.c b/ext/standard/exec.c
index f8a22adf39..3b07e00443 100644
--- a/ext/standard/exec.c
+++ b/ext/standard/exec.c
@@ -120,7 +120,7 @@ PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value TSRMLS_
 					bufl = l + 1;
 					buf[bufl] = '\0';
 				}
-				add_next_index_stringl(array, buf, bufl, 1);
+				add_next_index_stringl(array, buf, bufl);
 			}
 			b = buf;
 		}
@@ -134,12 +134,12 @@ PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value TSRMLS_
 					buf[bufl] = '\0';
 				}
 				if (type == 2) {
-					add_next_index_stringl(array, buf, bufl, 1);
+					add_next_index_stringl(array, buf, bufl);
 				}
 			}
 
 			/* Return last line from the shell command */
-			RETVAL_STRINGL(buf, bufl, 1);
+			RETVAL_STRINGL(buf, bufl);
 		} else { /* should return NULL, but for BC we return "" */
 			RETVAL_EMPTY_STRING();
 		}
@@ -192,6 +192,7 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
 	if (!ret_array) {
 		ret = php_exec(mode, cmd, NULL, return_value TSRMLS_CC);
 	} else {
+		ret_array = Z_REFVAL_P(ret_array);
 		if (Z_TYPE_P(ret_array) != IS_ARRAY) {
 			zval_dtor(ret_array);
 			array_init(ret_array);
@@ -199,6 +200,7 @@ static void php_exec_ex(INTERNAL_FUNCTION_PARAMETERS, int mode) /* {{{ */
 		ret = php_exec(2, cmd, ret_array, return_value TSRMLS_CC);
 	}
 	if (ret_code) {
+		ret_code = Z_REFVAL_P(ret_code);
 		zval_dtor(ret_code);
 		ZVAL_LONG(ret_code, ret);
 	}
@@ -238,16 +240,16 @@ PHP_FUNCTION(passthru)
 
    *NOT* safe for binary strings
 */
-PHPAPI char *php_escape_shell_cmd(char *str)
+PHPAPI zend_string *php_escape_shell_cmd(char *str)
 {
 	register int x, y, l = strlen(str);
-	char *cmd;
 	char *p = NULL;
 	size_t estimate = (2 * l) + 1;
+	zend_string *cmd;
 
 	TSRMLS_FETCH();
 
-	cmd = safe_emalloc(2, l, 1);
+	cmd = STR_ALLOC(2 * l, 0);
 
 	for (x = 0, y = 0; x < l; x++) {
 		int mb_len = php_mblen(str + x, (l - x));
@@ -256,7 +258,7 @@ PHPAPI char *php_escape_shell_cmd(char *str)
 		if (mb_len < 0) {
 			continue;
 		} else if (mb_len > 1) {
-			memcpy(cmd + y, str + x, mb_len);
+			memcpy(cmd->val + y, str + x, mb_len);
 			y += mb_len;
 			x += mb_len - 1;
 			continue;
@@ -271,13 +273,13 @@ PHPAPI char *php_escape_shell_cmd(char *str)
 				} else if (p && *p == str[x]) {
 					p = NULL;
 				} else {
-					cmd[y++] = '\\';
+					cmd->val[y++] = '\\';
 				}
-				cmd[y++] = str[x];
+				cmd->val[y++] = str[x];
 				break;
 #else
 			/* % is Windows specific for enviromental variables, ^%PATH% will 
-				output PATH whil ^%PATH^% not. escapeshellcmd will escape all %.
+				output PATH whil ^%PATH^% not. escapeshellcmd->val will escape all %.
 			*/
 			case '%':
 			case '"':
@@ -305,44 +307,46 @@ PHPAPI char *php_escape_shell_cmd(char *str)
 			case '\x0A': /* excluding these two */
 			case '\xFF':
 #ifdef PHP_WIN32
-				cmd[y++] = '^';
+				cmd->val[y++] = '^';
 #else
-				cmd[y++] = '\\';
+				cmd->val[y++] = '\\';
 #endif
 				/* fall-through */
 			default:
-				cmd[y++] = str[x];
+				cmd->val[y++] = str[x];
 
 		}
 	}
-	cmd[y] = '\0';
+	cmd->val[y] = '\0';
 
 	if ((estimate - y) > 4096) {
 		/* realloc if the estimate was way overill
 		 * Arbitrary cutoff point of 4096 */
-		cmd = erealloc(cmd, y + 1);
+		cmd = STR_REALLOC(cmd, y, 0);
 	}
 
+	cmd->len = y;
+
 	return cmd;
 }
 /* }}} */
 
 /* {{{ php_escape_shell_arg
  */
-PHPAPI char *php_escape_shell_arg(char *str)
+PHPAPI zend_string *php_escape_shell_arg(char *str)
 {
 	int x, y = 0, l = strlen(str);
-	char *cmd;
+	zend_string *cmd;
 	size_t estimate = (4 * l) + 3;
 
 	TSRMLS_FETCH();
 
-	cmd = safe_emalloc(4, l, 3); /* worst case */
+	cmd = STR_ALLOC(4 * l + 2, 0); /* worst case */
 
 #ifdef PHP_WIN32
-	cmd[y++] = '"';
+	cmd->val[y++] = '"';
 #else
-	cmd[y++] = '\'';
+	cmd->val[y++] = '\'';
 #endif
 
 	for (x = 0; x < l; x++) {
@@ -352,7 +356,7 @@ PHPAPI char *php_escape_shell_arg(char *str)
 		if (mb_len < 0) {
 			continue;
 		} else if (mb_len > 1) {
-			memcpy(cmd + y, str + x, mb_len);
+			memcpy(cmd->val + y, str + x, mb_len);
 			y += mb_len;
 			x += mb_len - 1;
 			continue;
@@ -362,31 +366,32 @@ PHPAPI char *php_escape_shell_arg(char *str)
 #ifdef PHP_WIN32
 		case '"':
 		case '%':
-			cmd[y++] = ' ';
+			cmd->val[y++] = ' ';
 			break;
 #else
 		case '\'':
-			cmd[y++] = '\'';
-			cmd[y++] = '\\';
-			cmd[y++] = '\'';
+			cmd->val[y++] = '\'';
+			cmd->val[y++] = '\\';
+			cmd->val[y++] = '\'';
 #endif
 			/* fall-through */
 		default:
-			cmd[y++] = str[x];
+			cmd->val[y++] = str[x];
 		}
 	}
 #ifdef PHP_WIN32
-	cmd[y++] = '"';
+	cmd->val[y++] = '"';
 #else
-	cmd[y++] = '\'';
+	cmd->val[y++] = '\'';
 #endif
-	cmd[y] = '\0';
+	cmd->val[y] = '\0';
 
 	if ((estimate - y) > 4096) {
 		/* realloc if the estimate was way overill
 		 * Arbitrary cutoff point of 4096 */
-		cmd = erealloc(cmd, y + 1);
+		cmd = STR_REALLOC(cmd, y, 0);
 	}
+	cmd->len = y;
 	return cmd;
 }
 /* }}} */
@@ -404,8 +409,7 @@ PHP_FUNCTION(escapeshellcmd)
 	}
 
 	if (command_len) {
-		cmd = php_escape_shell_cmd(command);
-		RETVAL_STRING(cmd, 0);
+		RETVAL_STR(php_escape_shell_cmd(command));
 	} else {
 		RETVAL_EMPTY_STRING();
 	}
@@ -425,8 +429,7 @@ PHP_FUNCTION(escapeshellarg)
 	}
 
 	if (argument) {
-		cmd = php_escape_shell_arg(argument);
-		RETVAL_STRING(cmd, 0);
+		RETVAL_STR(php_escape_shell_arg(argument));
 	}
 }
 /* }}} */
@@ -436,10 +439,9 @@ PHP_FUNCTION(escapeshellarg)
 PHP_FUNCTION(shell_exec)
 {
 	FILE *in;
-	size_t total_readbytes;
 	char *command;
 	int command_len;
-	char *ret;
+	zend_string *ret;
 	php_stream *stream;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &command, &command_len) == FAILURE) {
@@ -456,11 +458,11 @@ PHP_FUNCTION(shell_exec)
 	}
 
 	stream = php_stream_fopen_from_pipe(in, "rb");
-	total_readbytes = php_stream_copy_to_mem(stream, &ret, PHP_STREAM_COPY_ALL, 0);
+	ret = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0);
 	php_stream_close(stream);
 
-	if (total_readbytes > 0) {
-		RETVAL_STRINGL(ret, total_readbytes, 0);
+	if (ret && ret->len > 0) {
+		RETVAL_STR(ret);
 	}
 }
 /* }}} */
diff --git a/ext/standard/exec.h b/ext/standard/exec.h
index ddb6367570..8ffe471408 100644
--- a/ext/standard/exec.h
+++ b/ext/standard/exec.h
@@ -34,8 +34,8 @@ PHP_FUNCTION(proc_terminate);
 PHP_FUNCTION(proc_nice);
 PHP_MINIT_FUNCTION(proc_open);
 
-PHPAPI char *php_escape_shell_cmd(char *);
-PHPAPI char *php_escape_shell_arg(char *);
+PHPAPI zend_string *php_escape_shell_cmd(char *);
+PHPAPI zend_string *php_escape_shell_arg(char *);
 PHPAPI int php_exec(int type, char *cmd, zval *array, zval *return_value TSRMLS_DC);
 
 #endif /* EXEC_H */
diff --git a/ext/standard/file.c b/ext/standard/file.c
index e1f24abf64..2c4af49ec1 100644
--- a/ext/standard/file.c
+++ b/ext/standard/file.c
@@ -148,10 +148,10 @@ PHPAPI int php_le_stream_context(TSRMLS_D)
 */
 static ZEND_RSRC_DTOR_FUNC(file_context_dtor)
 {
-	php_stream_context *context = (php_stream_context*)rsrc->ptr;
-	if (context->options) {
+	php_stream_context *context = (php_stream_context*)res->ptr;
+	if (Z_TYPE(context->options) != IS_UNDEF) {
 		zval_ptr_dtor(&context->options);
-		context->options = NULL;
+		ZVAL_UNDEF(&context->options);
 	}
 	php_stream_context_free(context);
 }
@@ -348,7 +348,7 @@ PHP_FUNCTION(flock)
 		return;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	act = operation & 3;
 	if (act < 1 || act > 3) {
@@ -356,16 +356,16 @@ PHP_FUNCTION(flock)
 		RETURN_FALSE;
 	}
 
-	if (arg3 && PZVAL_IS_REF(arg3)) {
-		convert_to_long_ex(&arg3);
-		Z_LVAL_P(arg3) = 0;
+	if (arg3 && Z_ISREF_P(arg3)) {
+		convert_to_long_ex(Z_REFVAL_P(arg3));
+		Z_LVAL_P(Z_REFVAL_P(arg3)) = 0;
 	}
 
 	/* flock_values contains all possible actions if (operation & 4) we won't block on the lock */
 	act = flock_values[act - 1] | (operation & PHP_LOCK_NB ? LOCK_NB : 0);
 	if (php_stream_lock(stream, act)) {
-		if (operation && errno == EWOULDBLOCK && arg3 && PZVAL_IS_REF(arg3)) {
-			Z_LVAL_P(arg3) = 1;
+		if (operation && errno == EWOULDBLOCK && arg3 && Z_ISREF_P(arg3)) {
+			Z_LVAL_P(Z_REFVAL_P(arg3)) = 1;
 		}
 		RETURN_FALSE;
 	}
@@ -419,7 +419,7 @@ PHP_FUNCTION(get_meta_tags)
 				}
 			} else if (tok_last == TOK_EQUAL && looking_for_val) {
 				if (saw_name) {
-					STR_FREE(name);
+					if (name) efree(name);
 					/* Get the NAME attr (Single word attr, non-quoted) */
 					temp = name = estrndup(md.token_data, md.token_len);
 
@@ -432,7 +432,7 @@ PHP_FUNCTION(get_meta_tags)
 
 					have_name = 1;
 				} else if (saw_content) {
-					STR_FREE(value);
+					if (value) efree(value);
 					value = estrndup(md.token_data, md.token_len);
 					have_content = 1;
 				}
@@ -453,7 +453,7 @@ PHP_FUNCTION(get_meta_tags)
 			}
 		} else if (tok == TOK_STRING && tok_last == TOK_EQUAL && looking_for_val) {
 			if (saw_name) {
-				STR_FREE(name);
+				if (name) efree(name);
 				/* Get the NAME attr (Quoted single/double) */
 				temp = name = estrndup(md.token_data, md.token_len);
 
@@ -466,7 +466,7 @@ PHP_FUNCTION(get_meta_tags)
 
 				have_name = 1;
 			} else if (saw_content) {
-				STR_FREE(value);
+				if (value) efree(value);
 				value = estrndup(md.token_data, md.token_len);
 				have_content = 1;
 			}
@@ -484,13 +484,13 @@ PHP_FUNCTION(get_meta_tags)
 				/* For BC */
 				php_strtolower(name, strlen(name));
 				if (have_content) {
-					add_assoc_string(return_value, name, value, 1);
+					add_assoc_string(return_value, name, value);
 				} else {
-					add_assoc_string(return_value, name, "", 1);
+					add_assoc_string(return_value, name, "");
 				}
 
 				efree(name);
-				STR_FREE(value);
+				if (value) efree(value);
 			} else if (have_content) {
 				efree(value);
 			}
@@ -512,8 +512,8 @@ PHP_FUNCTION(get_meta_tags)
 		md.token_data = NULL;
 	}
 
-	STR_FREE(value);
-	STR_FREE(name);
+	if (value) efree(value);
+	if (name) efree(name);
 	php_stream_close(md.stream);
 }
 /* }}} */
@@ -524,14 +524,13 @@ PHP_FUNCTION(file_get_contents)
 {
 	char *filename;
 	int filename_len;
-	char *contents;
 	zend_bool use_include_path = 0;
 	php_stream *stream;
-	int len;
 	long offset = -1;
 	long maxlen = PHP_STREAM_COPY_ALL;
 	zval *zcontext = NULL;
 	php_stream_context *context = NULL;
+	zend_string *contents;
 
 	/* Parse arguments */
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|br!ll", &filename, &filename_len, &use_include_path, &zcontext, &offset, &maxlen) == FAILURE) {
@@ -558,12 +557,10 @@ PHP_FUNCTION(file_get_contents)
 		RETURN_FALSE;
 	}
 
-	if ((len = php_stream_copy_to_mem(stream, &contents, maxlen, 0)) > 0) {
-		RETVAL_STRINGL(contents, len, 0);
-	} else if (len == 0) {
-		RETVAL_EMPTY_STRING();
+	if ((contents = php_stream_copy_to_mem(stream, maxlen, 0)) != NULL) {
+		RETVAL_STR(contents);
 	} else {
-		RETVAL_FALSE;
+		RETVAL_EMPTY_STRING();
 	}
 
 	php_stream_close(stream);
@@ -590,7 +587,7 @@ PHP_FUNCTION(file_put_contents)
 	}
 
 	if (Z_TYPE_P(data) == IS_RESOURCE) {
-		php_stream_from_zval(srcstream, &data);
+		php_stream_from_zval(srcstream, data);
 	}
 
 	context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);
@@ -638,8 +635,7 @@ PHP_FUNCTION(file_put_contents)
 		case IS_LONG:
 		case IS_DOUBLE:
 		case IS_BOOL:
-		case IS_CONSTANT:
-			convert_to_string_ex(&data);
+			convert_to_string_ex(data);
 
 		case IS_STRING:
 			if (Z_STRLEN_P(data)) {
@@ -654,30 +650,27 @@ PHP_FUNCTION(file_put_contents)
 		case IS_ARRAY:
 			if (zend_hash_num_elements(Z_ARRVAL_P(data))) {
 				int bytes_written;
-				zval **tmp;
-				HashPosition pos;
+				zval *tmp;
 
-				zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(data), &pos);
-				while (zend_hash_get_current_data_ex(Z_ARRVAL_P(data), (void **) &tmp, &pos) == SUCCESS) {
-					if (Z_TYPE_PP(tmp) != IS_STRING) {
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(data), tmp) {
+					if (Z_TYPE_P(tmp) != IS_STRING) {
 						SEPARATE_ZVAL(tmp);
-						convert_to_string(*tmp);
+						convert_to_string(tmp);
 					}
-					if (Z_STRLEN_PP(tmp)) {
-						numbytes += Z_STRLEN_PP(tmp);
-						bytes_written = php_stream_write(stream, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
-						if (bytes_written < 0 || bytes_written != Z_STRLEN_PP(tmp)) {
+					if (Z_STRLEN_P(tmp)) {
+						numbytes += Z_STRLEN_P(tmp);
+						bytes_written = php_stream_write(stream, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
+						if (bytes_written < 0 || bytes_written != Z_STRLEN_P(tmp)) {
 							if (bytes_written < 0) {
-								php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write %d bytes to %s", Z_STRLEN_PP(tmp), filename);
+								php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to write %d bytes to %s", Z_STRLEN_P(tmp), filename);
 							} else {
-								php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %d of %d bytes written, possibly out of free disk space", bytes_written, Z_STRLEN_PP(tmp));
+								php_error_docref(NULL TSRMLS_CC, E_WARNING, "Only %d of %d bytes written, possibly out of free disk space", bytes_written, Z_STRLEN_P(tmp));
 							}
 							numbytes = -1;
 							break;
 						}
 					}
-					zend_hash_move_forward_ex(Z_ARRVAL_P(data), &pos);
-				}
+				} ZEND_HASH_FOREACH_END();
 			}
 			break;
 
@@ -717,9 +710,8 @@ PHP_FUNCTION(file)
 {
 	char *filename;
 	int filename_len;
-	char *target_buf=NULL, *p, *s, *e;
+	char *p, *s, *e;
 	register int i = 0;
-	int target_len;
 	char eol_marker = '\n';
 	long flags = 0;
 	zend_bool use_include_path;
@@ -728,6 +720,7 @@ PHP_FUNCTION(file)
 	php_stream *stream;
 	zval *zcontext = NULL;
 	php_stream_context *context = NULL;
+	zend_string *target_buf;
 
 	/* Parse arguments */
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "p|lr!", &filename, &filename_len, &flags, &zcontext) == FAILURE) {
@@ -752,11 +745,11 @@ PHP_FUNCTION(file)
 	/* Initialize return array */
 	array_init(return_value);
 
-	if ((target_len = php_stream_copy_to_mem(stream, &target_buf, PHP_STREAM_COPY_ALL, 0))) {
-		s = target_buf;
-		e = target_buf + target_len;
+	if ((target_buf = php_stream_copy_to_mem(stream, PHP_STREAM_COPY_ALL, 0)) != NULL) {
+		s = target_buf->val;
+		e = target_buf->val + target_buf->len;
 
-		if (!(p = php_stream_locate_eol(stream, target_buf, target_len TSRMLS_CC))) {
+		if (!(p = (char*)php_stream_locate_eol(stream, target_buf TSRMLS_CC))) {
 			p = e;
 			goto parse_eol;
 		}
@@ -771,20 +764,20 @@ PHP_FUNCTION(file)
 			do {
 				p++;
 parse_eol:
-				add_index_stringl(return_value, i++, estrndup(s, p-s), p-s, 0);
+				add_index_stringl(return_value, i++, s, p-s);
 				s = p;
 			} while ((p = memchr(p, eol_marker, (e-p))));
 		} else {
 			do {
 				int windows_eol = 0;
-				if (p != target_buf && eol_marker == '\n' && *(p - 1) == '\r') {
+				if (p != target_buf->val && eol_marker == '\n' && *(p - 1) == '\r') {
 					windows_eol++;
 				}
 				if (skip_blank_lines && !(p-s-windows_eol)) {
 					s = ++p;
 					continue;
 				}
-				add_index_stringl(return_value, i++, estrndup(s, p-s-windows_eol), p-s-windows_eol, 0);
+				add_index_stringl(return_value, i++, s, p-s-windows_eol);
 				s = ++p;
 			} while ((p = memchr(p, eol_marker, (e-p))));
 		}
@@ -797,7 +790,7 @@ parse_eol:
 	}
 
 	if (target_buf) {
-		efree(target_buf);
+		STR_FREE(target_buf);
 	}
 	php_stream_close(stream);
 }
@@ -809,10 +802,9 @@ PHP_FUNCTION(tempnam)
 {
 	char *dir, *prefix;
 	int dir_len, prefix_len;
-	size_t p_len;
 	char *opened_path;
-	char *p;
 	int fd;
+	zend_string *p;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ps", &dir, &dir_len, &prefix, &prefix_len) == FAILURE) {
 		return;
@@ -822,18 +814,20 @@ PHP_FUNCTION(tempnam)
 		RETURN_FALSE;
 	}
 
-	php_basename(prefix, prefix_len, NULL, 0, &p, &p_len TSRMLS_CC);
-	if (p_len > 64) {
-		p[63] = '\0';
+	p = php_basename(prefix, prefix_len, NULL, 0 TSRMLS_CC);
+	if (p->len > 64) {
+		p->val[63] = '\0';
 	}
 
 	RETVAL_FALSE;
 
-	if ((fd = php_open_temporary_fd_ex(dir, p, &opened_path, 1 TSRMLS_CC)) >= 0) {
+	if ((fd = php_open_temporary_fd_ex(dir, p->val, &opened_path, 1 TSRMLS_CC)) >= 0) {
 		close(fd);
-		RETVAL_STRING(opened_path, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRING(opened_path);
+		efree(opened_path);
 	}
-	efree(p);
+	STR_RELEASE(p);
 }
 /* }}} */
 
@@ -895,10 +889,10 @@ PHPAPI PHP_FUNCTION(fclose)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	if ((stream->flags & PHP_STREAM_FLAG_NO_FCLOSE) != 0) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%d is not a valid stream resource", stream->rsrc_id);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%ld is not a valid stream resource", stream->res->handle);
 		RETURN_FALSE;
 	}
 
@@ -967,10 +961,10 @@ PHP_FUNCTION(pclose)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	FG(pclose_wait) = 1;
-	zend_list_delete(stream->rsrc_id);
+	zend_list_close(stream->res);
 	FG(pclose_wait) = 0;
 	RETURN_LONG(FG(pclose_ret));
 }
@@ -987,7 +981,7 @@ PHPAPI PHP_FUNCTION(feof)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	if (php_stream_eof(stream)) {
 		RETURN_TRUE;
@@ -1012,7 +1006,7 @@ PHPAPI PHP_FUNCTION(fgets)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	if (argc == 1) {
 		/* ask streams to give us a buffer of an appropriate size */
@@ -1032,12 +1026,17 @@ PHPAPI PHP_FUNCTION(fgets)
 		}
 	}
 
-	ZVAL_STRINGL(return_value, buf, line_len, 0);
 	/* resize buffer if it's much larger than the result.
 	 * Only needed if the user requested a buffer size. */
-	if (argc > 1 && Z_STRLEN_P(return_value) < len / 2) {
-		Z_STRVAL_P(return_value) = erealloc(buf, line_len + 1);
-	}
+//??	if (argc > 1 && line_len < len / 2) {
+//???		
+		ZVAL_STRINGL(return_value, buf, line_len);
+		efree(buf);
+//??	} else {
+//???
+//???		ZVAL_STRINGL(return_value, buf, line_len);
+//???	efree(buf);
+//???	}
 	return;
 
 exit_failed:
@@ -1061,7 +1060,7 @@ PHPAPI PHP_FUNCTION(fgetc)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	result = php_stream_getc(stream);
 
@@ -1071,7 +1070,7 @@ PHPAPI PHP_FUNCTION(fgetc)
 		buf[0] = result;
 		buf[1] = '\0';
 
-		RETURN_STRINGL(buf, 1, 1);
+		RETURN_STRINGL(buf, 1);
 	}
 }
 /* }}} */
@@ -1086,14 +1085,15 @@ PHPAPI PHP_FUNCTION(fgetss)
 	size_t actual_len, retval_len;
 	char *buf = NULL, *retval;
 	php_stream *stream;
+	zend_string *allowed = NULL;
 	char *allowed_tags=NULL;
 	int allowed_tags_len=0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ls", &fd, &bytes, &allowed_tags, &allowed_tags_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|lS", &fd, &bytes, &allowed) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &fd);
+	PHP_STREAM_TO_ZVAL(stream, fd);
 
 	if (ZEND_NUM_ARGS() >= 2) {
 		if (bytes <= 0) {
@@ -1114,9 +1114,27 @@ PHPAPI PHP_FUNCTION(fgetss)
 		RETURN_FALSE;
 	}
 
+	if (allowed != NULL) {
+// TODO: reimplement to avoid reallocation ???
+		if (IS_INTERNED(allowed)) {
+			allowed_tags = estrndup(allowed->val, allowed->len);
+			allowed_tags_len = allowed->len;
+		} else {
+			allowed_tags = allowed->val;
+			allowed_tags_len = allowed->len;
+		}
+	}
+
 	retval_len = php_strip_tags(retval, actual_len, &stream->fgetss_state, allowed_tags, allowed_tags_len);
 
-	RETURN_STRINGL(retval, retval_len, 0);
+// TODO: reimplement to avoid reallocation ???
+	if (allowed && IS_INTERNED(allowed)) {
+		efree(allowed_tags);
+	}
+
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL(retval, retval_len);
+	efree(retval);
 }
 /* }}} */
 
@@ -1125,7 +1143,7 @@ PHPAPI PHP_FUNCTION(fgetss)
 PHP_FUNCTION(fscanf)
 {
 	int result, format_len, type, argc = 0;
-	zval ***args = NULL;
+	zval *args = NULL;
 	zval *file_handle;
 	char *buf, *format;
 	size_t len;
@@ -1135,31 +1153,22 @@ PHP_FUNCTION(fscanf)
 		return;
 	}
 
-	what = zend_fetch_resource(&file_handle TSRMLS_CC, -1, "File-Handle", &type, 2, php_file_le_stream(), php_file_le_pstream());
+	what = zend_fetch_resource(file_handle TSRMLS_CC, -1, "File-Handle", &type, 2, php_file_le_stream(), php_file_le_pstream());
 
 	/* we can't do a ZEND_VERIFY_RESOURCE(what), otherwise we end up
 	 * with a leak if we have an invalid filehandle. This needs changing
 	 * if the code behind ZEND_VERIFY_RESOURCE changed. - cc */
 	if (!what) {
-		if (args) {
-			efree(args);
-		}
 		RETURN_FALSE;
 	}
 
 	buf = php_stream_get_line((php_stream *) what, NULL, 0, &len);
 	if (buf == NULL) {
-		if (args) {
-			efree(args);
-		}
 		RETURN_FALSE;
 	}
 
-	result = php_sscanf_internal(buf, format, argc, args, 0, &return_value TSRMLS_CC);
+	result = php_sscanf_internal(buf, format, argc, args, 0, return_value TSRMLS_CC);
 
-	if (args) {
-		efree(args);
-	}
 	efree(buf);
 
 	if (SCAN_ERROR_WRONG_PARAM_COUNT == result) {
@@ -1195,7 +1204,7 @@ PHPAPI PHP_FUNCTION(fwrite)
 		RETURN_LONG(0);
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	ret = php_stream_write(stream, buffer ? buffer : arg2, num_bytes);
 	if (buffer) {
@@ -1218,7 +1227,7 @@ PHPAPI PHP_FUNCTION(fflush)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	ret = php_stream_flush(stream);
 	if (ret) {
@@ -1239,7 +1248,7 @@ PHPAPI PHP_FUNCTION(rewind)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	if (-1 == php_stream_rewind(stream)) {
 		RETURN_FALSE;
@@ -1260,7 +1269,7 @@ PHPAPI PHP_FUNCTION(ftell)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	ret = php_stream_tell(stream);
 	if (ret == -1)	{
@@ -1282,7 +1291,7 @@ PHPAPI PHP_FUNCTION(fseek)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	RETURN_LONG(php_stream_seek(stream, arg2, whence));
 }
@@ -1421,7 +1430,7 @@ PHPAPI PHP_FUNCTION(fpassthru)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	size = php_stream_passthru(stream);
 	RETURN_LONG(size);
@@ -1508,7 +1517,7 @@ PHP_NAMED_FUNCTION(php_if_ftruncate)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &fp);
+	PHP_STREAM_TO_ZVAL(stream, fp);
 
 	if (!php_stream_truncate_supported(stream)) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Can't truncate this stream!");
@@ -1524,8 +1533,8 @@ PHP_NAMED_FUNCTION(php_if_ftruncate)
 PHP_NAMED_FUNCTION(php_if_fstat)
 {
 	zval *fp;
-	zval *stat_dev, *stat_ino, *stat_mode, *stat_nlink, *stat_uid, *stat_gid, *stat_rdev,
-		 *stat_size, *stat_atime, *stat_mtime, *stat_ctime, *stat_blksize, *stat_blocks;
+	zval stat_dev, stat_ino, stat_mode, stat_nlink, stat_uid, stat_gid, stat_rdev,
+		 stat_size, stat_atime, stat_mtime, stat_ctime, stat_blksize, stat_blocks;
 	php_stream *stream;
 	php_stream_statbuf stat_ssb;
 	char *stat_sb_names[13] = {
@@ -1537,7 +1546,7 @@ PHP_NAMED_FUNCTION(php_if_fstat)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &fp);
+	PHP_STREAM_TO_ZVAL(stream, fp);
 
 	if (php_stream_stat(stream, &stat_ssb)) {
 		RETURN_FALSE;
@@ -1545,60 +1554,60 @@ PHP_NAMED_FUNCTION(php_if_fstat)
 
 	array_init(return_value);
 
-	MAKE_LONG_ZVAL_INCREF(stat_dev, stat_ssb.sb.st_dev);
-	MAKE_LONG_ZVAL_INCREF(stat_ino, stat_ssb.sb.st_ino);
-	MAKE_LONG_ZVAL_INCREF(stat_mode, stat_ssb.sb.st_mode);
-	MAKE_LONG_ZVAL_INCREF(stat_nlink, stat_ssb.sb.st_nlink);
-	MAKE_LONG_ZVAL_INCREF(stat_uid, stat_ssb.sb.st_uid);
-	MAKE_LONG_ZVAL_INCREF(stat_gid, stat_ssb.sb.st_gid);
+	ZVAL_LONG(&stat_dev, stat_ssb.sb.st_dev);
+	ZVAL_LONG(&stat_ino, stat_ssb.sb.st_ino);
+	ZVAL_LONG(&stat_mode, stat_ssb.sb.st_mode);
+	ZVAL_LONG(&stat_nlink, stat_ssb.sb.st_nlink);
+	ZVAL_LONG(&stat_uid, stat_ssb.sb.st_uid);
+	ZVAL_LONG(&stat_gid, stat_ssb.sb.st_gid);
 #ifdef HAVE_ST_RDEV
-	MAKE_LONG_ZVAL_INCREF(stat_rdev, stat_ssb.sb.st_rdev);
+	ZVAL_LONG(&stat_rdev, stat_ssb.sb.st_rdev);
 #else
-	MAKE_LONG_ZVAL_INCREF(stat_rdev, -1);
+	ZVAL_LONG(&stat_rdev, -1);
 #endif
-	MAKE_LONG_ZVAL_INCREF(stat_size, stat_ssb.sb.st_size);
-	MAKE_LONG_ZVAL_INCREF(stat_atime, stat_ssb.sb.st_atime);
-	MAKE_LONG_ZVAL_INCREF(stat_mtime, stat_ssb.sb.st_mtime);
-	MAKE_LONG_ZVAL_INCREF(stat_ctime, stat_ssb.sb.st_ctime);
+	ZVAL_LONG(&stat_size, stat_ssb.sb.st_size);
+	ZVAL_LONG(&stat_atime, stat_ssb.sb.st_atime);
+	ZVAL_LONG(&stat_mtime, stat_ssb.sb.st_mtime);
+	ZVAL_LONG(&stat_ctime, stat_ssb.sb.st_ctime);
 #ifdef HAVE_ST_BLKSIZE
-	MAKE_LONG_ZVAL_INCREF(stat_blksize, stat_ssb.sb.st_blksize);
+	ZVAL_LONG(&stat_blksize, stat_ssb.sb.st_blksize);
 #else
-	MAKE_LONG_ZVAL_INCREF(stat_blksize,-1);
+	ZVAL_LONG(&stat_blksize,-1);
 #endif
 #ifdef HAVE_ST_BLOCKS
-	MAKE_LONG_ZVAL_INCREF(stat_blocks, stat_ssb.sb.st_blocks);
+	ZVAL_LONG(&stat_blocks, stat_ssb.sb.st_blocks);
 #else
-	MAKE_LONG_ZVAL_INCREF(stat_blocks,-1);
+	ZVAL_LONG(&stat_blocks,-1);
 #endif
 	/* Store numeric indexes in propper order */
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_dev, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ino, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mode, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_nlink, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_uid, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_gid, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_rdev, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_size, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_atime, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mtime, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ctime, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blksize, sizeof(zval *), NULL);
-	zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_ino);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_mode);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_nlink);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_uid);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_gid);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_rdev);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_size);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_atime);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_mtime);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_ctime);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_blksize);
+	zend_hash_next_index_insert(HASH_OF(return_value), &stat_blocks);
 
 	/* Store string indexes referencing the same zval*/
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *)&stat_dev, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *)&stat_ino, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *)&stat_mode, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *)&stat_nlink, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *)&stat_uid, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *)&stat_gid, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *)&stat_rdev, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *)&stat_size, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *)&stat_atime, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *)&stat_mtime, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *)&stat_ctime, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *)&stat_blksize, sizeof(zval *), NULL);
-	zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *)&stat_blocks, sizeof(zval *), NULL);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0]), &stat_dev);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1]), &stat_ino);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2]), &stat_mode);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3]), &stat_nlink);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4]), &stat_uid);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5]), &stat_gid);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6]), &stat_rdev);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7]), &stat_size);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8]), &stat_atime);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9]), &stat_mtime);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10]), &stat_ctime);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11]), &stat_blksize);
+	zend_hash_str_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12]), &stat_blocks);
 }
 /* }}} */
 
@@ -1751,19 +1760,18 @@ PHPAPI PHP_FUNCTION(fread)
 		RETURN_FALSE;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &arg1);
+	PHP_STREAM_TO_ZVAL(stream, arg1);
 
 	if (len <= 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length parameter must be greater than 0");
 		RETURN_FALSE;
 	}
 
-	Z_STRVAL_P(return_value) = emalloc(len + 1);
+	ZVAL_NEW_STR(return_value, STR_ALLOC(len, 0));
 	Z_STRLEN_P(return_value) = php_stream_read(stream, Z_STRVAL_P(return_value), len);
 
 	/* needed because recv/read/gzread doesnt put a null at the end*/
 	Z_STRVAL_P(return_value)[Z_STRLEN_P(return_value)] = 0;
-	Z_TYPE_P(return_value) = IS_STRING;
 }
 /* }}} */
 
@@ -1862,7 +1870,7 @@ PHP_FUNCTION(fputcsv)
 		escape_char = *escape_str;
 	}
 
-	PHP_STREAM_TO_ZVAL(stream, &fp);
+	PHP_STREAM_TO_ZVAL(stream, fp);
 
 	ret = php_fputcsv(stream, fields, delimiter, enclosure, escape_char TSRMLS_CC);
 	RETURN_LONG(ret);
@@ -1873,16 +1881,14 @@ PHP_FUNCTION(fputcsv)
 PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char enclosure, char escape_char TSRMLS_DC)
 {
 	int count, i = 0, ret;
-	zval **field_tmp = NULL, field;
+	zval *field_tmp = NULL, field;
 	smart_str csvline = {0};
-	HashPosition pos;
 
 	count = zend_hash_num_elements(Z_ARRVAL_P(fields));
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(fields), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(fields), (void **) &field_tmp, &pos) == SUCCESS) {
-		field = **field_tmp;
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(fields), field_tmp) {
+		ZVAL_COPY_VALUE(&field, field_tmp);
 
-		if (Z_TYPE_PP(field_tmp) != IS_STRING) {
+		if (Z_TYPE(field) != IS_STRING) {
 			zval_copy_ctor(&field);
 			convert_to_string(&field);
 		}
@@ -1920,17 +1926,15 @@ PHPAPI int php_fputcsv(php_stream *stream, zval *fields, char delimiter, char en
 		if (++i != count) {
 			smart_str_appendl(&csvline, &delimiter, 1);
 		}
-		zend_hash_move_forward_ex(Z_ARRVAL_P(fields), &pos);
-
-		if (Z_TYPE_PP(field_tmp) != IS_STRING) {
+		if (Z_TYPE_P(field_tmp) != IS_STRING) {
 			zval_dtor(&field);
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	smart_str_appendc(&csvline, '\n');
 	smart_str_0(&csvline);
 
-	ret = php_stream_write(stream, csvline.c, csvline.len);
+	ret = php_stream_write(stream, csvline.s->val, csvline.s->len);
 
 	smart_str_free(&csvline);
 
@@ -1954,7 +1958,7 @@ PHP_FUNCTION(fgetcsv)
 	php_stream *stream;
 
 	{
-		zval *fd, **len_zv = NULL;
+		zval *fd, *len_zv = NULL;
 		char *delimiter_str = NULL;
 		int delimiter_str_len = 0;
 		char *enclosure_str = NULL;
@@ -1962,7 +1966,7 @@ PHP_FUNCTION(fgetcsv)
 		char *escape_str = NULL;
 		int escape_str_len = 0;
 
-		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|Zsss",
+		if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|zsss",
 			&fd, &len_zv, &delimiter_str, &delimiter_str_len,
 			&enclosure_str, &enclosure_str_len,
 			&escape_str, &escape_str_len) == FAILURE
@@ -2006,9 +2010,9 @@ PHP_FUNCTION(fgetcsv)
 			escape = escape_str[0];
 		}
 
-		if (len_zv != NULL && Z_TYPE_PP(len_zv) != IS_NULL) {
+		if (len_zv != NULL && Z_TYPE_P(len_zv) != IS_NULL) {
 			convert_to_long_ex(len_zv);
-			len = Z_LVAL_PP(len_zv);
+			len = Z_LVAL_P(len_zv);
 			if (len < 0) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Length parameter may not be negative");
 				RETURN_FALSE;
@@ -2019,7 +2023,7 @@ PHP_FUNCTION(fgetcsv)
 			len = -1;
 		}
 
-		PHP_STREAM_TO_ZVAL(stream, &fd);
+		PHP_STREAM_TO_ZVAL(stream, fd);
 	}
 
 	if (len < 0) {
@@ -2285,7 +2289,7 @@ PHPAPI void php_fgetcsv(php_stream *stream, char delimiter, char enclosure, char
 
 		/* 3. Now pass our field back to php */
 		*comp_end = '\0';
-		add_next_index_stringl(return_value, temp, comp_end - temp, 1);
+		add_next_index_stringl(return_value, temp, comp_end - temp);
 	} while (inc_len > 0);
 
 out:
@@ -2319,7 +2323,7 @@ PHP_FUNCTION(realpath)
 			RETURN_FALSE;
 		}
 #endif
-		RETURN_STRING(resolved_path_buff, 1);
+		RETURN_STRING(resolved_path_buff);
 	} else {
 		RETURN_FALSE;
 	}
@@ -2468,7 +2472,7 @@ PHP_FUNCTION(sys_get_temp_dir)
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
-	RETURN_STRING((char *)php_get_temporary_directory(TSRMLS_C), 1);
+	RETURN_STRING((char *)php_get_temporary_directory(TSRMLS_C));
 }
 /* }}} */
 
diff --git a/ext/standard/filestat.c b/ext/standard/filestat.c
index 2ec4ec3808..4232af4d1c 100644
--- a/ext/standard/filestat.c
+++ b/ext/standard/filestat.c
@@ -848,8 +848,8 @@ PHP_FUNCTION(clearstatcache)
  */
 PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int type, zval *return_value TSRMLS_DC)
 {
-	zval *stat_dev, *stat_ino, *stat_mode, *stat_nlink, *stat_uid, *stat_gid, *stat_rdev,
-		 *stat_size, *stat_atime, *stat_mtime, *stat_ctime, *stat_blksize, *stat_blocks;
+	zval stat_dev, stat_ino, stat_mode, stat_nlink, stat_uid, stat_gid, stat_rdev,
+		 stat_size, stat_atime, stat_mtime, stat_ctime, stat_blksize, stat_blocks;
 	struct stat *stat_sb;
 	php_stream_statbuf ssb;
 	int flags = 0, rmask=S_IROTH, wmask=S_IWOTH, xmask=S_IXOTH; /* access rights defaults to other */
@@ -979,20 +979,20 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ
 		RETURN_LONG((long)ssb.sb.st_ctime);
 	case FS_TYPE:
 		if (S_ISLNK(ssb.sb.st_mode)) {
-			RETURN_STRING("link", 1);
+			RETURN_STRING("link");
 		}
 		switch(ssb.sb.st_mode & S_IFMT) {
-		case S_IFIFO: RETURN_STRING("fifo", 1);
-		case S_IFCHR: RETURN_STRING("char", 1);
-		case S_IFDIR: RETURN_STRING("dir", 1);
-		case S_IFBLK: RETURN_STRING("block", 1);
-		case S_IFREG: RETURN_STRING("file", 1);
+		case S_IFIFO: RETURN_STRING("fifo");
+		case S_IFCHR: RETURN_STRING("char");
+		case S_IFDIR: RETURN_STRING("dir");
+		case S_IFBLK: RETURN_STRING("block");
+		case S_IFREG: RETURN_STRING("file");
 #if defined(S_IFSOCK) && !defined(ZEND_WIN32)&&!defined(__BEOS__)
-		case S_IFSOCK: RETURN_STRING("socket", 1);
+		case S_IFSOCK: RETURN_STRING("socket");
 #endif
 		}
 		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unknown file type (%d)", ssb.sb.st_mode&S_IFMT);
-		RETURN_STRING("unknown", 1);
+		RETURN_STRING("unknown");
 	case FS_IS_W:
 		RETURN_BOOL((ssb.sb.st_mode & wmask) != 0);
 	case FS_IS_R:
@@ -1012,61 +1012,61 @@ PHPAPI void php_stat(const char *filename, php_stat_len filename_length, int typ
 	case FS_STAT:
 		array_init(return_value);
 
-		MAKE_LONG_ZVAL_INCREF(stat_dev, stat_sb->st_dev);
-		MAKE_LONG_ZVAL_INCREF(stat_ino, stat_sb->st_ino);
-		MAKE_LONG_ZVAL_INCREF(stat_mode, stat_sb->st_mode);
-		MAKE_LONG_ZVAL_INCREF(stat_nlink, stat_sb->st_nlink);
-		MAKE_LONG_ZVAL_INCREF(stat_uid, stat_sb->st_uid);
-		MAKE_LONG_ZVAL_INCREF(stat_gid, stat_sb->st_gid);
+		ZVAL_LONG(&stat_dev, stat_sb->st_dev);
+		ZVAL_LONG(&stat_ino, stat_sb->st_ino);
+		ZVAL_LONG(&stat_mode, stat_sb->st_mode);
+		ZVAL_LONG(&stat_nlink, stat_sb->st_nlink);
+		ZVAL_LONG(&stat_uid, stat_sb->st_uid);
+		ZVAL_LONG(&stat_gid, stat_sb->st_gid);
 #ifdef HAVE_ST_RDEV
-		MAKE_LONG_ZVAL_INCREF(stat_rdev, stat_sb->st_rdev);
+		ZVAL_LONG(&stat_rdev, stat_sb->st_rdev);
 #else
-		MAKE_LONG_ZVAL_INCREF(stat_rdev, -1);
+		ZVAL_LONG(&stat_rdev, -1);
 #endif
-		MAKE_LONG_ZVAL_INCREF(stat_size, stat_sb->st_size);
-		MAKE_LONG_ZVAL_INCREF(stat_atime, stat_sb->st_atime);
-		MAKE_LONG_ZVAL_INCREF(stat_mtime, stat_sb->st_mtime);
-		MAKE_LONG_ZVAL_INCREF(stat_ctime, stat_sb->st_ctime);
+		ZVAL_LONG(&stat_size, stat_sb->st_size);
+		ZVAL_LONG(&stat_atime, stat_sb->st_atime);
+		ZVAL_LONG(&stat_mtime, stat_sb->st_mtime);
+		ZVAL_LONG(&stat_ctime, stat_sb->st_ctime);
 #ifdef HAVE_ST_BLKSIZE
-		MAKE_LONG_ZVAL_INCREF(stat_blksize, stat_sb->st_blksize);
+		ZVAL_LONG(&stat_blksize, stat_sb->st_blksize);
 #else
-		MAKE_LONG_ZVAL_INCREF(stat_blksize,-1);
+		ZVAL_LONG(&stat_blksize,-1);
 #endif
 #ifdef HAVE_ST_BLOCKS
-		MAKE_LONG_ZVAL_INCREF(stat_blocks, stat_sb->st_blocks);
+		ZVAL_LONG(&stat_blocks, stat_sb->st_blocks);
 #else
-		MAKE_LONG_ZVAL_INCREF(stat_blocks,-1);
+		ZVAL_LONG(&stat_blocks,-1);
 #endif
 		/* Store numeric indexes in propper order */
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_dev, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ino, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mode, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_nlink, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_uid, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_gid, sizeof(zval *), NULL);
-
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_rdev, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_size, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_atime, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_mtime, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_ctime, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blksize, sizeof(zval *), NULL);
-		zend_hash_next_index_insert(HASH_OF(return_value), (void *)&stat_blocks, sizeof(zval *), NULL);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_dev);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_ino);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_mode);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_nlink);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_uid);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_gid);
+
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_rdev);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_size);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_atime);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_mtime);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_ctime);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_blksize);
+		zend_hash_next_index_insert(HASH_OF(return_value), &stat_blocks);
 
 		/* Store string indexes referencing the same zval*/
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0])+1, (void *) &stat_dev, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1])+1, (void *) &stat_ino, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2])+1, (void *) &stat_mode, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3])+1, (void *) &stat_nlink, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4])+1, (void *) &stat_uid, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5])+1, (void *) &stat_gid, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6])+1, (void *) &stat_rdev, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7])+1, (void *) &stat_size, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8])+1, (void *) &stat_atime, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9])+1, (void *) &stat_mtime, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10])+1, (void *) &stat_ctime, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11])+1, (void *) &stat_blksize, sizeof(zval *), NULL);
-		zend_hash_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12])+1, (void *) &stat_blocks, sizeof(zval *), NULL);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[0], strlen(stat_sb_names[0]), &stat_dev);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[1], strlen(stat_sb_names[1]), &stat_ino);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[2], strlen(stat_sb_names[2]), &stat_mode);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[3], strlen(stat_sb_names[3]), &stat_nlink);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[4], strlen(stat_sb_names[4]), &stat_uid);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[5], strlen(stat_sb_names[5]), &stat_gid);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[6], strlen(stat_sb_names[6]), &stat_rdev);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[7], strlen(stat_sb_names[7]), &stat_size);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[8], strlen(stat_sb_names[8]), &stat_atime);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[9], strlen(stat_sb_names[9]), &stat_mtime);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[10], strlen(stat_sb_names[10]), &stat_ctime);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[11], strlen(stat_sb_names[11]), &stat_blksize);
+		zend_hash_str_update(HASH_OF(return_value), stat_sb_names[12], strlen(stat_sb_names[12]), &stat_blocks);
 
 		return;
 	}
@@ -1204,26 +1204,26 @@ PHP_FUNCTION(realpath_cache_get)
 	while(buckets < end) {
 		realpath_cache_bucket *bucket = *buckets;
 		while(bucket) {
-			zval *entry;
-			MAKE_STD_ZVAL(entry);
-			array_init(entry);
+			zval entry;
+
+			array_init(&entry);
 
 			/* bucket->key is unsigned long */
 			if (LONG_MAX >= bucket->key) {
-				add_assoc_long(entry, "key", bucket->key);
+				add_assoc_long(&entry, "key", bucket->key);
 			} else {
-				add_assoc_double(entry, "key", (double)bucket->key);
+				add_assoc_double(&entry, "key", (double)bucket->key);
 			}
-			add_assoc_bool(entry, "is_dir", bucket->is_dir);
-			add_assoc_stringl(entry, "realpath", bucket->realpath, bucket->realpath_len, 1);
-			add_assoc_long(entry, "expires", bucket->expires);
+			add_assoc_bool(&entry, "is_dir", bucket->is_dir);
+			add_assoc_stringl(&entry, "realpath", bucket->realpath, bucket->realpath_len);
+			add_assoc_long(&entry, "expires", bucket->expires);
 #ifdef PHP_WIN32
-			add_assoc_bool(entry, "is_rvalid", bucket->is_rvalid);
-			add_assoc_bool(entry, "is_wvalid", bucket->is_wvalid);
-			add_assoc_bool(entry, "is_readable", bucket->is_readable);
-			add_assoc_bool(entry, "is_writable", bucket->is_writable);
+			add_assoc_bool(&entry, "is_rvalid", bucket->is_rvalid);
+			add_assoc_bool(&entry, "is_wvalid", bucket->is_wvalid);
+			add_assoc_bool(&entry, "is_readable", bucket->is_readable);
+			add_assoc_bool(&entry, "is_writable", bucket->is_writable);
 #endif
-			zend_hash_update(Z_ARRVAL_P(return_value), bucket->path, bucket->path_len+1, &entry, sizeof(zval *), NULL);
+			zend_hash_str_update(Z_ARRVAL_P(return_value), bucket->path, bucket->path_len, &entry);
 			bucket = bucket->next;
 		}
 		buckets++;
diff --git a/ext/standard/filters.c b/ext/standard/filters.c
index 39ca68f94a..6897cde094 100644
--- a/ext/standard/filters.c
+++ b/ext/standard/filters.c
@@ -211,7 +211,7 @@ static php_stream_filter_status_t strfilter_strip_tags_filter(
 {
 	php_stream_bucket *bucket;
 	size_t consumed = 0;
-	php_strip_tags_filter *inst = (php_strip_tags_filter *) thisfilter->abstract;
+	php_strip_tags_filter *inst = (php_strip_tags_filter *) Z_PTR(thisfilter->abstract);
 
 	while (buckets_in->head) {
 		bucket = php_stream_bucket_make_writeable(buckets_in->head TSRMLS_CC);
@@ -231,11 +231,11 @@ static php_stream_filter_status_t strfilter_strip_tags_filter(
 
 static void strfilter_strip_tags_dtor(php_stream_filter *thisfilter TSRMLS_DC)
 {
-	assert(thisfilter->abstract != NULL);
+	assert(Z_PTR(thisfilter->abstract) != NULL);
 
-	php_strip_tags_filter_dtor((php_strip_tags_filter *)thisfilter->abstract);
+	php_strip_tags_filter_dtor((php_strip_tags_filter *)Z_PTR(thisfilter->abstract));
 
-	pefree(thisfilter->abstract, ((php_strip_tags_filter *)thisfilter->abstract)->persistent);
+	pefree(Z_PTR(thisfilter->abstract), ((php_strip_tags_filter *)Z_PTR(thisfilter->abstract))->persistent);
 }
 
 static php_stream_filter_ops strfilter_strip_tags_ops = {
@@ -247,7 +247,7 @@ static php_stream_filter_ops strfilter_strip_tags_ops = {
 static php_stream_filter *strfilter_strip_tags_create(const char *filtername, zval *filterparams, int persistent TSRMLS_DC)
 {
 	php_strip_tags_filter *inst;
-	smart_str tags_ss = { 0, 0, 0 };
+	smart_str tags_ss = {0};
 	
 	inst = pemalloc(sizeof(php_strip_tags_filter), persistent);
 
@@ -258,39 +258,29 @@ static php_stream_filter *strfilter_strip_tags_create(const char *filtername, zv
 	
 	if (filterparams != NULL) {
 		if (Z_TYPE_P(filterparams) == IS_ARRAY) {
-			HashPosition pos;
-			zval **tmp;
+			zval *tmp;
 
-			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(filterparams), &pos);
-			while (zend_hash_get_current_data_ex(Z_ARRVAL_P(filterparams), (void **) &tmp, &pos) == SUCCESS) {
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(filterparams), tmp) {
 				convert_to_string_ex(tmp);
 				smart_str_appendc(&tags_ss, '<');
-				smart_str_appendl(&tags_ss, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+				smart_str_appendl(&tags_ss, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
 				smart_str_appendc(&tags_ss, '>');
-				zend_hash_move_forward_ex(Z_ARRVAL_P(filterparams), &pos);
-			}
+			} ZEND_HASH_FOREACH_END();
 			smart_str_0(&tags_ss);
 		} else {
 			/* FIXME: convert_to_* may clutter zvals and lead it into segfault ? */
-			convert_to_string_ex(&filterparams);
-
-			tags_ss.c = Z_STRVAL_P(filterparams);
-			tags_ss.len = Z_STRLEN_P(filterparams);
-			tags_ss.a = 0;
+			convert_to_string_ex(filterparams);
+			smart_str_setl(&tags_ss, Z_STRVAL_P(filterparams), Z_STRLEN_P(filterparams));
 		}
 	}
 
-	if (php_strip_tags_filter_ctor(inst, tags_ss.c, tags_ss.len, persistent) != SUCCESS) {
-		if (tags_ss.a != 0) {
-			STR_FREE(tags_ss.c);
-		}
+	if (php_strip_tags_filter_ctor(inst, tags_ss.s->val, tags_ss.s->len, persistent) != SUCCESS) {
+		smart_str_free(&tags_ss);
 		pefree(inst, persistent);
 		return NULL;
 	}
 
-	if (tags_ss.a != 0) {
-		STR_FREE(tags_ss.c);
-	}
+	smart_str_free(&tags_ss);
 
 	return php_stream_filter_alloc(&strfilter_strip_tags_ops, inst, persistent);
 }
@@ -1220,15 +1210,16 @@ typedef struct _php_convert_filter {
 
 static php_conv_err_t php_conv_get_string_prop_ex(const HashTable *ht, char **pretval, size_t *pretval_len, char *field_name, size_t field_name_len, int persistent)
 {
-	zval **tmpval;
+	zval *tmpval;
 
 	*pretval = NULL;
 	*pretval_len = 0;
  
-	if (zend_hash_find((HashTable *)ht, field_name, field_name_len, (void **)&tmpval) == SUCCESS) {
-		if (Z_TYPE_PP(tmpval) != IS_STRING) {
-			zval zt = **tmpval;
-
+	if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) {
+		if (Z_TYPE_P(tmpval) != IS_STRING) {
+			zval zt;
+			
+			ZVAL_COPY_VALUE(&zt, tmpval);
 			convert_to_string(&zt);
 
 			if (NULL == (*pretval = pemalloc(Z_STRLEN(zt) + 1, persistent))) {
@@ -1239,11 +1230,11 @@ static php_conv_err_t php_conv_get_string_prop_ex(const HashTable *ht, char **pr
 			memcpy(*pretval, Z_STRVAL(zt), Z_STRLEN(zt) + 1);
 			zval_dtor(&zt);
 		} else {
-			if (NULL == (*pretval = pemalloc(Z_STRLEN_PP(tmpval) + 1, persistent))) {
+			if (NULL == (*pretval = pemalloc(Z_STRLEN_P(tmpval) + 1, persistent))) {
 				return PHP_CONV_ERR_ALLOC;
 			}
-			*pretval_len = Z_STRLEN_PP(tmpval);
-			memcpy(*pretval, Z_STRVAL_PP(tmpval), Z_STRLEN_PP(tmpval) + 1);
+			*pretval_len = Z_STRLEN_P(tmpval);
+			memcpy(*pretval, Z_STRVAL_P(tmpval), Z_STRLEN_P(tmpval) + 1);
 		}
 	} else {
 		return PHP_CONV_ERR_NOT_FOUND;
@@ -1277,23 +1268,22 @@ static php_conv_err_t php_conv_get_long_prop_ex(const HashTable *ht, long *pretv
 
 static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, unsigned long *pretval, char *field_name, size_t field_name_len)
 {
-	zval **tmpval;
+	zval *tmpval;
 
 	*pretval = 0;
 
-	if (zend_hash_find((HashTable *)ht, field_name, field_name_len, (void **)&tmpval) == SUCCESS) {
-		zval tmp, *ztval = *tmpval;
+	if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) {
+		zval tmp;
 
-		if (Z_TYPE_PP(tmpval) != IS_LONG) {
-			tmp = *ztval;
-			zval_copy_ctor(&tmp);
+		if (Z_TYPE_P(tmpval) != IS_LONG) {
+			ZVAL_DUP(&tmp, tmpval);;
 			convert_to_long(&tmp);
-			ztval = &tmp;
+			tmpval = &tmp;
 		}
-		if (Z_LVAL_P(ztval) < 0) {
+		if (Z_LVAL_P(tmpval) < 0) {
 			*pretval = 0;
 		} else {
-			*pretval = Z_LVAL_P(ztval);
+			*pretval = Z_LVAL_P(tmpval);
 		}
 	} else {
 		return PHP_CONV_ERR_NOT_FOUND;
@@ -1303,20 +1293,20 @@ static php_conv_err_t php_conv_get_ulong_prop_ex(const HashTable *ht, unsigned l
 
 static php_conv_err_t php_conv_get_bool_prop_ex(const HashTable *ht, int *pretval, char *field_name, size_t field_name_len)
 {
-	zval **tmpval;
+	zval *tmpval;
 
 	*pretval = 0;
 
-	if (zend_hash_find((HashTable *)ht, field_name, field_name_len, (void **)&tmpval) == SUCCESS) {
-		zval tmp, *ztval = *tmpval;
+	if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) {
+		zval tmp;
 
-		if (Z_TYPE_PP(tmpval) != IS_BOOL) {
-			tmp = *ztval;
+		if (Z_TYPE_P(tmpval) != IS_BOOL) {
+			ZVAL_DUP(&tmp, tmpval);
 			zval_copy_ctor(&tmp);
 			convert_to_boolean(&tmp);
-			ztval = &tmp;
+			tmpval = &tmp;
 		}
-		*pretval = Z_BVAL_P(ztval);
+		*pretval = Z_BVAL_P(tmpval);
 	} else {
 		return PHP_CONV_ERR_NOT_FOUND;
 	} 
@@ -1749,7 +1739,7 @@ static php_stream_filter_status_t strfilter_convert_filter(
 {
 	php_stream_bucket *bucket = NULL;
 	size_t consumed = 0;
-	php_convert_filter *inst = (php_convert_filter *)thisfilter->abstract;
+	php_convert_filter *inst = (php_convert_filter *)Z_PTR(thisfilter->abstract);
 
 	while (buckets_in->head != NULL) {
 		bucket = buckets_in->head;
@@ -1788,10 +1778,10 @@ out_failure:
 
 static void strfilter_convert_dtor(php_stream_filter *thisfilter TSRMLS_DC)
 {
-	assert(thisfilter->abstract != NULL);
+	assert(Z_PTR(thisfilter->abstract) != NULL);
 
-	php_convert_filter_dtor((php_convert_filter *)thisfilter->abstract);
-	pefree(thisfilter->abstract, ((php_convert_filter *)thisfilter->abstract)->persistent);
+	php_convert_filter_dtor((php_convert_filter *)Z_PTR(thisfilter->abstract));
+	pefree(Z_PTR(thisfilter->abstract), ((php_convert_filter *)Z_PTR(thisfilter->abstract))->persistent);
 }
 
 static php_stream_filter_ops strfilter_convert_ops = {
@@ -1866,7 +1856,7 @@ static php_stream_filter_status_t consumed_filter_filter(
 	int flags
 	TSRMLS_DC)
 {
-	php_consumed_filter_data *data = (php_consumed_filter_data *)(thisfilter->abstract);
+	php_consumed_filter_data *data = (php_consumed_filter_data *)Z_PTR(thisfilter->abstract);
 	php_stream_bucket *bucket;
 	size_t consumed = 0;
 
@@ -1891,8 +1881,8 @@ static php_stream_filter_status_t consumed_filter_filter(
 
 static void consumed_filter_dtor(php_stream_filter *thisfilter TSRMLS_DC)
 {
-	if (thisfilter && thisfilter->abstract) {
-		php_consumed_filter_data *data = (php_consumed_filter_data*)thisfilter->abstract;
+	if (thisfilter && Z_PTR(thisfilter->abstract)) {
+		php_consumed_filter_data *data = (php_consumed_filter_data*)Z_PTR(thisfilter->abstract);
 		pefree(data, data->persistent);
 	}
 }
@@ -2081,7 +2071,7 @@ static php_stream_filter_status_t php_chunked_filter(
 {
 	php_stream_bucket *bucket;
 	size_t consumed = 0;
-	php_chunked_filter_data *data = (php_chunked_filter_data *) thisfilter->abstract;
+	php_chunked_filter_data *data = (php_chunked_filter_data *) Z_PTR(thisfilter->abstract);
 
 	while (buckets_in->head) {
 		bucket = php_stream_bucket_make_writeable(buckets_in->head TSRMLS_CC);
@@ -2099,8 +2089,8 @@ static php_stream_filter_status_t php_chunked_filter(
 
 static void php_chunked_dtor(php_stream_filter *thisfilter TSRMLS_DC)
 {
-	if (thisfilter && thisfilter->abstract) {
-		php_chunked_filter_data *data = (php_chunked_filter_data *) thisfilter->abstract;
+	if (thisfilter && Z_PTR(thisfilter->abstract)) {
+		php_chunked_filter_data *data = (php_chunked_filter_data *) Z_PTR(thisfilter->abstract);
 		pefree(data, data->persistent);
 	}
 }
diff --git a/ext/standard/formatted_print.c b/ext/standard/formatted_print.c
index 3cd5839313..2942daaad3 100644
--- a/ext/standard/formatted_print.c
+++ b/ext/standard/formatted_print.c
@@ -52,21 +52,20 @@ static char HEXCHARS[] = "0123456789ABCDEF";
 
 /* php_spintf_appendchar() {{{ */
 inline static void
-php_sprintf_appendchar(char **buffer, int *pos, int *size, char add TSRMLS_DC)
+php_sprintf_appendchar(zend_string **buffer, int *pos, char add TSRMLS_DC)
 {
-	if ((*pos + 1) >= *size) {
-		*size <<= 1;
-		PRINTF_DEBUG(("%s(): ereallocing buffer to %d bytes\n", get_active_function_name(TSRMLS_C), *size));
-		*buffer = erealloc(*buffer, *size);
+	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_REALLOC(*buffer, (*buffer)->len << 1, 0);
 	}
 	PRINTF_DEBUG(("sprintf: appending '%c', pos=\n", add, *pos));
-	(*buffer)[(*pos)++] = add;
+	(*buffer)->val[(*pos)++] = add;
 }
 /* }}} */
 
 /* php_spintf_appendstring() {{{ */
 inline static void
-php_sprintf_appendstring(char **buffer, int *pos, int *size, char *add,
+php_sprintf_appendstring(zend_string **buffer, int *pos, char *add,
 						   int min_width, int max_width, char padding,
 						   int alignment, int len, int neg, int expprec, int always_sign)
 {
@@ -83,7 +82,7 @@ php_sprintf_appendstring(char **buffer, int *pos, int *size, char *add,
 	}
 	
 	PRINTF_DEBUG(("sprintf: appendstring(%x, %d, %d, \"%s\", %d, '%c', %d)\n",
-				  *buffer, *pos, *size, add, min_width, padding, alignment));
+				  *buffer, *pos, (*buffer)->len, add, min_width, padding, alignment));
 	m_width = MAX(min_width, copy_len);
 
 	if(m_width > INT_MAX - *pos - 1) {
@@ -92,33 +91,34 @@ php_sprintf_appendstring(char **buffer, int *pos, int *size, char *add,
 
 	req_size = *pos + m_width + 1;
 
-	if (req_size > *size) {
-		while (req_size > *size) {
-			if(*size > INT_MAX/2) {
+	if (!*buffer || req_size > (*buffer)->len) {
+		int size = (*buffer)->len;
+		while (req_size > size) {
+			if (size > INT_MAX/2) {
 				zend_error_noreturn(E_ERROR, "Field width %d is too long", req_size); 
 			}
-			*size <<= 1;
+			size <<= 1;
 		}
-		PRINTF_DEBUG(("sprintf ereallocing buffer to %d bytes\n", *size));
-		*buffer = erealloc(*buffer, *size);
+		PRINTF_DEBUG(("sprintf ereallocing buffer to %d bytes\n", size));
+		*buffer = STR_REALLOC(*buffer, size, 0);
 	}
 	if (alignment == ALIGN_RIGHT) {
 		if ((neg || always_sign) && padding=='0') {
-			(*buffer)[(*pos)++] = (neg) ? '-' : '+';
+			(*buffer)->val[(*pos)++] = (neg) ? '-' : '+';
 			add++;
 			len--;
 			copy_len--;
 		}
 		while (npad-- > 0) {
-			(*buffer)[(*pos)++] = padding;
+			(*buffer)->val[(*pos)++] = padding;
 		}
 	}
 	PRINTF_DEBUG(("sprintf: appending \"%s\"\n", add));
-	memcpy(&(*buffer)[*pos], add, copy_len + 1);
+	memcpy(&(*buffer)->val[*pos], add, copy_len + 1);
 	*pos += copy_len;
 	if (alignment == ALIGN_LEFT) {
 		while (npad--) {
-			(*buffer)[(*pos)++] = padding;
+			(*buffer)->val[(*pos)++] = padding;
 		}
 	}
 }
@@ -126,7 +126,7 @@ php_sprintf_appendstring(char **buffer, int *pos, int *size, char *add,
 
 /* php_spintf_appendint() {{{ */
 inline static void
-php_sprintf_appendint(char **buffer, int *pos, int *size, long number,
+php_sprintf_appendint(zend_string **buffer, int *pos, long number,
 						int width, char padding, int alignment, 
 						int always_sign)
 {
@@ -135,7 +135,7 @@ php_sprintf_appendint(char **buffer, int *pos, int *size, long number,
 	register unsigned int i = NUM_BUF_SIZE - 1, neg = 0;
 
 	PRINTF_DEBUG(("sprintf: appendint(%x, %x, %x, %d, %d, '%c', %d)\n",
-				  *buffer, pos, size, number, width, padding, alignment));
+				  *buffer, pos, &(*buffer)->len, number, width, padding, alignment));
 	if (number < 0) {
 		neg = 1;
 		magn = ((unsigned long) -(number + 1)) + 1;
@@ -162,7 +162,7 @@ php_sprintf_appendint(char **buffer, int *pos, int *size, long number,
 	}
 	PRINTF_DEBUG(("sprintf: appending %d as \"%s\", i=%d\n",
 				  number, &numbuf[i], i));
-	php_sprintf_appendstring(buffer, pos, size, &numbuf[i], width, 0,
+	php_sprintf_appendstring(buffer, pos, &numbuf[i], width, 0,
 							 padding, alignment, (NUM_BUF_SIZE - 1) - i,
 							 neg, 0, always_sign);
 }
@@ -170,7 +170,7 @@ php_sprintf_appendint(char **buffer, int *pos, int *size, long number,
 
 /* php_spintf_appenduint() {{{ */
 inline static void
-php_sprintf_appenduint(char **buffer, int *pos, int *size,
+php_sprintf_appenduint(zend_string **buffer, int *pos,
 					   unsigned long number,
 					   int width, char padding, int alignment)
 {
@@ -179,7 +179,7 @@ php_sprintf_appenduint(char **buffer, int *pos, int *size,
 	register unsigned int i = NUM_BUF_SIZE - 1;
 
 	PRINTF_DEBUG(("sprintf: appenduint(%x, %x, %x, %d, %d, '%c', %d)\n",
-				  *buffer, pos, size, number, width, padding, alignment));
+				  *buffer, pos, &(*buffer)->len, number, width, padding, alignment));
 	magn = (unsigned long) number;
 
 	/* Can't right-pad 0's on integers */
@@ -195,15 +195,15 @@ php_sprintf_appenduint(char **buffer, int *pos, int *size,
 	} while (magn > 0 && i > 0);
 
 	PRINTF_DEBUG(("sprintf: appending %d as \"%s\", i=%d\n", number, &numbuf[i], i));
-	php_sprintf_appendstring(buffer, pos, size, &numbuf[i], width, 0,
+	php_sprintf_appendstring(buffer, pos, &numbuf[i], width, 0,
 							 padding, alignment, (NUM_BUF_SIZE - 1) - i, 0, 0, 0);
 }
 /* }}} */
 
 /* php_spintf_appenddouble() {{{ */
 inline static void
-php_sprintf_appenddouble(char **buffer, int *pos,
-						 int *size, double number,
+php_sprintf_appenddouble(zend_string **buffer, int *pos,
+						 double number,
 						 int width, char padding,
 						 int alignment, int precision,
 						 int adjust, char fmt,
@@ -218,7 +218,7 @@ php_sprintf_appenddouble(char **buffer, int *pos,
 #endif
 
 	PRINTF_DEBUG(("sprintf: appenddouble(%x, %x, %x, %f, %d, '%c', %d, %c)\n",
-				  *buffer, pos, size, number, width, padding, alignment, fmt));
+				  *buffer, pos, &(*buffer)->len, number, width, padding, alignment, fmt));
 	if ((adjust & ADJ_PRECISION) == 0) {
 		precision = FLOAT_PRECISION;
 	} else if (precision > MAX_FLOAT_PRECISION) {
@@ -228,14 +228,14 @@ php_sprintf_appenddouble(char **buffer, int *pos,
 	
 	if (zend_isnan(number)) {
 		is_negative = (number<0);
-		php_sprintf_appendstring(buffer, pos, size, "NaN", 3, 0, padding,
+		php_sprintf_appendstring(buffer, pos, "NaN", 3, 0, padding,
 								 alignment, 3, is_negative, 0, always_sign);
 		return;
 	}
 
 	if (zend_isinf(number)) {
 		is_negative = (number<0);
-		php_sprintf_appendstring(buffer, pos, size, "INF", 3, 0, padding,
+		php_sprintf_appendstring(buffer, pos, "INF", 3, 0, padding,
 								 alignment, 3, is_negative, 0, always_sign);
 		return;
 	}
@@ -286,14 +286,14 @@ php_sprintf_appenddouble(char **buffer, int *pos,
 			break;
 	}
 
-	php_sprintf_appendstring(buffer, pos, size, s, width, 0, padding,
+	php_sprintf_appendstring(buffer, pos, s, width, 0, padding,
 							 alignment, s_len, is_negative, 0, always_sign);
 }
 /* }}} */
 
 /* php_spintf_appendd2n() {{{ */
 inline static void
-php_sprintf_append2n(char **buffer, int *pos, int *size, long number,
+php_sprintf_append2n(zend_string **buffer, int *pos, long number,
 					 int width, char padding, int alignment, int n,
 					 char *chartable, int expprec)
 {
@@ -303,7 +303,7 @@ php_sprintf_append2n(char **buffer, int *pos, int *size, long number,
 	register int andbits = (1 << n) - 1;
 
 	PRINTF_DEBUG(("sprintf: append2n(%x, %x, %x, %d, %d, '%c', %d, %d, %x)\n",
-				  *buffer, pos, size, number, width, padding, alignment, n,
+				  *buffer, pos, &(*buffer)->len, number, width, padding, alignment, n,
 				  chartable));
 	PRINTF_DEBUG(("sprintf: append2n 2^%d andbits=%x\n", n, andbits));
 
@@ -316,7 +316,7 @@ php_sprintf_append2n(char **buffer, int *pos, int *size, long number,
 	}
 	while (num > 0);
 
-	php_sprintf_appendstring(buffer, pos, size, &numbuf[i], width, 0,
+	php_sprintf_appendstring(buffer, pos, &numbuf[i], width, 0,
 							 padding, alignment, (NUM_BUF_SIZE - 1) - i,
 							 0, expprec, 0);
 }
@@ -368,13 +368,15 @@ php_sprintf_getnumber(char *buffer, int *pos)
  *  "X"   integer argument is printed as uppercase hexadecimal
  *
  */
-static char *
-php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC)
+static zend_string *
+php_formatted_print(int param_count, int use_array, int format_offset TSRMLS_DC)
 {
-	zval ***args, **z_format;
+	zval *newargs = NULL;
+	zval *args, *z_format;
 	int argc, size = 240, inpos = 0, outpos = 0, temppos;
 	int alignment, currarg, adjusting, argnum, width, precision;
-	char *format, *result, padding;
+	char *format, padding;
+	zend_string *result;
 	int always_sign;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "+", &args, &argc) == FAILURE) {
@@ -384,50 +386,47 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 	/* verify the number of args */
 	if ((use_array && argc != (2 + format_offset)) 
 			|| (!use_array && argc < (1 + format_offset))) {
-		efree(args);
 		WRONG_PARAM_COUNT_WITH_RETVAL(NULL);
 	}
 	
+	convert_to_string_ex(&args[format_offset]);
 	if (use_array) {
 		int i = 1;
-		zval ***newargs;
-		zval **array;
+		zval *zv;
+		zval *array;
 
-		z_format = args[format_offset];
-		array = args[1 + format_offset];
-		
+		z_format = &args[format_offset];
+		array = &args[1 + format_offset];
 		SEPARATE_ZVAL(array);
 		convert_to_array_ex(array);
 		
-		argc = 1 + zend_hash_num_elements(Z_ARRVAL_PP(array));
-		newargs = (zval ***)safe_emalloc(argc, sizeof(zval *), 0);
-		newargs[0] = z_format;
+		argc = 1 + zend_hash_num_elements(Z_ARRVAL_P(array));
+		newargs = (zval *)safe_emalloc(argc, sizeof(zval), 0);
+		ZVAL_COPY_VALUE(&newargs[0], z_format);
 		
-		for (zend_hash_internal_pointer_reset(Z_ARRVAL_PP(array));
-			 zend_hash_get_current_data(Z_ARRVAL_PP(array), (void **)&newargs[i++]) == SUCCESS;
-			 zend_hash_move_forward(Z_ARRVAL_PP(array)));
-
-		efree(args);
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(array), zv) {
+			ZVAL_COPY_VALUE(&newargs[i], zv);
+			i++;
+		} ZEND_HASH_FOREACH_END();
 		args = newargs;
 		format_offset = 0;
 	}
 	
-	convert_to_string_ex(args[format_offset]);
-	format = Z_STRVAL_PP(args[format_offset]);
-	result = emalloc(size);
+	format = Z_STRVAL(args[format_offset]);
+	result = STR_ALLOC(size, 0);
 
 	currarg = 1;
 
-	while (inpos<Z_STRLEN_PP(args[format_offset])) {
-		int expprec = 0, multiuse = 0;
-		zval *tmp;
+	while (inpos < Z_STRLEN(args[format_offset])) {
+		int expprec = 0;
+		zval tmp;
 
 		PRINTF_DEBUG(("sprintf: format[%d]='%c'\n", inpos, format[inpos]));
 		PRINTF_DEBUG(("sprintf: outpos=%d\n", outpos));
 		if (format[inpos] != '%') {
-			php_sprintf_appendchar(&result, &outpos, &size, format[inpos++] TSRMLS_CC);
+			php_sprintf_appendchar(&result, &outpos, format[inpos++] TSRMLS_CC);
 		} else if (format[inpos + 1] == '%') {
-			php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC);
+			php_sprintf_appendchar(&result, &outpos, '%' TSRMLS_CC);
 			inpos += 2;
 		} else {
 			/* starting a new format specifier, reset variables */
@@ -448,12 +447,13 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 
 					if (argnum <= 0) {
 						efree(result);
-						efree(args);
+						if (newargs) {
+							efree(newargs);
+						}
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument number must be greater than zero");
 						return NULL;
 					}
 
-					multiuse = 1;
 					inpos++;  /* skip the '$' */
 				} else {
 					argnum = currarg++;
@@ -490,8 +490,13 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 					PRINTF_DEBUG(("sprintf: getting width\n"));
 					if ((width = php_sprintf_getnumber(format, &inpos)) < 0) {
 						efree(result);
-						efree(args);
+						if (newargs) {
+							efree(newargs);
+						}
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Width must be greater than zero and less than %d", INT_MAX);
+						if (newargs) {
+							efree(newargs);
+						}
 						return NULL;
 					}
 					adjusting |= ADJ_WIDTH;
@@ -507,8 +512,13 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 					if (isdigit((int)format[inpos])) {
 						if ((precision = php_sprintf_getnumber(format, &inpos)) < 0) {
 							efree(result);
-							efree(args);
+							if (newargs) {
+								efree(newargs);
+							}
 							php_error_docref(NULL TSRMLS_CC, E_WARNING, "Precision must be greater than zero and less than %d", INT_MAX);
+							if (newargs) {
+								efree(newargs);
+							}
 							return NULL;
 						}
 						adjusting |= ADJ_PRECISION;
@@ -527,7 +537,9 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 
 			if (argnum >= argc) {
 				efree(result);
-				efree(args);
+				if (newargs) {
+					efree(newargs);
+				}
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Too few arguments");
 				return NULL;
 			}
@@ -537,51 +549,39 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 			}
 			PRINTF_DEBUG(("sprintf: format character='%c'\n", format[inpos]));
 			/* now we expect to find a type specifier */
-			if (multiuse) {
-				MAKE_STD_ZVAL(tmp);
-				*tmp = **(args[argnum]);
-				INIT_PZVAL(tmp);
-				zval_copy_ctor(tmp);
-			} else {
-				SEPARATE_ZVAL(args[argnum]);
-				tmp = *(args[argnum]);
-			}
+			//???? We don't hold zval** in args anymore
+			//if (multiuse) {
+				ZVAL_DUP(&tmp, &args[argnum]);
+			//} else {
+			//	SEPARATE_ZVAL(&args[argnum]);
+			//	ZVAL_COPY_VALUE(&tmp, &args[argnum]);
+			//}
 
 			switch (format[inpos]) {
 				case 's': {
-					zval *var, var_copy;
-					int use_copy;
-
-					zend_make_printable_zval(tmp, &var_copy, &use_copy);
-					if (use_copy) {
-						var = &var_copy;
-					} else {
-						var = tmp;
-					}
-					php_sprintf_appendstring(&result, &outpos, &size,
-											 Z_STRVAL_P(var),
+					zend_string *str = zval_get_string(&tmp);
+					php_sprintf_appendstring(&result, &outpos,
+											 str->val,
 											 width, precision, padding,
 											 alignment,
-											 Z_STRLEN_P(var),
+											 str->len,
 											 0, expprec, 0);
-					if (use_copy) {
-						zval_dtor(&var_copy);
-					}
+					STR_RELEASE(str);
 					break;
 				}
 
 				case 'd':
-					convert_to_long(tmp);
-					php_sprintf_appendint(&result, &outpos, &size,
-										  Z_LVAL_P(tmp),
+					convert_to_long(&tmp);
+					php_sprintf_appendint(&result, &outpos,
+										  Z_LVAL(tmp),
 										  width, padding, alignment,
 										  always_sign);
 					break;
 
 				case 'u':
-					convert_to_long(tmp);
-					php_sprintf_appenduint(&result, &outpos, &size,
-										  Z_LVAL_P(tmp),
+					convert_to_long(&tmp);
+					php_sprintf_appenduint(&result, &outpos,
+										  Z_LVAL(tmp),
 										  width, padding, alignment);
 					break;
 
@@ -591,9 +591,9 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 				case 'E':
 				case 'f':
 				case 'F':
-					convert_to_double(tmp);
-					php_sprintf_appenddouble(&result, &outpos, &size,
-											 Z_DVAL_P(tmp),
+					convert_to_double(&tmp);
+					php_sprintf_appenddouble(&result, &outpos,
+											 Z_DVAL(tmp),
 											 width, padding, alignment,
 											 precision, adjusting,
 											 format[inpos], always_sign
@@ -601,62 +601,62 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
 					break;
 					
 				case 'c':
-					convert_to_long(tmp);
-					php_sprintf_appendchar(&result, &outpos, &size,
-										(char) Z_LVAL_P(tmp) TSRMLS_CC);
+					convert_to_long(&tmp);
+					php_sprintf_appendchar(&result, &outpos,
+										(char) Z_LVAL(tmp) TSRMLS_CC);
 					break;
 
 				case 'o':
-					convert_to_long(tmp);
-					php_sprintf_append2n(&result, &outpos, &size,
-										 Z_LVAL_P(tmp),
+					convert_to_long(&tmp);
+					php_sprintf_append2n(&result, &outpos,
+										 Z_LVAL(tmp),
 										 width, padding, alignment, 3,
 										 hexchars, expprec);
 					break;
 
 				case 'x':
-					convert_to_long(tmp);
-					php_sprintf_append2n(&result, &outpos, &size,
-										 Z_LVAL_P(tmp),
+					convert_to_long(&tmp);
+					php_sprintf_append2n(&result, &outpos,
+										 Z_LVAL(tmp),
 										 width, padding, alignment, 4,
 										 hexchars, expprec);
 					break;
 
 				case 'X':
-					convert_to_long(tmp);
-					php_sprintf_append2n(&result, &outpos, &size,
-										 Z_LVAL_P(tmp),
+					convert_to_long(&tmp);
+					php_sprintf_append2n(&result, &outpos,
+										 Z_LVAL(tmp),
 										 width, padding, alignment, 4,
 										 HEXCHARS, expprec);
 					break;
 
 				case 'b':
-					convert_to_long(tmp);
-					php_sprintf_append2n(&result, &outpos, &size,
-										 Z_LVAL_P(tmp),
+					convert_to_long(&tmp);
+					php_sprintf_append2n(&result, &outpos,
+										 Z_LVAL(tmp),
 										 width, padding, alignment, 1,
 										 hexchars, expprec);
 					break;
 
 				case '%':
-					php_sprintf_appendchar(&result, &outpos, &size, '%' TSRMLS_CC);
+					php_sprintf_appendchar(&result, &outpos, '%' TSRMLS_CC);
 
 					break;
 				default:
 					break;
 			}
-			if (multiuse) {
-				zval_ptr_dtor(&tmp);
-			}
+			zval_ptr_dtor(&tmp);
 			inpos++;
 		}
 	}
-	
-	efree(args);
-	
+
+	if (newargs) {
+		efree(newargs);
+	}
+
 	/* possibly, we have to make sure we have room for the terminating null? */
-	result[outpos]=0;
-	*len = outpos;	
+	result->val[outpos]=0;
+	result->len = outpos;	
 	return result;
 }
 /* }}} */
@@ -665,13 +665,12 @@ php_formatted_print(int ht, int *len, int use_array, int format_offset TSRMLS_DC
    Return a formatted string */
 PHP_FUNCTION(user_sprintf)
 {
-	char *result;
-	int len;
+	zend_string *result;
 	
-	if ((result=php_formatted_print(ht, &len, 0, 0 TSRMLS_CC))==NULL) {
+	if ((result=php_formatted_print(ZEND_NUM_ARGS(), 0, 0 TSRMLS_CC))==NULL) {
 		RETURN_FALSE;
 	}
-	RETVAL_STRINGL(result, len, 0);
+	RETVAL_STR(result);
 }
 /* }}} */
 
@@ -679,13 +678,12 @@ PHP_FUNCTION(user_sprintf)
    Return a formatted string */
 PHP_FUNCTION(vsprintf)
 {
-	char *result;
-	int len;
+	zend_string *result;
 	
-	if ((result=php_formatted_print(ht, &len, 1, 0 TSRMLS_CC))==NULL) {
+	if ((result=php_formatted_print(ZEND_NUM_ARGS(), 1, 0 TSRMLS_CC))==NULL) {
 		RETURN_FALSE;
 	}
-	RETVAL_STRINGL(result, len, 0);
+	RETVAL_STR(result);
 }
 /* }}} */
 
@@ -693,14 +691,14 @@ PHP_FUNCTION(vsprintf)
    Output a formatted string */
 PHP_FUNCTION(user_printf)
 {
-	char *result;
-	int len, rlen;
+	zend_string *result;
+	int rlen;
 	
-	if ((result=php_formatted_print(ht, &len, 0, 0 TSRMLS_CC))==NULL) {
+	if ((result=php_formatted_print(ZEND_NUM_ARGS(), 0, 0 TSRMLS_CC))==NULL) {
 		RETURN_FALSE;
 	}
-	rlen = PHPWRITE(result, len);
-	efree(result);
+	rlen = PHPWRITE(result->val, result->len);
+	STR_FREE(result);
 	RETURN_LONG(rlen);
 }
 /* }}} */
@@ -709,14 +707,14 @@ PHP_FUNCTION(user_printf)
    Output a formatted string */
 PHP_FUNCTION(vprintf)
 {
-	char *result;
-	int len, rlen;
+	zend_string *result;
+	int rlen;
 	
-	if ((result=php_formatted_print(ht, &len, 1, 0 TSRMLS_CC))==NULL) {
+	if ((result=php_formatted_print(ZEND_NUM_ARGS(), 1, 0 TSRMLS_CC))==NULL) {
 		RETURN_FALSE;
 	}
-	rlen = PHPWRITE(result, len);
-	efree(result);
+	rlen = PHPWRITE(result->val, result->len);
+	STR_FREE(result);
 	RETURN_LONG(rlen);
 }
 /* }}} */
@@ -727,8 +725,7 @@ PHP_FUNCTION(fprintf)
 {
 	php_stream *stream;
 	zval *arg1;
-	char *result;
-	int len;
+	zend_string *result;
 	
 	if (ZEND_NUM_ARGS() < 2) {
 		WRONG_PARAM_COUNT;
@@ -738,17 +735,16 @@ PHP_FUNCTION(fprintf)
 		RETURN_FALSE;
 	}
 	
-	php_stream_from_zval(stream, &arg1);
+	php_stream_from_zval(stream, arg1);
 
-	if ((result=php_formatted_print(ht, &len, 0, 1 TSRMLS_CC))==NULL) {
+	if ((result=php_formatted_print(ZEND_NUM_ARGS(), 0, 1 TSRMLS_CC))==NULL) {
 		RETURN_FALSE;
 	}
 
-	php_stream_write(stream, result, len);
+	php_stream_write(stream, result->val, result->len);
 
-	efree(result);
-
-	RETURN_LONG(len);
+	RETVAL_LONG(result->len);
+	STR_FREE(result);
 }
 /* }}} */
 
@@ -758,8 +754,7 @@ PHP_FUNCTION(vfprintf)
 {
 	php_stream *stream;
 	zval *arg1;
-	char *result;
-	int len;
+	zend_string *result;
 	
 	if (ZEND_NUM_ARGS() != 3) {
 		WRONG_PARAM_COUNT;
@@ -769,17 +764,16 @@ PHP_FUNCTION(vfprintf)
 		RETURN_FALSE;
 	}
 	
-	php_stream_from_zval(stream, &arg1);
+	php_stream_from_zval(stream, arg1);
 
-	if ((result=php_formatted_print(ht, &len, 1, 1 TSRMLS_CC))==NULL) {
+	if ((result=php_formatted_print(ZEND_NUM_ARGS(), 1, 1 TSRMLS_CC))==NULL) {
 		RETURN_FALSE;
 	}
 
-	php_stream_write(stream, result, len);
-
-	efree(result);
+	php_stream_write(stream, result->val, result->len);
 
-	RETURN_LONG(len);
+	RETVAL_LONG(result->len);
+	STR_FREE(result);
 }
 /* }}} */
 
diff --git a/ext/standard/fsock.c b/ext/standard/fsock.c
index d5a554725a..8e164bab38 100644
--- a/ext/standard/fsock.c
+++ b/ext/standard/fsock.c
@@ -68,12 +68,14 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 	tv.tv_usec = conv % 1000000;
 
 	if (zerrno)	{
+		zerrno = Z_REFVAL_P(zerrno);
 		zval_dtor(zerrno);
 		ZVAL_LONG(zerrno, 0);
 	}
 	if (zerrstr) {
+		zerrstr = Z_REFVAL_P(zerrstr);
 		zval_dtor(zerrstr);
-		ZVAL_STRING(zerrstr, "", 1);
+		ZVAL_EMPTY_STRING(zerrstr);
 	}
 
 	stream = php_stream_xport_create(hostname, hostname_len, REPORT_ERRORS,
@@ -98,9 +100,10 @@ static void php_fsockopen_stream(INTERNAL_FUNCTION_PARAMETERS, int persistent)
 		if (zerrstr && errstr) {
 			/* no need to dup; we need to efree buf anyway */
 			zval_dtor(zerrstr);
-			ZVAL_STRING(zerrstr, errstr, 0);
-		}
-		else if (!zerrstr && errstr) {
+			// TODO: avoid reallocation ???
+			ZVAL_STRING(zerrstr, errstr);
+			efree(errstr);
+		} else if (!zerrstr && errstr) {
 			efree(errstr);
 		} 
 
diff --git a/ext/standard/ftp_fopen_wrapper.c b/ext/standard/ftp_fopen_wrapper.c
index df03772c39..31b96fb68c 100644
--- a/ext/standard/ftp_fopen_wrapper.c
+++ b/ext/standard/ftp_fopen_wrapper.c
@@ -423,7 +423,7 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa
 	int result = 0, use_ssl, use_ssl_on_data=0;
 	php_stream *reuseid=NULL;
 	size_t file_size = 0;
-	zval **tmpzval;
+	zval *tmpzval;
 	int allow_overwrite = 0;
 	int read_write = 0;
 	char *transport;
@@ -452,7 +452,7 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa
 	}
 
 	if (context &&
-		php_stream_context_get_option(context, "ftp", "proxy", &tmpzval) == SUCCESS) {
+		(tmpzval = php_stream_context_get_option(context, "ftp", "proxy")) != NULL) {
 		if (read_write == 1) {
 			/* Use http wrapper to proxy ftp request */
 			return php_stream_url_wrap_http(wrapper, path, mode, options, opened_path, context STREAMS_CC TSRMLS_CC);
@@ -497,8 +497,8 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa
 		}	
 	} else if (read_write == 2) {
 		/* when writing file (but not appending), it must NOT exist, unless a context option exists which allows it */
-		if (context && php_stream_context_get_option(context, "ftp", "overwrite", &tmpzval) == SUCCESS) {
-			allow_overwrite = Z_LVAL_PP(tmpzval);
+		if (context && (tmpzval = php_stream_context_get_option(context, "ftp", "overwrite")) != NULL) {
+			allow_overwrite = Z_LVAL_P(tmpzval);
 		}
 		if (result <= 299 && result >= 200) {
 			if (allow_overwrite) {
@@ -528,13 +528,13 @@ php_stream * php_stream_url_wrap_ftp(php_stream_wrapper *wrapper, const char *pa
 	if (read_write == 1) {
 		/* set resume position if applicable */
 		if (context &&
-			php_stream_context_get_option(context, "ftp", "resume_pos", &tmpzval) == SUCCESS &&
-			Z_TYPE_PP(tmpzval) == IS_LONG &&
-			Z_LVAL_PP(tmpzval) > 0) {
-			php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_LVAL_PP(tmpzval));
+			(tmpzval = php_stream_context_get_option(context, "ftp", "resume_pos")) != NULL &&
+			Z_TYPE_P(tmpzval) == IS_LONG &&
+			Z_LVAL_P(tmpzval) > 0) {
+			php_stream_printf(stream TSRMLS_CC, "REST %ld\r\n", Z_LVAL_P(tmpzval));
 			result = GET_FTP_RESULT(stream);
 			if (result < 300 || result > 399) {			
-				php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_LVAL_PP(tmpzval));
+				php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Unable to resume from offset %ld", Z_LVAL_P(tmpzval));
 				goto errexit;
 			}
 		}
@@ -611,8 +611,7 @@ static size_t php_ftp_dirstream_read(php_stream *stream, char *buf, size_t count
 	php_stream_dirent *ent = (php_stream_dirent *)buf;
 	php_stream *innerstream;
 	size_t tmp_len;
-	char *basename;
-	size_t basename_len;
+	zend_string *basename;
 
 	innerstream =  ((php_ftp_dirstream_data *)stream->abstract)->datastream;
 
@@ -628,20 +627,12 @@ static size_t php_ftp_dirstream_read(php_stream *stream, char *buf, size_t count
 		return 0;
 	}
 
-	php_basename(ent->d_name, tmp_len, NULL, 0, &basename, &basename_len TSRMLS_CC);
-	if (!basename) {
-		return 0;
-	}
-
-	if (!basename_len) {
-		efree(basename);
-		return 0;
-	}
+	basename = php_basename(ent->d_name, tmp_len, NULL, 0 TSRMLS_CC);
 
-	tmp_len = MIN(sizeof(ent->d_name), basename_len - 1);
-	memcpy(ent->d_name, basename, tmp_len);
+	tmp_len = MIN(sizeof(ent->d_name), basename->len - 1);
+	memcpy(ent->d_name, basename->val, tmp_len);
 	ent->d_name[tmp_len - 1] = '\0';
-	efree(basename);
+	STR_RELEASE(basename);
 
 	/* Trim off trailing whitespace characters */
 	tmp_len--;
diff --git a/ext/standard/head.c b/ext/standard/head.c
index eca032a97b..30846215f8 100644
--- a/ext/standard/head.c
+++ b/ext/standard/head.c
@@ -75,11 +75,12 @@ PHPAPI int php_header(TSRMLS_D)
 
 PHPAPI int php_setcookie(char *name, int name_len, char *value, int value_len, time_t expires, char *path, int path_len, char *domain, int domain_len, int secure, int url_encode, int httponly TSRMLS_DC)
 {
-	char *cookie, *encoded_value = NULL;
+	char *cookie;
 	int len=sizeof("Set-Cookie: ");
-	char *dt;
+	zend_string *dt;
 	sapi_header_line ctr = {0};
 	int result;
+	zend_string *encoded_value = NULL;
 
 	if (name && strpbrk(name, "=,; \t\r\n\013\014") != NULL) {   /* man isspace for \013 and \014 */
 		zend_error( E_WARNING, "Cookie names cannot contain any of the following '=,; \\t\\r\\n\\013\\014'" );
@@ -93,14 +94,13 @@ PHPAPI int php_setcookie(char *name, int name_len, char *value, int value_len, t
 
 	len += name_len;
 	if (value && url_encode) {
-		int encoded_value_len;
-
-		encoded_value = php_url_encode(value, value_len, &encoded_value_len);
-		len += encoded_value_len;
-	} else if ( value ) {
-		encoded_value = estrdup(value);
-		len += value_len;
+		encoded_value = php_url_encode(value, value_len);
+		len += encoded_value->len;
+	} else if (value) {
+		encoded_value = STR_INIT(value, value_len, 0);
+		len += encoded_value->len;
 	}
+
 	if (path) {
 		len += path_len;
 	}
@@ -117,26 +117,26 @@ PHPAPI int php_setcookie(char *name, int name_len, char *value, int value_len, t
 		 * pick an expiry date in the past
 		 */
 		dt = php_format_date("D, d-M-Y H:i:s T", sizeof("D, d-M-Y H:i:s T")-1, 1, 0 TSRMLS_CC);
-		snprintf(cookie, len + 100, "Set-Cookie: %s=deleted; expires=%s; Max-Age=0", name, dt);
-		efree(dt);
+		snprintf(cookie, len + 100, "Set-Cookie: %s=deleted; expires=%s; Max-Age=0", name, dt->val);
+		STR_FREE(dt);
 	} else {
-		snprintf(cookie, len + 100, "Set-Cookie: %s=%s", name, value ? encoded_value : "");
+		snprintf(cookie, len + 100, "Set-Cookie: %s=%s", name, value ? encoded_value->val : "");
 		if (expires > 0) {
 			const char *p;
 			char tsdelta[13];
 			strlcat(cookie, "; expires=", len + 100);
 			dt = php_format_date("D, d-M-Y H:i:s T", sizeof("D, d-M-Y H:i:s T")-1, expires, 0 TSRMLS_CC);
 			/* check to make sure that the year does not exceed 4 digits in length */
-			p = zend_memrchr(dt, '-', strlen(dt));
+			p = zend_memrchr(dt->val, '-', dt->len);
 			if (!p || *(p + 5) != ' ') {
-				efree(dt);
+				STR_FREE(dt);
 				efree(cookie);
-				efree(encoded_value);
+				STR_FREE(encoded_value);
 				zend_error(E_WARNING, "Expiry date cannot have a year greater than 9999");
 				return FAILURE;
 			}
-			strlcat(cookie, dt, len + 100);
-			efree(dt);
+			strlcat(cookie, dt->val, len + 100);
+			STR_FREE(dt);
 
 			snprintf(tsdelta, sizeof(tsdelta), "%li", (long) difftime(expires, time(NULL)));
 			strlcat(cookie, "; Max-Age=", len + 100);
@@ -145,7 +145,7 @@ PHPAPI int php_setcookie(char *name, int name_len, char *value, int value_len, t
 	}
 
 	if (encoded_value) {
-		efree(encoded_value);
+		STR_FREE(encoded_value);
 	}
 
 	if (path && path_len > 0) {
@@ -243,9 +243,9 @@ PHP_FUNCTION(headers_sent)
 	case 1:
 		zval_dtor(arg1);
 		if (file) {
-			ZVAL_STRING(arg1, file, 1);
+			ZVAL_STRING(arg1, file);
 		} else {
-			ZVAL_STRING(arg1, "", 1);
+			ZVAL_EMPTY_STRING(arg1);
 		}
 		break;
 	}
@@ -265,7 +265,7 @@ static void php_head_apply_header_list_to_hash(void *data, void *arg TSRMLS_DC)
 	sapi_header_struct *sapi_header = (sapi_header_struct *)data;
 
 	if (arg && sapi_header) {
-		add_next_index_string((zval *)arg, (char *)(sapi_header->header), 1);
+		add_next_index_string((zval *)arg, (char *)(sapi_header->header));
 	}
 }
 
diff --git a/ext/standard/html.c b/ext/standard/html.c
index 5bbe39ccbb..4b605e145c 100644
--- a/ext/standard/html.c
+++ b/ext/standard/html.c
@@ -936,8 +936,7 @@ static inline size_t write_octet_sequence(unsigned char *buf, enum entity_charse
 static void traverse_for_entities(
 	const char *old,
 	size_t oldlen,
-	char *ret, /* should have allocated TRAVERSE_FOR_ENTITIES_EXPAND_SIZE(olden) */
-	size_t *retlen,
+	zend_string *ret, /* should have allocated TRAVERSE_FOR_ENTITIES_EXPAND_SIZE(olden) */
 	int all,
 	int flags,
 	const entity_ht *inv_map,
@@ -951,7 +950,7 @@ static void traverse_for_entities(
 	lim = old + oldlen; /* terminator address */
 	assert(*lim == '\0');
 
-	for (p = old, q = ret; p < lim;) {
+	for (p = old, q = ret->val; p < lim;) {
 		unsigned code, code2 = 0;
 		const char *next = NULL; /* when set, next > p, otherwise possible inf loop */
 
@@ -1024,9 +1023,9 @@ static void traverse_for_entities(
 				goto invalid_code; /* not representable in target charset */
 		}
 
-		q += write_octet_sequence(q, charset, code);
+		q += write_octet_sequence((unsigned char*)q, charset, code);
 		if (code2) {
-			q += write_octet_sequence(q, charset, code2);
+			q += write_octet_sequence((unsigned char*)q, charset, code2);
 		}
 
 		/* jump over the valid entity; may go beyond size of buffer; np */
@@ -1040,7 +1039,7 @@ invalid_code:
 	}
 	
 	*q = '\0';
-	*retlen = (size_t)(q - ret);
+	ret->len = (size_t)(q - ret->val);
 }
 /* }}} */
 
@@ -1095,10 +1094,10 @@ static entity_table_opt determine_entity_table(int all, int doctype)
  * only the basic ones, i.e., those in basic_entities_ex + the numeric entities
  * that correspond to quotes.
  */
-PHPAPI char *php_unescape_html_entities(unsigned char *old, size_t oldlen, size_t *newlen, int all, int flags, char *hint_charset TSRMLS_DC)
+PHPAPI zend_string *php_unescape_html_entities(unsigned char *old, size_t oldlen, int all, int flags, char *hint_charset TSRMLS_DC)
 {
 	size_t retlen;
-	char *ret;
+	zend_string *ret;
 	enum entity_charset charset;
 	const entity_ht *inverse_map = NULL;
 	size_t new_size = TRAVERSE_FOR_ENTITIES_EXPAND_SIZE(oldlen);
@@ -1113,12 +1112,13 @@ PHPAPI char *php_unescape_html_entities(unsigned char *old, size_t oldlen, size_
 
 	if (oldlen > new_size) {
 		/* overflow, refuse to do anything */
-		ret = estrndup((char*)old, oldlen);
+		ret = STR_INIT((char*)old, oldlen, 0);
 		retlen = oldlen;
 		goto empty_source;
 	}
-	ret = emalloc(new_size);
-	*ret = '\0';
+	ret = STR_ALLOC(new_size, 0);
+	ret->val[0] = '\0';
+	ret->len = oldlen;
 	retlen = oldlen;
 	if (retlen == 0) {
 		goto empty_source;
@@ -1127,17 +1127,16 @@ PHPAPI char *php_unescape_html_entities(unsigned char *old, size_t oldlen, size_
 	inverse_map = unescape_inverse_map(all, flags);
 	
 	/* replace numeric entities */
-	traverse_for_entities(old, oldlen, ret, &retlen, all, flags, inverse_map, charset);
+	traverse_for_entities((char*)old, oldlen, ret, all, flags, inverse_map, charset);
 
 empty_source:	
-	*newlen = retlen;
 	return ret;
 }
 /* }}} */
 
-PHPAPI char *php_escape_html_entities(unsigned char *old, size_t oldlen, size_t *newlen, int all, int flags, char *hint_charset TSRMLS_DC)
+PHPAPI zend_string *php_escape_html_entities(unsigned char *old, size_t oldlen, int all, int flags, char *hint_charset TSRMLS_DC)
 {
-	return php_escape_html_entities_ex(old, oldlen, newlen, all, flags, hint_charset, 1 TSRMLS_CC);
+	return php_escape_html_entities_ex(old, oldlen, all, flags, hint_charset, 1 TSRMLS_CC);
 }
 
 /* {{{ find_entity_for_char */
@@ -1223,10 +1222,10 @@ static inline void find_entity_for_char_basic(
 
 /* {{{ php_escape_html_entities
  */
-PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size_t *newlen, int all, int flags, char *hint_charset, zend_bool double_encode TSRMLS_DC)
+PHPAPI zend_string *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, int all, int flags, char *hint_charset, zend_bool double_encode TSRMLS_DC)
 {
 	size_t cursor, maxlen, len;
-	char *replaced;
+	zend_string *replaced;
 	enum entity_charset charset = determine_charset(hint_charset TSRMLS_CC);
 	int doctype = flags & ENT_HTML_DOC_TYPE_MASK;
 	entity_table_opt entity_table;
@@ -1276,7 +1275,7 @@ PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size
 		}
 	}
 
-	replaced = emalloc(maxlen + 1); /* adding 1 is safe: maxlen is even */
+	replaced = STR_ALLOC(maxlen, 0);
 	len = 0;
 	cursor = 0;
 	while (cursor < oldlen) {
@@ -1289,7 +1288,7 @@ PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size
 		/* guarantee we have at least 40 bytes to write.
 		 * 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_SAFE_REALLOC(replaced, maxlen, 1, 128, 0);
 			maxlen += 128;
 		}
 
@@ -1298,12 +1297,11 @@ PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size
 			if (flags & ENT_HTML_IGNORE_ERRORS) {
 				continue;
 			} else if (flags & ENT_HTML_SUBSTITUTE_ERRORS) {
-				memcpy(&replaced[len], replacement, replacement_len);
+				memcpy(&replaced->val[len], replacement, replacement_len);
 				len += replacement_len;
 				continue;
 			} else {
-				efree(replaced);
-				*newlen = 0;
+				STR_FREE(replaced);
 				return STR_EMPTY_ALLOC();
 			}
 		} else { /* SUCCESS */
@@ -1336,10 +1334,10 @@ PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size
 			}
 
 			if (rep != NULL) {
-				replaced[len++] = '&';
-				memcpy(&replaced[len], rep, rep_len);
+				replaced->val[len++] = '&';
+				memcpy(&replaced->val[len], rep, rep_len);
 				len += rep_len;
-				replaced[len++] = ';';
+				replaced->val[len++] = ';';
 			} else {
 				/* we did not find an entity for this char.
 				 * check for its validity, if its valid pass it unchanged */
@@ -1373,16 +1371,16 @@ PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size
 				}
 pass_char_through:
 				if (mbseqlen > 1) {
-					memcpy(replaced + len, mbsequence, mbseqlen);
+					memcpy(replaced->val + len, mbsequence, mbseqlen);
 					len += mbseqlen;
 				} else {
-					replaced[len++] = mbsequence[0];
+					replaced->val[len++] = mbsequence[0];
 				}
 			}
 		} else { /* this_char == '&' */
 			if (double_encode) {
 encode_amp:
-				memcpy(&replaced[len], "&amp;", sizeof("&amp;") - 1);
+				memcpy(&replaced->val[len], "&amp;", sizeof("&amp;") - 1);
 				len += sizeof("&amp;") - 1;
 			} else { /* no double encode */
 				/* check if entity is valid */
@@ -1422,19 +1420,19 @@ encode_amp:
 				/* at this point maxlen - len >= 40 */
 				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_SAFE_REALLOC(replaced, maxlen, 1, ent_len + 128, 0);
 					maxlen += ent_len + 128;
 				}
-				replaced[len++] = '&';
-				memcpy(&replaced[len], &old[cursor], ent_len);
+				replaced->val[len++] = '&';
+				memcpy(&replaced->val[len], &old[cursor], ent_len);
 				len += ent_len;
-				replaced[len++] = ';';
+				replaced->val[len++] = ';';
 				cursor += ent_len + 1;
 			}
 		}
 	}
-	replaced[len] = '\0';
-	*newlen = len;
+	replaced->val[len] = '\0';
+	replaced->len = len;
 
 	return replaced;
 }
@@ -1446,9 +1444,8 @@ static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all)
 {
 	char *str, *hint_charset = NULL;
 	int str_len, hint_charset_len = 0;
-	size_t new_len;
 	long flags = ENT_COMPAT;
-	char *replaced;
+	zend_string *replaced;
 	zend_bool double_encode = 1;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls!b", &str, &str_len, &flags, &hint_charset, &hint_charset_len, &double_encode) == FAILURE) {
@@ -1458,9 +1455,8 @@ static void php_html_entities(INTERNAL_FUNCTION_PARAMETERS, int all)
 	if (!hint_charset) {
 		hint_charset = get_default_charset(TSRMLS_C);
 	}
-	replaced = php_escape_html_entities_ex(str, str_len, &new_len, all, (int) flags, hint_charset, double_encode TSRMLS_CC);
-
-	RETVAL_STRINGL(replaced, (int)new_len, 0);
+	replaced = php_escape_html_entities_ex((unsigned char*)str, str_len, all, (int) flags, hint_charset, double_encode TSRMLS_CC);
+	RETVAL_STR(replaced);
 }
 /* }}} */
 
@@ -1500,17 +1496,16 @@ PHP_FUNCTION(htmlspecialchars_decode)
 {
 	char *str;
 	int str_len;
-	size_t new_len = 0;
 	long quote_style = ENT_COMPAT;
-	char *replaced;
+	zend_string *replaced;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &quote_style) == FAILURE) {
 		return;
 	}
 
-	replaced = php_unescape_html_entities(str, str_len, &new_len, 0 /*!all*/, quote_style, NULL TSRMLS_CC);
+	replaced = php_unescape_html_entities((unsigned char*)str, str_len, 0 /*!all*/, quote_style, NULL TSRMLS_CC);
 	if (replaced) {
-		RETURN_STRINGL(replaced, (int)new_len, 0);
+		RETURN_STR(replaced);
 	}
 	RETURN_FALSE;
 }
@@ -1521,10 +1516,10 @@ PHP_FUNCTION(htmlspecialchars_decode)
 PHP_FUNCTION(html_entity_decode)
 {
 	char *str, *hint_charset = NULL;
-	int str_len, hint_charset_len;
+	int str_len, hint_charset_len = 0;
 	size_t new_len = 0;
 	long quote_style = ENT_COMPAT;
-	char *replaced;
+	zend_string *replaced;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls", &str, &str_len,
 							  &quote_style, &hint_charset, &hint_charset_len) == FAILURE) {
@@ -1534,10 +1529,10 @@ PHP_FUNCTION(html_entity_decode)
 	if (!hint_charset) {
 		hint_charset = get_default_charset(TSRMLS_C);
 	}
-	replaced = php_unescape_html_entities(str, str_len, &new_len, 1 /*all*/, quote_style, hint_charset TSRMLS_CC);
+	replaced = php_unescape_html_entities((unsigned char*)str, str_len, 1 /*all*/, quote_style, hint_charset TSRMLS_CC);
 
 	if (replaced) {
-		RETURN_STRINGL(replaced, (int)new_len, 0);
+		RETURN_STR(replaced);
 	}
 	RETURN_FALSE;
 }
@@ -1563,13 +1558,13 @@ static inline void write_s3row_data(
 	char entity[LONGEST_ENTITY_LENGTH + 2] = {'&'};
 	size_t written_k1;
 
-	written_k1 = write_octet_sequence(key, charset, orig_cp);
+	written_k1 = write_octet_sequence((unsigned char*)key, charset, orig_cp);
 
 	if (!r->ambiguous) {
 		size_t l = r->data.ent.entity_len;
 		memcpy(&entity[1], r->data.ent.entity, l);
 		entity[l + 1] = ';';
-		add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
+		add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2);
 	} else {
 		unsigned i,
 			     num_entries;
@@ -1579,7 +1574,7 @@ static inline void write_s3row_data(
 			size_t l = mcpr[0].leading_entry.default_entity_len;
 			memcpy(&entity[1], mcpr[0].leading_entry.default_entity, l);
 			entity[l + 1] = ';';
-			add_assoc_stringl_ex(arr, key, written_k1 + 1, entity, l + 2, 1);
+			add_assoc_stringl_ex(arr, key, written_k1, entity, l + 2);
 		}
 		num_entries = mcpr[0].leading_entry.size;
 		for (i = 1; i <= num_entries; i++) {
@@ -1598,11 +1593,11 @@ static inline void write_s3row_data(
 				spe_cp = uni_cp;
 			}
 			
-			written_k2 = write_octet_sequence(&key[written_k1], charset, spe_cp);
+			written_k2 = write_octet_sequence((unsigned char*)&key[written_k1], charset, spe_cp);
 			memcpy(&entity[1], mcpr[i].normal_entry.entity, l);
 			entity[l + 1] = ';';
 			entity[l + 1] = '\0';
-			add_assoc_stringl_ex(arr, key, written_k1 + written_k2 + 1, entity, l + 1, 1);
+			add_assoc_stringl_ex(arr, key, written_k1 + written_k2, entity, l + 1);
 		}
 	}
 }
diff --git a/ext/standard/html.h b/ext/standard/html.h
index b3da83f307..0777130e0f 100644
--- a/ext/standard/html.h
+++ b/ext/standard/html.h
@@ -54,9 +54,9 @@ PHP_FUNCTION(htmlspecialchars_decode);
 PHP_FUNCTION(html_entity_decode);
 PHP_FUNCTION(get_html_translation_table);
 
-PHPAPI char *php_escape_html_entities(unsigned char *old, size_t oldlen, size_t *newlen, int all, int flags, char *hint_charset TSRMLS_DC);
-PHPAPI char *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, size_t *newlen, int all, int flags, char *hint_charset, zend_bool double_encode TSRMLS_DC);
-PHPAPI char *php_unescape_html_entities(unsigned char *old, size_t oldlen, size_t *newlen, int all, int flags, char *hint_charset TSRMLS_DC);
+PHPAPI zend_string *php_escape_html_entities(unsigned char *old, size_t oldlen, int all, int flags, char *hint_charset TSRMLS_DC);
+PHPAPI zend_string *php_escape_html_entities_ex(unsigned char *old, size_t oldlen, int all, int flags, char *hint_charset, zend_bool double_encode TSRMLS_DC);
+PHPAPI zend_string *php_unescape_html_entities(unsigned char *old, size_t oldlen, int all, int flags, char *hint_charset TSRMLS_DC);
 PHPAPI unsigned int php_next_utf8_char(const unsigned char *str, size_t str_len, size_t *cursor, int *status);
 
 #endif /* HTML_H */
diff --git a/ext/standard/http.c b/ext/standard/http.c
index 2b1c1390bd..fbda5ccc9e 100644
--- a/ext/standard/http.c
+++ b/ext/standard/http.c
@@ -31,18 +31,18 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 				const char *key_suffix, int key_suffix_len,
 			  zval *type, char *arg_sep, int enc_type TSRMLS_DC)
 {
-	char *key = NULL;
-	char *ekey, *newprefix, *p;
-	int arg_sep_len, ekey_len, key_type, newprefix_len;
-	uint key_len;
+	zend_string *key = NULL;
+	char *newprefix, *p;
+	const char *prop_name;
+	int arg_sep_len, newprefix_len, prop_len;
 	ulong idx;
-	zval **zdata = NULL, *copyzval;
+	zval *zdata = NULL, copyzval;
 
 	if (!ht) {
 		return FAILURE;
 	}
 
-	if (ht->nApplyCount > 0) {
+	if (ht->u.v.nApplyCount > 0) {
 		/* Prevent recursion */
 		return SUCCESS;
 	}
@@ -55,39 +55,36 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 	}
 	arg_sep_len = strlen(arg_sep);
 
-	for (zend_hash_internal_pointer_reset(ht);
-		(key_type = zend_hash_get_current_key_ex(ht, &key, &key_len, &idx, 0, NULL)) != HASH_KEY_NON_EXISTENT;
-		zend_hash_move_forward(ht)
-	) {
-		if (key_type == HASH_KEY_IS_STRING && key_len && key[key_len-1] == '\0') {
-			/* We don't want that trailing NULL */
-			key_len -= 1;
-		}
-
+	ZEND_HASH_FOREACH_KEY_VAL_IND(ht, idx, key, zdata) {
 		/* handling for private & protected object properties */
-		if (key && *key == '\0' && type != NULL) {
-			const char *tmp;
+		if (key) {
+			if (key->val[0] == '\0' && type != NULL) {
+				const char *tmp;
 
-			zend_object *zobj = zend_objects_get_address(type TSRMLS_CC);
-			if (zend_check_property_access(zobj, key, key_len TSRMLS_CC) != SUCCESS) {
-				/* private or protected property access outside of the class */
-				continue;
+				zend_object *zobj = Z_OBJ_P(type);
+				if (zend_check_property_access(zobj, key TSRMLS_CC) != SUCCESS) {
+					/* private or protected property access outside of the class */
+					continue;
+				}
+				zend_unmangle_property_name_ex(key->val, key->len, &tmp, &prop_name, &prop_len);
+			} else {
+				prop_name = key->val;
+				prop_len = key->len;
 			}
-			zend_unmangle_property_name_ex(key, key_len, &tmp, (const char**)&key, &key_len);
+		} else {
+			prop_name = NULL;
+			prop_len = 0;
 		}
 
-		if (zend_hash_get_current_data_ex(ht, (void **)&zdata, NULL) == FAILURE || !zdata || !(*zdata)) {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Error traversing form data array");
-			return FAILURE;
-		}
-		if (Z_TYPE_PP(zdata) == IS_ARRAY || Z_TYPE_PP(zdata) == IS_OBJECT) {
-			if (key_type == HASH_KEY_IS_STRING) {
+		if (Z_TYPE_P(zdata) == IS_ARRAY || Z_TYPE_P(zdata) == IS_OBJECT) {
+			if (key) {
+				zend_string *ekey;
 				if (enc_type == PHP_QUERY_RFC3986) {
-					ekey = php_raw_url_encode(key, key_len, &ekey_len);
+					ekey = php_raw_url_encode(prop_name, prop_len);
 				} else {
-					ekey = php_url_encode(key, key_len, &ekey_len);
+					ekey = php_url_encode(prop_name, prop_len);
 				}
-				newprefix_len = key_suffix_len + ekey_len + key_prefix_len + 3 /* %5B */;
+				newprefix_len = key_suffix_len + ekey->len + key_prefix_len + 3 /* %5B */;
 				newprefix = emalloc(newprefix_len + 1);
 				p = newprefix;
 
@@ -96,9 +93,9 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 					p += key_prefix_len;
 				}
 
-				memcpy(p, ekey, ekey_len);
-				p += ekey_len;
-				efree(ekey);
+				memcpy(p, ekey->val, ekey->len);
+				p += ekey->len;
+				STR_FREE(ekey);
 
 				if (key_suffix) {
 					memcpy(p, key_suffix, key_suffix_len);
@@ -109,6 +106,8 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 				*(p++) = 'B';
 				*p = '\0';
 			} else {
+				char *ekey;
+				int ekey_len;
 				/* Is an integer key */
 				ekey_len = spprintf(&ekey, 0, "%ld", idx);
 				newprefix_len = key_prefix_len + num_prefix_len + ekey_len + key_suffix_len + 3 /* %5B */;
@@ -136,28 +135,31 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 				*(p++) = 'B';
 				*p = '\0';
 			}
-			ht->nApplyCount++;
-			php_url_encode_hash_ex(HASH_OF(*zdata), formstr, NULL, 0, newprefix, newprefix_len, "%5D", 3, (Z_TYPE_PP(zdata) == IS_OBJECT ? *zdata : NULL), arg_sep, enc_type TSRMLS_CC);
-			ht->nApplyCount--;
+			ht->u.v.nApplyCount++;
+			php_url_encode_hash_ex(HASH_OF(zdata), formstr, NULL, 0, newprefix, newprefix_len, "%5D", 3, (Z_TYPE_P(zdata) == IS_OBJECT ? zdata : NULL), arg_sep, enc_type TSRMLS_CC);
+			ht->u.v.nApplyCount--;
 			efree(newprefix);
-		} else if (Z_TYPE_PP(zdata) == IS_NULL || Z_TYPE_PP(zdata) == IS_RESOURCE) {
+		} else if (Z_TYPE_P(zdata) == IS_NULL || Z_TYPE_P(zdata) == IS_RESOURCE) {
 			/* Skip these types */
 			continue;
 		} else {
-			if (formstr->len) {
+			if (formstr->s) {
 				smart_str_appendl(formstr, arg_sep, arg_sep_len);
 			}
 			/* Simple key=value */
 			smart_str_appendl(formstr, key_prefix, key_prefix_len);
-			if (key_type == HASH_KEY_IS_STRING) {
+			if (key) {
+				zend_string *ekey;
 				if (enc_type == PHP_QUERY_RFC3986) {
-					ekey = php_raw_url_encode(key, key_len, &ekey_len);
+					ekey = php_raw_url_encode(prop_name, prop_len);
 				} else {
-					ekey = php_url_encode(key, key_len, &ekey_len);
+					ekey = php_url_encode(prop_name, prop_len);
 				}
-				smart_str_appendl(formstr, ekey, ekey_len);
-				efree(ekey);
+				smart_str_appendl(formstr, ekey->val, ekey->len);
+				STR_FREE(ekey);
 			} else {
+				char *ekey;
+				int ekey_len;
 				/* Numeric key */
 				if (num_prefix) {
 					smart_str_appendl(formstr, num_prefix, num_prefix_len);
@@ -168,38 +170,55 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
 			}
 			smart_str_appendl(formstr, key_suffix, key_suffix_len);
 			smart_str_appendl(formstr, "=", 1);
-			switch (Z_TYPE_PP(zdata)) {
-				case IS_STRING:
-					if (enc_type == PHP_QUERY_RFC3986) {
-						ekey = php_raw_url_encode(Z_STRVAL_PP(zdata), Z_STRLEN_PP(zdata), &ekey_len);
-					} else {
-						ekey = php_url_encode(Z_STRVAL_PP(zdata), Z_STRLEN_PP(zdata), &ekey_len);						
+			switch (Z_TYPE_P(zdata)) {
+				case IS_STRING: {
+						zend_string *ekey;
+						if (enc_type == PHP_QUERY_RFC3986) {
+							ekey = php_raw_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata));
+						} else {
+							ekey = php_url_encode(Z_STRVAL_P(zdata), Z_STRLEN_P(zdata));						
+						}
+						smart_str_appendl(formstr, ekey->val, ekey->len);
+						STR_FREE(ekey);
 					}
 					break;
 				case IS_LONG:
 				case IS_BOOL:
-					ekey_len = spprintf(&ekey, 0, "%ld", Z_LVAL_PP(zdata));
+					{
+						char *ekey;
+					  	int ekey_len;
+					  	ekey_len = spprintf(&ekey, 0, "%ld", Z_LVAL_P(zdata));
+						smart_str_appendl(formstr, ekey, ekey_len);
+						efree(ekey);
+				  	}
 					break;
 				case IS_DOUBLE:
-					ekey_len = spprintf(&ekey, 0, "%.*G", (int) EG(precision), Z_DVAL_PP(zdata));
+					{
+						char *ekey;
+					  	int ekey_len;
+						ekey_len = spprintf(&ekey, 0, "%.*G", (int) EG(precision), Z_DVAL_P(zdata));
+						smart_str_appendl(formstr, ekey, ekey_len);
+						efree(ekey);
+				  	}
 					break;
 				default:
-					/* fall back on convert to string */
-					MAKE_STD_ZVAL(copyzval);
-					*copyzval = **zdata;
-					zval_copy_ctor(copyzval);
-					convert_to_string_ex(&copyzval);
-					if (enc_type == PHP_QUERY_RFC3986) {
-						ekey = php_raw_url_encode(Z_STRVAL_P(copyzval), Z_STRLEN_P(copyzval), &ekey_len);
-					} else {
-						ekey = php_url_encode(Z_STRVAL_P(copyzval), Z_STRLEN_P(copyzval), &ekey_len);
+					{
+						zend_string *ekey;
+						/* fall back on convert to string */
+						ZVAL_DUP(&copyzval, zdata);
+						convert_to_string_ex(&copyzval);
+						if (enc_type == PHP_QUERY_RFC3986) {
+							ekey = php_raw_url_encode(Z_STRVAL(copyzval), Z_STRLEN(copyzval));
+						} else {
+							ekey = php_url_encode(Z_STRVAL(copyzval), Z_STRLEN(copyzval));
+						}
+						smart_str_appendl(formstr, ekey->val, ekey->len);
+						zval_ptr_dtor(&copyzval);
+						STR_FREE(ekey);
 					}
-					zval_ptr_dtor(&copyzval);
 			}
-			smart_str_appendl(formstr, ekey, ekey_len);
-			efree(ekey);
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	return SUCCESS;
 }
@@ -225,19 +244,19 @@ PHP_FUNCTION(http_build_query)
 	}
 
 	if (php_url_encode_hash_ex(HASH_OF(formdata), &formstr, prefix, prefix_len, NULL, 0, NULL, 0, (Z_TYPE_P(formdata) == IS_OBJECT ? formdata : NULL), arg_sep, enc_type TSRMLS_CC) == FAILURE) {
-		if (formstr.c) {
-			efree(formstr.c);
+		if (formstr.s) {
+			smart_str_free(&formstr);
 		}
 		RETURN_FALSE;
 	}
 
-	if (!formstr.c) {
+	if (!formstr.s) {
 		RETURN_EMPTY_STRING();
 	}
 
 	smart_str_0(&formstr);
 	
-	RETURN_STRINGL(formstr.c, formstr.len, 0);
+	RETURN_STR(formstr.s);
 }
 /* }}} */
 
diff --git a/ext/standard/http_fopen_wrapper.c b/ext/standard/http_fopen_wrapper.c
index 3ef722bde0..7ac15a69ca 100644
--- a/ext/standard/http_fopen_wrapper.c
+++ b/ext/standard/http_fopen_wrapper.c
@@ -120,7 +120,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 	char *scratch = NULL;
 	char *tmp = NULL;
 	char *ua_str = NULL;
-	zval **ua_zval = NULL, **tmpzval = NULL;
+	zval *ua_zval = NULL, *tmpzval = NULL;
 	int scratch_len = 0;
 	int body = 0;
 	char location[HTTP_HEADER_BLOCK_SIZE];
@@ -156,9 +156,9 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 
 	if (strncasecmp(resource->scheme, "http", sizeof("http")) && strncasecmp(resource->scheme, "https", sizeof("https"))) {
 		if (!context || 
-			php_stream_context_get_option(context, wrapper->wops->label, "proxy", &tmpzval) == FAILURE ||
-			Z_TYPE_PP(tmpzval) != IS_STRING ||
-			Z_STRLEN_PP(tmpzval) <= 0) {
+			(tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "proxy")) == NULL ||
+			Z_TYPE_P(tmpzval) != IS_STRING ||
+			Z_STRLEN_P(tmpzval) <= 0) {
 			php_url_free(resource);
 			return php_stream_open_wrapper_ex(path, mode, REPORT_ERRORS, NULL, context);
 		}
@@ -167,8 +167,8 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 		use_ssl = 0;
 		use_proxy = 1;
 
-		transport_len = Z_STRLEN_PP(tmpzval);
-		transport_string = estrndup(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval));
+		transport_len = Z_STRLEN_P(tmpzval);
+		transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval));
 	} else {
 		/* Normal http request (possibly with proxy) */
 	
@@ -186,22 +186,22 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 			resource->port = 80;
 
 		if (context &&
-			php_stream_context_get_option(context, wrapper->wops->label, "proxy", &tmpzval) == SUCCESS &&
-			Z_TYPE_PP(tmpzval) == IS_STRING &&
-			Z_STRLEN_PP(tmpzval) > 0) {
+			(tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "proxy")) != NULL &&
+			Z_TYPE_P(tmpzval) == IS_STRING &&
+			Z_STRLEN_P(tmpzval) > 0) {
 			use_proxy = 1;
-			transport_len = Z_STRLEN_PP(tmpzval);
-			transport_string = estrndup(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval));
+			transport_len = Z_STRLEN_P(tmpzval);
+			transport_string = estrndup(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval));
 		} else {
 			transport_len = spprintf(&transport_string, 0, "%s://%s:%d", use_ssl ? "ssl" : "tcp", resource->host, resource->port);
 		}
 	}
 
-	if (context && php_stream_context_get_option(context, wrapper->wops->label, "timeout", &tmpzval) == SUCCESS) {
+	if (context && (tmpzval = php_stream_context_get_option(context, wrapper->wops->label, "timeout")) != NULL) {
 		SEPARATE_ZVAL(tmpzval);
 		convert_to_double_ex(tmpzval);
-		timeout.tv_sec = (time_t) Z_DVAL_PP(tmpzval);
-		timeout.tv_usec = (size_t) ((Z_DVAL_PP(tmpzval) - timeout.tv_sec) * 1000000);
+		timeout.tv_sec = (time_t) Z_DVAL_P(tmpzval);
+		timeout.tv_usec = (size_t) ((Z_DVAL_P(tmpzval) - timeout.tv_sec) * 1000000);
 	} else {
 		timeout.tv_sec = FG(default_socket_timeout);
 		timeout.tv_usec = 0;
@@ -233,18 +233,15 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 		smart_str_appendl(&header, " HTTP/1.0\r\n", sizeof(" HTTP/1.0\r\n")-1);
 
 	    /* check if we have Proxy-Authorization header */
-		if (context && php_stream_context_get_option(context, "http", "header", &tmpzval) == SUCCESS) {
+		if (context && (tmpzval = php_stream_context_get_option(context, "http", "header")) != NULL) {
 			char *s, *p;
 
-			if (Z_TYPE_PP(tmpzval) == IS_ARRAY) {
-				HashPosition pos;
-				zval **tmpheader = NULL;
+			if (Z_TYPE_P(tmpzval) == IS_ARRAY) {
+				zval *tmpheader = NULL;
 
-				for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(tmpzval), &pos);
-					SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(tmpzval), (void *)&tmpheader, &pos);
-					zend_hash_move_forward_ex(Z_ARRVAL_PP(tmpzval), &pos)) {
-					if (Z_TYPE_PP(tmpheader) == IS_STRING) {
-						s = Z_STRVAL_PP(tmpheader);
+				ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmpzval), tmpheader) {
+					if (Z_TYPE_P(tmpheader) == IS_STRING) {
+						s = Z_STRVAL_P(tmpheader);
 						do {
 							while (*s == ' ' || *s == '\t') s++;
 							p = s;
@@ -266,9 +263,9 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 							while (*s == '\r' || *s == '\n') s++;
 						} while (*s != 0);
 					}
-				}
-			} else if (Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval)) {
-				s = Z_STRVAL_PP(tmpzval);
+				} ZEND_HASH_FOREACH_END();
+			} else if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval)) {
+				s = Z_STRVAL_P(tmpzval);
 				do {
 					while (*s == ' ' || *s == '\t') s++;
 					p = s;
@@ -294,7 +291,7 @@ php_stream *php_stream_url_wrap_http_ex(php_stream_wrapper *wrapper,
 finish:
 		smart_str_appendl(&header, "\r\n", sizeof("\r\n")-1);
 
-		if (php_stream_write(stream, header.c, header.len) != header.len) {
+		if (php_stream_write(stream, header.s->val, header.s->len) != header.s->len) {
 			php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "Cannot connect to HTTPS server through proxy");
 			php_stream_close(stream);
 			stream = NULL;
@@ -341,32 +338,32 @@ finish:
 
 	php_stream_notify_info(context, PHP_STREAM_NOTIFY_CONNECT, NULL, 0);
 
-	if (header_init && context && php_stream_context_get_option(context, "http", "max_redirects", &tmpzval) == SUCCESS) {
+	if (header_init && context && (tmpzval = php_stream_context_get_option(context, "http", "max_redirects")) != NULL) {
 		SEPARATE_ZVAL(tmpzval);
 		convert_to_long_ex(tmpzval);
-		redirect_max = Z_LVAL_PP(tmpzval);
+		redirect_max = Z_LVAL_P(tmpzval);
 	}
 
-	if (context && php_stream_context_get_option(context, "http", "method", &tmpzval) == SUCCESS) {
-		if (Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval) > 0) {
+	if (context && (tmpzval = php_stream_context_get_option(context, "http", "method")) != NULL) {
+		if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0) {
 			/* As per the RFC, automatically redirected requests MUST NOT use other methods than
 			 * GET and HEAD unless it can be confirmed by the user */
 			if (!redirected
-				|| (Z_STRLEN_PP(tmpzval) == 3 && memcmp("GET", Z_STRVAL_PP(tmpzval), 3) == 0)
-				|| (Z_STRLEN_PP(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_PP(tmpzval), 4) == 0)
+				|| (Z_STRLEN_P(tmpzval) == 3 && memcmp("GET", Z_STRVAL_P(tmpzval), 3) == 0)
+				|| (Z_STRLEN_P(tmpzval) == 4 && memcmp("HEAD",Z_STRVAL_P(tmpzval), 4) == 0)
 			) {
-				scratch_len = strlen(path) + 29 + Z_STRLEN_PP(tmpzval);
+				scratch_len = strlen(path) + 29 + Z_STRLEN_P(tmpzval);
 				scratch = emalloc(scratch_len);
-				strlcpy(scratch, Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval) + 1);
+				strlcpy(scratch, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval) + 1);
 				strncat(scratch, " ", 1);
 			}
 		}
 	}
  
-	if (context && php_stream_context_get_option(context, "http", "protocol_version", &tmpzval) == SUCCESS) {
+	if (context && (tmpzval = php_stream_context_get_option(context, "http", "protocol_version")) != NULL) {
 		SEPARATE_ZVAL(tmpzval);
 		convert_to_double_ex(tmpzval);
-		protocol_version_len = spprintf(&protocol_version, 0, "%.1F", Z_DVAL_PP(tmpzval));
+		protocol_version_len = spprintf(&protocol_version, 0, "%.1F", Z_DVAL_P(tmpzval));
 	}
 
 	if (!scratch) {
@@ -378,10 +375,10 @@ finish:
 	/* Should we send the entire path in the request line, default to no. */
 	if (!request_fulluri &&
 		context &&
-		php_stream_context_get_option(context, "http", "request_fulluri", &tmpzval) == SUCCESS) {
-		zval ztmp = **tmpzval;
-
-		zval_copy_ctor(&ztmp);
+		(tmpzval = php_stream_context_get_option(context, "http", "request_fulluri")) != NULL) {
+		zval ztmp;
+		
+		ZVAL_DUP(&ztmp, tmpzval);
 		convert_to_boolean(&ztmp);
 		request_fulluri = Z_BVAL(ztmp) ? 1 : 0;
 		zval_dtor(&ztmp);
@@ -419,33 +416,29 @@ finish:
 	/* send it */
 	php_stream_write(stream, scratch, strlen(scratch));
 
-	if (context && php_stream_context_get_option(context, "http", "header", &tmpzval) == SUCCESS) {
+	if (context && (tmpzval = php_stream_context_get_option(context, "http", "header")) != NULL) {
 		tmp = NULL;
 		
-		if (Z_TYPE_PP(tmpzval) == IS_ARRAY) {
-			HashPosition pos;
-			zval **tmpheader = NULL;
+		if (Z_TYPE_P(tmpzval) == IS_ARRAY) {
+			zval *tmpheader = NULL;
 			smart_str tmpstr = {0};
 
-			for (zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(tmpzval), &pos);
-				SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(tmpzval), (void *)&tmpheader, &pos);
-				zend_hash_move_forward_ex(Z_ARRVAL_PP(tmpzval), &pos)
-			) {
-				if (Z_TYPE_PP(tmpheader) == IS_STRING) {
-					smart_str_appendl(&tmpstr, Z_STRVAL_PP(tmpheader), Z_STRLEN_PP(tmpheader));
+			ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(tmpzval), tmpheader) {
+				if (Z_TYPE_P(tmpheader) == IS_STRING) {
+					smart_str_appendl(&tmpstr, Z_STRVAL_P(tmpheader), Z_STRLEN_P(tmpheader));
 					smart_str_appendl(&tmpstr, "\r\n", sizeof("\r\n") - 1);
 				}
-			}
+			} ZEND_HASH_FOREACH_END();
 			smart_str_0(&tmpstr);
 			/* Remove newlines and spaces from start and end. there's at least one extra \r\n at the end that needs to go. */
-			if (tmpstr.c) {
-				tmp = php_trim(tmpstr.c, strlen(tmpstr.c), NULL, 0, NULL, 3 TSRMLS_CC);
+			if (tmpstr.s) {
+				tmp = php_trim(tmpstr.s->val, tmpstr.s->len, NULL, 0, NULL, 3 TSRMLS_CC);
 				smart_str_free(&tmpstr);
 			}
 		}
-		if (Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval)) {
+		if (Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval)) {
 			/* Remove newlines and spaces from start and end php_trim will estrndup() */
-			tmp = php_trim(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC);
+			tmp = php_trim(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), NULL, 0, NULL, 3 TSRMLS_CC);
 		}
 		if (tmp && strlen(tmp) > 0) {
 			char *s;
@@ -526,6 +519,7 @@ finish:
 
 	/* auth header if it was specified */
 	if (((have_header & HTTP_HEADER_AUTH) == 0) && resource->user) {
+		zend_string *stmp;
 		/* decode the strings first */
 		php_url_decode(resource->user, strlen(resource->user));
 
@@ -539,15 +533,14 @@ finish:
 			strcat(scratch, resource->pass);
 		}
 
-		tmp = (char*)php_base64_encode((unsigned char*)scratch, strlen(scratch), NULL);
+		stmp = php_base64_encode((unsigned char*)scratch, strlen(scratch));
 		
-		if (snprintf(scratch, scratch_len, "Authorization: Basic %s\r\n", tmp) > 0) {
+		if (snprintf(scratch, scratch_len, "Authorization: Basic %s\r\n", stmp->val) > 0) {
 			php_stream_write(stream, scratch, strlen(scratch));
 			php_stream_notify_info(context, PHP_STREAM_NOTIFY_AUTH_REQUIRED, NULL, 0);
 		}
 
-		efree(tmp);
-		tmp = NULL;
+		STR_FREE(stmp);
 	}
 
 	/* if the user has configured who they are, send a From: line */
@@ -580,9 +573,9 @@ finish:
 	}
 
 	if (context && 
-	    php_stream_context_get_option(context, "http", "user_agent", &ua_zval) == SUCCESS &&
-		Z_TYPE_PP(ua_zval) == IS_STRING) {
-		ua_str = Z_STRVAL_PP(ua_zval);
+	    (ua_zval = php_stream_context_get_option(context, "http", "user_agent")) != NULL &&
+		Z_TYPE_P(ua_zval) == IS_STRING) {
+		ua_str = Z_STRVAL_P(ua_zval);
 	} else if (FG(user_agent)) {
 		ua_str = FG(user_agent);
 	}
@@ -618,10 +611,10 @@ finish:
 				header_init &&
 				context &&
 				!(have_header & HTTP_HEADER_CONTENT_LENGTH) &&
-				php_stream_context_get_option(context, "http", "content", &tmpzval) == SUCCESS &&
-				Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval) > 0
+				(tmpzval = php_stream_context_get_option(context, "http", "content")) != NULL &&
+				Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0
 		) {
-			scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_PP(tmpzval));
+			scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_P(tmpzval));
 			php_stream_write(stream, scratch, scratch_len);
 			have_header |= HTTP_HEADER_CONTENT_LENGTH;
 		}
@@ -633,10 +626,10 @@ finish:
 
 	/* Request content, such as for POST requests */
 	if (header_init && context &&
-		php_stream_context_get_option(context, "http", "content", &tmpzval) == SUCCESS &&
-		Z_TYPE_PP(tmpzval) == IS_STRING && Z_STRLEN_PP(tmpzval) > 0) {
+		(tmpzval = php_stream_context_get_option(context, "http", "content")) != NULL &&
+		Z_TYPE_P(tmpzval) == IS_STRING && Z_STRLEN_P(tmpzval) > 0) {
 		if (!(have_header & HTTP_HEADER_CONTENT_LENGTH)) {
-			scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_PP(tmpzval));
+			scratch_len = slprintf(scratch, scratch_len, "Content-Length: %d\r\n", Z_STRLEN_P(tmpzval));
 			php_stream_write(stream, scratch, scratch_len);
 		}
 		if (!(have_header & HTTP_HEADER_TYPE)) {
@@ -645,7 +638,7 @@ finish:
 			php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Content-type not specified assuming application/x-www-form-urlencoded");
 		}
 		php_stream_write(stream, "\r\n", sizeof("\r\n")-1);
-		php_stream_write(stream, Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval));
+		php_stream_write(stream, Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval));
 	} else {
 		php_stream_write(stream, "\r\n", sizeof("\r\n")-1);
 	}
@@ -657,32 +650,27 @@ finish:
 	}
 
 	if (header_init) {
-		zval *ztmp;
-		MAKE_STD_ZVAL(ztmp);
-		array_init(ztmp);
-		ZEND_SET_SYMBOL(EG(active_symbol_table), "http_response_header", ztmp);
+		zval ztmp;
+		array_init(&ztmp);
+		zend_set_local_var_str("http_response_header", sizeof("http_response_header")-1, &ztmp, 0 TSRMLS_CC);
 	}
 
-	{
-		zval **rh;
-		zend_hash_find(EG(active_symbol_table), "http_response_header", sizeof("http_response_header"), (void **) &rh);
-		response_header = *rh;
-	}
+	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;
 		/* get response header */
 
 		if (php_stream_get_line(stream, tmp_line, sizeof(tmp_line) - 1, &tmp_line_len) != NULL) {
-			zval *http_response;
+			zval http_response;
 
 			if (tmp_line_len > 9) {
 				response_code = atoi(tmp_line + 9);
 			} else {
 				response_code = 0;
 			}
-			if (context && SUCCESS==php_stream_context_get_option(context, "http", "ignore_errors", &tmpzval)) {
-				ignore_errors = zend_is_true(*tmpzval TSRMLS_CC);
+			if (context && NULL != (tmpzval = php_stream_context_get_option(context, "http", "ignore_errors"))) {
+				ignore_errors = zend_is_true(tmpzval TSRMLS_CC);
 			}
 			/* when we request only the header, don't fail even on error codes */
 			if ((options & STREAM_ONLY_GET_HEADERS) || ignore_errors) {
@@ -714,9 +702,8 @@ finish:
 					--tmp_line_len;
 				}
 			}
-			MAKE_STD_ZVAL(http_response);
-			ZVAL_STRINGL(http_response, tmp_line, tmp_line_len, 1);
-			zend_hash_next_index_insert(Z_ARRVAL_P(response_header), &http_response, sizeof(zval *), NULL);
+			ZVAL_STRINGL(&http_response, tmp_line, tmp_line_len);
+			zend_hash_next_index_insert(Z_ARRVAL_P(response_header), &http_response);
 		}
 	} else {
 		php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "HTTP request failed, unexpected end of socket!");
@@ -748,11 +735,11 @@ finish:
 			http_header_line[http_header_line_length] = '\0';
 
 			if (!strncasecmp(http_header_line, "Location: ", 10)) {
-				if (context && php_stream_context_get_option(context, "http", "follow_location", &tmpzval) == SUCCESS) {
+				if (context && (tmpzval = php_stream_context_get_option(context, "http", "follow_location")) != NULL) {
 					SEPARATE_ZVAL(tmpzval);
 					convert_to_long_ex(tmpzval);
-					follow_location = Z_LVAL_PP(tmpzval);
-				} else if (!(response_code >= 300 && response_code < 304 || 307 == response_code)) { 
+					follow_location = Z_LVAL_P(tmpzval);
+				} else if (!((response_code >= 300 && response_code < 304) || 307 == response_code)) { 
 					/* we shouldn't redirect automatically
 					if follow_location isn't set and response_code not in (300, 301, 302, 303 and 307) 
 					see http://www.w3.org/Protocols/rfc2616/rfc2616-sec10.html#sec10.3.1 */
@@ -770,10 +757,10 @@ finish:
 				if (!(options & STREAM_ONLY_GET_HEADERS)) {
 					long decode = 1;
 
-					if (context && php_stream_context_get_option(context, "http", "auto_decode", &tmpzval) == SUCCESS) {
+					if (context && (tmpzval = php_stream_context_get_option(context, "http", "auto_decode")) != NULL) {
 						SEPARATE_ZVAL(tmpzval);
-						convert_to_boolean(*tmpzval);
-						decode = Z_LVAL_PP(tmpzval);
+						convert_to_boolean(tmpzval);
+						decode = Z_LVAL_P(	tmpzval);
 					}
 					if (decode) {
 						transfer_encoding = php_stream_filter_create("dechunk", NULL, php_stream_is_persistent(stream) TSRMLS_CC);
@@ -788,13 +775,11 @@ finish:
 			if (http_header_line[0] == '\0') {
 				body = 1;
 			} else {
-				zval *http_header;
-
-				MAKE_STD_ZVAL(http_header);
+				zval http_header;
 
-				ZVAL_STRINGL(http_header, http_header_line, http_header_line_length, 1);
+				ZVAL_STRINGL(&http_header, http_header_line, http_header_line_length);
 				
-				zend_hash_next_index_insert(Z_ARRVAL_P(response_header), &http_header, sizeof(zval *), NULL);
+				zend_hash_next_index_insert(Z_ARRVAL_P(response_header), &http_header);
 			}
 		} else {
 			break;
@@ -908,8 +893,7 @@ out:
 
 	if (stream) {
 		if (header_init) {
-			zval_add_ref(&response_header);
-			stream->wrapperdata = response_header;
+			ZVAL_COPY(&stream->wrapperdata, response_header);
 		}
 		php_stream_notify_progress_init(context, 0, file_size);
 		
diff --git a/ext/standard/image.c b/ext/standard/image.c
index 02246c6268..8b51688bd6 100644
--- a/ext/standard/image.c
+++ b/ext/standard/image.c
@@ -108,7 +108,7 @@ static struct gfxinfo *php_handle_gif (php_stream * stream TSRMLS_DC)
 	if (php_stream_seek(stream, 3, SEEK_CUR))
 		return NULL;
 
-	if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim))
+	if (php_stream_read(stream, (char*)dim, sizeof(dim)) != sizeof(dim))
 		return NULL;
 
 	result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo));
@@ -131,7 +131,7 @@ static struct gfxinfo *php_handle_psd (php_stream * stream TSRMLS_DC)
 	if (php_stream_seek(stream, 11, SEEK_CUR))
 		return NULL;
 
-	if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim))
+	if (php_stream_read(stream, (char*)dim, sizeof(dim)) != sizeof(dim))
 		return NULL;
 
 	result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo));
@@ -153,7 +153,7 @@ static struct gfxinfo *php_handle_bmp (php_stream * stream TSRMLS_DC)
 	if (php_stream_seek(stream, 11, SEEK_CUR))
 		return NULL;
 
-	if (php_stream_read(stream, dim, sizeof(dim)) != sizeof(dim))
+	if (php_stream_read(stream, (char*)dim, sizeof(dim)) != sizeof(dim))
 		return NULL;
 
 	size   = (((unsigned int)dim[ 3]) << 24) + (((unsigned int)dim[ 2]) << 16) + (((unsigned int)dim[ 1]) << 8) + ((unsigned int) dim[ 0]);
@@ -276,7 +276,7 @@ static struct gfxinfo *php_handle_swf (php_stream * stream TSRMLS_DC)
 	if (php_stream_seek(stream, 5, SEEK_CUR))
 		return NULL;
 
-	if (php_stream_read(stream, a, sizeof(a)) != sizeof(a))
+	if (php_stream_read(stream, (char*)a, sizeof(a)) != sizeof(a))
 		return NULL;
 
 	result = (struct gfxinfo *) ecalloc (1, sizeof (struct gfxinfo));
@@ -309,7 +309,7 @@ static struct gfxinfo *php_handle_png (php_stream * stream TSRMLS_DC)
 	if (php_stream_seek(stream, 8, SEEK_CUR))
 		return NULL;
 
-	if((php_stream_read(stream, dim, sizeof(dim))) < sizeof(dim))
+	if((php_stream_read(stream, (char*)dim, sizeof(dim))) < sizeof(dim))
 		return NULL;
 
 	result = (struct gfxinfo *) ecalloc(1, sizeof(struct gfxinfo));
@@ -366,7 +366,7 @@ static unsigned short php_read2(php_stream * stream TSRMLS_DC)
 	unsigned char a[2];
 
 	/* just return 0 if we hit the end-of-file */
-	if((php_stream_read(stream, a, sizeof(a))) <= 0) return 0;
+	if((php_stream_read(stream, (char*)a, sizeof(a))) <= 0) return 0;
 
 	return (((unsigned short)a[0]) << 8) + ((unsigned short)a[1]);
 }
@@ -440,8 +440,8 @@ static int php_skip_variable(php_stream * stream TSRMLS_DC)
 static int php_read_APP(php_stream * stream, unsigned int marker, zval *info TSRMLS_DC)
 {
 	unsigned short length;
-	unsigned char *buffer;
-	unsigned char markername[16];
+	char *buffer;
+	char markername[16];
 	zval *tmp;
 
 	length = php_read2(stream TSRMLS_CC);
@@ -459,9 +459,9 @@ static int php_read_APP(php_stream * stream, unsigned int marker, zval *info TSR
 
 	snprintf(markername, sizeof(markername), "APP%d", marker - M_APP0);
 
-	if (zend_hash_find(Z_ARRVAL_P(info), markername, strlen(markername)+1, (void **) &tmp) == FAILURE) {
+	if ((tmp = zend_hash_str_find(Z_ARRVAL_P(info), markername, strlen(markername))) == NULL) {
 		/* XXX we onyl catch the 1st tag of it's kind! */
-		add_assoc_stringl(info, markername, buffer, length, 1);
+		add_assoc_stringl(info, markername, buffer, length);
 	}
 
 	efree(buffer);
@@ -565,7 +565,7 @@ static unsigned int php_read4(php_stream * stream TSRMLS_DC)
 	unsigned char a[4];
 
 	/* just return 0 if we hit the end-of-file */
-	if ((php_stream_read(stream, a, sizeof(a))) != sizeof(a)) return 0;
+	if ((php_stream_read(stream, (char*)a, sizeof(a))) != sizeof(a)) return 0;
 
 	return (((unsigned int)a[0]) << 24)
 	     + (((unsigned int)a[1]) << 16)
@@ -897,7 +897,7 @@ static struct gfxinfo *php_handle_iff(php_stream * stream TSRMLS_DC)
 
 	/* loop chunks to find BMHD chunk */
 	do {
-		if (php_stream_read(stream, a, 8) != 8) {
+		if (php_stream_read(stream, (char*)a, 8) != 8) {
 			return NULL;
 		}
 		chunkId = php_ifd_get32s(a+0, 1);
@@ -909,7 +909,7 @@ static struct gfxinfo *php_handle_iff(php_stream * stream TSRMLS_DC)
 			size++;
 		}
 		if (chunkId == 0x424d4844) { /* BMHD chunk */
-			if (size < 9 || php_stream_read(stream, a, 9) != 9) {
+			if (size < 9 || php_stream_read(stream, (char*)a, 9) != 9) {
 				return NULL;
 			}
 			width  = php_ifd_get16s(a+0, 1);
@@ -1165,7 +1165,7 @@ PHP_FUNCTION(image_type_to_mime_type)
 		return;
 	}
 
-	ZVAL_STRING(return_value, (char*)php_image_type_to_mime_type(p_image_type), 1);
+	ZVAL_STRING(return_value, (char*)php_image_type_to_mime_type(p_image_type));
 }
 /* }}} */
 
@@ -1182,36 +1182,36 @@ PHP_FUNCTION(image_type_to_extension)
 
 	switch (image_type) {
 		case IMAGE_FILETYPE_GIF:
-			RETURN_STRING(".gif" + !inc_dot, 1);
+			RETURN_STRING(".gif" + !inc_dot);
 		case IMAGE_FILETYPE_JPEG:
-			RETURN_STRING(".jpeg" + !inc_dot, 1);
+			RETURN_STRING(".jpeg" + !inc_dot);
 		case IMAGE_FILETYPE_PNG:
-			RETURN_STRING(".png" + !inc_dot, 1);
+			RETURN_STRING(".png" + !inc_dot);
 		case IMAGE_FILETYPE_SWF:
 		case IMAGE_FILETYPE_SWC:
-			RETURN_STRING(".swf" + !inc_dot, 1);
+			RETURN_STRING(".swf" + !inc_dot);
 		case IMAGE_FILETYPE_PSD:
-			RETURN_STRING(".psd" + !inc_dot, 1);
+			RETURN_STRING(".psd" + !inc_dot);
 		case IMAGE_FILETYPE_BMP:
 		case IMAGE_FILETYPE_WBMP:
-			RETURN_STRING(".bmp" + !inc_dot, 1);
+			RETURN_STRING(".bmp" + !inc_dot);
 		case IMAGE_FILETYPE_TIFF_II:
 		case IMAGE_FILETYPE_TIFF_MM:
-			RETURN_STRING(".tiff" + !inc_dot, 1);
+			RETURN_STRING(".tiff" + !inc_dot);
 		case IMAGE_FILETYPE_IFF:
-			RETURN_STRING(".iff" + !inc_dot, 1);
+			RETURN_STRING(".iff" + !inc_dot);
 		case IMAGE_FILETYPE_JPC:
-			RETURN_STRING(".jpc" + !inc_dot, 1);
+			RETURN_STRING(".jpc" + !inc_dot);
 		case IMAGE_FILETYPE_JP2:
-			RETURN_STRING(".jp2" + !inc_dot, 1);
+			RETURN_STRING(".jp2" + !inc_dot);
 		case IMAGE_FILETYPE_JPX:
-			RETURN_STRING(".jpx" + !inc_dot, 1);
+			RETURN_STRING(".jpx" + !inc_dot);
 		case IMAGE_FILETYPE_JB2:
-			RETURN_STRING(".jb2" + !inc_dot, 1);
+			RETURN_STRING(".jb2" + !inc_dot);
 		case IMAGE_FILETYPE_XBM:
-			RETURN_STRING(".xbm" + !inc_dot, 1);
+			RETURN_STRING(".xbm" + !inc_dot);
 		case IMAGE_FILETYPE_ICO:
-			RETURN_STRING(".ico" + !inc_dot, 1);
+			RETURN_STRING(".ico" + !inc_dot);
 	}
 
 	RETURN_FALSE;
@@ -1293,9 +1293,8 @@ PHPAPI int php_getimagetype(php_stream * stream, char *filetype TSRMLS_DC)
 }
 /* }}} */
 
-static void php_getimagesize_from_stream(php_stream *stream, zval **info, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
+static void php_getimagesize_from_stream(php_stream *stream, zval *info, INTERNAL_FUNCTION_PARAMETERS) /* {{{ */
 {
-	char *temp;
 	int itype = 0;
 	struct gfxinfo *result = NULL;
 
@@ -1310,7 +1309,7 @@ static void php_getimagesize_from_stream(php_stream *stream, zval **info, INTERN
 			break;
 		case IMAGE_FILETYPE_JPEG:
 			if (info) {
-				result = php_handle_jpeg(stream, *info TSRMLS_CC);
+				result = php_handle_jpeg(stream, info TSRMLS_CC);
 			} else {
 				result = php_handle_jpeg(stream, NULL TSRMLS_CC);
 			}
@@ -1364,12 +1363,13 @@ static void php_getimagesize_from_stream(php_stream *stream, zval **info, INTERN
 	}
 
 	if (result) {
+		char temp[MAX_LENGTH_OF_LONG * 2 + sizeof("width=\"\" height=\"\"")];
 		array_init(return_value);
 		add_index_long(return_value, 0, result->width);
 		add_index_long(return_value, 1, result->height);
 		add_index_long(return_value, 2, itype);
-		spprintf(&temp, 0, "width=\"%d\" height=\"%d\"", result->width, result->height);
-		add_index_string(return_value, 3, temp, 0);
+		snprintf(temp, sizeof(temp), "width=\"%d\" height=\"%d\"", result->width, result->height);
+		add_index_string(return_value, 3, temp);
 
 		if (result->bits != 0) {
 			add_assoc_long(return_value, "bits", result->bits);
@@ -1377,7 +1377,7 @@ static void php_getimagesize_from_stream(php_stream *stream, zval **info, INTERN
 		if (result->channels != 0) {
 			add_assoc_long(return_value, "channels", result->channels);
 		}
-		add_assoc_string(return_value, "mime", (char*)php_image_type_to_mime_type(itype), 1);
+		add_assoc_string(return_value, "mime", (char*)php_image_type_to_mime_type(itype));
 		efree(result);
 	} else {
 		RETURN_FALSE;
@@ -1389,22 +1389,22 @@ static void php_getimagesize_from_stream(php_stream *stream, zval **info, INTERN
 #define FROM_PATH 1
 
 static void php_getimagesize_from_any(INTERNAL_FUNCTION_PARAMETERS, int mode) {  /* {{{ */
-	zval **info = NULL;
+	zval *info = NULL;
 	php_stream *stream = NULL;
 	char *input;
 	int input_len;
 	const int argc = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(argc TSRMLS_CC, "s|Z", &input, &input_len, &info) == FAILURE) {
+	if (zend_parse_parameters(argc TSRMLS_CC, "s|z", &input, &input_len, &info) == FAILURE) {
 			return;
 	}
 
 	if (argc == 2) {
-			zval_dtor(*info);
-			array_init(*info);
+		info = Z_REFVAL_P(info);
+		zval_dtor(info);
+		array_init(info);
 	}
 
-
 	if (mode == FROM_PATH) {
 		stream = php_stream_open_wrapper(input, "rb", STREAM_MUST_SEEK|REPORT_ERRORS|IGNORE_PATH, NULL);
 	} else {
diff --git a/ext/standard/incomplete_class.c b/ext/standard/incomplete_class.c
index 968a5e2ebd..0a08ad4929 100644
--- a/ext/standard/incomplete_class.c
+++ b/ext/standard/incomplete_class.c
@@ -36,82 +36,79 @@ static zend_object_handlers php_incomplete_object_handlers;
  */
 static void incomplete_class_message(zval *object, int error_type TSRMLS_DC)
 {
-	char *class_name;
-	zend_bool class_name_alloced = 1;
+	zend_string *class_name;
 
-	class_name = php_lookup_class_name(object, NULL);
+	class_name = php_lookup_class_name(object);
 
-	if (!class_name) {
-		class_name_alloced = 0;
-		class_name = "unknown";
-	}
-
-	php_error_docref(NULL TSRMLS_CC, error_type, INCOMPLETE_CLASS_MSG, class_name);
-
-	if (class_name_alloced) {
-		efree(class_name);
+	if (class_name) {
+		php_error_docref(NULL TSRMLS_CC, error_type, INCOMPLETE_CLASS_MSG, class_name->val);
+		STR_RELEASE(class_name);
+	} else {
+		php_error_docref(NULL TSRMLS_CC, error_type, INCOMPLETE_CLASS_MSG, "unknown");
 	}
 }
 /* }}} */
 
-static zval *incomplete_class_get_property(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *incomplete_class_get_property(zval *object, zval *member, int type, zend_uint cache_slot, zval *rv TSRMLS_DC) /* {{{ */
 {
 	incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 
 	if (type == BP_VAR_W || type == BP_VAR_RW) {
-		return EG(error_zval_ptr);
+		return &EG(error_zval);
 	} else {
-		return EG(uninitialized_zval_ptr);
+		return &EG(uninitialized_zval);
 	}
 }
 /* }}} */
 
-static void incomplete_class_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void incomplete_class_write_property(zval *object, zval *member, zval *value, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 }
 /* }}} */
 
-static zval **incomplete_class_get_property_ptr_ptr(zval *object, zval *member, int type, const zend_literal *key TSRMLS_DC) /* {{{ */
+static zval *incomplete_class_get_property_ptr_ptr(zval *object, zval *member, int type, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	incomplete_class_message(object, E_NOTICE TSRMLS_CC);
-	return &EG(error_zval_ptr);
+	return &EG(error_zval);
 }
 /* }}} */
 
-static void incomplete_class_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
+static void incomplete_class_unset_property(zval *object, zval *member, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 }
 /* }}} */
 
-static int incomplete_class_has_property(zval *object, zval *member, int check_empty, const zend_literal *key TSRMLS_DC) /* {{{ */
+static int incomplete_class_has_property(zval *object, zval *member, int check_empty, zend_uint cache_slot TSRMLS_DC) /* {{{ */
 {
 	incomplete_class_message(object, E_NOTICE TSRMLS_CC);
 	return 0;
 }
 /* }}} */
 
-static union _zend_function *incomplete_class_get_method(zval **object, char *method, int method_len, const zend_literal *key TSRMLS_DC) /* {{{ */
+static union _zend_function *incomplete_class_get_method(zend_object **object, zend_string *method, const zval *key TSRMLS_DC) /* {{{ */
 {
-	incomplete_class_message(*object, E_ERROR TSRMLS_CC);
+	zval zobject;
+
+	ZVAL_OBJ(&zobject, *object);
+	incomplete_class_message(&zobject, E_ERROR TSRMLS_CC);
 	return NULL;
 }
 /* }}} */
 
 /* {{{ php_create_incomplete_class
  */
-static zend_object_value php_create_incomplete_object(zend_class_entry *class_type TSRMLS_DC)
+static zend_object *php_create_incomplete_object(zend_class_entry *class_type TSRMLS_DC)
 {
 	zend_object *object;
-	zend_object_value value;
 
-	value = zend_objects_new(&object, class_type TSRMLS_CC);
-	value.handlers = &php_incomplete_object_handlers;
+	object = zend_objects_new( class_type TSRMLS_CC);
+	object->handlers = &php_incomplete_object_handlers;
 
 	object_properties_init(object, class_type);
 
-	return value;
+	return object;
 }
 
 PHPAPI zend_class_entry *php_create_incomplete_class(TSRMLS_D)
@@ -135,24 +132,19 @@ PHPAPI zend_class_entry *php_create_incomplete_class(TSRMLS_D)
 
 /* {{{ php_lookup_class_name
  */
-PHPAPI char *php_lookup_class_name(zval *object, zend_uint *nlen)
+PHPAPI zend_string *php_lookup_class_name(zval *object)
 {
-	zval **val;
-	char *retval = NULL;
+	zval *val;
 	HashTable *object_properties;
 	TSRMLS_FETCH();
 
 	object_properties = Z_OBJPROP_P(object);
 
-	if (zend_hash_find(object_properties, MAGIC_MEMBER, sizeof(MAGIC_MEMBER), (void **) &val) == SUCCESS) {
-		retval = estrndup(Z_STRVAL_PP(val), Z_STRLEN_PP(val));
-
-		if (nlen) {
-			*nlen = Z_STRLEN_PP(val);
-		}
+	if ((val = zend_hash_str_find(object_properties, MAGIC_MEMBER, sizeof(MAGIC_MEMBER)-1)) != NULL) {
+		return STR_COPY(Z_STR_P(val));
 	}
 
-	return retval;
+	return NULL;
 }
 /* }}} */
 
@@ -160,16 +152,12 @@ PHPAPI char *php_lookup_class_name(zval *object, zend_uint *nlen)
  */
 PHPAPI void php_store_class_name(zval *object, const char *name, zend_uint len)
 {
-	zval *val;
+	zval val;
 	TSRMLS_FETCH();
 
-	MAKE_STD_ZVAL(val);
-
-	Z_TYPE_P(val)   = IS_STRING;
-	Z_STRVAL_P(val) = estrndup(name, len);
-	Z_STRLEN_P(val) = len;
 
-	zend_hash_update(Z_OBJPROP_P(object), MAGIC_MEMBER, sizeof(MAGIC_MEMBER), &val, sizeof(val), NULL);
+	ZVAL_STRINGL(&val, name, len);
+	zend_hash_str_update(Z_OBJPROP_P(object), MAGIC_MEMBER, sizeof(MAGIC_MEMBER)-1, &val);
 }
 /* }}} */
 
diff --git a/ext/standard/info.c b/ext/standard/info.c
index 03ced35fb3..ea2278a76b 100644
--- a/ext/standard/info.c
+++ b/ext/standard/info.c
@@ -63,14 +63,13 @@ PHPAPI extern char *php_ini_scanned_files;
 
 static int php_info_print_html_esc(const char *str, int len) /* {{{ */
 {
-	size_t new_len;
 	int written;
-	char *new_str;
+	zend_string *new_str;
 	TSRMLS_FETCH();
 
-	new_str = php_escape_html_entities((unsigned char *) str, len, &new_len, 0, ENT_QUOTES, "utf-8" TSRMLS_CC);
-	written = php_output_write(new_str, new_len TSRMLS_CC);
-	str_efree(new_str);
+	new_str = php_escape_html_entities((unsigned char *) str, len, 0, ENT_QUOTES, "utf-8" TSRMLS_CC);
+	written = php_output_write(new_str->val, new_str->len TSRMLS_CC);
+	STR_FREE(new_str);
 	return written;
 }
 /* }}} */
@@ -101,8 +100,7 @@ static int php_info_print(const char *str) /* {{{ */
 
 static void php_info_print_stream_hash(const char *name, HashTable *ht TSRMLS_DC) /* {{{ */
 {
-	char *key;
-	uint len;
+	zend_string *key;
 
 	if (ht) {
 		if (zend_hash_num_elements(ht)) {
@@ -115,15 +113,15 @@ static void php_info_print_stream_hash(const char *name, HashTable *ht TSRMLS_DC
 			}
 
 			zend_hash_internal_pointer_reset_ex(ht, &pos);
-			while (zend_hash_get_current_key_ex(ht, &key, &len, NULL, 0, &pos) == HASH_KEY_IS_STRING)
+			while (zend_hash_get_current_key_ex(ht, &key, NULL, 0, &pos) == HASH_KEY_IS_STRING)
 			{
 				if (!sapi_module.phpinfo_as_text) {
-					php_info_print_html_esc(key, len-1);
+					php_info_print_html_esc(key->val, key->len);
 				} else {
-					php_info_print(key);
+					php_info_print(key->val);
 				}
 				zend_hash_move_forward_ex(ht, &pos);
-				if (zend_hash_get_current_key_ex(ht, &key, &len, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
+				if (zend_hash_get_current_key_ex(ht, &key, NULL, 0, &pos) == HASH_KEY_IS_STRING) {
 					php_info_print(", ");
 				} else {
 					break;
@@ -172,8 +170,9 @@ PHPAPI void php_info_print_module(zend_module_entry *zend_module TSRMLS_DC) /* {
 }
 /* }}} */
 
-static int _display_module_info_func(zend_module_entry *module TSRMLS_DC) /* {{{ */
+static int _display_module_info_func(zval *el TSRMLS_DC) /* {{{ */
 {
+	zend_module_entry *module = (zend_module_entry*)Z_PTR_P(el);
 	if (module->info_func || module->version) {
 		php_info_print_module(module TSRMLS_CC);
 	}
@@ -181,8 +180,9 @@ static int _display_module_info_func(zend_module_entry *module TSRMLS_DC) /* {{{
 }
 /* }}} */
 
-static int _display_module_info_def(zend_module_entry *module TSRMLS_DC) /* {{{ */
+static int _display_module_info_def(zval *el TSRMLS_DC) /* {{{ */
 {
+	zend_module_entry *module = (zend_module_entry*)Z_PTR_P(el);
 	if (!module->info_func && !module->version) {
 		php_info_print_module(module TSRMLS_CC);
 	}
@@ -194,17 +194,18 @@ static int _display_module_info_def(zend_module_entry *module TSRMLS_DC) /* {{{
  */
 static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC)
 {
-	zval **data, **tmp, tmp2;
-	char *string_key;
-	uint string_len;
+	zval *data, *tmp, tmp2;
+	zend_string *string_key;
 	ulong num_key;
-
-	zend_is_auto_global(name, name_length TSRMLS_CC);
-
-	if (zend_hash_find(&EG(symbol_table), name, name_length+1, (void **) &data)!=FAILURE
-		&& (Z_TYPE_PP(data)==IS_ARRAY)) {
-		zend_hash_internal_pointer_reset(Z_ARRVAL_PP(data));
-		while (zend_hash_get_current_data(Z_ARRVAL_PP(data), (void **) &tmp) == SUCCESS) {
+	zend_string *key;
+	
+	key = STR_INIT(name, name_length, 0);
+	zend_is_auto_global(key TSRMLS_CC);
+
+	if ((data = zend_hash_find(&EG(symbol_table).ht, key)) != NULL
+		&& (Z_TYPE_P(data)==IS_ARRAY)) {
+		zend_hash_internal_pointer_reset(Z_ARRVAL_P(data));
+		while ((tmp = zend_hash_get_current_data(Z_ARRVAL_P(data))) != NULL) {
 			if (!sapi_module.phpinfo_as_text) {
 				php_info_print("<tr>");
 				php_info_print("<td class=\"e\">");
@@ -213,12 +214,12 @@ static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC)
 			php_info_print(name);
 			php_info_print("[\"");
 
-			switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(data), &string_key, &string_len, &num_key, 0, NULL)) {
+			switch (zend_hash_get_current_key(Z_ARRVAL_P(data), &string_key, &num_key, 0)) {
 				case HASH_KEY_IS_STRING:
 					if (!sapi_module.phpinfo_as_text) {
-						php_info_print_html_esc(string_key, string_len-1);
+						php_info_print_html_esc(string_key->val, string_key->len);
 					} else {
-						php_info_print(string_key);
+						php_info_print(string_key->val);
 					}
 					break;
 				case HASH_KEY_IS_LONG:
@@ -231,17 +232,17 @@ static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC)
 			} else {
 				php_info_print(" => ");
 			}
-			if (Z_TYPE_PP(tmp) == IS_ARRAY) {
+			if (Z_TYPE_P(tmp) == IS_ARRAY) {
 				if (!sapi_module.phpinfo_as_text) {
 					php_info_print("<pre>");
-					zend_print_zval_r_ex((zend_write_func_t) php_info_print_html_esc, *tmp, 0 TSRMLS_CC);
+					zend_print_zval_r_ex((zend_write_func_t) php_info_print_html_esc, tmp, 0 TSRMLS_CC);
 					php_info_print("</pre>");
 				} else {
-					zend_print_zval_r(*tmp, 0 TSRMLS_CC);
+					zend_print_zval_r(tmp, 0 TSRMLS_CC);
 				}
 			} else {
-				tmp2 = **tmp;
-				if (Z_TYPE_PP(tmp) != IS_STRING) {
+				ZVAL_COPY_VALUE(&tmp2, tmp);
+				if (Z_TYPE(tmp2) != IS_STRING) {
 					tmp = NULL;
 					zval_copy_ctor(&tmp2);
 					convert_to_string(&tmp2);
@@ -266,9 +267,10 @@ static void php_print_gpcse_array(char *name, uint name_length TSRMLS_DC)
 			} else {
 				php_info_print("\n");
 			}
-			zend_hash_move_forward(Z_ARRVAL_PP(data));
+			zend_hash_move_forward(Z_ARRVAL_P(data));
 		}
 	}
+	STR_FREE(key);
 }
 /* }}} */
 
@@ -284,10 +286,9 @@ void php_info_print_style(TSRMLS_D)
 
 /* {{{ php_info_html_esc
  */
-PHPAPI char *php_info_html_esc(char *string TSRMLS_DC)
+PHPAPI zend_string *php_info_html_esc(char *string TSRMLS_DC)
 {
-	size_t new_len;
-	return php_escape_html_entities((unsigned char *) string, strlen(string), &new_len, 0, ENT_QUOTES, NULL TSRMLS_CC);
+	return php_escape_html_entities((unsigned char *) string, strlen(string), 0, ENT_QUOTES, NULL TSRMLS_CC);
 }
 /* }}} */
 
@@ -524,7 +525,7 @@ void php_get_windows_cpu(char *buf, int bufsize)
 
 /* {{{ php_get_uname
  */
-PHPAPI char *php_get_uname(char mode)
+PHPAPI zend_string *php_get_uname(char mode)
 {
 	char *php_uname;
 	char tmp_uname[256];
@@ -626,7 +627,7 @@ PHPAPI char *php_get_uname(char mode)
 	php_uname = PHP_UNAME;
 #endif
 #endif
-	return estrdup(php_uname);
+	return STR_INIT(php_uname, strlen(php_uname), 0);
 }
 /* }}} */
 
@@ -648,11 +649,11 @@ PHPAPI void php_print_info_htmlhead(TSRMLS_D)
 /* {{{ module_name_cmp */
 static int module_name_cmp(const void *a, const void *b TSRMLS_DC)
 {
-	Bucket *f = *((Bucket **) a);
-	Bucket *s = *((Bucket **) b);
+	Bucket *f = (Bucket *) a;
+	Bucket *s = (Bucket *) b;
 
-	return strcasecmp(((zend_module_entry *)f->pData)->name,
-				  ((zend_module_entry *)s->pData)->name);
+	return strcasecmp(((zend_module_entry *)Z_PTR(f->val))->name,
+				  ((zend_module_entry *)Z_PTR(s->val))->name);
 }
 /* }}} */
 
@@ -661,7 +662,7 @@ static int module_name_cmp(const void *a, const void *b TSRMLS_DC)
 PHPAPI void php_print_info(int flag TSRMLS_DC)
 {
 	char **env, *tmp1, *tmp2;
-	char *php_uname;
+	zend_string *php_uname;
 
 	if (!sapi_module.phpinfo_as_text) {
 		php_print_info_htmlhead(TSRMLS_C);
@@ -701,8 +702,8 @@ PHPAPI void php_print_info(int flag TSRMLS_DC)
 		}
 		php_info_print_box_end();
 		php_info_print_table_start();
-		php_info_print_table_row(2, "System", php_uname );
-		php_info_print_table_row(2, "Build Date", __DATE__ " " __TIME__ );
+		php_info_print_table_row(2, "System", php_uname->val);
+		php_info_print_table_row(2, "Build Date", __DATE__ " " __TIME__);
 #ifdef COMPILER
 		php_info_print_table_row(2, "Compiler", COMPILER);
 #endif
@@ -804,7 +805,7 @@ PHPAPI void php_print_info(int flag TSRMLS_DC)
 			zend_html_puts(zend_version, strlen(zend_version) TSRMLS_CC);
 		}
 		php_info_print_box_end();
-		efree(php_uname);
+		STR_FREE(php_uname);
 	}
 
 	zend_ini_sort_entries(TSRMLS_C);
@@ -824,18 +825,18 @@ PHPAPI void php_print_info(int flag TSRMLS_DC)
 
 	if (flag & PHP_INFO_MODULES) {
 		HashTable sorted_registry;
-		zend_module_entry tmp;
 
 		zend_hash_init(&sorted_registry, zend_hash_num_elements(&module_registry), NULL, NULL, 1);
-		zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
+//???		zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
+		zend_hash_copy(&sorted_registry, &module_registry, NULL);
 		zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);
 
-		zend_hash_apply(&sorted_registry, (apply_func_t) _display_module_info_func TSRMLS_CC);
+		zend_hash_apply(&sorted_registry, _display_module_info_func TSRMLS_CC);
 
 		SECTION("Additional Modules");
 		php_info_print_table_start();
 		php_info_print_table_header(1, "Module Name");
-		zend_hash_apply(&sorted_registry, (apply_func_t) _display_module_info_def TSRMLS_CC);
+		zend_hash_apply(&sorted_registry, _display_module_info_def TSRMLS_CC);
 		php_info_print_table_end();
 
 		zend_hash_destroy(&sorted_registry);
@@ -860,23 +861,23 @@ PHPAPI void php_print_info(int flag TSRMLS_DC)
 	}
 
 	if (flag & PHP_INFO_VARIABLES) {
-		zval **data;
+		zval *data;
 
 		SECTION("PHP Variables");
 
 		php_info_print_table_start();
 		php_info_print_table_header(2, "Variable", "Value");
-		if (zend_hash_find(&EG(symbol_table), "PHP_SELF", sizeof("PHP_SELF"), (void **) &data) != FAILURE) {
-			php_info_print_table_row(2, "PHP_SELF", Z_STRVAL_PP(data));
+		if ((data = zend_hash_str_find(&EG(symbol_table).ht, "PHP_SELF", sizeof("PHP_SELF")-1)) != NULL) {
+			php_info_print_table_row(2, "PHP_SELF", Z_STRVAL_P(data));
 		}
-		if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_TYPE", sizeof("PHP_AUTH_TYPE"), (void **) &data) != FAILURE) {
-			php_info_print_table_row(2, "PHP_AUTH_TYPE", Z_STRVAL_PP(data));
+		if ((data = zend_hash_str_find(&EG(symbol_table).ht, "PHP_AUTH_TYPE", sizeof("PHP_AUTH_TYPE")-1)) != NULL) {
+			php_info_print_table_row(2, "PHP_AUTH_TYPE", Z_STRVAL_P(data));
 		}
-		if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_USER", sizeof("PHP_AUTH_USER"), (void **) &data) != FAILURE) {
-			php_info_print_table_row(2, "PHP_AUTH_USER", Z_STRVAL_PP(data));
+		if ((data = zend_hash_str_find(&EG(symbol_table).ht, "PHP_AUTH_USER", sizeof("PHP_AUTH_USER")-1)) != NULL) {
+			php_info_print_table_row(2, "PHP_AUTH_USER", Z_STRVAL_P(data));
 		}
-		if (zend_hash_find(&EG(symbol_table), "PHP_AUTH_PW", sizeof("PHP_AUTH_PW"), (void **) &data) != FAILURE) {
-			php_info_print_table_row(2, "PHP_AUTH_PW", Z_STRVAL_PP(data));
+		if ((data = zend_hash_str_find(&EG(symbol_table).ht, "PHP_AUTH_PW", sizeof("PHP_AUTH_PW")-1)) != NULL) {
+			php_info_print_table_row(2, "PHP_AUTH_PW", Z_STRVAL_P(data));
 		}
 		php_print_gpcse_array(ZEND_STRL("_REQUEST") TSRMLS_CC);
 		php_print_gpcse_array(ZEND_STRL("_GET") TSRMLS_CC);
@@ -1166,14 +1167,14 @@ PHP_FUNCTION(phpversion)
 	}
 
 	if (!ext_name) {
-		RETURN_STRING(PHP_VERSION, 1);
+		RETURN_STRING(PHP_VERSION);
 	} else {
 		const char *version;
 		version = zend_get_module_version(ext_name);
 		if (version == NULL) {
 			RETURN_FALSE;
 		}
-		RETURN_STRING(version, 1);
+		RETURN_STRING(version);
 	}
 }
 /* }}} */
@@ -1202,7 +1203,7 @@ PHP_FUNCTION(php_sapi_name)
 	}
 
 	if (sapi_module.name) {
-		RETURN_STRING(sapi_module.name, 1);
+		RETURN_STRING(sapi_module.name);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1220,7 +1221,7 @@ PHP_FUNCTION(php_uname)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|s", &mode, &modelen) == FAILURE) {
 		return;
 	}
-	RETURN_STRING(php_get_uname(*mode), 0);
+	RETURN_STR(php_get_uname(*mode));
 }
 
 /* }}} */
@@ -1234,7 +1235,7 @@ PHP_FUNCTION(php_ini_scanned_files)
 	}
 
 	if (strlen(PHP_CONFIG_FILE_SCAN_DIR) && php_ini_scanned_files) {
-		RETURN_STRING(php_ini_scanned_files, 1);
+		RETURN_STRING(php_ini_scanned_files);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1250,7 +1251,7 @@ PHP_FUNCTION(php_ini_loaded_file)
 	}
 
 	if (php_ini_opened_path) {
-		RETURN_STRING(php_ini_opened_path, 1);
+		RETURN_STRING(php_ini_opened_path);
 	} else {
 		RETURN_FALSE;
 	}
diff --git a/ext/standard/info.h b/ext/standard/info.h
index 03c652822f..8be58160ed 100644
--- a/ext/standard/info.h
+++ b/ext/standard/info.h
@@ -63,7 +63,7 @@ PHP_FUNCTION(php_sapi_name);
 PHP_FUNCTION(php_uname);
 PHP_FUNCTION(php_ini_scanned_files);
 PHP_FUNCTION(php_ini_loaded_file);
-PHPAPI char *php_info_html_esc(char *string TSRMLS_DC);
+PHPAPI zend_string *php_info_html_esc(char *string TSRMLS_DC);
 PHPAPI void php_info_html_esc_write(char *string, int str_len TSRMLS_DC);
 PHPAPI void php_print_info_htmlhead(TSRMLS_D);
 PHPAPI void php_print_info(int flag TSRMLS_DC);
@@ -79,7 +79,7 @@ PHPAPI void php_info_print_box_start(int bg);
 PHPAPI void php_info_print_box_end(void);
 PHPAPI void php_info_print_hr(void);
 PHPAPI void php_info_print_module(zend_module_entry *module TSRMLS_DC);
-PHPAPI char *php_get_uname(char mode);
+PHPAPI zend_string *php_get_uname(char mode);
 
 void register_phpinfo_constants(INIT_FUNC_ARGS);
 END_EXTERN_C()
diff --git a/ext/standard/iptc.c b/ext/standard/iptc.c
index 3257339106..2df16daaac 100644
--- a/ext/standard/iptc.c
+++ b/ext/standard/iptc.c
@@ -285,7 +285,9 @@ PHP_FUNCTION(iptcembed)
 	fclose(fp);
 
 	if (spool < 2) {
-		RETVAL_STRINGL(spoolbuf, poi - spoolbuf, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRINGL(spoolbuf, poi - spoolbuf);
+		efree(spoolbuf);
 	} else {
 		RETURN_TRUE;
 	}
@@ -301,7 +303,7 @@ PHP_FUNCTION(iptcparse)
 	unsigned char *buffer, recnum, dataset, key[ 16 ];
 	char *str;
 	int str_len;
-	zval *values, **element;
+	zval values, *element;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) != SUCCESS) {
 		return;
@@ -347,14 +349,13 @@ PHP_FUNCTION(iptcparse)
 			array_init(return_value);
 		}
 
-		if (zend_hash_find(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void **) &element) == FAILURE) {
-			MAKE_STD_ZVAL(values);
-			array_init(values);
+		if ((element = zend_hash_str_find(Z_ARRVAL_P(return_value), key, strlen(key))) == NULL) {
+			array_init(&values);
 			
-			zend_hash_update(Z_ARRVAL_P(return_value), key, strlen(key) + 1, (void *) &values, sizeof(zval*), (void **) &element);
+			element = zend_hash_str_update(Z_ARRVAL_P(return_value), key, strlen(key), &values);
 		} 
 			
-		add_next_index_stringl(*element, buffer+inx, len, 1);
+		add_next_index_stringl(element, buffer+inx, len);
 		inx += len;
 		tagsfound++;
 	}
diff --git a/ext/standard/link.c b/ext/standard/link.c
index c57484e766..0f889a9e6a 100644
--- a/ext/standard/link.c
+++ b/ext/standard/link.c
@@ -76,7 +76,7 @@ PHP_FUNCTION(readlink)
 	/* Append NULL to the end of the string */
 	buff[ret] = '\0';
 
-	RETURN_STRING(buff, 1);
+	RETURN_STRING(buff);
 }
 /* }}} */
 
diff --git a/ext/standard/mail.c b/ext/standard/mail.c
index b877b87420..815f83118f 100644
--- a/ext/standard/mail.c
+++ b/ext/standard/mail.c
@@ -101,14 +101,15 @@ PHP_FUNCTION(ezmlm_hash)
 PHP_FUNCTION(mail)
 {
 	char *to=NULL, *message=NULL, *headers=NULL, *headers_trimmed=NULL;
-	char *subject=NULL, *extra_cmd=NULL;
+	char *subject=NULL;
+	zend_string *extra_cmd=NULL;
 	int to_len, message_len, headers_len = 0;
-	int subject_len, extra_cmd_len = 0, i;
+	int subject_len, i;
 	char *force_extra_parameters = INI_STR("mail.force_extra_parameters");
 	char *to_r, *subject_r;
 	char *p, *e;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|ss",	&to, &to_len, &subject, &subject_len, &message, &message_len, &headers, &headers_len, &extra_cmd, &extra_cmd_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sss|sS",	&to, &to_len, &subject, &subject_len, &message, &message_len, &headers, &headers_len, &extra_cmd) == FAILURE) {
 		return;
 	}
 
@@ -121,7 +122,7 @@ PHP_FUNCTION(mail)
 		headers_trimmed = php_trim(headers, headers_len, NULL, 0, NULL, 2 TSRMLS_CC);
 	}
 	if (extra_cmd) {
-		MAIL_ASCIIZ_CHECK(extra_cmd, extra_cmd_len);
+		MAIL_ASCIIZ_CHECK(extra_cmd->val, extra_cmd->len);
 	}
 
 	if (to_len > 0) {
@@ -167,10 +168,10 @@ PHP_FUNCTION(mail)
 	if (force_extra_parameters) {
 		extra_cmd = php_escape_shell_cmd(force_extra_parameters);
 	} else if (extra_cmd) {
-		extra_cmd = php_escape_shell_cmd(extra_cmd);
+		extra_cmd = php_escape_shell_cmd(extra_cmd->val);
 	}
 
-	if (php_mail(to_r, subject_r, message, headers_trimmed, extra_cmd TSRMLS_CC)) {
+	if (php_mail(to_r, subject_r, message, headers_trimmed, extra_cmd ? extra_cmd->val : NULL TSRMLS_CC)) {
 		RETVAL_TRUE;
 	} else {
 		RETVAL_FALSE;
@@ -181,7 +182,7 @@ PHP_FUNCTION(mail)
 	}
 
 	if (extra_cmd) {
-		efree (extra_cmd);
+		STR_RELEASE(extra_cmd);
 	}
 	if (to_r != to) {
 		efree(to_r);
@@ -248,16 +249,17 @@ PHPAPI int php_mail(char *to, char *subject, char *message, char *headers, char
 	return val;	\
 
 	if (mail_log && *mail_log) {
-		char *tmp, *date_str;
+		char *tmp;
 		time_t curtime;
 		int l;
+		zend_string *date_str;
 
 		time(&curtime);
 		date_str = php_format_date("d-M-Y H:i:s e", 13, curtime, 1 TSRMLS_CC);
 
-		l = spprintf(&tmp, 0, "[%s] mail() on [%s:%d]: To: %s -- Headers: %s\n", date_str, zend_get_executed_filename(TSRMLS_C), zend_get_executed_lineno(TSRMLS_C), to, hdr ? hdr : "");
+		l = spprintf(&tmp, 0, "[%s] mail() on [%s:%d]: To: %s -- Headers: %s\n", date_str->val, zend_get_executed_filename(TSRMLS_C), zend_get_executed_lineno(TSRMLS_C), to, hdr ? hdr : "");
 
-		efree(date_str);
+		STR_FREE(date_str);
 
 		if (hdr) {
 			php_mail_log_crlf_to_spaces(tmp);
@@ -278,17 +280,16 @@ PHPAPI int php_mail(char *to, char *subject, char *message, char *headers, char
 	}
 	if (PG(mail_x_header)) {
 		const char *tmp = zend_get_executed_filename(TSRMLS_C);
-		char *f;
-		size_t f_len;
+		zend_string *f;
 
-		php_basename(tmp, strlen(tmp), NULL, 0,&f, &f_len TSRMLS_CC);
+		f = php_basename(tmp, strlen(tmp), NULL, 0 TSRMLS_CC);
 
 		if (headers != NULL) {
-			spprintf(&hdr, 0, "X-PHP-Originating-Script: %ld:%s\n%s", php_getuid(TSRMLS_C), f, headers);
+			spprintf(&hdr, 0, "X-PHP-Originating-Script: %ld:%s\n%s", php_getuid(TSRMLS_C), f->val, headers);
 		} else {
-			spprintf(&hdr, 0, "X-PHP-Originating-Script: %ld:%s", php_getuid(TSRMLS_C), f);
+			spprintf(&hdr, 0, "X-PHP-Originating-Script: %ld:%s", php_getuid(TSRMLS_C), f->val);
 		}
-		efree(f);
+		STR_RELEASE(f);
 	}
 
 	if (!sendmail_path) {
diff --git a/ext/standard/math.c b/ext/standard/math.c
index 65702ddf14..b5ad90e8d8 100644
--- a/ext/standard/math.c
+++ b/ext/standard/math.c
@@ -276,20 +276,20 @@ static double php_expm1(double x)
    Return the absolute value of the number */
 PHP_FUNCTION(abs) 
 {
-	zval **value;
+	zval *value;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &value) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
 		return;
 	}
 	convert_scalar_to_number_ex(value);
 	
-	if (Z_TYPE_PP(value) == IS_DOUBLE) {
-		RETURN_DOUBLE(fabs(Z_DVAL_PP(value)));
-	} else if (Z_TYPE_PP(value) == IS_LONG) {
-		if (Z_LVAL_PP(value) == LONG_MIN) {
+	if (Z_TYPE_P(value) == IS_DOUBLE) {
+		RETURN_DOUBLE(fabs(Z_DVAL_P(value)));
+	} else if (Z_TYPE_P(value) == IS_LONG) {
+		if (Z_LVAL_P(value) == LONG_MIN) {
 			RETURN_DOUBLE(-(double)LONG_MIN);
 		} else {
-			RETURN_LONG(Z_LVAL_PP(value) < 0 ? -Z_LVAL_PP(value) : Z_LVAL_PP(value));
+			RETURN_LONG(Z_LVAL_P(value) < 0 ? -Z_LVAL_P(value) : Z_LVAL_P(value));
 		}
 	}
 	RETURN_FALSE;
@@ -300,18 +300,18 @@ PHP_FUNCTION(abs)
    Returns the next highest integer value of the number */
 PHP_FUNCTION(ceil) 
 {
-	zval **value;
+	zval *value;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &value) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
 		return;
 	}
 	convert_scalar_to_number_ex(value);
 
-	if (Z_TYPE_PP(value) == IS_DOUBLE) {
-		RETURN_DOUBLE(ceil(Z_DVAL_PP(value)));
-	} else if (Z_TYPE_PP(value) == IS_LONG) {
+	if (Z_TYPE_P(value) == IS_DOUBLE) {
+		RETURN_DOUBLE(ceil(Z_DVAL_P(value)));
+	} else if (Z_TYPE_P(value) == IS_LONG) {
 		convert_to_double_ex(value);
-		RETURN_DOUBLE(Z_DVAL_PP(value));
+		RETURN_DOUBLE(Z_DVAL_P(value));
 	}
 	RETURN_FALSE;
 }
@@ -321,18 +321,18 @@ PHP_FUNCTION(ceil)
    Returns the next lowest integer value from the number */
 PHP_FUNCTION(floor)
 {
-	zval **value;
+	zval *value;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &value) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &value) == FAILURE) {
 		return;
 	}
 	convert_scalar_to_number_ex(value);
 
-	if (Z_TYPE_PP(value) == IS_DOUBLE) {
-		RETURN_DOUBLE(floor(Z_DVAL_PP(value)));
-	} else if (Z_TYPE_PP(value) == IS_LONG) {
+	if (Z_TYPE_P(value) == IS_DOUBLE) {
+		RETURN_DOUBLE(floor(Z_DVAL_P(value)));
+	} else if (Z_TYPE_P(value) == IS_LONG) {
 		convert_to_double_ex(value);
-		RETURN_DOUBLE(Z_DVAL_PP(value));
+		RETURN_DOUBLE(Z_DVAL_P(value));
 	}
 	RETURN_FALSE;
 }
@@ -342,13 +342,13 @@ PHP_FUNCTION(floor)
    Returns the number rounded to specified precision */
 PHP_FUNCTION(round)
 {
-	zval **value;
+	zval *value;
 	int places = 0;
 	long precision = 0;
 	long mode = PHP_ROUND_HALF_UP;
 	double return_val;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|ll", &value, &precision, &mode) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|ll", &value, &precision, &mode) == FAILURE) {
 		return;
 	}
 
@@ -357,16 +357,16 @@ PHP_FUNCTION(round)
 	}
 	convert_scalar_to_number_ex(value);
 
-	switch (Z_TYPE_PP(value)) {
+	switch (Z_TYPE_P(value)) {
 		case IS_LONG:
 			/* Simple case - long that doesn't need to be rounded. */
 			if (places >= 0) {
-				RETURN_DOUBLE((double) Z_LVAL_PP(value));
+				RETURN_DOUBLE((double) Z_LVAL_P(value));
 			}
 			/* break omitted intentionally */
 
 		case IS_DOUBLE:
-			return_val = (Z_TYPE_PP(value) == IS_LONG) ? (double)Z_LVAL_PP(value) : Z_DVAL_PP(value);
+			return_val = (Z_TYPE_P(value) == IS_LONG) ? (double)Z_LVAL_P(value) : Z_DVAL_P(value);
 			return_val = _php_math_round(return_val, places, mode);
 			RETURN_DOUBLE(return_val);
 			break;
@@ -864,7 +864,7 @@ PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret)
  * Convert a long to a string containing a base(2-36) representation of
  * the number.
  */
-PHPAPI char * _php_math_longtobase(zval *arg, int base)
+PHPAPI zend_string * _php_math_longtobase(zval *arg, int base TSRMLS_DC)
 {
 	static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 	char buf[(sizeof(unsigned long) << 3) + 1];
@@ -885,7 +885,7 @@ PHPAPI char * _php_math_longtobase(zval *arg, int base)
 		value /= base;
 	} while (ptr > buf && value);
 
-	return estrndup(ptr, end - ptr);
+	return STR_INIT(ptr, end - ptr, 0);
 }
 /* }}} */
 
@@ -894,7 +894,7 @@ PHPAPI char * _php_math_longtobase(zval *arg, int base)
  * Convert a zval to a string containing a base(2-36) representation of
  * the number.
  */
-PHPAPI char * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC)
+PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC)
 {
 	static char digits[] = "0123456789abcdefghijklmnopqrstuvwxyz";
 
@@ -921,10 +921,10 @@ PHPAPI char * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC)
 			fvalue /= base;
 		} while (ptr > buf && fabs(fvalue) >= 1);
 
-		return estrndup(ptr, end - ptr);
+		return STR_INIT(ptr, end - ptr, 0);
 	}
 	
-	return _php_math_longtobase(arg, base);
+	return _php_math_longtobase(arg, base TSRMLS_CC);
 }	
 /* }}} */
 
@@ -932,13 +932,13 @@ PHPAPI char * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC)
    Returns the decimal equivalent of the binary number */
 PHP_FUNCTION(bindec)
 {
-	zval **arg;
+	zval *arg;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 	convert_to_string_ex(arg);
-	if (_php_math_basetozval(*arg, 2, return_value) == FAILURE) {
+	if (_php_math_basetozval(arg, 2, return_value) == FAILURE) {
 		RETURN_FALSE;
 	}
 }
@@ -948,13 +948,13 @@ PHP_FUNCTION(bindec)
    Returns the decimal equivalent of the hexadecimal number */
 PHP_FUNCTION(hexdec)
 {
-	zval **arg;
+	zval *arg;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 	convert_to_string_ex(arg);
-	if (_php_math_basetozval(*arg, 16, return_value) == FAILURE) {
+	if (_php_math_basetozval(arg, 16, return_value) == FAILURE) {
 		RETURN_FALSE;
 	}
 }
@@ -964,13 +964,13 @@ PHP_FUNCTION(hexdec)
    Returns the decimal equivalent of an octal string */
 PHP_FUNCTION(octdec)
 {
-	zval **arg;
+	zval *arg;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 	convert_to_string_ex(arg);
-	if (_php_math_basetozval(*arg, 8, return_value) == FAILURE) {
+	if (_php_math_basetozval(arg, 8, return_value) == FAILURE) {
 		RETURN_FALSE;
 	}
 }
@@ -980,15 +980,15 @@ PHP_FUNCTION(octdec)
    Returns a string containing a binary representation of the number */
 PHP_FUNCTION(decbin)
 {
-	zval **arg;
-	char *result;
+	zval *arg;
+	zend_string *result;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 	convert_to_long_ex(arg);
-	result = _php_math_longtobase(*arg, 2);
-	RETURN_STRING(result, 0);
+	result = _php_math_longtobase(arg, 2 TSRMLS_CC);
+	RETURN_STR(result);
 }
 /* }}} */
 
@@ -996,15 +996,15 @@ PHP_FUNCTION(decbin)
    Returns a string containing an octal representation of the given number */
 PHP_FUNCTION(decoct)
 {
-	zval **arg;
-	char *result;
+	zval *arg;
+	zend_string *result;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 	convert_to_long_ex(arg);
-	result = _php_math_longtobase(*arg, 8);
-	RETURN_STRING(result, 0);
+	result = _php_math_longtobase(arg, 8 TSRMLS_CC);
+	RETURN_STR(result);
 }
 /* }}} */
 
@@ -1012,15 +1012,15 @@ PHP_FUNCTION(decoct)
    Returns a string containing a hexadecimal representation of the given number */
 PHP_FUNCTION(dechex)
 {
-	zval **arg;
-	char *result;
+	zval *arg;
+	zend_string *result;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 	convert_to_long_ex(arg);
-	result = _php_math_longtobase(*arg, 16);
-	RETURN_STRING(result, 0);
+	result = _php_math_longtobase(arg, 16 TSRMLS_CC);
+	RETURN_STR(result);
 }
 /* }}} */
 
@@ -1028,11 +1028,11 @@ PHP_FUNCTION(dechex)
    Converts a number in a string from any base <= 36 to any base <= 36 */
 PHP_FUNCTION(base_convert)
 {
-	zval **number, temp;
+	zval *number, temp;
 	long frombase, tobase;
-	char *result;
+	zend_string *result;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zll", &number, &frombase, &tobase) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zll", &number, &frombase, &tobase) == FAILURE) {
 		return;
 	}
 	convert_to_string_ex(number);
@@ -1046,31 +1046,31 @@ PHP_FUNCTION(base_convert)
 		RETURN_FALSE;
 	}
 
-	if(_php_math_basetozval(*number, frombase, &temp) == FAILURE) {
+	if(_php_math_basetozval(number, frombase, &temp) == FAILURE) {
 		RETURN_FALSE;
 	}
 	result = _php_math_zvaltobase(&temp, tobase TSRMLS_CC);
-	RETVAL_STRING(result, 0);
+	RETVAL_STR(result);
 } 
 /* }}} */
 
 /* {{{ _php_math_number_format 
 */
-PHPAPI char *_php_math_number_format(double d, int dec, char dec_point, char thousand_sep)
+PHPAPI zend_string *_php_math_number_format(double d, int dec, char dec_point, char thousand_sep)
 {
 	return _php_math_number_format_ex(d, dec, &dec_point, 1, &thousand_sep, 1);
 }
 
-static char *_php_math_number_format_ex_len(double d, int dec, char *dec_point,
-		size_t dec_point_len, char *thousand_sep, size_t thousand_sep_len,
-		int *result_len)
+PHPAPI zend_string *_php_math_number_format_ex(double d, int dec, char *dec_point,
+		size_t dec_point_len, char *thousand_sep, size_t thousand_sep_len)
 {
-	char *tmpbuf = NULL, *resbuf;
+	zend_string *res;
+	char *tmpbuf;
 	char *s, *t;  /* source, target */
 	char *dp;
 	int integral;
-	int tmplen, reslen=0;
-	int count=0;
+	int tmplen, reslen = 0;
+	int count = 0;
 	int is_negative=0;
 
 	if (d < 0) {
@@ -1080,15 +1080,13 @@ static char *_php_math_number_format_ex_len(double d, int dec, char *dec_point,
 
 	dec = MAX(0, dec);
 	d = _php_math_round(d, dec, PHP_ROUND_HALF_UP);
-
 	tmplen = spprintf(&tmpbuf, 0, "%.*F", dec, d);
-
-	if (tmpbuf == NULL || !isdigit((int)tmpbuf[0])) {
-		if (result_len) {
-			*result_len = tmplen;
-		}
-
-		return tmpbuf;
+	if (tmpbuf == NULL) {
+		return NULL;
+	} else if (!isdigit((int)tmpbuf[0])) {
+		res = STR_INIT(tmpbuf, tmplen, 0);
+		efree(tmpbuf);
+		return res;
 	}
 
 	/* find decimal point, if expected */
@@ -1125,10 +1123,10 @@ static char *_php_math_number_format_ex_len(double d, int dec, char *dec_point,
 	if (is_negative) {
 		reslen++;
 	}
-	resbuf = (char *) emalloc(reslen+1); /* +1 for NUL terminator */
+	res = STR_ALLOC(reslen, 0);
 
-	s = tmpbuf+tmplen-1;
-	t = resbuf+reslen;
+	s = tmpbuf + tmplen - 1;
+	t = res->val + reslen;
 	*t-- = '\0';
 
 	/* copy the decimal places.
@@ -1173,22 +1171,10 @@ static char *_php_math_number_format_ex_len(double d, int dec, char *dec_point,
 		*t-- = '-';
 	}
 
+	res->len = reslen;
 	efree(tmpbuf);
-	
-	if (result_len) {
-		*result_len = reslen;
-	}
-
-	return resbuf;
-}
-
-PHPAPI char *_php_math_number_format_ex(double d, int dec, char *dec_point,
-		size_t dec_point_len, char *thousand_sep, size_t thousand_sep_len)
-{
-	return _php_math_number_format_ex_len(d, dec, dec_point, dec_point_len,
-			thousand_sep, thousand_sep_len, NULL);
+	return res;
 }
-/* }}} */
 
 /* {{{ proto string number_format(float number [, int num_decimal_places [, string dec_separator, string thousands_separator]])
    Formats a number with grouped thousands */
@@ -1206,10 +1192,10 @@ PHP_FUNCTION(number_format)
 
 	switch(ZEND_NUM_ARGS()) {
 	case 1:
-		RETURN_STRING(_php_math_number_format(num, 0, dec_point_chr, thousand_sep_chr), 0);
+		RETURN_STR(_php_math_number_format(num, 0, dec_point_chr, thousand_sep_chr));
 		break;
 	case 2:
-		RETURN_STRING(_php_math_number_format(num, dec, dec_point_chr, thousand_sep_chr), 0);
+		RETURN_STR(_php_math_number_format(num, dec, dec_point_chr, thousand_sep_chr));
 		break;
 	case 4:
 		if (dec_point == NULL) {
@@ -1222,10 +1208,8 @@ PHP_FUNCTION(number_format)
 			thousand_sep_len = 1;
 		}
 
-		Z_TYPE_P(return_value) = IS_STRING;
-		Z_STRVAL_P(return_value) = _php_math_number_format_ex_len(num, dec,
-				dec_point, dec_point_len, thousand_sep, thousand_sep_len,
-				&Z_STRLEN_P(return_value));
+		RETVAL_STR(_php_math_number_format_ex(num, dec,
+				dec_point, dec_point_len, thousand_sep, thousand_sep_len));
 		break;
 	default:
 		WRONG_PARAM_COUNT;
diff --git a/ext/standard/md5.c b/ext/standard/md5.c
index 134b650212..d2545e913a 100644
--- a/ext/standard/md5.c
+++ b/ext/standard/md5.c
@@ -62,10 +62,10 @@ PHP_NAMED_FUNCTION(php_if_md5)
 	PHP_MD5Update(&context, arg, arg_len);
 	PHP_MD5Final(digest, &context);
 	if (raw_output) {
-		RETURN_STRINGL(digest, 16, 1);
+		RETURN_STRINGL(digest, 16);
 	} else {
 		make_digest_ex(md5str, digest, 16);
-		RETVAL_STRING(md5str, 1);
+		RETVAL_STRING(md5str);
 	}
 
 }
@@ -96,7 +96,7 @@ PHP_NAMED_FUNCTION(php_if_md5_file)
 
 	PHP_MD5Init(&context);
 
-	while ((n = php_stream_read(stream, buf, sizeof(buf))) > 0) {
+	while ((n = php_stream_read(stream, (char*)buf, sizeof(buf))) > 0) {
 		PHP_MD5Update(&context, buf, n);
 	}
 
@@ -109,10 +109,10 @@ PHP_NAMED_FUNCTION(php_if_md5_file)
 	}
 
 	if (raw_output) {
-		RETURN_STRINGL(digest, 16, 1);
+		RETURN_STRINGL(digest, 16);
 	} else {
 		make_digest_ex(md5str, digest, 16);
-		RETVAL_STRING(md5str, 1);
+		RETVAL_STRING(md5str);
 	}
 }
 /* }}} */
diff --git a/ext/standard/metaphone.c b/ext/standard/metaphone.c
index 07143dfa7d..9d22868b8c 100644
--- a/ext/standard/metaphone.c
+++ b/ext/standard/metaphone.c
@@ -25,14 +25,14 @@
 #include "php.h"
 #include "php_metaphone.h"
 
-static int metaphone(unsigned char *word, int word_len, long max_phonemes, char **phoned_word, int traditional);
+static int metaphone(unsigned char *word, int word_len, long max_phonemes, zend_string **phoned_word, int traditional);
 
 /* {{{ proto string metaphone(string text[, int phones])
    Break english phrases down into their phonemes */
 PHP_FUNCTION(metaphone)
 {
 	char *str;
-	char *result = 0;
+	zend_string *result = NULL;
 	int str_len;
 	long phones = 0;
 
@@ -42,10 +42,10 @@ PHP_FUNCTION(metaphone)
 	}
 
 	if (metaphone((unsigned char *)str, str_len, phones, &result, 1) == 0) {
-		RETVAL_STRING(result, 0);
+		RETVAL_STR(result);
 	} else {
 		if (result) {
-			efree(result);
+			STR_FREE(result);
 		}
 		RETURN_FALSE;
 	}
@@ -144,17 +144,20 @@ 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 = safe_erealloc(*phoned_word, 2, sizeof(char), max_buffer_len); \
+							*phoned_word = STR_REALLOC(*phoned_word, 2 * sizeof(char) + max_buffer_len, 0); \
 							max_buffer_len += 2; \
 						} \
-						(*phoned_word)[p_idx++] = c; \
+						(*phoned_word)->val[p_idx++] = c; \
+						(*phoned_word)->len = p_idx; \
 					}
 /* Slap a null character on the end of the phoned word */
 #define End_Phoned_Word	{ \
 							if (p_idx == max_buffer_len) { \
-								*phoned_word = safe_erealloc(*phoned_word, 1, sizeof(char), max_buffer_len); \
+								*phoned_word = STR_REALLOC(*phoned_word, 1 * sizeof(char) + max_buffer_len, 0); \
+								max_buffer_len += 1; \
 							} \
-							(*phoned_word)[p_idx] = '\0'; \
+							(*phoned_word)->val[p_idx] = '\0'; \
+							(*phoned_word)->len = p_idx; \
 						}
 /* How long is the phoned word? */
 #define Phone_Len	(p_idx)
@@ -164,7 +167,7 @@ static char Lookahead(char *word, int how_far)
 
 /* {{{ metaphone
  */
-static int metaphone(unsigned char *word, int word_len, long max_phonemes, char **phoned_word, int traditional)
+static int metaphone(unsigned char *word, int word_len, long max_phonemes, zend_string **phoned_word, int traditional)
 {
 	int w_idx = 0;				/* point in the phonization we're at. */
 	int p_idx = 0;				/* end of the phoned phrase */
@@ -186,10 +189,10 @@ static int metaphone(unsigned char *word, int word_len, long max_phonemes, char
 /*-- Allocate memory for our phoned_phrase --*/
 	if (max_phonemes == 0) {	/* Assume largest possible */
 		max_buffer_len = word_len;
-		*phoned_word = safe_emalloc(sizeof(char), word_len, 1);
+		*phoned_word = STR_ALLOC(sizeof(char) * word_len + 1, 0);
 	} else {
 		max_buffer_len = max_phonemes;
-		*phoned_word = safe_emalloc(sizeof(char), max_phonemes, 1);
+		*phoned_word = STR_ALLOC(sizeof(char) * max_phonemes + 1, 0);
 	}
 
 
diff --git a/ext/standard/microtime.c b/ext/standard/microtime.c
index fe2236683a..f8e19c74ca 100644
--- a/ext/standard/microtime.c
+++ b/ext/standard/microtime.c
@@ -84,7 +84,7 @@ static void _php_gettimeofday(INTERNAL_FUNCTION_PARAMETERS, int mode)
 		char ret[100];
 
 		snprintf(ret, 100, "%.8F %ld", tp.tv_usec / MICRO_IN_SEC, tp.tv_sec);
-		RETURN_STRING(ret, 1);
+		RETURN_STRING(ret);
 	}
 }
 
diff --git a/ext/standard/pack.c b/ext/standard/pack.c
index 16a30668dc..53a18c8fec 100644
--- a/ext/standard/pack.c
+++ b/ext/standard/pack.c
@@ -84,13 +84,13 @@ static int little_endian_long_map[4];
 
 /* {{{ php_pack
  */
-static void php_pack(zval **val, int size, int *map, char *output)
+static void php_pack(zval *val, int size, int *map, char *output)
 {
 	int i;
 	char *v;
 
 	convert_to_long_ex(val);
-	v = (char *) &Z_LVAL_PP(val);
+	v = (char *) &Z_LVAL_P(val);
 
 	for (i = 0; i < size; i++) {
 		*output++ = v[map[i]];
@@ -105,7 +105,7 @@ static void php_pack(zval **val, int size, int *map, char *output)
    Takes one or more arguments and packs them into a binary string according to the format argument */
 PHP_FUNCTION(pack)
 {
-	zval ***argv = NULL;
+	zval *argv = NULL;
 	int num_args, i;
 	int currentarg;
 	char *format;
@@ -120,13 +120,13 @@ PHP_FUNCTION(pack)
 		return;
 	}
 
-	if (Z_ISREF_PP(argv[0])) {
-		SEPARATE_ZVAL(argv[0]);
+	if (Z_ISREF(argv[0])) {
+		SEPARATE_ZVAL(&argv[0]);
 	}
-	convert_to_string_ex(argv[0]);
+	convert_to_string_ex(&argv[0]);
 
-	format = Z_STRVAL_PP(argv[0]);
-	formatlen = Z_STRLEN_PP(argv[0]);
+	format = Z_STRVAL(argv[0]);
+	formatlen = Z_STRLEN(argv[0]);
 
 	/* We have a maximum of <formatlen> format codes to deal with */
 	formatcodes = safe_emalloc(formatlen, sizeof(*formatcodes), 0);
@@ -174,7 +174,6 @@ PHP_FUNCTION(pack)
 			case 'h': 
 			case 'H':
 				if (currentarg >= num_args) {
-					efree(argv);
 					efree(formatcodes);
 					efree(formatargs);
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: not enough arguments", code);
@@ -182,11 +181,11 @@ PHP_FUNCTION(pack)
 				}
 
 				if (arg < 0) {
-					if (Z_ISREF_PP(argv[currentarg])) {
-						SEPARATE_ZVAL(argv[currentarg]);
+					if (Z_ISREF(argv[currentarg])) {
+						SEPARATE_ZVAL(&argv[currentarg]);
 					}
-					convert_to_string_ex(argv[currentarg]);
-					arg = Z_STRLEN_PP(argv[currentarg]);
+					convert_to_string_ex(&argv[currentarg]);
+					arg = Z_STRLEN(argv[currentarg]);
 					if (code == 'Z') {
 						/* add one because Z is always NUL-terminated:
 						 * pack("Z*", "aa") === "aa\0"
@@ -220,7 +219,6 @@ PHP_FUNCTION(pack)
 				currentarg += arg;
 
 				if (currentarg > num_args) {
-					efree(argv);
 					efree(formatcodes);
 					efree(formatargs);
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: too few arguments", code);
@@ -229,7 +227,6 @@ PHP_FUNCTION(pack)
 				break;
 
 			default:
-				efree(argv);
 				efree(formatcodes);
 				efree(formatargs);
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: unknown format code", code);
@@ -318,7 +315,7 @@ PHP_FUNCTION(pack)
 	for (i = 0; i < formatcount; i++) {
 	    int code = (int) formatcodes[i];
 		int arg = formatargs[i];
-		zval **val;
+		zval *val;
 
 		switch ((int) code) {
 			case 'a': 
@@ -326,13 +323,13 @@ PHP_FUNCTION(pack)
 			case 'Z': {
 				int arg_cp = (code != 'Z') ? arg : MAX(0, arg - 1);
 				memset(&output[outputpos], (code == 'a' || code == 'Z') ? '\0' : ' ', arg);
-				val = argv[currentarg++];
-				if (Z_ISREF_PP(val)) {
+				val = &argv[currentarg++];
+				if (Z_ISREF_P(val)) {
 					SEPARATE_ZVAL(val);
 				}
 				convert_to_string_ex(val);
-				memcpy(&output[outputpos], Z_STRVAL_PP(val),
-					   (Z_STRLEN_PP(val) < arg_cp) ? Z_STRLEN_PP(val) : arg_cp);
+				memcpy(&output[outputpos], Z_STRVAL_P(val),
+					   (Z_STRLEN_P(val) < arg_cp) ? Z_STRLEN_P(val) : arg_cp);
 				outputpos += arg;
 				break;
 			}
@@ -343,16 +340,16 @@ PHP_FUNCTION(pack)
 				int first = 1;
 				char *v;
 
-				val = argv[currentarg++];
-				if (Z_ISREF_PP(val)) {
+				val = &argv[currentarg++];
+				if (Z_ISREF_P(val)) {
 					SEPARATE_ZVAL(val);
 				}
 				convert_to_string_ex(val);
-				v = Z_STRVAL_PP(val);
+				v = Z_STRVAL_P(val);
 				outputpos--;
-				if(arg > Z_STRLEN_PP(val)) {
+				if(arg > Z_STRLEN_P(val)) {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Type %c: not enough characters in string", code);
-					arg = Z_STRLEN_PP(val);
+					arg = Z_STRLEN_P(val);
 				}
 
 				while (arg-- > 0) {
@@ -386,7 +383,7 @@ PHP_FUNCTION(pack)
 			case 'c': 
 			case 'C':
 				while (arg-- > 0) {
-					php_pack(argv[currentarg++], 1, byte_map, &output[outputpos]);
+					php_pack(&argv[currentarg++], 1, byte_map, &output[outputpos]);
 					outputpos++;
 				}
 				break;
@@ -404,7 +401,7 @@ PHP_FUNCTION(pack)
 				}
 
 				while (arg-- > 0) {
-					php_pack(argv[currentarg++], 2, map, &output[outputpos]);
+					php_pack(&argv[currentarg++], 2, map, &output[outputpos]);
 					outputpos += 2;
 				}
 				break;
@@ -413,7 +410,7 @@ PHP_FUNCTION(pack)
 			case 'i': 
 			case 'I': 
 				while (arg-- > 0) {
-					php_pack(argv[currentarg++], sizeof(int), int_map, &output[outputpos]);
+					php_pack(&argv[currentarg++], sizeof(int), int_map, &output[outputpos]);
 					outputpos += sizeof(int);
 				}
 				break;
@@ -431,7 +428,7 @@ PHP_FUNCTION(pack)
 				}
 
 				while (arg-- > 0) {
-					php_pack(argv[currentarg++], 4, map, &output[outputpos]);
+					php_pack(&argv[currentarg++], 4, map, &output[outputpos]);
 					outputpos += 4;
 				}
 				break;
@@ -441,9 +438,9 @@ PHP_FUNCTION(pack)
 				float v;
 
 				while (arg-- > 0) {
-					val = argv[currentarg++];
+					val = &argv[currentarg++];
 					convert_to_double_ex(val);
-					v = (float) Z_DVAL_PP(val);
+					v = (float) Z_DVAL_P(val);
 					memcpy(&output[outputpos], &v, sizeof(v));
 					outputpos += sizeof(v);
 				}
@@ -454,9 +451,9 @@ PHP_FUNCTION(pack)
 				double v;
 
 				while (arg-- > 0) {
-					val = argv[currentarg++];
+					val = &argv[currentarg++];
 					convert_to_double_ex(val);
-					v = (double) Z_DVAL_PP(val);
+					v = (double) Z_DVAL_P(val);
 					memcpy(&output[outputpos], &v, sizeof(v));
 					outputpos += sizeof(v);
 				}
@@ -485,11 +482,10 @@ PHP_FUNCTION(pack)
 		}
 	}
 
-	efree(argv);
 	efree(formatcodes);
 	efree(formatargs);
 	output[outputpos] = '\0';
-	RETVAL_STRINGL(output, outputpos, 1);
+	RETVAL_STRINGL(output, outputpos);
 	efree(output);
 }
 /* }}} */
@@ -685,7 +681,7 @@ PHP_FUNCTION(unpack)
 
 						size = len;
 
-						add_assoc_stringl(return_value, n, &input[inputpos], len, 1);
+						add_assoc_stringl(return_value, n, &input[inputpos], len);
 						break;
 					}
 					case 'A': {
@@ -711,7 +707,7 @@ PHP_FUNCTION(unpack)
 								break;
 						}
 
-						add_assoc_stringl(return_value, n, &input[inputpos], len + 1, 1);
+						add_assoc_stringl(return_value, n, &input[inputpos], len + 1);
 						break;
 					}
 					/* New option added for Z to remain in-line with the Perl implementation */
@@ -735,7 +731,7 @@ PHP_FUNCTION(unpack)
 						}
 						len = s;
 
-						add_assoc_stringl(return_value, n, &input[inputpos], len, 1);
+						add_assoc_stringl(return_value, n, &input[inputpos], len);
 						break;
 					}
 
@@ -778,7 +774,7 @@ PHP_FUNCTION(unpack)
 						}
 
 						buf[len] = '\0';
-						add_assoc_stringl(return_value, n, buf, len, 1);
+						add_assoc_stringl(return_value, n, buf, len);
 						efree(buf);
 						break;
 					}
diff --git a/ext/standard/password.c b/ext/standard/password.c
index 0da1de66f5..738bdcc7ac 100644
--- a/ext/standard/password.c
+++ b/ext/standard/password.c
@@ -82,28 +82,27 @@ static int php_password_salt_is_alphabet(const char *str, const size_t len) /* {
 static int php_password_salt_to64(const char *str, const size_t str_len, const size_t out_len, char *ret) /* {{{ */
 {
 	size_t pos = 0;
-	size_t ret_len = 0;
-	unsigned char *buffer;
+	zend_string *buffer;
 	if ((int) str_len < 0) {
 		return FAILURE;
 	}
-	buffer = php_base64_encode((unsigned char*) str, (int) str_len, (int*) &ret_len);
-	if (ret_len < out_len) {
+	buffer = php_base64_encode((unsigned char*) str, (int) str_len);
+	if (buffer->len < out_len) {
 		/* Too short of an encoded string generated */
-		efree(buffer);
+		STR_RELEASE(buffer);
 		return FAILURE;
 	}
 	for (pos = 0; pos < out_len; pos++) {
-		if (buffer[pos] == '+') {
+		if (buffer->val[pos] == '+') {
 			ret[pos] = '.';
-		} else if (buffer[pos] == '=') {
-			efree(buffer);
+		} else if (buffer->val[pos] == '=') {
+			STR_FREE(buffer);
 			return FAILURE;
 		} else {
-			ret[pos] = buffer[pos];
+			ret[pos] = buffer->val[pos];
 		}
 	}
-	efree(buffer);
+	STR_FREE(buffer);
 	return SUCCESS;
 }
 /* }}} */
@@ -177,7 +176,7 @@ PHP_FUNCTION(password_get_info)
 	php_password_algo algo;
 	int hash_len;
 	char *hash, *algo_name;
-	zval *options;
+	zval options;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &hash, &hash_len) == FAILURE) {
 		return;
@@ -188,8 +187,7 @@ PHP_FUNCTION(password_get_info)
 		RETURN_FALSE;
 	}
 
-	ALLOC_INIT_ZVAL(options);
-	array_init(options);
+	array_init(&options);
 
 	algo = php_password_determine_algo(hash, (size_t) hash_len);
 	algo_name = php_password_get_algo_name(algo);
@@ -199,7 +197,7 @@ PHP_FUNCTION(password_get_info)
 			{
 				long cost = PHP_PASSWORD_BCRYPT_COST;
 				sscanf(hash, "$2y$%ld$", &cost);
-				add_assoc_long(options, "cost", cost);
+				add_assoc_long(&options, "cost", cost);
 			}
 			break;
 		case PHP_PASSWORD_UNKNOWN:
@@ -210,8 +208,8 @@ PHP_FUNCTION(password_get_info)
 	array_init(return_value);
 	
 	add_assoc_long(return_value, "algo", algo);
-	add_assoc_string(return_value, "algoName", algo_name, 1);
-	add_assoc_zval(return_value, "options", options);	
+	add_assoc_string(return_value, "algoName", algo_name);
+	add_assoc_zval(return_value, "options", &options);	
 }
 
 PHP_FUNCTION(password_needs_rehash)
@@ -221,7 +219,7 @@ PHP_FUNCTION(password_needs_rehash)
 	int hash_len;
 	char *hash;
 	HashTable *options = 0;
-	zval **option_buffer;
+	zval *option_buffer;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|H", &hash, &hash_len, &new_algo, &options) == FAILURE) {
 		return;
@@ -243,15 +241,15 @@ PHP_FUNCTION(password_needs_rehash)
 			{
 				long new_cost = PHP_PASSWORD_BCRYPT_COST, cost = 0;
 				
-				if (options && zend_symtable_find(options, "cost", sizeof("cost"), (void **) &option_buffer) == SUCCESS) {
-					if (Z_TYPE_PP(option_buffer) != IS_LONG) {
+				if (options && (option_buffer = zend_symtable_str_find(options, "cost", sizeof("cost")-1)) != NULL) {
+					if (Z_TYPE_P(option_buffer) != IS_LONG) {
 						zval cast_option_buffer;
-						MAKE_COPY_ZVAL(option_buffer, &cast_option_buffer);
+						ZVAL_DUP(&cast_option_buffer, option_buffer);
 						convert_to_long(&cast_option_buffer);
 						new_cost = Z_LVAL(cast_option_buffer);
 						zval_dtor(&cast_option_buffer);
 					} else {
-						new_cost = Z_LVAL_PP(option_buffer);
+						new_cost = Z_LVAL_P(option_buffer);
 					}
 				}
 
@@ -274,17 +272,18 @@ PHP_FUNCTION(password_verify)
 {
 	int status = 0, i;
 	int password_len, hash_len;
-	char *ret, *password, *hash;
+	char *password, *hash;
+	zend_string *ret;
 	
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &password, &password_len, &hash, &hash_len) == FAILURE) {
 		RETURN_FALSE;
 	}
-	if (php_crypt(password, password_len, hash, hash_len, &ret) == FAILURE) {
+	if ((ret = php_crypt(password, password_len, hash, hash_len)) == NULL) {
 		RETURN_FALSE;
 	}
 
-	if (strlen(ret) != hash_len || hash_len < 13) {
-		efree(ret);
+	if (ret->len != hash_len || hash_len < 13) {
+		STR_FREE(ret);
 		RETURN_FALSE;
 	}
 	
@@ -293,10 +292,10 @@ PHP_FUNCTION(password_verify)
 	 * equality check that will always check every byte of both
 	 * values. */
 	for (i = 0; i < hash_len; i++) {
-		status |= (ret[i] ^ hash[i]);
+		status |= (ret->val[i] ^ hash[i]);
 	}
 
-	efree(ret);
+	STR_FREE(ret);
 
 	RETURN_BOOL(status == 0);
 	
@@ -307,12 +306,13 @@ PHP_FUNCTION(password_verify)
 Hash a password */
 PHP_FUNCTION(password_hash)
 {
-	char *hash_format, *hash, *salt, *password, *result;
+	char *hash_format, *hash, *salt, *password;
 	long algo = 0;
 	int password_len = 0, hash_len;
 	size_t salt_len = 0, required_salt_len = 0, hash_format_len;
 	HashTable *options = 0;
-	zval **option_buffer;
+	zval *option_buffer;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|H", &password, &password_len, &algo, &options) == FAILURE) {
 		return;
@@ -323,15 +323,15 @@ PHP_FUNCTION(password_hash)
 		{
 			long cost = PHP_PASSWORD_BCRYPT_COST;
 	
-			if (options && zend_symtable_find(options, "cost", 5, (void **) &option_buffer) == SUCCESS) {
-				if (Z_TYPE_PP(option_buffer) != IS_LONG) {
+			if (options && (option_buffer = zend_symtable_str_find(options, "cost", sizeof("cost")-1)) != NULL) {
+				if (Z_TYPE_P(option_buffer) != IS_LONG) {
 					zval cast_option_buffer;
-					MAKE_COPY_ZVAL(option_buffer, &cast_option_buffer);
+					ZVAL_DUP(&cast_option_buffer, option_buffer);
 					convert_to_long(&cast_option_buffer);
 					cost = Z_LVAL(cast_option_buffer);
 					zval_dtor(&cast_option_buffer);
 				} else {
-					cost = Z_LVAL_PP(option_buffer);
+					cost = Z_LVAL_P(option_buffer);
 				}
 			}
 	
@@ -352,20 +352,21 @@ PHP_FUNCTION(password_hash)
 			RETURN_NULL();
 	}
 
-	if (options && zend_symtable_find(options, "salt", 5, (void**) &option_buffer) == SUCCESS) {
+	if (options && (option_buffer = zend_symtable_str_find(options, "salt", sizeof("salt")-1)) != NULL) {
 		char *buffer;
 		int buffer_len_int = 0;
 		size_t buffer_len;
-		switch (Z_TYPE_PP(option_buffer)) {
+		switch (Z_TYPE_P(option_buffer)) {
 			case IS_STRING:
-				buffer = estrndup(Z_STRVAL_PP(option_buffer), Z_STRLEN_PP(option_buffer));
-				buffer_len_int = Z_STRLEN_PP(option_buffer);
+				buffer = estrndup(Z_STRVAL_P(option_buffer), Z_STRLEN_P(option_buffer));
+				buffer_len_int = Z_STRLEN_P(option_buffer);
 				break;
 			case IS_LONG:
 			case IS_DOUBLE:
 			case IS_OBJECT: {
 				zval cast_option_buffer;
-				MAKE_COPY_ZVAL(option_buffer, &cast_option_buffer);
+
+				ZVAL_DUP(&cast_option_buffer, option_buffer);
 				convert_to_string(&cast_option_buffer);
 				if (Z_TYPE(cast_option_buffer) == IS_STRING) {
 					buffer = estrndup(Z_STRVAL(cast_option_buffer), Z_STRLEN(cast_option_buffer));
@@ -433,19 +434,19 @@ PHP_FUNCTION(password_hash)
 	/* This cast is safe, since both values are defined here in code and cannot overflow */
 	hash_len = (int) (hash_format_len + salt_len);
 
-	if (php_crypt(password, password_len, hash, hash_len, &result) == FAILURE) {
+	if ((result = php_crypt(password, password_len, hash, hash_len)) == NULL) {
 		efree(hash);
 		RETURN_FALSE;
 	}
 
 	efree(hash);
 
-	if (strlen(result) < 13) {
-		efree(result);
+	if (result->len < 13) {
+		STR_FREE(result);
 		RETURN_FALSE;
 	}
 
-	RETURN_STRING(result, 0);
+	RETURN_STR(result);
 }
 /* }}} */
 
diff --git a/ext/standard/php_array.h b/ext/standard/php_array.h
index 1b30e34787..d123ddfe41 100644
--- a/ext/standard/php_array.h
+++ b/ext/standard/php_array.h
@@ -103,7 +103,7 @@ PHP_FUNCTION(array_key_exists);
 PHP_FUNCTION(array_chunk);
 PHP_FUNCTION(array_combine);
 
-PHPAPI void php_splice(HashTable *ht, zend_uint offset, zend_uint length, zval ***list, zend_uint list_count, HashTable *removed TSRMLS_DC);
+PHPAPI HashTable* php_splice(HashTable *, int, int, zval *, int, HashTable *);
 PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS_DC);
 PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC);
 PHPAPI int php_multisort_compare(const void *a, const void *b TSRMLS_DC);
diff --git a/ext/standard/php_crypt.h b/ext/standard/php_crypt.h
index f0b96010bc..a23811c320 100644
--- a/ext/standard/php_crypt.h
+++ b/ext/standard/php_crypt.h
@@ -23,7 +23,7 @@
 #ifndef PHP_CRYPT_H
 #define PHP_CRYPT_H
 
-PHPAPI int php_crypt(const char *password, const int pass_len, const char *salt, int salt_len, char **result);
+PHPAPI zend_string *php_crypt(const char *password, const int pass_len, const char *salt, int salt_len);
 PHP_FUNCTION(crypt);
 #if HAVE_CRYPT
 PHP_MINIT_FUNCTION(crypt);
diff --git a/ext/standard/php_filestat.h b/ext/standard/php_filestat.h
index ef72e584f1..4f29553aea 100644
--- a/ext/standard/php_filestat.h
+++ b/ext/standard/php_filestat.h
@@ -61,11 +61,6 @@ PHP_FUNCTION(touch);
 #endif
 PHP_FUNCTION(clearstatcache);
 
-#define MAKE_LONG_ZVAL_INCREF(name, val)\
-	MAKE_STD_ZVAL(name); \
-	ZVAL_LONG(name, val); \
-	Z_ADDREF_P(name); 
-
 #ifdef PHP_WIN32
 #define S_IRUSR S_IREAD
 #define S_IWUSR S_IWRITE
diff --git a/ext/standard/php_incomplete_class.h b/ext/standard/php_incomplete_class.h
index b5a2a322f7..804ca05206 100644
--- a/ext/standard/php_incomplete_class.h
+++ b/ext/standard/php_incomplete_class.h
@@ -30,24 +30,20 @@
 	/* OBJECTS_FIXME: Fix for new object model */	\
 	if (Z_OBJ_HT_P(struc)->get_class_entry && \
             Z_OBJCE_P(struc) == BG(incomplete_class)) {	\
-		class_name = php_lookup_class_name(struc, &name_len); \
+		class_name = php_lookup_class_name(struc); \
 		if (!class_name) { \
-			name_len = sizeof(INCOMPLETE_CLASS) - 1; \
-			class_name = estrndup(INCOMPLETE_CLASS, name_len); \
+			class_name = STR_INIT(INCOMPLETE_CLASS, sizeof(INCOMPLETE_CLASS) - 1, 0); \
 		} \
-		free_class_name = 1; \
 		incomplete_class = 1; \
 	} else { \
-		free_class_name = !zend_get_object_classname(struc, (const char **)&class_name, &name_len TSRMLS_CC);\
+		class_name = zend_get_object_classname(Z_OBJ_P(struc) TSRMLS_CC); \
 	}
 
 #define PHP_CLEANUP_CLASS_ATTRIBUTES()	\
-	if (free_class_name) efree(class_name)
+	STR_RELEASE(class_name)
 
 #define PHP_CLASS_ATTRIBUTES											\
-	char *class_name;													\
-	zend_uint name_len;													\
-	zend_bool free_class_name = 0;										\
+	zend_string *class_name;											\
 	zend_bool incomplete_class = 0
 
 #define INCOMPLETE_CLASS "__PHP_Incomplete_Class"
@@ -58,7 +54,7 @@ extern "C" {
 #endif
 
 PHPAPI zend_class_entry *php_create_incomplete_class(TSRMLS_D);
-PHPAPI char *php_lookup_class_name(zval *object, zend_uint *nlen);
+PHPAPI zend_string *php_lookup_class_name(zval *object);
 PHPAPI void  php_store_class_name(zval *object, const char *name, zend_uint len);
 
 #ifdef __cplusplus
diff --git a/ext/standard/php_math.h b/ext/standard/php_math.h
index 8dec21acf3..0334ac40ce 100644
--- a/ext/standard/php_math.h
+++ b/ext/standard/php_math.h
@@ -22,12 +22,12 @@
 #ifndef PHP_MATH_H
 #define PHP_MATH_H
 
-PHPAPI char *_php_math_number_format(double, int, char, char);
-PHPAPI char *_php_math_number_format_ex(double, int, char *, size_t, char *, size_t);
-PHPAPI char * _php_math_longtobase(zval *arg, int base);
+PHPAPI zend_string *_php_math_number_format(double, int, char, char);
+PHPAPI zend_string *_php_math_number_format_ex(double, int, char *, size_t, char *, size_t);
+PHPAPI zend_string * _php_math_longtobase(zval *arg, int base TSRMLS_DC);
 PHPAPI long _php_math_basetolong(zval *arg, int base);
 PHPAPI int _php_math_basetozval(zval *arg, int base, zval *ret);
-PHPAPI char * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC);
+PHPAPI zend_string * _php_math_zvaltobase(zval *arg, int base TSRMLS_DC);
 
 PHP_FUNCTION(sin);
 PHP_FUNCTION(cos);
diff --git a/ext/standard/php_smart_str.h b/ext/standard/php_smart_str.h
index d59258f091..5cc3a62137 100644
--- a/ext/standard/php_smart_str.h
+++ b/ext/standard/php_smart_str.h
@@ -29,8 +29,8 @@
 #endif
 
 #define smart_str_0(x) do {											\
-	if ((x)->c) {													\
-		(x)->c[(x)->len] = '\0';									\
+	if ((x)->s) {													\
+		(x)->s->val[(x)->s->len] = '\0';							\
 	}																\
 } while (0)
 
@@ -42,28 +42,31 @@
 #define SMART_STR_START_SIZE 78
 #endif
 
+
 #ifdef SMART_STR_USE_REALLOC
-#define SMART_STR_REALLOC(a,b,c) realloc((a),(b))
+#define SMART_STR_DO_REALLOC(b, w) do {								\
+	(b)->s = erealloc((buf)->s, _STR_HEADER_SIZE + (b)->a + 1);		\
+} while (0)
 #else
-#define SMART_STR_REALLOC(a,b,c) perealloc((a),(b),(c))
+#define SMART_STR_DO_REALLOC(b, w) do {								\
+	(b)->s = perealloc((b)->s, _STR_HEADER_SIZE + (b)->a + 1, (w));	\
+} while (0)
 #endif
 
-#define SMART_STR_DO_REALLOC(d, what) \
-	(d)->c = SMART_STR_REALLOC((d)->c, (d)->a + 1, (what))
 
 #define smart_str_alloc4(d, n, what, newlen) do {					\
-	if (!(d)->c) {													\
-		(d)->len = 0;												\
+	if (!(d)->s) {													\
 		newlen = (n);												\
 		(d)->a = newlen < SMART_STR_START_SIZE 						\
 				? SMART_STR_START_SIZE 								\
 				: newlen + SMART_STR_PREALLOC;						\
-		SMART_STR_DO_REALLOC(d, what);								\
+		(d)->s = STR_ALLOC((d)->a, (what));							\
+		(d)->s->len = 0;											\
 	} else {														\
-		newlen = (d)->len + (n);									\
+		newlen = (d)->s->len + (n);									\
 		if (newlen >= (d)->a) {										\
 			(d)->a = newlen + SMART_STR_PREALLOC;					\
-			SMART_STR_DO_REALLOC(d, what);							\
+			SMART_STR_DO_REALLOC((d), (what));						\
 		}															\
 	}																\
 } while (0)
@@ -93,20 +96,20 @@
 #define smart_str_append_unsigned(dest, val) \
 	smart_str_append_unsigned_ex((dest), (val), 0)
 
-#define smart_str_appendc_ex(dest, ch, what) do {					\
-	register size_t __nl;											\
-	smart_str_alloc4((dest), 1, (what), __nl);						\
-	(dest)->len = __nl;												\
-	((unsigned char *) (dest)->c)[(dest)->len - 1] = (ch);			\
+#define smart_str_appendc_ex(dest, ch, what) do {				   \
+	register size_t __nl;										   \
+	smart_str_alloc4((dest), 1, (what), __nl);					   \
+	(dest)->s->len = __nl;										   \
+	((unsigned char *) (dest)->s->val)[(dest)->s->len - 1] = (ch); \
 } while (0)
 
-#define smart_str_free_ex(s, what) do {								\
-	smart_str *__s = (smart_str *) (s);								\
-	if (__s->c) {													\
-		pefree(__s->c, what);										\
-		__s->c = NULL;												\
+#define smart_str_free_ex(buf, what) do {							\
+	smart_str *__s = (smart_str *) (buf);							\
+	if (__s->s) {													\
+		STR_RELEASE(__s->s);										\
+		__s->s = NULL;												\
 	}																\
-	__s->a = __s->len = 0;											\
+	__s->a = 0;														\
 } while (0)
 
 #define smart_str_appendl_ex(dest, src, nlen, what) do {			\
@@ -114,8 +117,8 @@
 	smart_str *__dest = (smart_str *) (dest);						\
 																	\
 	smart_str_alloc4(__dest, (nlen), (what), __nl);					\
-	memcpy(__dest->c + __dest->len, (src), (nlen));					\
-	__dest->len = __nl;												\
+	memcpy(__dest->s->val + __dest->s->len, (src), (nlen));			\
+	__dest->s->len = __nl;											\
 } while (0)
 
 /* input: buf points to the END of the buffer */
@@ -131,12 +134,12 @@
 } while (0)
 
 /* buf points to the END of the buffer */
-#define smart_str_print_long4(buf, num, vartype, result) do {	\
+#define smart_str_print_long4(buf, num, vartype, result) do {		\
 	if (num < 0) {													\
 		/* this might cause problems when dealing with LONG_MIN		\
 		   and machines which don't support long long.  Works		\
 		   flawlessly on 32bit x86 */								\
-		smart_str_print_unsigned4((buf), -(num), vartype, (result));	\
+		smart_str_print_unsigned4((buf), -(num), vartype, (result));\
 		*--(result) = '-';											\
 	} else {														\
 		smart_str_print_unsigned4((buf), (num), vartype, (result));	\
@@ -178,15 +181,13 @@ static inline char *smart_str_print_unsigned(char *buf, long num) {
 #define smart_str_append_off_t_ex(dest, num, type) \
 	smart_str_append_generic_ex((dest), (num), (type), off_t, _long)
 
-#define smart_str_append_ex(dest, src, what) \
-	smart_str_appendl_ex((dest), ((smart_str *)(src))->c, \
-		((smart_str *)(src))->len, (what));
-
+#define smart_str_append_ex(dest, src, what) 						\
+	smart_str_appendl_ex((dest), ((smart_str *)(src))->s->val, 		\
+		((smart_str *)(src))->s->len, (what));
 
 #define smart_str_setl(dest, src, nlen) do {						\
-	(dest)->len = (nlen);											\
-	(dest)->a = (nlen) + 1;											\
-	(dest)->c = (char *) (src);										\
+	smart_str_free((dest));											\
+	smart_str_appendl_ex((dest), (src), (nlen), 0);					\
 } while (0)
 
 #define smart_str_sets(dest, src) \
diff --git a/ext/standard/php_smart_str_public.h b/ext/standard/php_smart_str_public.h
index b445dd7767..7ce299e442 100644
--- a/ext/standard/php_smart_str_public.h
+++ b/ext/standard/php_smart_str_public.h
@@ -24,8 +24,7 @@
 #include <sys/types.h>
 
 typedef struct {
-	char *c;
-	size_t len;
+	zend_string *s;
 	size_t a;
 } smart_str;
 
diff --git a/ext/standard/php_string.h b/ext/standard/php_string.h
index 2396d40461..0f4240ea57 100644
--- a/ext/standard/php_string.h
+++ b/ext/standard/php_string.h
@@ -121,17 +121,17 @@ PHPAPI struct lconv *localeconv_r(struct lconv *out);
 PHPAPI char *php_strtoupper(char *s, size_t len);
 PHPAPI char *php_strtolower(char *s, size_t len);
 PHPAPI char *php_strtr(char *str, int len, char *str_from, char *str_to, int trlen);
-PHPAPI char *php_addslashes(char *str, int length, int *new_length, int freeit TSRMLS_DC);
-PHPAPI char *php_addcslashes(const char *str, int length, int *new_length, int freeit, char *what, int wlength TSRMLS_DC);
+PHPAPI zend_string *php_addslashes(char *str, int length, int should_free TSRMLS_DC);
+PHPAPI zend_string *php_addcslashes(const char *str, int length, int freeit, char *what, int wlength TSRMLS_DC);
 PHPAPI void php_stripslashes(char *str, int *len TSRMLS_DC);
 PHPAPI void php_stripcslashes(char *str, int *len);
-PHPAPI void php_basename(const char *s, size_t len, char *suffix, size_t sufflen, char **p_ret, size_t *p_len TSRMLS_DC);
+PHPAPI zend_string *php_basename(const char *s, size_t len, char *suffix, size_t sufflen TSRMLS_DC);
 PHPAPI size_t php_dirname(char *str, size_t len);
 PHPAPI char *php_stristr(char *s, char *t, size_t s_len, size_t t_len);
-PHPAPI char *php_str_to_str_ex(char *haystack, int length, char *needle,
-		int needle_len, char *str, int str_len, int *_new_length, int case_sensitivity, int *replace_count);
-PHPAPI char *php_str_to_str(char *haystack, int length, char *needle,
-		int needle_len, char *str, int str_len, int *_new_length);
+PHPAPI zend_string *php_str_to_str_ex(char *haystack, int length, char *needle,
+		int needle_len, char *str, int str_len, int case_sensitivity, int *replace_count);
+PHPAPI zend_string *php_str_to_str(char *haystack, int length, char *needle,
+		int needle_len, char *str, int str_len);
 PHPAPI char *php_trim(char *c, int len, char *what, int what_len, zval *return_value, int mode TSRMLS_DC);
 PHPAPI size_t php_strip_tags(char *rbuf, int len, int *state, char *allow, int allow_len);
 PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, int *stateptr, char *allow, int allow_len, zend_bool allow_tag_spaces);
diff --git a/ext/standard/php_uuencode.h b/ext/standard/php_uuencode.h
index 5b2b852606..fedfe660e9 100644
--- a/ext/standard/php_uuencode.h
+++ b/ext/standard/php_uuencode.h
@@ -24,8 +24,8 @@
 PHP_FUNCTION(convert_uudecode);
 PHP_FUNCTION(convert_uuencode);
 
-PHPAPI int php_uudecode(char *src, int src_len, char **dest);
-PHPAPI int php_uuencode(char *src, int src_len, char **dest);
+PHPAPI zend_string *php_uudecode(char *src, int src_len);
+PHPAPI zend_string *php_uuencode(char *src, int src_len);
 
 #endif /* PHP_UUENCODE_H */
 
diff --git a/ext/standard/php_var.h b/ext/standard/php_var.h
index 48692e57c3..2dc13f4012 100644
--- a/ext/standard/php_var.h
+++ b/ext/standard/php_var.h
@@ -32,11 +32,11 @@ PHP_FUNCTION(unserialize);
 PHP_FUNCTION(memory_get_usage);
 PHP_FUNCTION(memory_get_peak_usage);
 
-PHPAPI void php_var_dump(zval **struc, int level TSRMLS_DC);
-PHPAPI void php_var_export(zval **struc, int level TSRMLS_DC);
-PHPAPI void php_var_export_ex(zval **struc, int level, smart_str *buf TSRMLS_DC);
+PHPAPI void php_var_dump(zval *struc, int level TSRMLS_DC);
+PHPAPI void php_var_export(zval *struc, int level TSRMLS_DC);
+PHPAPI void php_var_export_ex(zval *struc, int level, smart_str *buf TSRMLS_DC);
 
-PHPAPI void php_debug_zval_dump(zval **struc, int level TSRMLS_DC);
+PHPAPI void php_debug_zval_dump(zval *struc, int level TSRMLS_DC);
 
 typedef HashTable* php_serialize_data_t;
 
@@ -49,15 +49,17 @@ struct php_unserialize_data {
 
 typedef struct php_unserialize_data* php_unserialize_data_t;
 
-PHPAPI void php_var_serialize(smart_str *buf, zval **struc, php_serialize_data_t *var_hash TSRMLS_DC);
-PHPAPI int php_var_unserialize(zval **rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC);
+PHPAPI void php_var_serialize(smart_str *buf, zval *struc, php_serialize_data_t *var_hash TSRMLS_DC);
+PHPAPI int php_var_unserialize(zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC);
+PHPAPI int php_var_unserialize_ref(zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC);
+PHPAPI int php_var_unserialize_intern(zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC);
 
 #define PHP_VAR_SERIALIZE_INIT(var_hash_ptr) \
 do  { \
 	/* fprintf(stderr, "SERIALIZE_INIT      == lock: %u, level: %u\n", BG(serialize_lock), BG(serialize).level); */ \
 	if (BG(serialize_lock) || !BG(serialize).level) { \
 		ALLOC_HASHTABLE(var_hash_ptr); \
-		zend_hash_init((var_hash_ptr), 10, NULL, NULL, 0); \
+		zend_hash_init((var_hash_ptr), 16, NULL, NULL, 0); \
 		if (!BG(serialize_lock)) { \
 			BG(serialize).var_hash = (void *)(var_hash_ptr); \
 			BG(serialize).level = 1; \
@@ -113,13 +115,10 @@ do { \
 	} \
 } while (0)
 
-PHPAPI void var_replace(php_unserialize_data_t *var_hash, zval *ozval, zval **nzval);
-PHPAPI void var_push_dtor(php_unserialize_data_t *var_hash, zval **val);
-PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval **rval);
+PHPAPI void var_replace(php_unserialize_data_t *var_hash, zval *ozval, zval *nzval);
+PHPAPI void var_push_dtor(php_unserialize_data_t *var_hash, zval *val);
+PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval *rval);
 PHPAPI void var_destroy(php_unserialize_data_t *var_hash);
-
-#define PHP_VAR_UNSERIALIZE_ZVAL_CHANGED(var_hash, ozval, nzval) \
-	var_replace((var_hash), (ozval), &(nzval))
 	
 PHPAPI zend_class_entry *php_create_empty_class(char *class_name, int len);
 
diff --git a/ext/standard/proc_open.c b/ext/standard/proc_open.c
index 50ceb605ed..0ab8ffa7e7 100644
--- a/ext/standard/proc_open.c
+++ b/ext/standard/proc_open.c
@@ -75,17 +75,17 @@ static int le_proc_open;
 /* {{{ _php_array_to_envp */
 static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent TSRMLS_DC)
 {
-	zval **element;
+	zval *element;
 	php_process_env_t env;
-	char *string_key, *data;
+	zend_string *string_key;
+	char *data;
 #ifndef PHP_WIN32
 	char **ep;
 #endif
 	char *p;
-	uint string_length, cnt, l, sizeenv=0, el_len;
+	uint cnt, l, sizeenv=0, el_len;
 	ulong num_key;
 	HashTable *target_hash;
-	HashPosition pos;
 
 	memset(&env, 0, sizeof(env));
 
@@ -109,20 +109,16 @@ static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent
 	}
 
 	/* first, we have to get the size of all the elements in the hash */
-	for (zend_hash_internal_pointer_reset_ex(target_hash, &pos);
-			zend_hash_get_current_data_ex(target_hash, (void **) &element, &pos) == SUCCESS;
-			zend_hash_move_forward_ex(target_hash, &pos)) {
-
-		if (Z_TYPE_PP(element) != IS_STRING) {
-			zval tmp;
+	ZEND_HASH_FOREACH_KEY_VAL(target_hash, num_key, string_key, element) {
+		zval tmp;
 
-			MAKE_COPY_ZVAL(element, &tmp);
+		if (Z_TYPE_P(element) != IS_STRING) {
+			ZVAL_DUP(&tmp, element);
 			convert_to_string(&tmp);
 			el_len = Z_STRLEN(tmp);
-
 			zval_dtor(&tmp);
 		} else {
-			el_len = Z_STRLEN_PP(element);
+			el_len = Z_STRLEN_P(element);
 		}
 		if (el_len == 0) {
 			continue;
@@ -130,31 +126,27 @@ static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent
 
 		sizeenv += el_len+1;
 
-		switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_length, &num_key, 0, &pos)) {
-			case HASH_KEY_IS_STRING:
-				if (string_length == 0) {
-					continue;
-				}
-				sizeenv += string_length;
-				break;
+		if (string_key) {
+			if (string_key->len == 0) {
+				continue;
+			}
+			sizeenv += string_key->len + 1;
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 #ifndef PHP_WIN32
 	ep = env.envarray = (char **) pecalloc(cnt + 1, sizeof(char *), is_persistent);
 #endif
 	p = env.envp = (char *) pecalloc(sizeenv + 4, 1, is_persistent);
 
-	for (zend_hash_internal_pointer_reset_ex(target_hash, &pos);
-			zend_hash_get_current_data_ex(target_hash, (void **) &element, &pos) == SUCCESS;
-			zend_hash_move_forward_ex(target_hash, &pos)) {
+	ZEND_HASH_FOREACH_KEY_VAL(target_hash, num_key, string_key, element) {
 		zval tmp;
 
-		if (Z_TYPE_PP(element) != IS_STRING) {
-			MAKE_COPY_ZVAL(element, &tmp);
+		if (Z_TYPE_P(element) != IS_STRING) {
+			ZVAL_DUP(&tmp, element);
 			convert_to_string(&tmp);
 		} else {
-			tmp = **element;
+			ZVAL_COPY_VALUE(&tmp, element);
 		}
 
 		el_len = Z_STRLEN(tmp);
@@ -164,45 +156,38 @@ static php_process_env_t _php_array_to_envp(zval *environment, int is_persistent
 		}
 
 		data = Z_STRVAL(tmp);
-		switch (zend_hash_get_current_key_ex(target_hash, &string_key, &string_length, &num_key, 0, &pos)) {
-			case HASH_KEY_IS_STRING:
-				if (string_length == 0) {
-					goto next_element;
-				}
 
-				l = string_length + el_len + 1;
-				memcpy(p, string_key, string_length);
-				strncat(p, "=", 1);
-				strncat(p, data, el_len);
+		if (string_key) {
+			if (string_key->len == 0) {
+				goto next_element;
+			}
+
+			l = string_key->len + el_len + 2;
+			memcpy(p, string_key->val, string_key->len);
+			strncat(p, "=", 1);
+			strncat(p, data, el_len);
 
 #ifndef PHP_WIN32
-				*ep = p;
-				++ep;
+			*ep = p;
+			++ep;
 #endif
-				p += l;
-				break;
-			case HASH_KEY_IS_LONG:
-				memcpy(p,data,el_len);
+			p += l;
+		} else {
+			memcpy(p,data,el_len);
 #ifndef PHP_WIN32
-				*ep = p;
-				++ep;
+			*ep = p;
+			++ep;
 #endif
-				p += el_len + 1;
-				break;
-			case HASH_KEY_NON_EXISTENT:
-				break;
+			p += el_len + 1;
 		}
-
 next_element:
-		if (Z_TYPE_PP(element) != IS_STRING) {
+		if (Z_TYPE_P(element) != IS_STRING) {
 			zval_dtor(&tmp);
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	assert((uint)(p - env.envp) <= sizeenv);
 
-	zend_hash_internal_pointer_reset_ex(target_hash, &pos);
-
 	return env;
 }
 /* }}} */
@@ -222,7 +207,7 @@ static void _php_free_envp(php_process_env_t env, int is_persistent)
 /* }}} */
 
 /* {{{ proc_open_rsrc_dtor */
-static void proc_open_rsrc_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void proc_open_rsrc_dtor(zend_resource *rsrc TSRMLS_DC)
 {
 	struct php_process_handle *proc = (struct php_process_handle*)rsrc->ptr;
 	int i;
@@ -237,7 +222,9 @@ static void proc_open_rsrc_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
 	/* Close all handles to avoid a deadlock */
 	for (i = 0; i < proc->npipes; i++) {
 		if (proc->pipes[i] != 0) {
-			zend_list_delete(proc->pipes[i]);
+			if (--GC_REFCOUNT(proc->pipes[i]) <= 0) {
+				zend_list_delete(proc->pipes[i]);
+			}
 			proc->pipes[i] = 0;
 		}
 	}
@@ -301,7 +288,7 @@ PHP_FUNCTION(proc_terminate)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, &zproc, -1, "process", le_proc_open);
+	ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, zproc, -1, "process", le_proc_open);
 
 #ifdef PHP_WIN32
 	if (TerminateProcess(proc->childHandle, 255)) {
@@ -330,10 +317,10 @@ PHP_FUNCTION(proc_close)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, &zproc, -1, "process", le_proc_open);
+	ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, zproc, -1, "process", le_proc_open);
 
 	FG(pclose_wait) = 1;
-	zend_list_delete(Z_LVAL_P(zproc));
+	zend_list_delete(Z_RES_P(zproc));
 	FG(pclose_wait) = 0;
 	RETURN_LONG(FG(pclose_ret));
 }
@@ -358,11 +345,11 @@ PHP_FUNCTION(proc_get_status)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, &zproc, -1, "process", le_proc_open);
+	ZEND_FETCH_RESOURCE(proc, struct php_process_handle *, zproc, -1, "process", le_proc_open);
 
 	array_init(return_value);
 
-	add_assoc_string(return_value, "command", proc->command, 1);
+	add_assoc_string(return_value, "command", proc->command);
 	add_assoc_long(return_value, "pid", (long) proc->child);
 
 #ifdef PHP_WIN32
@@ -460,8 +447,9 @@ PHP_FUNCTION(proc_open)
 	php_process_env_t env;
 	int ndesc = 0;
 	int i;
-	zval **descitem = NULL;
-	HashPosition pos;
+	zval *descitem = NULL;
+	zend_string *str_index;
+	ulong nindex;
 	struct php_proc_open_descriptor_item descriptors[PHP_PROC_OPEN_MAX_DESCRIPTORS];
 #ifdef PHP_WIN32
 	PROCESS_INFORMATION pi;
@@ -538,14 +526,8 @@ PHP_FUNCTION(proc_open)
 #endif
 
 	/* walk the descriptor spec and set up files/pipes */
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(descriptorspec), &pos);
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(descriptorspec), (void **)&descitem, &pos) == SUCCESS) {
-		char *str_index;
-		ulong nindex;
-		zval **ztype;
-
-		str_index = NULL;
-		zend_hash_get_current_key_ex(Z_ARRVAL_P(descriptorspec), &str_index, NULL, &nindex, 0, &pos);
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(descriptorspec), nindex, str_index, descitem) {
+		zval *ztype;
 
 		if (str_index) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "descriptor spec must be an integer indexed array");
@@ -554,7 +536,7 @@ PHP_FUNCTION(proc_open)
 
 		descriptors[ndesc].index = nindex;
 
-		if (Z_TYPE_PP(descitem) == IS_RESOURCE) {
+		if (Z_TYPE_P(descitem) == IS_RESOURCE) {
 			/* should be a stream - try and dup the descriptor */
 			php_stream *stream;
 			php_socket_t fd;
@@ -580,23 +562,23 @@ PHP_FUNCTION(proc_open)
 #endif
 			descriptors[ndesc].mode = DESC_FILE;
 
-		} else if (Z_TYPE_PP(descitem) != IS_ARRAY) {
+		} else if (Z_TYPE_P(descitem) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Descriptor item must be either an array or a File-Handle");
 			goto exit_fail;
 		} else {
 
-			if (zend_hash_index_find(Z_ARRVAL_PP(descitem), 0, (void **)&ztype) == SUCCESS) {
+			if ((ztype = zend_hash_index_find(Z_ARRVAL_P(descitem), 0)) != NULL) {
 				convert_to_string_ex(ztype);
 			} else {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing handle qualifier in array");
 				goto exit_fail;
 			}
 
-			if (strcmp(Z_STRVAL_PP(ztype), "pipe") == 0) {
+			if (strcmp(Z_STRVAL_P(ztype), "pipe") == 0) {
 				php_file_descriptor_t newpipe[2];
-				zval **zmode;
+				zval *zmode;
 
-				if (zend_hash_index_find(Z_ARRVAL_PP(descitem), 1, (void **)&zmode) == SUCCESS) {
+				if ((zmode = zend_hash_index_find(Z_ARRVAL_P(descitem), 1)) != NULL) {
 					convert_to_string_ex(zmode);
 				} else {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing mode parameter for 'pipe'");
@@ -610,7 +592,7 @@ PHP_FUNCTION(proc_open)
 					goto exit_fail;
 				}
 
-				if (strncmp(Z_STRVAL_PP(zmode), "w", 1) != 0) {
+				if (strncmp(Z_STRVAL_P(zmode), "w", 1) != 0) {
 					descriptors[ndesc].parentend = newpipe[1];
 					descriptors[ndesc].childend = newpipe[0];
 					descriptors[ndesc].mode |= DESC_PARENT_MODE_WRITE;
@@ -624,25 +606,25 @@ PHP_FUNCTION(proc_open)
 #endif
 				descriptors[ndesc].mode_flags = descriptors[ndesc].mode & DESC_PARENT_MODE_WRITE ? O_WRONLY : O_RDONLY;
 #ifdef PHP_WIN32
-				if (Z_STRLEN_PP(zmode) >= 2 && Z_STRVAL_PP(zmode)[1] == 'b')
+				if (Z_STRLEN_P(zmode) >= 2 && Z_STRVAL_P(zmode)[1] == 'b')
 					descriptors[ndesc].mode_flags |= O_BINARY;
 #endif
 
-			} else if (strcmp(Z_STRVAL_PP(ztype), "file") == 0) {
-				zval **zfile, **zmode;
+			} else if (strcmp(Z_STRVAL_P(ztype), "file") == 0) {
+				zval *zfile, *zmode;
 				php_socket_t fd;
 				php_stream *stream;
 
 				descriptors[ndesc].mode = DESC_FILE;
 
-				if (zend_hash_index_find(Z_ARRVAL_PP(descitem), 1, (void **)&zfile) == SUCCESS) {
+				if ((zfile = zend_hash_index_find(Z_ARRVAL_P(descitem), 1)) != NULL) {
 					convert_to_string_ex(zfile);
 				} else {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing file name parameter for 'file'");
 					goto exit_fail;
 				}
 
-				if (zend_hash_index_find(Z_ARRVAL_PP(descitem), 2, (void **)&zmode) == SUCCESS) {
+				if ((zmode = zend_hash_index_find(Z_ARRVAL_P(descitem), 2)) != NULL) {
 					convert_to_string_ex(zmode);
 				} else {
 					php_error_docref(NULL TSRMLS_CC, E_WARNING, "Missing mode parameter for 'file'");
@@ -650,7 +632,7 @@ PHP_FUNCTION(proc_open)
 				}
 
 				/* try a wrapper */
-				stream = php_stream_open_wrapper(Z_STRVAL_PP(zfile), Z_STRVAL_PP(zmode),
+				stream = php_stream_open_wrapper(Z_STRVAL_P(zfile), Z_STRVAL_P(zmode),
 						REPORT_ERRORS|STREAM_WILL_CAST, NULL);
 
 				/* force into an fd */
@@ -672,7 +654,7 @@ PHP_FUNCTION(proc_open)
 #else
 				descriptors[ndesc].childend = fd;
 #endif
-			} else if (strcmp(Z_STRVAL_PP(ztype), "pty") == 0) {
+			} else if (strcmp(Z_STRVAL_P(ztype), "pty") == 0) {
 #if PHP_CAN_DO_PTS
 				if (dev_ptmx == -1) {
 					/* open things up */
@@ -699,15 +681,14 @@ PHP_FUNCTION(proc_open)
 				goto exit_fail;
 #endif
 			} else {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not a valid descriptor spec/mode", Z_STRVAL_PP(ztype));
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s is not a valid descriptor spec/mode", Z_STRVAL_P(ztype));
 				goto exit_fail;
 			}
 		}
 
-		zend_hash_move_forward_ex(Z_ARRVAL_P(descriptorspec), &pos);
 		if (++ndesc == PHP_PROC_OPEN_MAX_DESCRIPTORS)
 			break;
-	}
+	} ZEND_HASH_FOREACH_END();
 
 #ifdef PHP_WIN32
 	if (cwd == NULL) {
@@ -918,8 +899,10 @@ PHP_FUNCTION(proc_open)
 	proc->env = env;
 
 	if (pipes != NULL) {
+		ZVAL_DEREF(pipes);
 		zval_dtor(pipes);
-	}
+	} 
+
 	array_init(pipes);
 
 #if PHP_CAN_DO_PTS
@@ -969,20 +952,20 @@ PHP_FUNCTION(proc_open)
 # endif
 #endif
 				if (stream) {
-					zval *retfp;
+					zval retfp;
 
 					/* nasty hack; don't copy it */
 					stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
 
-					MAKE_STD_ZVAL(retfp);
-					php_stream_to_zval(stream, retfp);
-					add_index_zval(pipes, descriptors[i].index, retfp);
+					php_stream_to_zval(stream, &retfp);
+					add_index_zval(pipes, descriptors[i].index, &retfp);
 
-					proc->pipes[i] = Z_LVAL_P(retfp);
+					proc->pipes[i] = Z_RES(retfp);
+					Z_ADDREF(retfp);
 				}
 				break;
 			default:
-				proc->pipes[i] = 0;
+				proc->pipes[i] = NULL;
 		}
 	}
 
diff --git a/ext/standard/proc_open.h b/ext/standard/proc_open.h
index 6708fded59..8545f201f2 100644
--- a/ext/standard/proc_open.h
+++ b/ext/standard/proc_open.h
@@ -44,7 +44,7 @@ struct php_process_handle {
 	HANDLE childHandle;
 #endif
 	int npipes;
-	long pipes[PHP_PROC_OPEN_MAX_DESCRIPTORS];
+	zend_resource *pipes[PHP_PROC_OPEN_MAX_DESCRIPTORS];
 	char *command;
 	int is_persistent;
 	php_process_env_t env;
diff --git a/ext/standard/quot_print.c b/ext/standard/quot_print.c
index 7f54ce4d21..aa3d256c3a 100644
--- a/ext/standard/quot_print.c
+++ b/ext/standard/quot_print.c
@@ -51,7 +51,7 @@ static char php_hex2int(int c) /* {{{ */
 }
 /* }}} */
 
-PHPAPI unsigned char *php_quot_print_decode(const unsigned char *str, size_t length, size_t *ret_length, int replace_us_by_ws) /* {{{ */
+PHPAPI zend_string *php_quot_print_decode(const unsigned char *str, size_t length, int replace_us_by_ws) /* {{{ */
 {
 	register unsigned int i;
 	register unsigned const char *p1;
@@ -59,7 +59,7 @@ PHPAPI unsigned char *php_quot_print_decode(const unsigned char *str, size_t len
 	register unsigned int h_nbl, l_nbl;
 
 	size_t decoded_len, buf_size;
-	unsigned char *retval;
+	zend_string *retval;
 
 	static unsigned int hexval_tbl[256] = {
 		64, 64, 64, 64, 64, 64, 64, 64, 64, 32, 16, 64, 64, 16, 64, 64,
@@ -96,8 +96,8 @@ PHPAPI unsigned char *php_quot_print_decode(const unsigned char *str, size_t len
 		i--;
 	}
 
-	retval = emalloc(buf_size + 1);
-	i = length; p1 = str; p2 = retval;
+	retval = STR_ALLOC(buf_size, 0);
+	i = length; p1 = str; p2 = (unsigned char*)retval->val;
 	decoded_len = 0;
 
 	while (i > 0 && *p1 != '\0') {
@@ -138,21 +138,22 @@ PHPAPI unsigned char *php_quot_print_decode(const unsigned char *str, size_t len
 	}
 
 	*p2 = '\0';
-	*ret_length = decoded_len;
+	retval->len = decoded_len;
 	return retval;
 }
 /* }}} */
 
 #define PHP_QPRINT_MAXL 75
  
-PHPAPI unsigned char *php_quot_print_encode(const unsigned char *str, size_t length, size_t *ret_length) /* {{{ */
+PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t length) /* {{{ */
 {
 	unsigned long lp = 0;
-	unsigned char c, *ret, *d;
+	unsigned char c, *d;
 	char *hex = "0123456789ABCDEF";
+	zend_string *ret;
 
-	ret = safe_emalloc(3, length + (((3 * length)/(PHP_QPRINT_MAXL-9)) + 1), 1);
-	d = ret;
+	ret = STR_SAFE_ALLOC(3, (length + (((3 * length)/(PHP_QPRINT_MAXL-9)) + 1)), 0, 0);
+	d = (unsigned char*)ret->val;
 
 	while (length--) {
 		if (((c = *str++) == '\015') && (*str == '\012') && length > 0) {
@@ -186,9 +187,7 @@ PHPAPI unsigned char *php_quot_print_encode(const unsigned char *str, size_t len
 		}
 	}
 	*d = '\0';
-	*ret_length = d - ret;
-
-	ret = erealloc(ret, *ret_length + 1);
+	ret = STR_REALLOC(ret, d - (unsigned char*)ret->val, 0);
 	return ret;
 }
 /* }}} */
@@ -202,7 +201,8 @@ PHPAPI unsigned char *php_quot_print_encode(const unsigned char *str, size_t len
    Convert a quoted-printable string to an 8 bit string */
 PHP_FUNCTION(quoted_printable_decode)
 {
-	char *arg1, *str_in, *str_out;
+	char *arg1, *str_in;
+	zend_string *str_out;
 	int arg1_len, i = 0, j = 0, k;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg1, &arg1_len) == FAILURE) {
@@ -215,7 +215,7 @@ PHP_FUNCTION(quoted_printable_decode)
 	}
 
 	str_in = arg1;
-	str_out = emalloc(arg1_len + 1);
+	str_out = STR_ALLOC(arg1_len, 0);
 	while (str_in[i]) {
 		switch (str_in[i]) {
 		case '=':
@@ -223,7 +223,7 @@ PHP_FUNCTION(quoted_printable_decode)
 				isxdigit((int) str_in[i + 1]) && 
 				isxdigit((int) str_in[i + 2]))
 			{
-				str_out[j++] = (php_hex2int((int) str_in[i + 1]) << 4) 
+				str_out->val[j++] = (php_hex2int((int) str_in[i + 1]) << 4) 
 						+ php_hex2int((int) str_in[i + 2]);
 				i += 3;
 			} else  /* check for soft line break according to RFC 2045*/ {
@@ -245,26 +245,27 @@ PHP_FUNCTION(quoted_printable_decode)
 					i += k + 1;
 				}
 				else {
-					str_out[j++] = str_in[i++];
+					str_out->val[j++] = str_in[i++];
 				}
 			}
 			break;
 		default:
-			str_out[j++] = str_in[i++];
+			str_out->val[j++] = str_in[i++];
 		}
 	}
-	str_out[j] = '\0';
+	str_out->val[j] = '\0';
+	str_out->len = j;
     
-	RETVAL_STRINGL(str_out, j, 0);
+	RETVAL_NEW_STR(str_out);
 }
 /* }}} */
 
 /* {{{ proto string quoted_printable_encode(string str) */
 PHP_FUNCTION(quoted_printable_encode)
 {
-	char *str, *new_str;
+	char *str;
+	zend_string *new_str;
 	int str_len;
-	size_t new_str_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) != SUCCESS) {
 		return;
@@ -274,8 +275,8 @@ PHP_FUNCTION(quoted_printable_encode)
 		RETURN_EMPTY_STRING();
 	}
 
-	new_str = (char *)php_quot_print_encode((unsigned char *)str, (size_t)str_len, &new_str_len);
-	RETURN_STRINGL(new_str, new_str_len, 0);
+	new_str = php_quot_print_encode((unsigned char *)str, (size_t)str_len);
+	RETURN_STR(new_str);
 }
 /* }}} */
 
diff --git a/ext/standard/quot_print.h b/ext/standard/quot_print.h
index 8be7faa388..7055d05717 100644
--- a/ext/standard/quot_print.h
+++ b/ext/standard/quot_print.h
@@ -21,8 +21,8 @@
 #ifndef QUOT_PRINT_H
 #define QUOT_PRINT_H
 
-PHPAPI unsigned char *php_quot_print_decode(const unsigned char *str, size_t length, size_t *ret_length, int replace_us_by_ws);
-PHPAPI unsigned char *php_quot_print_encode(const unsigned char *str, size_t length, size_t *ret_length);
+PHPAPI zend_string *php_quot_print_decode(const unsigned char *str, size_t length, int replace_us_by_ws);
+PHPAPI zend_string *php_quot_print_encode(const unsigned char *str, size_t length);
 
 PHP_FUNCTION(quoted_printable_decode);
 PHP_FUNCTION(quoted_printable_encode);
diff --git a/ext/standard/scanf.c b/ext/standard/scanf.c
index d092bbcfcf..3eb58e1837 100644
--- a/ext/standard/scanf.c
+++ b/ext/standard/scanf.c
@@ -118,7 +118,7 @@ typedef struct CharSet {
 static char *BuildCharSet(CharSet *cset, char *format);
 static int	CharInSet(CharSet *cset, int ch);
 static void	ReleaseCharSet(CharSet *cset);
-static inline void scan_set_error_return(int numVars, zval **return_value);
+static inline void scan_set_error_return(int numVars, zval *return_value);
 
 
 /* {{{ BuildCharSet
@@ -577,15 +577,15 @@ error:
  */
 
 PHPAPI int php_sscanf_internal( char *string, char *format,
-				int argCount, zval ***args,
-				int varStart, zval **return_value TSRMLS_DC)
+				int argCount, zval *args,
+				int varStart, zval *return_value TSRMLS_DC)
 {
 	int  numVars, nconversions, totalVars = -1;
 	int  i, result;
 	long value;
 	int  objIndex;
 	char *end, *baseString;
-	zval **current;
+	zval *current;
 	char op   = 0;
 	int  base = 0;
 	int  underflow = 0;
@@ -624,7 +624,7 @@ PHPAPI int php_sscanf_internal( char *string, char *format,
 	 */
 	if (numVars) {
 		for (i = varStart;i < argCount;i++){
-			if ( ! PZVAL_IS_REF( *args[ i ] ) ) {
+			if ( ! Z_ISREF(args[ i ] ) ) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Parameter %d must be passed by reference", i);
 				scan_set_error_return(numVars, return_value);
 				return SCAN_ERROR_VAR_PASSED_BYVAL;
@@ -637,15 +637,14 @@ PHPAPI int php_sscanf_internal( char *string, char *format,
 	 * are specified
 	 */
 	if (!numVars) {
-		zval *tmp;
+		zval tmp;
 
 		/* allocate an array for return */
-		array_init(*return_value);
+		array_init(return_value);
 
 		for (i = 0; i < totalVars; i++) {
-			MAKE_STD_ZVAL(tmp);
-			ZVAL_NULL(tmp);
-			if (add_next_index_zval(*return_value, tmp) == FAILURE) {
+			ZVAL_NULL(&tmp);
+			if (add_next_index_zval(return_value, &tmp) == FAILURE) {
 				scan_set_error_return(0, return_value);
 				return FAILURE;
 			}
@@ -743,16 +742,13 @@ literal:
 					if (numVars && objIndex >= argCount) {
 						break;
 					} else if (numVars) {
-						zend_uint refcount;
-
-						current = args[objIndex++];
-						refcount = Z_REFCOUNT_PP(current);
-						zval_dtor( *current );
-						ZVAL_LONG( *current, (long)(string - baseString) );
-						Z_SET_REFCOUNT_PP(current, refcount);
-						Z_SET_ISREF_PP(current);
+						current = &args[objIndex++];
+						zval_dtor(Z_REFVAL_P(current));
+						ZVAL_LONG(Z_REFVAL_P(current), (long)(string - baseString) );
+//						Z_SET_REFCOUNT_P(current, refcount);
+//???					Z_SET_ISREF_P(current);
 					} else {
-						add_index_long(*return_value, objIndex++, string - baseString);
+						add_index_long(return_value, objIndex++, string - baseString);
 					}
 				}
 				nconversions++;
@@ -867,16 +863,13 @@ literal:
 					if (numVars && objIndex >= argCount) {
 						break;
 					} else if (numVars) {
-						zend_uint refcount;
-
-						current = args[objIndex++];
-						refcount = Z_REFCOUNT_PP(current);
-						zval_dtor( *current );
-						ZVAL_STRINGL( *current, string, end-string, 1);
-						Z_SET_REFCOUNT_PP(current, refcount);
-						Z_SET_ISREF_PP(current);
+						current = &args[objIndex++];
+						zval_dtor(Z_REFVAL_P(current));
+						ZVAL_STRINGL(Z_REFVAL_P(current), string, end-string);
+//???						Z_SET_REFCOUNT_P(current, refcount);
+//???						Z_SET_ISREF_PP(current);
 					} else {
-						add_index_stringl( *return_value, objIndex++, string, end-string, 1);
+						add_index_stringl(return_value, objIndex++, string, end-string);
 					}
 				}
 				string = end;
@@ -913,11 +906,11 @@ literal:
 					if (numVars && objIndex >= argCount) {
 						break;
 					} else if (numVars) {
-						current = args[objIndex++];
-						zval_dtor( *current );
-						ZVAL_STRINGL( *current, string, end-string, 1);
+						current = &args[objIndex++];
+						zval_dtor(Z_REFVAL_P(current));
+						ZVAL_STRINGL(Z_REFVAL_P(current), string, end-string);
 					} else {
-						add_index_stringl(*return_value, objIndex++, string, end-string, 1);
+						add_index_stringl(return_value, objIndex++, string, end-string);
 					}
 				}
 				string = end;
@@ -938,7 +931,7 @@ literal:
 						zval_dtor(*current);
 						ZVAL_STRINGL( *current, __buf, 1, 1);
 					} else {
-						add_index_stringl(*return_value, objIndex++, &sch, 1, 1);
+						add_index_stringl(return_value, objIndex++, &sch, 1);
 					}
 				}
 				break;
@@ -1067,21 +1060,21 @@ addToInt:
 							break;
 						} else if (numVars) {
 						  /* change passed value type to string */
-							current = args[objIndex++];
-							zval_dtor(*current);
-							ZVAL_STRING( *current, buf, 1 );
+							current = &args[objIndex++];
+							zval_dtor(Z_REFVAL_P(current));
+							ZVAL_STRING(Z_REFVAL_P(current), buf);
 						} else {
-							add_index_string(*return_value, objIndex++, buf, 1);
+							add_index_string(return_value, objIndex++, buf);
 						}
 					} else {
 						if (numVars && objIndex >= argCount) {
 							break;
 						} else if (numVars) {
-							current = args[objIndex++];
-							zval_dtor(*current);
-							ZVAL_LONG(*current, value);
+							current = &args[objIndex++];
+							zval_dtor(Z_REFVAL_P(current));
+							ZVAL_LONG(Z_REFVAL_P(current), value);
 						} else {
-							add_index_long(*return_value, objIndex++, value);
+							add_index_long(return_value, objIndex++, value);
 						}
 					}
 				}
@@ -1182,11 +1175,11 @@ addToFloat:
 					if (numVars && objIndex >= argCount) {
 						break;
 					} else if (numVars) {
-						current = args[objIndex++];
-						zval_dtor(*current);
-						ZVAL_DOUBLE(*current, dvalue);
+						current = &args[objIndex++];
+						zval_dtor(Z_REFVAL_P(current));
+						ZVAL_DOUBLE(Z_REFVAL_P(current), dvalue);
 					} else {
-						add_index_double( *return_value, objIndex++, dvalue );
+						add_index_double(return_value, objIndex++, dvalue );
 					}
 				}
 				break;
@@ -1201,8 +1194,8 @@ done:
 		scan_set_error_return( numVars, return_value );
 		result = SCAN_ERROR_EOF;
 	} else if (numVars) {
-		convert_to_long( *return_value );
-		Z_LVAL_PP(return_value) = nconversions;
+		convert_to_long(return_value );
+		Z_LVAL_P(return_value) = nconversions;
 	} else if (nconversions < totalVars) {
 		/* TODO: not all elements converted. we need to prune the list - cc */
 	}
@@ -1211,14 +1204,13 @@ done:
 /* }}} */
 
 /* the compiler choked when i tried to make this a macro    */
-static inline void scan_set_error_return(int numVars, zval **return_value) /* {{{ */
+static inline void scan_set_error_return(int numVars, zval *return_value) /* {{{ */
 {
 	if (numVars) {
-		Z_TYPE_PP(return_value) = IS_LONG;
-		Z_LVAL_PP(return_value) = SCAN_ERROR_EOF;  /* EOF marker */
+		ZVAL_LONG(return_value, SCAN_ERROR_EOF);  /* EOF marker */
 	} else {
 		/* convert_to_null calls destructor */
-		convert_to_null( *return_value );
+		convert_to_null(return_value);
 	}
 }
 /* }}} */
diff --git a/ext/standard/scanf.h b/ext/standard/scanf.h
index 9d4acd4a8f..8d5fee22e1 100644
--- a/ext/standard/scanf.h
+++ b/ext/standard/scanf.h
@@ -42,8 +42,8 @@
  * e.g. fscanf
  */
 PHPAPI int ValidateFormat(char *format, int numVars, int *totalVars);
-PHPAPI int php_sscanf_internal(char *string,char *format,int argCount,zval ***args,
-				int varStart, zval **return_value TSRMLS_DC);
+PHPAPI int php_sscanf_internal(char *string,char *format,int argCount,zval *args,
+				int varStart, zval *return_value TSRMLS_DC);
 
 
 #endif /* SCANF_H */
diff --git a/ext/standard/sha1.c b/ext/standard/sha1.c
index 67e5d520f4..84a7d258c1 100644
--- a/ext/standard/sha1.c
+++ b/ext/standard/sha1.c
@@ -50,10 +50,10 @@ PHP_FUNCTION(sha1)
 	PHP_SHA1Update(&context, arg, arg_len);
 	PHP_SHA1Final(digest, &context);
 	if (raw_output) {
-		RETURN_STRINGL(digest, 20, 1);
+		RETURN_STRINGL(digest, 20);
 	} else {
 		make_digest_ex(sha1str, digest, 20);
-		RETVAL_STRING(sha1str, 1);
+		RETVAL_STRING(sha1str);
 	}
 
 }
@@ -99,10 +99,10 @@ PHP_FUNCTION(sha1_file)
 	}
 
 	if (raw_output) {
-		RETURN_STRINGL(digest, 20, 1);
+		RETURN_STRINGL(digest, 20);
 	} else {
 		make_digest_ex(sha1str, digest, 20);
-		RETVAL_STRING(sha1str, 1);
+		RETVAL_STRING(sha1str);
 	}
 }
 /* }}} */
diff --git a/ext/standard/soundex.c b/ext/standard/soundex.c
index cf915d4c1d..af9a719d39 100644
--- a/ext/standard/soundex.c
+++ b/ext/standard/soundex.c
@@ -101,7 +101,7 @@ PHP_FUNCTION(soundex)
 	}
 	soundex[_small] = '\0';
 
-	RETURN_STRINGL(soundex, _small, 1);
+	RETURN_STRINGL(soundex, _small);
 }
 /* }}} */
 
diff --git a/ext/standard/streamsfuncs.c b/ext/standard/streamsfuncs.c
index 8d42a51af6..71cdc13927 100644
--- a/ext/standard/streamsfuncs.c
+++ b/ext/standard/streamsfuncs.c
@@ -75,8 +75,8 @@ PHP_FUNCTION(stream_socket_pair)
 	php_stream_auto_cleanup(s1);
 	php_stream_auto_cleanup(s2);
 
-	add_next_index_resource(return_value, php_stream_get_resource_id(s1));
-	add_next_index_resource(return_value, php_stream_get_resource_id(s2));
+	add_next_index_resource(return_value, s1->res);
+	add_next_index_resource(return_value, s2->res);
 }
 /* }}} */
 #endif
@@ -120,12 +120,14 @@ PHP_FUNCTION(stream_socket_client)
 	tv.tv_usec = conv % 1000000;
 #endif
 	if (zerrno)	{
+		zerrno = Z_REFVAL_P(zerrno);
 		zval_dtor(zerrno);
 		ZVAL_LONG(zerrno, 0);
 	}
 	if (zerrstr) {
+		zerrstr = Z_REFVAL_P(zerrstr);
 		zval_dtor(zerrstr);
-		ZVAL_STRING(zerrstr, "", 1);
+		ZVAL_EMPTY_STRING(zerrstr);
 	}
 
 	stream = php_stream_xport_create(host, host_len, REPORT_ERRORS,
@@ -136,10 +138,10 @@ PHP_FUNCTION(stream_socket_client)
 
 	if (stream == NULL) {
 		/* host might contain binary characters */
-		char *quoted_host = php_addslashes(host, host_len, NULL, 0 TSRMLS_CC);
+		zend_string *quoted_host = php_addslashes(host, host_len, 0 TSRMLS_CC);
 
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to connect to %s (%s)", quoted_host, errstr == NULL ? "Unknown error" : errstr);
-		efree(quoted_host);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "unable to connect to %s (%s)", quoted_host->val, errstr == NULL ? "Unknown error" : errstr);
+		STR_RELEASE(quoted_host);
 	}
 
 	if (hashkey) {
@@ -154,7 +156,9 @@ PHP_FUNCTION(stream_socket_client)
 		if (zerrstr && errstr) {
 			/* no need to dup; we need to efree buf anyway */
 			zval_dtor(zerrstr);
-			ZVAL_STRING(zerrstr, errstr, 0);
+			// TODO: avoid reallocation ???
+			ZVAL_STRING(zerrstr, errstr);
+			efree(errstr);
 		} else if (errstr) {
 			efree(errstr);
 		}
@@ -192,7 +196,7 @@ PHP_FUNCTION(stream_socket_server)
 	context = php_stream_context_from_zval(zcontext, flags & PHP_FILE_NO_DEFAULT_CONTEXT);
 
 	if (context) {
-		zend_list_addref(context->rsrc_id);
+		GC_REFCOUNT(context->res)++;
 	}
 
 	if (zerrno)	{
@@ -201,7 +205,7 @@ PHP_FUNCTION(stream_socket_server)
 	}
 	if (zerrstr) {
 		zval_dtor(zerrstr);
-		ZVAL_STRING(zerrstr, "", 1);
+		ZVAL_EMPTY_STRING(zerrstr);
 	}
 
 	stream = php_stream_xport_create(host, host_len, REPORT_ERRORS,
@@ -220,7 +224,9 @@ PHP_FUNCTION(stream_socket_server)
 		if (zerrstr && errstr) {
 			/* no need to dup; we need to efree buf anyway */
 			zval_dtor(zerrstr);
-			ZVAL_STRING(zerrstr, errstr, 0);
+			// TODO: avoid reallocation ???
+			ZVAL_STRING(zerrstr, errstr);
+			efree(errstr);
 		} else if (errstr) {
 			efree(errstr);
 		}
@@ -254,7 +260,7 @@ PHP_FUNCTION(stream_socket_accept)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	/* prepare the timeout value for use */
 	conv = (php_timeout_ull) (timeout * 1000000.0);
@@ -278,7 +284,9 @@ PHP_FUNCTION(stream_socket_accept)
 				TSRMLS_CC) && clistream) {
 
 		if (peername) {
-			ZVAL_STRINGL(zpeername, peername, peername_len, 0);
+			// TODO: avoid reallocation ???
+			ZVAL_STRINGL(zpeername, peername, peername_len);
+			efree(peername);
 		}
 		php_stream_to_zval(clistream, return_value);
 	} else {
@@ -306,7 +314,7 @@ PHP_FUNCTION(stream_socket_get_name)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	if (0 != php_stream_xport_get_name(stream, want_peer,
 				&name,
@@ -316,7 +324,9 @@ PHP_FUNCTION(stream_socket_get_name)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL(name, name_len, 0);
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL(name, name_len);
+	efree(name);
 }
 /* }}} */
 
@@ -335,7 +345,7 @@ PHP_FUNCTION(stream_socket_sendto)
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rs|ls", &zstream, &data, &datalen, &flags, &target_addr, &target_addr_len) == FAILURE) {
 		RETURN_FALSE;
 	}
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	if (target_addr_len) {
 		/* parse the address */
@@ -358,7 +368,7 @@ PHP_FUNCTION(stream_socket_recvfrom)
 	char *remote_addr = NULL;
 	int remote_addr_len;
 	long to_read = 0;
-	char *read_buf;
+	zend_string *read_buf;
 	long flags = 0;
 	int recvd;
 
@@ -366,7 +376,7 @@ PHP_FUNCTION(stream_socket_recvfrom)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	if (zremote) {
 		zval_dtor(zremote);
@@ -378,23 +388,25 @@ PHP_FUNCTION(stream_socket_recvfrom)
 		RETURN_FALSE;
 	}
 
-	read_buf = safe_emalloc(1, to_read, 1);
+	read_buf = STR_ALLOC(to_read, 0);
 
-	recvd = php_stream_xport_recvfrom(stream, read_buf, to_read, flags, NULL, NULL,
+	recvd = php_stream_xport_recvfrom(stream, read_buf->val, to_read, flags, NULL, NULL,
 			zremote ? &remote_addr : NULL,
 			zremote ? &remote_addr_len : NULL
 			TSRMLS_CC);
 
 	if (recvd >= 0) {
 		if (zremote) {
-			ZVAL_STRINGL(zremote, remote_addr, remote_addr_len, 0);
+			// TODO: avoid reallocation ???
+			ZVAL_STRINGL(zremote, remote_addr, remote_addr_len);
+			efree(remote_addr);
 		}
-		read_buf[recvd] = '\0';
-
-		RETURN_STRINGL(read_buf, recvd, 0);
+		read_buf->val[recvd] = '\0';
+		read_buf->len = recvd;
+		RETURN_NEW_STR(read_buf);
 	}
 
-	efree(read_buf);
+	STR_FREE(read_buf);
 	RETURN_FALSE;
 }
 /* }}} */
@@ -407,14 +419,13 @@ PHP_FUNCTION(stream_get_contents)
 	zval		*zsrc;
 	long		maxlen		= PHP_STREAM_COPY_ALL,
 				desiredpos	= -1L;
-	int			len;
-	char		*contents	= NULL;
+	zend_string *contents;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r|ll", &zsrc, &maxlen, &desiredpos) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zsrc);
+	php_stream_from_zval(stream, zsrc);
 
 	if (desiredpos >= 0) {
 		int		seek_res = 0;
@@ -436,12 +447,10 @@ PHP_FUNCTION(stream_get_contents)
 		}
 	}
 
-	len = php_stream_copy_to_mem(stream, &contents, maxlen, 0);
-
-	if (contents) {
-		RETVAL_STRINGL(contents, len, 0);
+	if ((contents = php_stream_copy_to_mem(stream, maxlen, 0))) {
+		RETURN_STR(contents);
 	} else {
-		RETVAL_EMPTY_STRING();
+		RETURN_EMPTY_STRING();
 	}
 }
 /* }}} */
@@ -460,8 +469,8 @@ PHP_FUNCTION(stream_copy_to_stream)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(src, &zsrc);
-	php_stream_from_zval(dest, &zdest);
+	php_stream_from_zval(src, zsrc);
+	php_stream_from_zval(dest, zdest);
 
 	if (pos > 0 && php_stream_seek(src, pos, SEEK_SET) < 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to seek to position %ld in the stream", pos);
@@ -483,27 +492,24 @@ PHP_FUNCTION(stream_get_meta_data)
 {
 	zval *arg1;
 	php_stream *stream;
-	zval *newval;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &arg1) == FAILURE) {
 		return;
 	}
-	php_stream_from_zval(stream, &arg1);
+	php_stream_from_zval(stream, arg1);
 
 	array_init(return_value);
 
-	if (stream->wrapperdata) {
-		MAKE_STD_ZVAL(newval);
-		MAKE_COPY_ZVAL(&stream->wrapperdata, newval);
-
-		add_assoc_zval(return_value, "wrapper_data", newval);
+	if (!ZVAL_IS_UNDEF(&stream->wrapperdata)) {
+		Z_ADDREF_P(&stream->wrapperdata);
+		add_assoc_zval(return_value, "wrapper_data", &stream->wrapperdata);
 	}
 	if (stream->wrapper) {
-		add_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label, 1);
+		add_assoc_string(return_value, "wrapper_type", (char *)stream->wrapper->wops->label);
 	}
-	add_assoc_string(return_value, "stream_type", (char *)stream->ops->label, 1);
+	add_assoc_string(return_value, "stream_type", (char *)stream->ops->label);
 
-	add_assoc_string(return_value, "mode", stream->mode, 1);
+	add_assoc_string(return_value, "mode", stream->mode);
 
 #if 0	/* TODO: needs updating for new filter API */
 	if (stream->filterhead) {
@@ -513,7 +519,7 @@ PHP_FUNCTION(stream_get_meta_data)
 		array_init(newval);
 
 		for (filter = stream->filterhead; filter != NULL; filter = filter->next) {
-			add_next_index_string(newval, (char *)filter->fops->label, 1);
+			add_next_index_string(newval, (char *)filter->fops->label);
 		}
 
 		add_assoc_zval(return_value, "filters", newval);
@@ -524,7 +530,7 @@ PHP_FUNCTION(stream_get_meta_data)
 
 	add_assoc_bool(return_value, "seekable", (stream->ops->seek) && (stream->flags & PHP_STREAM_FLAG_NO_SEEK) == 0);
 	if (stream->orig_path) {
-		add_assoc_string(return_value, "uri", stream->orig_path, 1);
+		add_assoc_string(return_value, "uri", stream->orig_path);
 	}
 
 	if (!php_stream_populate_meta_data(stream, return_value)) {
@@ -541,24 +547,17 @@ PHP_FUNCTION(stream_get_meta_data)
 PHP_FUNCTION(stream_get_transports)
 {
 	HashTable *stream_xport_hash;
-	char *stream_xport;
-	uint stream_xport_len;
-	ulong num_key;
+	zend_string *stream_xport;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	if ((stream_xport_hash = php_stream_xport_get_hash())) {
-		HashPosition pos;
 		array_init(return_value);
-		zend_hash_internal_pointer_reset_ex(stream_xport_hash, &pos);
-		while (zend_hash_get_current_key_ex(stream_xport_hash,
-					&stream_xport, &stream_xport_len,
-					&num_key, 0, &pos) == HASH_KEY_IS_STRING) {
-			add_next_index_stringl(return_value, stream_xport, stream_xport_len - 1, 1);
-			zend_hash_move_forward_ex(stream_xport_hash, &pos);
-		}
+		ZEND_HASH_FOREACH_STR_KEY(stream_xport_hash, stream_xport) {
+			add_next_index_str(return_value, STR_COPY(stream_xport));
+		} ZEND_HASH_FOREACH_END();
 	} else {
 		RETURN_FALSE;
 	}
@@ -570,25 +569,19 @@ PHP_FUNCTION(stream_get_transports)
 PHP_FUNCTION(stream_get_wrappers)
 {
 	HashTable *url_stream_wrappers_hash;
-	char *stream_protocol;
-	int key_flags;
-	uint stream_protocol_len = 0;
-	ulong num_key;
+	zend_string *stream_protocol;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
 	if ((url_stream_wrappers_hash = php_stream_get_url_stream_wrappers_hash())) {
-		HashPosition pos;
 		array_init(return_value);
-		for (zend_hash_internal_pointer_reset_ex(url_stream_wrappers_hash, &pos);
-			(key_flags = zend_hash_get_current_key_ex(url_stream_wrappers_hash, &stream_protocol, &stream_protocol_len, &num_key, 0, &pos)) != HASH_KEY_NON_EXISTENT;
-			zend_hash_move_forward_ex(url_stream_wrappers_hash, &pos)) {
-				if (key_flags == HASH_KEY_IS_STRING) {
-					add_next_index_stringl(return_value, stream_protocol, stream_protocol_len - 1, 1);
-				}
-		}
+		ZEND_HASH_FOREACH_STR_KEY(url_stream_wrappers_hash, stream_protocol) {
+			if (stream_protocol) {
+				add_next_index_str(return_value, STR_COPY(stream_protocol));
+			}
+		} ZEND_HASH_FOREACH_END();
 	} else {
 		RETURN_FALSE;
 	}
@@ -599,17 +592,18 @@ PHP_FUNCTION(stream_get_wrappers)
 /* {{{ stream_select related functions */
 static int stream_array_to_fd_set(zval *stream_array, fd_set *fds, php_socket_t *max_fd TSRMLS_DC)
 {
-	zval **elem;
+	zval *elem;
 	php_stream *stream;
 	int cnt = 0;
 
 	if (Z_TYPE_P(stream_array) != IS_ARRAY) {
 		return 0;
 	}
-	for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream_array));
-		 zend_hash_get_current_data(Z_ARRVAL_P(stream_array), (void **) &elem) == SUCCESS;
-		 zend_hash_move_forward(Z_ARRVAL_P(stream_array))) {
 
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(stream_array), elem) {
+		/* Temporary int fd is needed for the STREAM data type on windows, passing this_fd directly to php_stream_cast()
+			would eventually bring a wrong result on x64. php_stream_cast() casts to int internally, and this will leave
+			the higher bits of a SOCKET variable uninitialized on systems with little endian. */
 		php_socket_t this_fd;
 
 		php_stream_from_zval_no_verify(stream, elem);
@@ -630,41 +624,27 @@ static int stream_array_to_fd_set(zval *stream_array, fd_set *fds, php_socket_t
 			}
 			cnt++;
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 	return cnt ? 1 : 0;
 }
 
 static int stream_array_from_fd_set(zval *stream_array, fd_set *fds TSRMLS_DC)
 {
-	zval **elem, **dest_elem;
+	zval *elem, *dest_elem, new_array;
 	php_stream *stream;
-	HashTable *new_hash;
 	int ret = 0;
+	zend_string *key;
+	ulong num_ind;
 
 	if (Z_TYPE_P(stream_array) != IS_ARRAY) {
 		return 0;
 	}
-	ALLOC_HASHTABLE(new_hash);
-	zend_hash_init(new_hash, zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0);
+	ZVAL_NEW_ARR(&new_array);
+	zend_hash_init(Z_ARRVAL(new_array), zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0);
 
-	for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream_array));
-		 zend_hash_has_more_elements(Z_ARRVAL_P(stream_array)) == SUCCESS;
-		 zend_hash_move_forward(Z_ARRVAL_P(stream_array))) {
-
-		int type;
-		char *key;
-		uint key_len;
-		ulong num_ind;
+	ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(stream_array), num_ind, key, elem) {
 		php_socket_t this_fd;
 
-
-		type = zend_hash_get_current_key_ex(Z_ARRVAL_P(stream_array),
-				&key, &key_len, &num_ind, 0, NULL);
-		if (type == HASH_KEY_NON_EXISTENT ||
-			zend_hash_get_current_data(Z_ARRVAL_P(stream_array), (void **) &elem) == FAILURE) {
-			continue; /* should not happen */
-		}
-
 		php_stream_from_zval_no_verify(stream, elem);
 		if (stream == NULL) {
 			continue;
@@ -676,10 +656,10 @@ static int stream_array_from_fd_set(zval *stream_array, fd_set *fds TSRMLS_DC)
 		 */
 		if (SUCCESS == php_stream_cast(stream, PHP_STREAM_AS_FD_FOR_SELECT | PHP_STREAM_CAST_INTERNAL, (void*)&this_fd, 1) && this_fd != SOCK_ERR) {
 			if (PHP_SAFE_FD_ISSET(this_fd, fds)) {
-				if (type == HASH_KEY_IS_LONG) {
-					zend_hash_index_update(new_hash, num_ind, (void *)elem, sizeof(zval *), (void **)&dest_elem);
-				} else { /* HASH_KEY_IS_STRING */
-					zend_hash_update(new_hash, key, key_len, (void *)elem, sizeof(zval *), (void **)&dest_elem);
+				if (!key) {
+					dest_elem = zend_hash_index_update(Z_ARRVAL(new_array), num_ind, elem);
+				} else {
+					dest_elem = zend_hash_update(Z_ARRVAL(new_array), key, elem);
 				}
 				
 				if (dest_elem) {
@@ -689,35 +669,31 @@ static int stream_array_from_fd_set(zval *stream_array, fd_set *fds TSRMLS_DC)
 				continue;
 			}
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	/* destroy old array and add new one */
 	zend_hash_destroy(Z_ARRVAL_P(stream_array));
-	efree(Z_ARRVAL_P(stream_array));
+	GC_REMOVE_FROM_BUFFER(Z_ARR_P(stream_array));
+	efree(Z_ARR_P(stream_array));
 
-	zend_hash_internal_pointer_reset(new_hash);
-	Z_ARRVAL_P(stream_array) = new_hash;
+	Z_ARR_P(stream_array) = Z_ARR(new_array);
 
 	return ret;
 }
 
 static int stream_array_emulate_read_fd_set(zval *stream_array TSRMLS_DC)
 {
-	zval **elem, **dest_elem;
+	zval *elem, *dest_elem, new_array;
 	php_stream *stream;
-	HashTable *new_hash;
 	int ret = 0;
 
 	if (Z_TYPE_P(stream_array) != IS_ARRAY) {
 		return 0;
 	}
-	ALLOC_HASHTABLE(new_hash);
-	zend_hash_init(new_hash, zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0);
-
-	for (zend_hash_internal_pointer_reset(Z_ARRVAL_P(stream_array));
-		 zend_hash_get_current_data(Z_ARRVAL_P(stream_array), (void **) &elem) == SUCCESS;
-		 zend_hash_move_forward(Z_ARRVAL_P(stream_array))) {
+	ZVAL_NEW_ARR(&new_array);
+	zend_hash_init(Z_ARRVAL(new_array), zend_hash_num_elements(Z_ARRVAL_P(stream_array)), NULL, ZVAL_PTR_DTOR, 0);
 
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(stream_array), elem) {
 		php_stream_from_zval_no_verify(stream, elem);
 		if (stream == NULL) {
 			continue;
@@ -729,25 +705,23 @@ static int stream_array_emulate_read_fd_set(zval *stream_array TSRMLS_DC)
 			 * This branch of code also allows blocking streams with buffered data to
 			 * operate correctly in stream_select.
 			 * */
-			zend_hash_next_index_insert(new_hash, (void *)elem, sizeof(zval *), (void **)&dest_elem);
+			dest_elem = zend_hash_next_index_insert(Z_ARRVAL(new_array), elem);
 			if (dest_elem) {
 				zval_add_ref(dest_elem);
 			}
 			ret++;
 			continue;
 		}
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	if (ret > 0) {
 		/* destroy old array and add new one */
 		zend_hash_destroy(Z_ARRVAL_P(stream_array));
-		efree(Z_ARRVAL_P(stream_array));
-
-		zend_hash_internal_pointer_reset(new_hash);
-		Z_ARRVAL_P(stream_array) = new_hash;
+		efree(Z_ARR_P(stream_array));
+		Z_ARR_P(stream_array) = Z_ARR(new_array);
 	} else {
-		zend_hash_destroy(new_hash);
-		FREE_HASHTABLE(new_hash);
+		zend_hash_destroy(Z_ARRVAL(new_array));
+		efree(Z_ARR(new_array));
 	}
 
 	return ret;
@@ -758,7 +732,7 @@ static int stream_array_emulate_read_fd_set(zval *stream_array TSRMLS_DC)
    Runs the select() system call on the sets of streams with a timeout specified by tv_sec and tv_usec */
 PHP_FUNCTION(stream_select)
 {
-	zval			*r_array, *w_array, *e_array, **sec = NULL;
+	zval			*r_array, *w_array, *e_array, *sec = NULL;
 	struct timeval	tv;
 	struct timeval *tv_p = NULL;
 	fd_set			rfds, wfds, efds;
@@ -767,7 +741,7 @@ PHP_FUNCTION(stream_select)
 	long			usec = 0;
 	int				set_count, max_set_count = 0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!Z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE)
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a!a!a!z!|l", &r_array, &w_array, &e_array, &sec, &usec) == FAILURE)
 		return;
 
 	FD_ZERO(&rfds);
@@ -806,7 +780,7 @@ PHP_FUNCTION(stream_select)
 	if (sec != NULL) {
 		convert_to_long_ex(sec);
 
-		if (Z_LVAL_PP(sec) < 0) {
+		if (Z_LVAL_P(sec) < 0) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "The seconds parameter must be greater than 0");
 			RETURN_FALSE;
 		} else if (usec < 0) {
@@ -816,10 +790,10 @@ PHP_FUNCTION(stream_select)
 
 		/* Solaris + BSD do not like microsecond values which are >= 1 sec */
 		if (usec > 999999) {
-			tv.tv_sec = Z_LVAL_PP(sec) + (usec / 1000000);
+			tv.tv_sec = Z_LVAL_P(sec) + (usec / 1000000);
 			tv.tv_usec = usec % 1000000;
 		} else {
-			tv.tv_sec = Z_LVAL_PP(sec);
+			tv.tv_sec = Z_LVAL_P(sec);
 			tv.tv_usec = usec;
 		}
 
@@ -863,78 +837,58 @@ PHP_FUNCTION(stream_select)
 static void user_space_stream_notifier(php_stream_context *context, int notifycode, int severity,
 		char *xmsg, int xcode, size_t bytes_sofar, size_t bytes_max, void * ptr TSRMLS_DC)
 {
-	zval *callback = (zval*)context->notifier->ptr;
-	zval *retval = NULL;
+	zval *callback = &context->notifier->ptr;
+	zval retval;
 	zval zvs[6];
-	zval *ps[6];
-	zval **ptps[6];
 	int i;
 
-	for (i = 0; i < 6; i++) {
-		INIT_ZVAL(zvs[i]);
-		ps[i] = &zvs[i];
-		ptps[i] = &ps[i];
-		MAKE_STD_ZVAL(ps[i]);
-	}
-
-	ZVAL_LONG(ps[0], notifycode);
-	ZVAL_LONG(ps[1], severity);
+	ZVAL_LONG(&zvs[0], notifycode);
+	ZVAL_LONG(&zvs[1], severity);
 	if (xmsg) {
-		ZVAL_STRING(ps[2], xmsg, 1);
+		ZVAL_STRING(&zvs[2], xmsg);
 	} else {
-		ZVAL_NULL(ps[2]);
+		ZVAL_NULL(&zvs[2]);
 	}
-	ZVAL_LONG(ps[3], xcode);
-	ZVAL_LONG(ps[4], bytes_sofar);
-	ZVAL_LONG(ps[5], bytes_max);
+	ZVAL_LONG(&zvs[3], xcode);
+	ZVAL_LONG(&zvs[4], bytes_sofar);
+	ZVAL_LONG(&zvs[5], bytes_max);
 
-	if (FAILURE == call_user_function_ex(EG(function_table), NULL, callback, &retval, 6, ptps, 0, NULL TSRMLS_CC)) {
+	if (FAILURE == call_user_function_ex(EG(function_table), NULL, callback, &retval, 6, zvs, 0, NULL TSRMLS_CC)) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call user notifier");
 	}
 	for (i = 0; i < 6; i++) {
-		zval_ptr_dtor(&ps[i]);
-	}
-	if (retval) {
-		zval_ptr_dtor(&retval);
+		zval_ptr_dtor(&zvs[i]);
 	}
+	zval_ptr_dtor(&retval);
 }
 
 static void user_space_stream_notifier_dtor(php_stream_notifier *notifier)
 {
-	if (notifier && notifier->ptr) {
-		zval_ptr_dtor((zval **)&(notifier->ptr));
-		notifier->ptr = NULL;
+	if (notifier && Z_TYPE(notifier->ptr) != IS_UNDEF) {
+		zval_ptr_dtor(&notifier->ptr);
+		ZVAL_UNDEF(&notifier->ptr);
 	}
 }
 
 static int parse_context_options(php_stream_context *context, zval *options TSRMLS_DC)
 {
-	HashPosition pos, opos;
-	zval **wval, **oval;
-	char *wkey, *okey;
-	uint wkey_len, okey_len;
+	zval *wval, *oval;
+	zend_string *wkey, *okey;
 	int ret = SUCCESS;
-	ulong num_key;
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(options), &pos);
-	while (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_P(options), (void**)&wval, &pos)) {
-		if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_P(options), &wkey, &wkey_len, &num_key, 0, &pos)
-				&& Z_TYPE_PP(wval) == IS_ARRAY) {
+	ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(options), wkey, wval) {
+		if (wkey && Z_TYPE_P(wval) == IS_ARRAY) {
 
-			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(wval), &opos);
-			while (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(wval), (void**)&oval, &opos)) {
-
-				if (HASH_KEY_IS_STRING == zend_hash_get_current_key_ex(Z_ARRVAL_PP(wval), &okey, &okey_len, &num_key, 0, &opos)) {
-					php_stream_context_set_option(context, wkey, okey, *oval);
+		    ZEND_HASH_FOREACH_STR_KEY_VAL(Z_ARRVAL_P(wval), okey, oval) {
+				if (okey) {
+					php_stream_context_set_option(context, wkey->val, okey->val, oval);
 				}
-				zend_hash_move_forward_ex(Z_ARRVAL_PP(wval), &opos);
-			}
+			} ZEND_HASH_FOREACH_END();
 
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "options should have the form [\"wrappername\"][\"optionname\"] = $value");
 		}
-		zend_hash_move_forward_ex(Z_ARRVAL_P(options), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	return ret;
 }
@@ -942,9 +896,9 @@ static int parse_context_options(php_stream_context *context, zval *options TSRM
 static int parse_context_params(php_stream_context *context, zval *params TSRMLS_DC)
 {
 	int ret = SUCCESS;
-	zval **tmp;
+	zval *tmp;
 
-	if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "notification", sizeof("notification"), (void**)&tmp)) {
+	if (NULL != (tmp = zend_hash_str_find(Z_ARRVAL_P(params), "notification", sizeof("notification")-1))) {
 
 		if (context->notifier) {
 			php_stream_notification_free(context->notifier);
@@ -953,13 +907,12 @@ static int parse_context_params(php_stream_context *context, zval *params TSRMLS
 
 		context->notifier = php_stream_notification_alloc();
 		context->notifier->func = user_space_stream_notifier;
-		context->notifier->ptr = *tmp;
-		Z_ADDREF_P(*tmp);
+		ZVAL_COPY(&context->notifier->ptr, tmp);
 		context->notifier->dtor = user_space_stream_notifier_dtor;
 	}
-	if (SUCCESS == zend_hash_find(Z_ARRVAL_P(params), "options", sizeof("options"), (void**)&tmp)) {
-		if (Z_TYPE_PP(tmp) == IS_ARRAY) {
-			parse_context_options(context, *tmp TSRMLS_CC);
+	if (NULL != (tmp = zend_hash_str_find(Z_ARRVAL_P(params), "options", sizeof("options")-1))) {
+		if (Z_TYPE_P(tmp) == IS_ARRAY) {
+			parse_context_options(context, tmp TSRMLS_CC);
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid stream/context parameter");
 		}
@@ -975,11 +928,11 @@ static php_stream_context *decode_context_param(zval *contextresource TSRMLS_DC)
 {
 	php_stream_context *context = NULL;
 
-	context = zend_fetch_resource(&contextresource TSRMLS_CC, -1, NULL, NULL, 1, php_le_stream_context(TSRMLS_C));
+	context = zend_fetch_resource(contextresource TSRMLS_CC, -1, NULL, NULL, 1, php_le_stream_context(TSRMLS_C));
 	if (context == NULL) {
 		php_stream *stream;
 
-		stream = zend_fetch_resource(&contextresource TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream);
+		stream = zend_fetch_resource(contextresource TSRMLS_CC, -1, NULL, NULL, 2, php_file_le_stream(), php_file_le_pstream);
 
 		if (stream) {
 			context = stream->context;
@@ -1013,7 +966,7 @@ PHP_FUNCTION(stream_context_get_options)
 		RETURN_FALSE;
 	}
 
-	RETURN_ZVAL(context->options, 1, 0);
+	RETURN_ZVAL(&context->options, 1, 0);
 }
 /* }}} */
 
@@ -1078,7 +1031,7 @@ PHP_FUNCTION(stream_context_set_params)
    Get parameters of a file context */
 PHP_FUNCTION(stream_context_get_params)
 {
-	zval *zcontext, *options;
+	zval *zcontext, options;
 	php_stream_context *context;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "r", &zcontext) == FAILURE) {
@@ -1092,13 +1045,12 @@ PHP_FUNCTION(stream_context_get_params)
 	}
 
 	array_init(return_value);
-	if (context->notifier && context->notifier->ptr && context->notifier->func == user_space_stream_notifier) {
-		add_assoc_zval_ex(return_value, ZEND_STRS("notification"), context->notifier->ptr);
-		Z_ADDREF_P(context->notifier->ptr);
+	if (context->notifier && Z_TYPE(context->notifier->ptr) != IS_UNDEF && context->notifier->func == user_space_stream_notifier) {
+		add_assoc_zval_ex(return_value, "notification", sizeof("notification")-1, &context->notifier->ptr);
+		if (Z_REFCOUNTED(context->notifier->ptr)) Z_ADDREF(context->notifier->ptr);
 	}
-	ALLOC_INIT_ZVAL(options);
-	ZVAL_ZVAL(options, context->options, 1, 0);
-	add_assoc_zval_ex(return_value, ZEND_STRS("options"), options);
+	ZVAL_ZVAL(&options, &context->options, 1, 0);
+	add_assoc_zval_ex(return_value, "options", sizeof("options")-1, &options);
 }
 /* }}} */
 
@@ -1169,7 +1121,7 @@ PHP_FUNCTION(stream_context_create)
 		parse_context_params(context, params TSRMLS_CC);
 	}
 
-	RETURN_RESOURCE(context->rsrc_id);
+	RETURN_RES(context->res);
 }
 /* }}} */
 
@@ -1190,7 +1142,7 @@ static void apply_filter_to_stream(int append, INTERNAL_FUNCTION_PARAMETERS)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	if ((read_write & PHP_STREAM_FILTER_ALL) == 0) {
 		/* Chain not specified.
@@ -1241,7 +1193,9 @@ static void apply_filter_to_stream(int append, INTERNAL_FUNCTION_PARAMETERS)
 	}
 
 	if (filter) {
-		RETURN_RESOURCE(filter->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, filter, php_file_le_stream_filter()));
+		filter->res = ZEND_REGISTER_RESOURCE(NULL, filter, php_file_le_stream_filter());
+		GC_REFCOUNT(filter->res)++;
+		RETURN_RES(filter->res);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1275,7 +1229,7 @@ PHP_FUNCTION(stream_filter_remove)
 		RETURN_FALSE;
 	}
 
-	filter = zend_fetch_resource(&zfilter TSRMLS_CC, -1, NULL, NULL, 1, php_file_le_stream_filter());
+	filter = zend_fetch_resource(zfilter TSRMLS_CC, -1, NULL, NULL, 1, php_file_le_stream_filter());
 	if (!filter) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid resource given, not a stream filter");
 		RETURN_FALSE;
@@ -1286,7 +1240,7 @@ PHP_FUNCTION(stream_filter_remove)
 		RETURN_FALSE;
 	}
 
-	if (zend_list_delete(Z_LVAL_P(zfilter)) == FAILURE) {
+	if (zend_list_close(Z_RES_P(zfilter)) == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not invalidate filter, not removing");
 		RETURN_FALSE;
 	} else {
@@ -1304,8 +1258,7 @@ PHP_FUNCTION(stream_get_line)
 	int str_len = 0;
 	long max_length;
 	zval *zstream;
-	char *buf;
-	size_t buf_size;
+	zend_string *buf;
 	php_stream *stream;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "rl|s", &zstream, &max_length, &str, &str_len) == FAILURE) {
@@ -1320,10 +1273,10 @@ PHP_FUNCTION(stream_get_line)
 		max_length = PHP_SOCK_CHUNK_SIZE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
-	if ((buf = php_stream_get_record(stream, max_length, &buf_size, str, str_len TSRMLS_CC))) {
-		RETURN_STRINGL(buf, buf_size, 0);
+	if ((buf = php_stream_get_record(stream, max_length, str, str_len TSRMLS_CC))) {
+		RETURN_STR(buf);
 	} else {
 		RETURN_FALSE;
 	}
@@ -1344,7 +1297,7 @@ PHP_FUNCTION(stream_set_blocking)
 		return;
 	}
 
-	php_stream_from_zval(stream, &arg1);
+	php_stream_from_zval(stream, arg1);
 
 	block = arg2;
 
@@ -1372,7 +1325,7 @@ PHP_FUNCTION(stream_set_timeout)
 		return;
 	}
 
-	php_stream_from_zval(stream, &socket);
+	php_stream_from_zval(stream, socket);
 
 	t.tv_sec = seconds;
 
@@ -1406,7 +1359,7 @@ PHP_FUNCTION(stream_set_write_buffer)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &arg1);
+	php_stream_from_zval(stream, arg1);
 
 	buff = arg2;
 
@@ -1447,7 +1400,7 @@ PHP_FUNCTION(stream_set_chunk_size)
 		RETURN_FALSE;
 	}
 	
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	ret = php_stream_set_option(stream, PHP_STREAM_OPTION_SET_CHUNK_SIZE, (int)csize, NULL);
 	
@@ -1469,7 +1422,7 @@ PHP_FUNCTION(stream_set_read_buffer)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &arg1);
+	php_stream_from_zval(stream, arg1);
 
 	buff = arg2;
 
@@ -1498,11 +1451,11 @@ PHP_FUNCTION(stream_socket_enable_crypto)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	if (ZEND_NUM_ARGS() >= 3) {
 		if (zsessstream) {
-			php_stream_from_zval(sessstream, &zsessstream);
+			php_stream_from_zval(sessstream, zsessstream);
 		}
 
 		if (php_stream_xport_crypto_setup(stream, cryptokind, sessstream TSRMLS_CC) < 0) {
@@ -1541,7 +1494,10 @@ PHP_FUNCTION(stream_resolve_include_path)
 	resolved_path = zend_resolve_path(filename, filename_len TSRMLS_CC);
 
 	if (resolved_path) {
-		RETURN_STRING(resolved_path, 0);
+		// TODO: avoid reallocation ???
+		RETVAL_STRING(resolved_path);
+		efree(resolved_path);
+		return;
 	}
 	RETURN_FALSE;
 }
@@ -1551,15 +1507,15 @@ PHP_FUNCTION(stream_resolve_include_path)
 */
 PHP_FUNCTION(stream_is_local)
 {
-	zval **zstream;
+	zval *zstream;
 	php_stream *stream = NULL;
 	php_stream_wrapper *wrapper = NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &zstream) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &zstream) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	if (Z_TYPE_PP(zstream) == IS_RESOURCE) {
+	if (Z_TYPE_P(zstream) == IS_RESOURCE) {
 		php_stream_from_zval(stream, zstream);
 		if (stream == NULL) {
 			RETURN_FALSE;
@@ -1568,7 +1524,7 @@ PHP_FUNCTION(stream_is_local)
 	} else {
 		convert_to_string_ex(zstream);
 
-		wrapper = php_stream_locate_url_wrapper(Z_STRVAL_PP(zstream), NULL, 0 TSRMLS_CC);
+		wrapper = php_stream_locate_url_wrapper(Z_STRVAL_P(zstream), NULL, 0 TSRMLS_CC);
 	}
 
 	if (!wrapper) {
@@ -1590,7 +1546,7 @@ PHP_FUNCTION(stream_supports_lock)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zsrc);
+	php_stream_from_zval(stream, zsrc);
 
 	if (!php_stream_supports_lock(stream)) {
 		RETURN_FALSE;
@@ -1622,7 +1578,7 @@ PHP_FUNCTION(stream_socket_shutdown)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	RETURN_BOOL(php_stream_xport_shutdown(stream, (stream_shutdown_t)how TSRMLS_CC) == 0);
 }
diff --git a/ext/standard/string.c b/ext/standard/string.c
index 9139906653..a77084551e 100644
--- a/ext/standard/string.c
+++ b/ext/standard/string.c
@@ -127,23 +127,20 @@ static MUTEX_T locale_mutex = NULL;
 
 /* {{{ php_bin2hex
  */
-static char *php_bin2hex(const unsigned char *old, const size_t oldlen, size_t *newlen)
+static zend_string *php_bin2hex(const unsigned char *old, const size_t oldlen)
 {
-	register unsigned char *result = NULL;
+	zend_string *result;
 	size_t i, j;
 
-	result = (unsigned char *) safe_emalloc(oldlen, 2 * sizeof(char), 1);
+	result = STR_SAFE_ALLOC(oldlen, 2 * sizeof(char), 0, 0);
 
 	for (i = j = 0; i < oldlen; i++) {
-		result[j++] = hexconvtab[old[i] >> 4];
-		result[j++] = hexconvtab[old[i] & 15];
+		result->val[j++] = hexconvtab[old[i] >> 4];
+		result->val[j++] = hexconvtab[old[i] & 15];
 	}
-	result[j] = '\0';
+	result->val[j] = '\0';
 
-	if (newlen)
-		*newlen = oldlen * 2 * sizeof(char);
-
-	return (char *)result;
+	return result;
 }
 /* }}} */
 
@@ -237,21 +234,21 @@ PHP_MSHUTDOWN_FUNCTION(localeconv)
    Converts the binary representation of data to hex */
 PHP_FUNCTION(bin2hex)
 {
-	char *result, *data;
-	size_t newlen;
+	zend_string *result;
+	char *data;
 	int datalen;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &data, &datalen) == FAILURE) {
 		return;
 	}
 
-	result = php_bin2hex((unsigned char *)data, datalen, &newlen);
+	result = php_bin2hex((unsigned char *)data, datalen);
 
 	if (!result) {
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL(result, newlen, 0);
+	RETURN_STR(result);
 }
 /* }}} */
 
@@ -279,7 +276,9 @@ PHP_FUNCTION(hex2bin)
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL(result, newlen, 0);
+	// TODO: avoid reallocation ???
+	RETVAL_STRINGL(result, newlen);
+	efree(result);
 }
 /* }}} */
 
@@ -706,7 +705,7 @@ PHP_FUNCTION(nl_langinfo)
 	if (value == NULL) {
 		RETURN_FALSE;
 	} else {
-		RETURN_STRING(value, 1);
+		RETURN_STRING(value);
 	}
 }
 #endif
@@ -818,7 +817,7 @@ PHPAPI char *php_trim(char *c, int len, char *what, int what_len, zval *return_v
 	}
 
 	if (return_value) {
-		RETVAL_STRINGL(c, len, 1);
+		RETVAL_STRINGL(c, len);
 	} else {
 		return estrndup(c, len);
 	}
@@ -872,12 +871,12 @@ PHP_FUNCTION(ltrim)
 PHP_FUNCTION(wordwrap)
 {
 	const char *text, *breakchar = "\n";
-	char *newtext;
 	int textlen, breakcharlen = 1, newtextlen, chk;
 	size_t alloced;
 	long current = 0, laststart = 0, lastspace = 0;
 	long linelength = 75;
 	zend_bool docut = 0;
+	zend_string *newtext;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|lsb", &text, &textlen, &linelength, &breakchar, &breakcharlen, &docut) == FAILURE) {
 		return;
@@ -900,7 +899,7 @@ PHP_FUNCTION(wordwrap)
 	/* Special case for a single-character break as it needs no
 	   additional storage space */
 	if (breakcharlen == 1 && !docut) {
-		newtext = estrndup(text, textlen);
+		newtext = STR_INIT(text, textlen, 0);
 
 		laststart = lastspace = 0;
 		for (current = 0; current < textlen; current++) {
@@ -908,27 +907,27 @@ PHP_FUNCTION(wordwrap)
 				laststart = lastspace = current + 1;
 			} else if (text[current] == ' ') {
 				if (current - laststart >= linelength) {
-					newtext[current] = breakchar[0];
+					newtext->val[current] = breakchar[0];
 					laststart = current + 1;
 				}
 				lastspace = current;
 			} else if (current - laststart >= linelength && laststart != lastspace) {
-				newtext[lastspace] = breakchar[0];
+				newtext->val[lastspace] = breakchar[0];
 				laststart = lastspace + 1;
 			}
 		}
 
-		RETURN_STRINGL(newtext, textlen, 0);
+		RETURN_NEW_STR(newtext);
 	} else {
 		/* Multiple character line break or forced cut */
 		if (linelength > 0) {
 			chk = (int)(textlen/linelength + 1);
-			newtext = safe_emalloc(chk, breakcharlen, textlen + 1);
+			newtext = STR_ALLOC(chk * breakcharlen + textlen, 0);
 			alloced = textlen + chk * breakcharlen + 1;
 		} else {
 			chk = textlen;
 			alloced = textlen * (breakcharlen + 1) + 1;
-			newtext = safe_emalloc(textlen, (breakcharlen + 1), 1);
+			newtext = STR_ALLOC(textlen * (breakcharlen + 1), 0);
 		}
 
 		/* now keep track of the actual new text length */
@@ -938,7 +937,7 @@ PHP_FUNCTION(wordwrap)
 		for (current = 0; current < textlen; current++) {
 			if (chk <= 0) {
 				alloced += (int) (((textlen - current + 1)/linelength + 1) * breakcharlen) + 1;
-				newtext = erealloc(newtext, alloced);
+				newtext = STR_REALLOC(newtext, alloced, 0);
 				chk = (int) ((textlen - current)/linelength) + 1;
 			}
 			/* when we hit an existing break, copy to new buffer, and
@@ -946,8 +945,8 @@ PHP_FUNCTION(wordwrap)
 			if (text[current] == breakchar[0]
 				&& current + breakcharlen < textlen
 				&& !strncmp(text+current, breakchar, breakcharlen)) {
-				memcpy(newtext+newtextlen, text+laststart, current-laststart+breakcharlen);
-				newtextlen += current-laststart+breakcharlen;
+				memcpy(newtext->val + newtextlen, text + laststart, current - laststart + breakcharlen);
+				newtextlen += current - laststart + breakcharlen;
 				current += breakcharlen - 1;
 				laststart = lastspace = current + 1;
 				chk--;
@@ -956,9 +955,9 @@ PHP_FUNCTION(wordwrap)
 			 * copy and insert a break, or just keep track of it */
 			else if (text[current] == ' ') {
 				if (current - laststart >= linelength) {
-					memcpy(newtext+newtextlen, text+laststart, current-laststart);
+					memcpy(newtext->val + newtextlen, text + laststart, current - laststart);
 					newtextlen += current - laststart;
-					memcpy(newtext+newtextlen, breakchar, breakcharlen);
+					memcpy(newtext->val + newtextlen, breakchar, breakcharlen);
 					newtextlen += breakcharlen;
 					laststart = current + 1;
 					chk--;
@@ -970,9 +969,9 @@ PHP_FUNCTION(wordwrap)
 			 * copy and insert a break. */
 			else if (current - laststart >= linelength
 					&& docut && laststart >= lastspace) {
-				memcpy(newtext+newtextlen, text+laststart, current-laststart);
+				memcpy(newtext->val + newtextlen, text + laststart, current - laststart);
 				newtextlen += current - laststart;
-				memcpy(newtext+newtextlen, breakchar, breakcharlen);
+				memcpy(newtext->val + newtextlen, breakchar, breakcharlen);
 				newtextlen += breakcharlen;
 				laststart = lastspace = current;
 				chk--;
@@ -982,9 +981,9 @@ PHP_FUNCTION(wordwrap)
 			 * up the laststart */
 			else if (current - laststart >= linelength
 					&& laststart < lastspace) {
-				memcpy(newtext+newtextlen, text+laststart, lastspace-laststart);
+				memcpy(newtext->val + newtextlen, text + laststart, lastspace - laststart);
 				newtextlen += lastspace - laststart;
-				memcpy(newtext+newtextlen, breakchar, breakcharlen);
+				memcpy(newtext->val + newtextlen, breakchar, breakcharlen);
 				newtextlen += breakcharlen;
 				laststart = lastspace = lastspace + 1;
 				chk--;
@@ -993,15 +992,15 @@ PHP_FUNCTION(wordwrap)
 
 		/* copy over any stragglers */
 		if (laststart != current) {
-			memcpy(newtext+newtextlen, text+laststart, current-laststart);
+			memcpy(newtext->val + newtextlen, text + laststart, current - laststart);
 			newtextlen += current - laststart;
 		}
 
-		newtext[newtextlen] = '\0';
+		newtext->val[newtextlen] = '\0';
 		/* free unused memory */
-		newtext = erealloc(newtext, newtextlen+1);
+		newtext = STR_REALLOC(newtext, newtextlen, 0);
 
-		RETURN_STRINGL(newtext, newtextlen, 0);
+		RETURN_NEW_STR(newtext);
 	}
 }
 /* }}} */
@@ -1015,19 +1014,19 @@ PHPAPI void php_explode(zval *delim, zval *str, zval *return_value, long limit)
 	endp = Z_STRVAL_P(str) + Z_STRLEN_P(str);
 
 	p1 = Z_STRVAL_P(str);
-	p2 = php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
+	p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
 
 	if (p2 == NULL) {
-		add_next_index_stringl(return_value, p1, Z_STRLEN_P(str), 1);
+		add_next_index_stringl(return_value, p1, Z_STRLEN_P(str));
 	} else {
 		do {
-			add_next_index_stringl(return_value, p1, p2 - p1, 1);
+			add_next_index_stringl(return_value, p1, p2 - p1);
 			p1 = p2 + Z_STRLEN_P(delim);
-		} while ((p2 = php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL &&
+		} while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL &&
 				 --limit > 1);
 
 		if (p1 <= endp)
-			add_next_index_stringl(return_value, p1, endp-p1, 1);
+			add_next_index_stringl(return_value, p1, endp-p1);
 	}
 }
 /* }}} */
@@ -1042,7 +1041,7 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu
 	endp = Z_STRVAL_P(str) + Z_STRLEN_P(str);
 
 	p1 = Z_STRVAL_P(str);
-	p2 = php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
+	p2 = (char*)php_memnstr(Z_STRVAL_P(str), Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp);
 
 	if (p2 == NULL) {
 		/*
@@ -1061,15 +1060,13 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu
 				positions = erealloc(positions, allocated*sizeof(char *));
 			}
 			positions[found++] = p1 = p2 + Z_STRLEN_P(delim);
-		} while ((p2 = php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL);
+		} while ((p2 = (char*)php_memnstr(p1, Z_STRVAL_P(delim), Z_STRLEN_P(delim), endp)) != NULL);
 
 		to_return = limit + found;
 		/* limit is at least -1 therefore no need of bounds checking : i will be always less than found */
 		for (i = 0;i < to_return;i++) { /* this checks also for to_return > 0 */
 			add_next_index_stringl(return_value, positions[i],
-					(positions[i+1] - Z_STRLEN_P(delim)) - positions[i],
-					1
-				);
+					(positions[i+1] - Z_STRLEN_P(delim)) - positions[i]);
 		}
 		efree(positions);
 	}
@@ -1081,37 +1078,36 @@ PHPAPI void php_explode_negative_limit(zval *delim, zval *str, zval *return_valu
    Splits a string on string separator and return array of components. If limit is positive only limit number of components is returned. If limit is negative all components except the last abs(limit) are returned. */
 PHP_FUNCTION(explode)
 {
-	char *str, *delim;
-	int str_len = 0, delim_len = 0;
+	zend_string *str, *delim;
 	long limit = LONG_MAX; /* No limit */
 	zval zdelim, zstr;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &delim, &delim_len, &str, &str_len, &limit) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|l", &delim, &str, &limit) == FAILURE) {
 		return;
 	}
 
-	if (delim_len == 0) {
+	if (delim->len == 0) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Empty delimiter");
 		RETURN_FALSE;
 	}
 
 	array_init(return_value);
 
-	if (str_len == 0) {
+	if (str->len == 0) {
 	  	if (limit >= 0) {
-			add_next_index_stringl(return_value, "", sizeof("") - 1, 1);
+			add_next_index_stringl(return_value, "", sizeof("") - 1);
 		}
 		return;
 	}
 
-	ZVAL_STRINGL(&zstr, str, str_len, 0);
-	ZVAL_STRINGL(&zdelim, delim, delim_len, 0);
+	ZVAL_STR(&zstr, str);
+	ZVAL_STR(&zdelim, delim);
 	if (limit > 1) {
 		php_explode(&zdelim, &zstr, return_value, limit);
 	} else if (limit < 0) {
 		php_explode_negative_limit(&zdelim, &zstr, return_value, limit);
 	} else {
-		add_index_stringl(return_value, 0, str, str_len, 1);
+		add_index_stringl(return_value, 0, str->val, str->len);
 	}
 }
 /* }}} */
@@ -1124,8 +1120,7 @@ PHP_FUNCTION(explode)
  */
 PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
 {
-	zval         **tmp;
-	HashPosition   pos;
+	zval          *tmp;
 	smart_str      implstr = {0};
 	int            numelems, i = 0;
 	zval tmp_val;
@@ -1137,23 +1132,22 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
 		RETURN_EMPTY_STRING();
 	}
 
-	zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(arr), &pos);
-
-	while (zend_hash_get_current_data_ex(Z_ARRVAL_P(arr), (void **) &tmp, &pos) == SUCCESS) {
-		switch ((*tmp)->type) {
+	ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(arr), tmp) {
+again:
+		switch (Z_TYPE_P(tmp)) {
 			case IS_STRING:
-				smart_str_appendl(&implstr, Z_STRVAL_PP(tmp), Z_STRLEN_PP(tmp));
+				smart_str_appendl(&implstr, Z_STRVAL_P(tmp), Z_STRLEN_P(tmp));
 				break;
 
 			case IS_LONG: {
 				char stmp[MAX_LENGTH_OF_LONG + 1];
-				str_len = slprintf(stmp, sizeof(stmp), "%ld", Z_LVAL_PP(tmp));
+				str_len = slprintf(stmp, sizeof(stmp), "%ld", Z_LVAL_P(tmp));
 				smart_str_appendl(&implstr, stmp, str_len);
 			}
 				break;
 
 			case IS_BOOL:
-				if (Z_LVAL_PP(tmp) == 1) {
+				if (Z_LVAL_P(tmp) == 1) {
 					smart_str_appendl(&implstr, "1", sizeof("1")-1);
 				}
 				break;
@@ -1163,7 +1157,7 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
 
 			case IS_DOUBLE: {
 				char *stmp;
-				str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_PP(tmp));
+				str_len = spprintf(&stmp, 0, "%.*G", (int) EG(precision), Z_DVAL_P(tmp));
 				smart_str_appendl(&implstr, stmp, str_len);
 				efree(stmp);
 			}
@@ -1172,17 +1166,18 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
 			case IS_OBJECT: {
 				int copy;
 				zval expr;
-				zend_make_printable_zval(*tmp, &expr, &copy);
+				zend_make_printable_zval(tmp, &expr, &copy);
 				smart_str_appendl(&implstr, Z_STRVAL(expr), Z_STRLEN(expr));
 				if (copy) {
 					zval_dtor(&expr);
 				}
 			}
 				break;
-
+			case IS_REFERENCE:
+				tmp = Z_REFVAL_P(tmp);
+				goto again;
 			default:
-				tmp_val = **tmp;
-				zval_copy_ctor(&tmp_val);
+				ZVAL_DUP(&tmp_val, tmp);
 				convert_to_string(&tmp_val);
 				smart_str_appendl(&implstr, Z_STRVAL(tmp_val), Z_STRLEN(tmp_val));
 				zval_dtor(&tmp_val);
@@ -1193,12 +1188,12 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
 		if (++i != numelems) {
 			smart_str_appendl(&implstr, Z_STRVAL_P(delim), Z_STRLEN_P(delim));
 		}
-		zend_hash_move_forward_ex(Z_ARRVAL_P(arr), &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
+
 	smart_str_0(&implstr);
 
-	if (implstr.len) {
-		RETURN_STRINGL(implstr.c, implstr.len, 0);
+	if (implstr.s) {
+		RETURN_STR(implstr.s);
 	} else {
 		smart_str_free(&implstr);
 		RETURN_EMPTY_STRING();
@@ -1210,33 +1205,32 @@ PHPAPI void php_implode(zval *delim, zval *arr, zval *return_value TSRMLS_DC)
    Joins array elements placing glue string between items and return one string */
 PHP_FUNCTION(implode)
 {
-	zval **arg1 = NULL, **arg2 = NULL, *delim, *arr;
+	zval *arg1 = NULL, *arg2 = NULL, *delim, *arr, tmp;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z|Z", &arg1, &arg2) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|z", &arg1, &arg2) == FAILURE) {
 		return;
 	}
 
 	if (arg2 == NULL) {
-		if (Z_TYPE_PP(arg1) != IS_ARRAY) {
+		if (Z_TYPE_P(arg1) != IS_ARRAY) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument must be an array");
 			return;
 		}
 
-		MAKE_STD_ZVAL(delim);
-#define _IMPL_EMPTY ""
-		ZVAL_STRINGL(delim, _IMPL_EMPTY, sizeof(_IMPL_EMPTY) - 1, 0);
+		ZVAL_EMPTY_STRING(&tmp);
+		delim = &tmp;
 
 		SEPARATE_ZVAL(arg1);
-		arr = *arg1;
+		arr = arg1;
 	} else {
-		if (Z_TYPE_PP(arg1) == IS_ARRAY) {
-			arr = *arg1;
+		if (Z_TYPE_P(arg1) == IS_ARRAY) {
+			arr = arg1;
 			convert_to_string_ex(arg2);
-			delim = *arg2;
-		} else if (Z_TYPE_PP(arg2) == IS_ARRAY) {
-			arr = *arg2;
+			delim = arg2;
+		} else if (Z_TYPE_P(arg2) == IS_ARRAY) {
+			arr = arg2;
 			convert_to_string_ex(arg1);
-			delim = *arg1;
+			delim = arg1;
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid arguments passed");
 			return;
@@ -1244,10 +1238,6 @@ PHP_FUNCTION(implode)
 	}
 
 	php_implode(delim, arr, return_value TSRMLS_CC);
-
-	if (arg2 == NULL) {
-		FREE_ZVAL(delim);
-	}
 }
 /* }}} */
 
@@ -1259,8 +1249,6 @@ PHP_FUNCTION(strtok)
 {
 	char *str, *tok = NULL;
 	int str_len, tok_len = 0;
-	zval *zv;
-
 	char *token;
 	char *token_end;
 	char *p;
@@ -1275,14 +1263,9 @@ PHP_FUNCTION(strtok)
 		tok = str;
 		tok_len = str_len;
 	} else {
-		if (BG(strtok_zval)) {
-			zval_ptr_dtor(&BG(strtok_zval));
-		}
-		MAKE_STD_ZVAL(zv);
-		ZVAL_STRINGL(zv, str, str_len, 1);
-
-		BG(strtok_zval) = zv;
-		BG(strtok_last) = BG(strtok_string) = Z_STRVAL_P(zv);
+		zval_ptr_dtor(&BG(strtok_zval));
+		ZVAL_STRINGL(&BG(strtok_zval), str, str_len);
+		BG(strtok_last) = BG(strtok_string) = Z_STRVAL(BG(strtok_zval));
 		BG(strtok_len) = str_len;
 	}
 
@@ -1320,7 +1303,7 @@ PHP_FUNCTION(strtok)
 
 	if (p - BG(strtok_last)) {
 return_token:
-		RETVAL_STRINGL(BG(strtok_last) + skipped, (p - BG(strtok_last)) - skipped, 1);
+		RETVAL_STRINGL(BG(strtok_last) + skipped, (p - BG(strtok_last)) - skipped);
 		BG(strtok_last) = p + 1;
 	} else {
 		RETVAL_FALSE;
@@ -1360,14 +1343,15 @@ PHP_FUNCTION(strtoupper)
 {
 	char *arg;
 	int arglen;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arg, &arglen) == FAILURE) {
 		return;
 	}
 
-	arg = estrndup(arg, arglen);
-	php_strtoupper(arg, arglen);
-	RETURN_STRINGL(arg, arglen, 0);
+	result = STR_INIT(arg, arglen, 0);
+	php_strtoupper(result->val, result->len);
+	RETURN_NEW_STR(result);
 }
 /* }}} */
 
@@ -1394,24 +1378,26 @@ PHP_FUNCTION(strtolower)
 {
 	char *str;
 	int arglen;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &arglen) == FAILURE) {
 		return;
 	}
 
-	str = estrndup(str, arglen);
-	php_strtolower(str, arglen);
-	RETURN_STRINGL(str, arglen, 0);
+	result = STR_INIT(str, arglen, 0);
+	php_strtolower(result->val, result->len);
+	RETURN_NEW_STR(result);
 }
 /* }}} */
 
 /* {{{ php_basename
  */
-PHPAPI void php_basename(const char *s, size_t len, char *suffix, size_t sufflen, char **p_ret, size_t *p_len TSRMLS_DC)
+PHPAPI zend_string *php_basename(const char *s, size_t len, char *suffix, size_t sufflen TSRMLS_DC)
 {
-	char *ret = NULL, *c, *comp, *cend;
+	char *c, *comp, *cend;
 	size_t inc_len, cnt;
 	int state;
+	zend_string *ret;
 
 	c = comp = cend = (char*)s;
 	cnt = len;
@@ -1479,15 +1465,8 @@ quit_loop:
 
 	len = cend - comp;
 
-	if (p_ret) {
-		ret = emalloc(len + 1);
-		memcpy(ret, comp, len);
-		ret[len] = '\0';
-		*p_ret = ret;
-	}
-	if (p_len) {
-		*p_len = len;
-	}
+	ret = STR_INIT(comp, len, 0);
+	return ret;
 }
 /* }}} */
 
@@ -1495,16 +1474,14 @@ quit_loop:
    Returns the filename component of the path */
 PHP_FUNCTION(basename)
 {
-	char *string, *suffix = NULL, *ret;
+	char *string, *suffix = NULL;
 	int   string_len, suffix_len = 0;
-	size_t ret_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|s", &string, &string_len, &suffix, &suffix_len) == FAILURE) {
 		return;
 	}
 
-	php_basename(string, string_len, suffix, suffix_len, &ret, &ret_len TSRMLS_CC);
-	RETURN_STRINGL(ret, (int)ret_len, 0);
+	RETURN_STR(php_basename(string, string_len, suffix, suffix_len TSRMLS_CC));
 }
 /* }}} */
 
@@ -1521,18 +1498,17 @@ PHPAPI size_t php_dirname(char *path, size_t len)
 PHP_FUNCTION(dirname)
 {
 	char *str;
-	char *ret;
+	zend_string *ret;
 	int str_len;
-	size_t ret_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
 		return;
 	}
 
-	ret = estrndup(str, str_len);
-	ret_len = php_dirname(ret, str_len);
+	ret = STR_INIT(str, str_len, 0);
+	ret->len = zend_dirname(ret->val, str_len);
 
-	RETURN_STRINGL(ret, ret_len, 0);
+	RETURN_NEW_STR(ret);
 }
 /* }}} */
 
@@ -1540,11 +1516,11 @@ PHP_FUNCTION(dirname)
    Returns information about a certain string */
 PHP_FUNCTION(pathinfo)
 {
-	zval *tmp;
-	char *path, *ret = NULL;
+	zval tmp;
+	char *path, *dirname;
 	int path_len, have_basename;
-	size_t ret_len;
 	long opt = PHP_PATHINFO_ALL;
+	zend_string *ret = NULL;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &path, &path_len, &opt) == FAILURE) {
 		return;
@@ -1552,22 +1528,20 @@ PHP_FUNCTION(pathinfo)
 
 	have_basename = ((opt & PHP_PATHINFO_BASENAME) == PHP_PATHINFO_BASENAME);
 
-	MAKE_STD_ZVAL(tmp);
-	array_init(tmp);
+	array_init(&tmp);
 
 	if ((opt & PHP_PATHINFO_DIRNAME) == PHP_PATHINFO_DIRNAME) {
-		ret = estrndup(path, path_len);
-		php_dirname(ret, path_len);
-		if (*ret) {
-			add_assoc_string(tmp, "dirname", ret, 1);
+		dirname = estrndup(path, path_len);
+		php_dirname(dirname, path_len);
+		if (*dirname) {
+			add_assoc_string(&tmp, "dirname", dirname);
 		}
-		efree(ret);
-		ret = NULL;
+		efree(dirname);
 	}
 
 	if (have_basename) {
-		php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC);
-		add_assoc_stringl(tmp, "basename", ret, ret_len, 0);
+		ret = php_basename(path, path_len, NULL, 0 TSRMLS_CC);
+		add_assoc_str(&tmp, "basename", STR_COPY(ret));
 	}
 
 	if ((opt & PHP_PATHINFO_EXTENSION) == PHP_PATHINFO_EXTENSION) {
@@ -1575,14 +1549,14 @@ PHP_FUNCTION(pathinfo)
 		int idx;
 
 		if (!have_basename) {
-			php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC);
+			ret = php_basename(path, path_len, NULL, 0 TSRMLS_CC);
 		}
 
-		p = zend_memrchr(ret, '.', ret_len);
+		p = zend_memrchr(ret->val, '.', ret->len);
 
 		if (p) {
-			idx = p - ret;
-			add_assoc_stringl(tmp, "extension", ret + idx + 1, ret_len - idx - 1, 1);
+			idx = p - ret->val;
+			add_assoc_stringl(&tmp, "extension", ret->val + idx + 1, ret->len - idx - 1);
 		}
 	}
 
@@ -1592,25 +1566,25 @@ PHP_FUNCTION(pathinfo)
 
 		/* Have we already looked up the basename? */
 		if (!have_basename && !ret) {
-			php_basename(path, path_len, NULL, 0, &ret, &ret_len TSRMLS_CC);
+			ret = php_basename(path, path_len, NULL, 0 TSRMLS_CC);
 		}
 
-		p = zend_memrchr(ret, '.', ret_len);
+		p = zend_memrchr(ret->val, '.', ret->len);
 
-		idx = p ? (p - ret) : ret_len;
-		add_assoc_stringl(tmp, "filename", ret, idx, 1);
+		idx = p ? (p - ret->val) : ret->len;
+		add_assoc_stringl(&tmp, "filename", ret->val, idx);
 	}
 
-	if (!have_basename && ret) {
-		efree(ret);
+	if (ret) {
+		STR_RELEASE(ret);
 	}
 
 	if (opt == PHP_PATHINFO_ALL) {
-		RETURN_ZVAL(tmp, 0, 1);
+		RETURN_ZVAL(&tmp, 0, 1);
 	} else {
-		zval **element;
-		if (zend_hash_get_current_data(Z_ARRVAL_P(tmp), (void **) &element) == SUCCESS) {
-			RETVAL_ZVAL(*element, 1, 0);
+		zval *element;
+		if ((element = zend_hash_get_current_data(Z_ARRVAL(tmp))) != NULL) {
+			RETVAL_ZVAL(element, 1, 0);
 		} else {
 			ZVAL_EMPTY_STRING(return_value);
 		}
@@ -1626,7 +1600,7 @@ PHPAPI char *php_stristr(char *s, char *t, size_t s_len, size_t t_len)
 {
 	php_strtolower(s, s_len);
 	php_strtolower(t, t_len);
-	return php_memnstr(s, t, t_len, s + s_len);
+	return (char*)php_memnstr(s, t, t_len, s + s_len);
 }
 /* }}} */
 
@@ -1744,9 +1718,9 @@ PHP_FUNCTION(stristr)
 	if (found) {
 		found_offset = found - haystack_dup;
 		if (part) {
-			RETVAL_STRINGL(haystack, found_offset, 1);
+			RETVAL_STRINGL(haystack, found_offset);
 		} else {
-			RETVAL_STRINGL(haystack + found_offset, haystack_len - found_offset, 1);
+			RETVAL_STRINGL(haystack + found_offset, haystack_len - found_offset);
 		}
 	} else {
 		RETVAL_FALSE;
@@ -1778,22 +1752,22 @@ PHP_FUNCTION(strstr)
 			RETURN_FALSE;
 		}
 
-		found = php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack + haystack_len);
+		found = (char*)php_memnstr(haystack, Z_STRVAL_P(needle), Z_STRLEN_P(needle), haystack + haystack_len);
 	} else {
 		if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) {
 			RETURN_FALSE;
 		}
 		needle_char[1] = 0;
 
-		found = php_memnstr(haystack, needle_char,	1, haystack + haystack_len);
+		found = (char*)php_memnstr(haystack, needle_char,	1, haystack + haystack_len);
 	}
 
 	if (found) {
 		found_offset = found - haystack;
 		if (part) {
-			RETURN_STRINGL(haystack, found_offset, 1);
+			RETURN_STRINGL(haystack, found_offset);
 		} else {
-			RETURN_STRINGL(found, haystack_len - found_offset, 1);
+			RETURN_STRINGL(found, haystack_len - found_offset);
 		}
 	}
 	RETURN_FALSE;
@@ -1830,7 +1804,7 @@ PHP_FUNCTION(strpos)
 			RETURN_FALSE;
 		}
 
-		found = php_memnstr(haystack + offset,
+		found = (char*)php_memnstr(haystack + offset,
 			                Z_STRVAL_P(needle),
 			                Z_STRLEN_P(needle),
 			                haystack + haystack_len);
@@ -1840,7 +1814,7 @@ PHP_FUNCTION(strpos)
 		}
 		needle_char[1] = 0;
 
-		found = php_memnstr(haystack + offset,
+		found = (char*)php_memnstr(haystack + offset,
 							needle_char,
 							1,
 		                    haystack + haystack_len);
@@ -1890,7 +1864,7 @@ PHP_FUNCTION(stripos)
 
 		needle_dup = estrndup(Z_STRVAL_P(needle), Z_STRLEN_P(needle));
 		php_strtolower(needle_dup, Z_STRLEN_P(needle));
-		found = php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack_len);
+		found = (char*)php_memnstr(haystack_dup + offset, needle_dup, Z_STRLEN_P(needle), haystack_dup + haystack_len);
 	} else {
 		if (php_needle_char(needle, needle_char TSRMLS_CC) != SUCCESS) {
 			efree(haystack_dup);
@@ -1898,7 +1872,7 @@ PHP_FUNCTION(stripos)
 		}
 		needle_char[0] = tolower(needle_char[0]);
 		needle_char[1] = '\0';
-		found = php_memnstr(haystack_dup + offset,
+		found = (char*)php_memnstr(haystack_dup + offset,
 							needle_char,
 							sizeof(needle_char) - 1,
 							haystack_dup + haystack_len);
@@ -2121,7 +2095,7 @@ PHP_FUNCTION(strrchr)
 
 	if (found) {
 		found_offset = found - haystack;
-		RETURN_STRINGL(found, haystack_len - found_offset, 1);
+		RETURN_STRINGL(found, haystack_len - found_offset);
 	} else {
 		RETURN_FALSE;
 	}
@@ -2130,33 +2104,33 @@ PHP_FUNCTION(strrchr)
 
 /* {{{ php_chunk_split
  */
-static char *php_chunk_split(char *src, int srclen, char *end, int endlen, int chunklen, int *destlen)
+static zend_string *php_chunk_split(char *src, int srclen, char *end, int endlen, int chunklen)
 {
-	char *dest;
 	char *p, *q;
 	int chunks; /* complete chunks! */
 	int restlen;
 	int out_len;
+	zend_string *dest;
 
 	chunks = srclen / chunklen;
 	restlen = srclen - chunks * chunklen; /* srclen % chunklen */
 
-	if(chunks > INT_MAX - 1) {
+	if (chunks > INT_MAX - 1) {
 		return NULL;
 	}
 	out_len = chunks + 1;
-	if(endlen !=0 && out_len > INT_MAX/endlen) {
+	if (endlen !=0 && out_len > INT_MAX/endlen) {
 		return NULL;
 	}
 	out_len *= endlen;
-	if(out_len > INT_MAX - srclen - 1) {
+	if (out_len > INT_MAX - srclen - 1) {
 		return NULL;
 	}
 	out_len += srclen + 1;
 
-	dest = safe_emalloc((int)out_len, sizeof(char), 0);
+	dest = STR_ALLOC(out_len * sizeof(char), 0);
 
-	for (p = src, q = dest; p < (src + srclen - chunklen + 1); ) {
+	for (p = src, q = dest->val; p < (src + srclen - chunklen + 1); ) {
 		memcpy(q, p, chunklen);
 		q += chunklen;
 		memcpy(q, end, endlen);
@@ -2172,11 +2146,9 @@ static char *php_chunk_split(char *src, int srclen, char *end, int endlen, int c
 	}
 
 	*q = '\0';
-	if (destlen) {
-		*destlen = q - dest;
-	}
+	dest->len = q - dest->val;
 
-	return(dest);
+	return dest;
 }
 /* }}} */
 
@@ -2185,12 +2157,11 @@ static char *php_chunk_split(char *src, int srclen, char *end, int endlen, int c
 PHP_FUNCTION(chunk_split)
 {
 	char *str;
-	char *result;
 	char *end    = "\r\n";
 	int endlen   = 2;
 	long chunklen = 76;
-	int result_len;
 	int str_len;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|ls", &str, &str_len, &chunklen, &end, &endlen) == FAILURE) {
 		return;
@@ -2203,22 +2174,21 @@ PHP_FUNCTION(chunk_split)
 
 	if (chunklen > str_len) {
 		/* to maintain BC, we must return original string + ending */
-		result_len = endlen + str_len;
-		result = emalloc(result_len + 1);
-		memcpy(result, str, str_len);
-		memcpy(result + str_len, end, endlen);
-		result[result_len] = '\0';
-		RETURN_STRINGL(result, result_len, 0);
+		result = STR_ALLOC(endlen + str_len, 0);
+		memcpy(result->val, str, str_len);
+		memcpy(result->val + str_len, end, endlen);
+		result->val[result->len] = '\0';
+		RETURN_NEW_STR(result);
 	}
 
 	if (!str_len) {
 		RETURN_EMPTY_STRING();
 	}
 
-	result = php_chunk_split(str, str_len, end, endlen, chunklen, &result_len);
+	result = php_chunk_split(str, str_len, end, endlen, chunklen);
 
 	if (result) {
-		RETURN_STRINGL(result, result_len, 0);
+		RETURN_STR(result);
 	} else {
 		RETURN_FALSE;
 	}
@@ -2286,7 +2256,7 @@ PHP_FUNCTION(substr)
 		l = str_len - f;
 	}
 
-	RETURN_STRINGL(str + f, l, 1);
+	RETURN_STRINGL(str + f, l);
 }
 /* }}} */
 
@@ -2294,176 +2264,172 @@ PHP_FUNCTION(substr)
    Replaces part of a string with another string */
 PHP_FUNCTION(substr_replace)
 {
-	zval **str;
-	zval **from;
-	zval **len = NULL;
-	zval **repl;
-	char *result;
-	int result_len;
+	zval *str;
+	zval *from;
+	zval *len = NULL;
+	zval *repl;
 	int l = 0;
 	int f;
 	int argc = ZEND_NUM_ARGS();
+	zend_string *result;
 
-	HashPosition pos_str, pos_from, pos_repl, pos_len;
-	zval **tmp_str = NULL, **tmp_from = NULL, **tmp_repl = NULL, **tmp_len= NULL;
+	HashPosition pos_from, pos_repl, pos_len;
+	zval *tmp_str = NULL, *tmp_from = NULL, *tmp_repl = NULL, *tmp_len= NULL;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|Z", &str, &repl, &from, &len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &str, &repl, &from, &len) == FAILURE) {
 		return;
 	}
 
-	if (Z_TYPE_PP(str) != IS_ARRAY) {
-		if (Z_ISREF_PP(str)) {
-			SEPARATE_ZVAL(str);
-		}
+	if (Z_TYPE_P(str) != IS_ARRAY) {
+		SEPARATE_ZVAL_IF_REF(str);
 		convert_to_string_ex(str);
 	}
-	if (Z_TYPE_PP(repl) != IS_ARRAY) {
-		if (Z_ISREF_PP(repl)) {
-			SEPARATE_ZVAL(repl);
-		}
+	if (Z_TYPE_P(repl) != IS_ARRAY) {
+		SEPARATE_ZVAL_IF_REF(repl);
 		convert_to_string_ex(repl);
 	}
-	if (Z_TYPE_PP(from) != IS_ARRAY) {
-		if (Z_ISREF_PP(from)) {
-			SEPARATE_ZVAL(from);
-		}
+	if (Z_TYPE_P(from) != IS_ARRAY) {
+		SEPARATE_ZVAL_IF_REF(from);
 		convert_to_long_ex(from);
 	}
 
 	if (argc > 3) {
 		SEPARATE_ZVAL(len);
-		if (Z_TYPE_PP(len) != IS_ARRAY) {
+		if (Z_TYPE_P(len) != IS_ARRAY) {
 			convert_to_long_ex(len);
-			l = Z_LVAL_PP(len);
+			l = Z_LVAL_P(len);
 		}
 	} else {
-		if (Z_TYPE_PP(str) != IS_ARRAY) {
-			l = Z_STRLEN_PP(str);
+		if (Z_TYPE_P(str) != IS_ARRAY) {
+			l = Z_STRLEN_P(str);
 		}
 	}
 
-	if (Z_TYPE_PP(str) == IS_STRING) {
+	if (Z_TYPE_P(str) == IS_STRING) {
 		if (
-			(argc == 3 && Z_TYPE_PP(from) == IS_ARRAY) ||
-			(argc == 4 && Z_TYPE_PP(from) != Z_TYPE_PP(len))
+			(argc == 3 && Z_TYPE_P(from) == IS_ARRAY) ||
+			(argc == 4 && Z_TYPE_P(from) != Z_TYPE_P(len))
 		) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should be of same type - numerical or array ");
-			RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+			RETURN_STR(STR_COPY(Z_STR_P(str)));
 		}
-		if (argc == 4 && Z_TYPE_PP(from) == IS_ARRAY) {
-			if (zend_hash_num_elements(Z_ARRVAL_PP(from)) != zend_hash_num_elements(Z_ARRVAL_PP(len))) {
+		if (argc == 4 && Z_TYPE_P(from) == IS_ARRAY) {
+			if (zend_hash_num_elements(Z_ARRVAL_P(from)) != zend_hash_num_elements(Z_ARRVAL_P(len))) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "'from' and 'len' should have the same number of elements");
-				RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+				RETURN_STR(STR_COPY(Z_STR_P(str)));
 			}
 		}
 	}
 
-	if (Z_TYPE_PP(str) != IS_ARRAY) {
-		if (Z_TYPE_PP(from) != IS_ARRAY) {
+	if (Z_TYPE_P(str) != IS_ARRAY) {
+		if (Z_TYPE_P(from) != IS_ARRAY) {
 			int repl_len = 0;
 
-			f = Z_LVAL_PP(from);
+			f = Z_LVAL_P(from);
 
 			/* if "from" position is negative, count start position from the end
 			 * of the string
 			 */
 			if (f < 0) {
-				f = Z_STRLEN_PP(str) + f;
+				f = Z_STRLEN_P(str) + f;
 				if (f < 0) {
 					f = 0;
 				}
-			} else if (f > Z_STRLEN_PP(str)) {
-				f = Z_STRLEN_PP(str);
+			} else if (f > Z_STRLEN_P(str)) {
+				f = Z_STRLEN_P(str);
 			}
 			/* if "length" position is negative, set it to the length
 			 * needed to stop that many chars from the end of the string
 			 */
 			if (l < 0) {
-				l = (Z_STRLEN_PP(str) - f) + l;
+				l = (Z_STRLEN_P(str) - f) + l;
 				if (l < 0) {
 					l = 0;
 				}
 			}
 
-			if (f > Z_STRLEN_PP(str) || (f < 0 && -f > Z_STRLEN_PP(str))) {
+			if (f > Z_STRLEN_P(str) || (f < 0 && -f > Z_STRLEN_P(str))) {
 				RETURN_FALSE;
-			} else if (l > Z_STRLEN_PP(str) || (l < 0 && -l > Z_STRLEN_PP(str))) {
-				l = Z_STRLEN_PP(str);
+			} else if (l > Z_STRLEN_P(str) || (l < 0 && -l > Z_STRLEN_P(str))) {
+				l = Z_STRLEN_P(str);
 			}
 
-			if ((f + l) > Z_STRLEN_PP(str)) {
-				l = Z_STRLEN_PP(str) - f;
+			if ((f + l) > Z_STRLEN_P(str)) {
+				l = Z_STRLEN_P(str) - f;
 			}
-			if (Z_TYPE_PP(repl) == IS_ARRAY) {
-				zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(repl), &pos_repl);
-				if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(repl), (void **) &tmp_repl, &pos_repl)) {
+			if (Z_TYPE_P(repl) == IS_ARRAY) {
+				zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl);
+				if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) {
 					convert_to_string_ex(tmp_repl);
-					repl_len = Z_STRLEN_PP(tmp_repl);
+					repl_len = Z_STRLEN_P(tmp_repl);
 				}
 			} else {
-				repl_len = Z_STRLEN_PP(repl);
+				repl_len = Z_STRLEN_P(repl);
 			}
-			result_len = Z_STRLEN_PP(str) - l + repl_len;
-			result = emalloc(result_len + 1);
 
-			memcpy(result, Z_STRVAL_PP(str), f);
+			result = STR_ALLOC(Z_STRLEN_P(str) - l + repl_len, 0);
+
+			memcpy(result->val, Z_STRVAL_P(str), f);
 			if (repl_len) {
-				memcpy((result + f), (Z_TYPE_PP(repl) == IS_ARRAY ? Z_STRVAL_PP(tmp_repl) : Z_STRVAL_PP(repl)), repl_len);
+				memcpy((result->val + f), (Z_TYPE_P(repl) == IS_ARRAY ? Z_STRVAL_P(tmp_repl) : Z_STRVAL_P(repl)), repl_len);
 			}
-			memcpy((result + f + repl_len), Z_STRVAL_PP(str) + f + l, Z_STRLEN_PP(str) - f - l);
-			result[result_len] = '\0';
-			RETURN_STRINGL(result, result_len, 0);
+			memcpy((result->val + f + repl_len), Z_STRVAL_P(str) + f + l, Z_STRLEN_P(str) - f - l);
+			result->val[result->len] = '\0';
+			RETURN_NEW_STR(result);
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Functionality of 'from' and 'len' as arrays is not implemented");
-			RETURN_STRINGL(Z_STRVAL_PP(str), Z_STRLEN_PP(str), 1);
+			RETURN_STR(STR_COPY(Z_STR_P(str)));
 		}
 	} else { /* str is array of strings */
-		char *str_index = NULL;
-		uint str_index_len;
+		zend_string *str_index = NULL;
 		ulong num_index;
+		int result_len;
 
 		array_init(return_value);
 
-		if (Z_TYPE_PP(from) == IS_ARRAY) {
-			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(from), &pos_from);
+		if (Z_TYPE_P(from) == IS_ARRAY) {
+			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(from), &pos_from);
 		}
 
-		if (argc > 3 && Z_TYPE_PP(len) == IS_ARRAY) {
-			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(len), &pos_len);
+		if (argc > 3 && Z_TYPE_P(len) == IS_ARRAY) {
+			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(len), &pos_len);
 		}
 
-		if (Z_TYPE_PP(repl) == IS_ARRAY) {
-			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(repl), &pos_repl);
+		if (Z_TYPE_P(repl) == IS_ARRAY) {
+			zend_hash_internal_pointer_reset_ex(Z_ARRVAL_P(repl), &pos_repl);
 		}
 
-		zend_hash_internal_pointer_reset_ex(Z_ARRVAL_PP(str), &pos_str);
-		while (zend_hash_get_current_data_ex(Z_ARRVAL_PP(str), (void **) &tmp_str, &pos_str) == SUCCESS) {
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(str), num_index, str_index, tmp_str) {
 			zval *orig_str;
 			zval dummy;
-			ulong refcount;
-			int was_ref;
 
-			if(Z_TYPE_PP(tmp_str) != IS_STRING) {
-				dummy = **tmp_str;
+			if (Z_ISREF_P(tmp_str)) {
+				/* see bug #55871 */
+				ZVAL_DUP(&dummy, Z_REFVAL_P(tmp_str));
+				convert_to_string(&dummy);
+				orig_str = &dummy;
+			} else if (Z_TYPE_P(tmp_str) != IS_STRING) {
+				ZVAL_DUP(&dummy, tmp_str);
+				convert_to_string(&dummy);
 				orig_str = &dummy;
-				zval_copy_ctor(orig_str);
-				convert_to_string(orig_str);
 			} else {
-				orig_str = *tmp_str;
+				orig_str = tmp_str;
 			}
-			was_ref = Z_ISREF_P(orig_str);
-			Z_UNSET_ISREF_P(orig_str);
-			refcount = Z_REFCOUNT_P(orig_str);
 
-			if (Z_TYPE_PP(from) == IS_ARRAY) {
-				if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(from), (void **) &tmp_from, &pos_from)) {
-					if(Z_TYPE_PP(tmp_from) != IS_LONG) {
-						zval dummy = **tmp_from;
-						zval_copy_ctor(&dummy);
+			/*
+			refcount = Z_REFCOUNT_P(orig_str);
+			*/
+
+			if (Z_TYPE_P(from) == IS_ARRAY) {
+				if (NULL != (tmp_from = zend_hash_get_current_data_ex(Z_ARRVAL_P(from), &pos_from))) {
+					if(Z_TYPE_P(tmp_from) != IS_LONG) {
+						zval dummy;
+						
+						ZVAL_DUP(&dummy, tmp_from);
 						convert_to_long(&dummy);
 						f = Z_LVAL(dummy);
 					} else {
-						f = Z_LVAL_PP(tmp_from);
+						f = Z_LVAL_P(tmp_from);
 					}
 
 					if (f < 0) {
@@ -2474,12 +2440,12 @@ PHP_FUNCTION(substr_replace)
 					} else if (f > Z_STRLEN_P(orig_str)) {
 						f = Z_STRLEN_P(orig_str);
 					}
-					zend_hash_move_forward_ex(Z_ARRVAL_PP(from), &pos_from);
+					zend_hash_move_forward_ex(Z_ARRVAL_P(from), &pos_from);
 				} else {
 					f = 0;
 				}
 			} else {
-				f = Z_LVAL_PP(from);
+				f = Z_LVAL_P(from);
 				if (f < 0) {
 					f = Z_STRLEN_P(orig_str) + f;
 					if (f < 0) {
@@ -2490,22 +2456,23 @@ PHP_FUNCTION(substr_replace)
 				}
 			}
 
-			if (argc > 3 && Z_TYPE_PP(len) == IS_ARRAY) {
-				if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(len), (void **) &tmp_len, &pos_len)) {
-					if(Z_TYPE_PP(tmp_len) != IS_LONG) {
-						zval dummy = **tmp_len;
-						zval_copy_ctor(&dummy);
+			if (argc > 3 && Z_TYPE_P(len) == IS_ARRAY) {
+				if (NULL != (tmp_len = zend_hash_get_current_data_ex(Z_ARRVAL_P(len), &pos_len))) {
+					if(Z_TYPE_P(tmp_len) != IS_LONG) {
+						zval dummy;
+						
+						ZVAL_DUP(&dummy, tmp_len);
 						convert_to_long(&dummy);
 						l = Z_LVAL(dummy);
 					} else {
-						l = Z_LVAL_PP(tmp_len);
+						l = Z_LVAL_P(tmp_len);
 					}
-					zend_hash_move_forward_ex(Z_ARRVAL_PP(len), &pos_len);
+					zend_hash_move_forward_ex(Z_ARRVAL_P(len), &pos_len);
 				} else {
 					l = Z_STRLEN_P(orig_str);
 				}
 			} else if (argc > 3) {
-				l = Z_LVAL_PP(len);
+				l = Z_LVAL_P(len);
 			} else {
 				l = Z_STRLEN_P(orig_str);
 			}
@@ -2523,68 +2490,72 @@ PHP_FUNCTION(substr_replace)
 
 			result_len = Z_STRLEN_P(orig_str) - l;
 
-			if (Z_TYPE_PP(repl) == IS_ARRAY) {
-				if (SUCCESS == zend_hash_get_current_data_ex(Z_ARRVAL_PP(repl), (void **) &tmp_repl, &pos_repl)) {
+			if (Z_TYPE_P(repl) == IS_ARRAY) {
+				if (NULL != (tmp_repl = zend_hash_get_current_data_ex(Z_ARRVAL_P(repl), &pos_repl))) {
 					zval *repl_str;
 					zval zrepl;
-					if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
-						zrepl = **tmp_repl;
+
+					ZVAL_DEREF(tmp_repl);
+					if (Z_TYPE_P(tmp_repl) != IS_STRING) {
+						ZVAL_DUP(&zrepl, tmp_repl);
+						convert_to_string(&zrepl);
 						repl_str = &zrepl;
-						zval_copy_ctor(repl_str);
-						convert_to_string(repl_str);
 					} else {
-						repl_str = *tmp_repl;
+						repl_str = tmp_repl;
 					}
-
-					if(Z_REFCOUNT_P(orig_str) != refcount) {
+					/*
+					if (Z_REFCOUNT_P(orig_str) != refcount) {
 						php_error_docref(NULL TSRMLS_CC, E_WARNING, "Argument was modified while replacing");
-						if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
+						if (Z_TYPE_P(tmp_repl) != IS_STRING) {
 							zval_dtor(repl_str);
 						}
 						break;
 					}
+					*/
 
 					result_len += Z_STRLEN_P(repl_str);
-					zend_hash_move_forward_ex(Z_ARRVAL_PP(repl), &pos_repl);
-					result = emalloc(result_len + 1);
+					zend_hash_move_forward_ex(Z_ARRVAL_P(repl), &pos_repl);
+					result = STR_ALLOC(result_len, 0);
 
-					memcpy(result, Z_STRVAL_P(orig_str), f);
-					memcpy((result + f), Z_STRVAL_P(repl_str), Z_STRLEN_P(repl_str));
-					memcpy((result + f + Z_STRLEN_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
-					if(Z_TYPE_PP(tmp_repl) != IS_STRING) {
+					memcpy(result->val, Z_STRVAL_P(orig_str), f);
+					memcpy((result->val + f), Z_STRVAL_P(repl_str), Z_STRLEN_P(repl_str));
+					memcpy((result->val + f + Z_STRLEN_P(repl_str)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
+					if(Z_TYPE_P(tmp_repl) != IS_STRING) {
 						zval_dtor(repl_str);
 					}
 				} else {
-					result = emalloc(result_len + 1);
+					result = STR_ALLOC(result_len, 0);
 
-					memcpy(result, Z_STRVAL_P(orig_str), f);
-					memcpy((result + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
+					memcpy(result->val, Z_STRVAL_P(orig_str), f);
+					memcpy((result->val + f), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
 				}
 			} else {
-				result_len += Z_STRLEN_PP(repl);
+				result_len += Z_STRLEN_P(repl);
 
-				result = emalloc(result_len + 1);
+				result = STR_ALLOC(result_len, 0);
 
-				memcpy(result, Z_STRVAL_P(orig_str), f);
-				memcpy((result + f), Z_STRVAL_PP(repl), Z_STRLEN_PP(repl));
-				memcpy((result + f + Z_STRLEN_PP(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
+				memcpy(result->val, Z_STRVAL_P(orig_str), f);
+				memcpy((result->val + f), Z_STRVAL_P(repl), Z_STRLEN_P(repl));
+				memcpy((result->val + f + Z_STRLEN_P(repl)), Z_STRVAL_P(orig_str) + f + l, Z_STRLEN_P(orig_str) - f - l);
 			}
 
-			result[result_len] = '\0';
+			result->val[result->len] = '\0';
+
+			if (str_index) {
+				zval tmp;
 
-			if (zend_hash_get_current_key_ex(Z_ARRVAL_PP(str), &str_index, &str_index_len, &num_index, 0, &pos_str) == HASH_KEY_IS_STRING) {
-				add_assoc_stringl_ex(return_value, str_index, str_index_len, result, result_len, 0);
+				ZVAL_STR(&tmp, result);
+				zend_symtable_update(Z_ARRVAL_P(return_value), str_index, &tmp);
 			} else {
-				add_index_stringl(return_value, num_index, result, result_len, 0);
+				add_index_str(return_value, num_index, result);
 			}
 
-			if(Z_TYPE_PP(tmp_str) != IS_STRING) {
+			if(Z_TYPE_P(tmp_str) != IS_STRING) {
 				zval_dtor(orig_str);
 			} else {
-				Z_SET_ISREF_TO_P(orig_str, was_ref);
+//???			Z_SET_ISREF_TO_P(orig_str, was_ref);
 			}
-			zend_hash_move_forward_ex(Z_ARRVAL_PP(str), &pos_str);
-		} /*while*/
+		} ZEND_HASH_FOREACH_END();
 	} /* if */
 }
 /* }}} */
@@ -2593,11 +2564,12 @@ PHP_FUNCTION(substr_replace)
    Quotes meta characters */
 PHP_FUNCTION(quotemeta)
 {
-	char *str, *old;
+	char *old;
 	char *old_end;
 	char *p, *q;
 	char c;
 	int  old_len;
+	zend_string *str;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &old, &old_len) == FAILURE) {
 		return;
@@ -2609,9 +2581,9 @@ PHP_FUNCTION(quotemeta)
 		RETURN_FALSE;
 	}
 
-	str = safe_emalloc(2, old_len, 1);
+	str = STR_ALLOC(2 * old_len, 0);
 
-	for (p = old, q = str; p != old_end; p++) {
+	for (p = old, q = str->val; p != old_end; p++) {
 		c = *p;
 		switch (c) {
 			case '.':
@@ -2631,9 +2603,10 @@ PHP_FUNCTION(quotemeta)
 				*q++ = c;
 		}
 	}
-	*q = 0;
 
-	RETURN_STRINGL(erealloc(str, q - str + 1), q - str, 0);
+	*q = '\0';
+
+	RETURN_NEW_STR(STR_REALLOC(str, q - str->val, 0));
 }
 /* }}} */
 
@@ -2670,7 +2643,7 @@ PHP_FUNCTION(chr)
 	temp[0] = (char)c;
 	temp[1] = '\0';
 
-	RETURN_STRINGL(temp, 1, 1);
+	RETURN_STRINGL(temp, 1);
 }
 /* }}} */
 
@@ -2699,7 +2672,7 @@ PHP_FUNCTION(ucfirst)
 		RETURN_EMPTY_STRING();
 	}
 
-	ZVAL_STRINGL(return_value, str, str_len, 1);
+	ZVAL_STRINGL(return_value, str, str_len);
 	php_ucfirst(Z_STRVAL_P(return_value));
 }
 /* }}} */
@@ -2729,7 +2702,7 @@ PHP_FUNCTION(lcfirst)
 		RETURN_EMPTY_STRING();
 	}
 
-	ZVAL_STRINGL(return_value, str, str_len, 1);
+	ZVAL_STRINGL(return_value, str, str_len);
 	php_lcfirst(Z_STRVAL_P(return_value));
 }
 /* }}} */
@@ -2750,7 +2723,7 @@ PHP_FUNCTION(ucwords)
 		RETURN_EMPTY_STRING();
 	}
 
-	ZVAL_STRINGL(return_value, str, str_len, 1);
+	ZVAL_STRINGL(return_value, str, str_len);
 	r = Z_STRVAL_P(return_value);
 
 	*r = toupper((unsigned char) *r);
@@ -2787,333 +2760,174 @@ PHPAPI char *php_strtr(char *str, int len, char *str_from, char *str_to, int trl
 }
 /* }}} */
 
-/* {{{ Definitions for php_strtr_array */
-typedef size_t STRLEN;	/* STRLEN should be unsigned */
-typedef uint16_t HASH;
-typedef struct {
-	HASH			table_mask;
-	STRLEN			entries[1];
-} SHIFT_TAB;
-typedef struct {
-	HASH			table_mask;
-	int				entries[1];
-} HASH_TAB;
-typedef struct {
-	const char	*s;
-	STRLEN		l;
-} STR;
-typedef struct _pat_and_repl {
-	STR			pat;
-	STR			repl;
-} PATNREPL;
-
-#define S(a) ((a)->s)
-#define L(a) ((a)->l)
-
-#define SHIFT_TAB_BITS	13
-#define HASH_TAB_BITS	10 /* should be less than sizeof(HASH) * 8 */
-#define SHIFT_TAB_SIZE	(1U << SHIFT_TAB_BITS)
-#define HASH_TAB_SIZE	(1U << HASH_TAB_BITS)
-
-typedef struct {
-	int				B;			/* size of suffixes */
-	int				Bp;			/* size of prefixes */
-	STRLEN			m;			/* minimum pattern length */
-	int				patnum;		/* number of patterns */
-	SHIFT_TAB		*shift;		/* table mapping hash to allowed shift */
-	HASH_TAB		*hash;		/* table mapping hash to int (pair of pointers) */
-	HASH			*prefix;	/* array of hashes of prefixes by pattern suffix hash order */
-	PATNREPL		*patterns;	/* array of prefixes by pattern suffix hash order */
-} PPRES;
-/* }}} */
-
-/* {{{ php_strtr_hash */
-static inline HASH php_strtr_hash(const char *str, int len)
+static int php_strtr_key_compare(const void *a, const void *b TSRMLS_DC) /* {{{ */
 {
-	HASH	res = 0;
-	int		i;
-	for (i = 0; i < len; i++) {
-		res = res * 33 + (unsigned char)str[i];
-	}
+	Bucket *f = (Bucket *) a;
+	Bucket *s = (Bucket *) b;
 
-	return res;
-}
-/* }}} */
-/* {{{ php_strtr_populate_shift */
-static inline void php_strtr_populate_shift(PATNREPL *patterns, int patnum, int B, STRLEN m, SHIFT_TAB *shift)
-{
-	int		i;
-	STRLEN	j,
-			max_shift;
-
-	max_shift = m - B + 1;
-	for (i = 0; i < SHIFT_TAB_SIZE; i++) {
-		shift->entries[i] = max_shift;
-	}
-	for (i = 0; i < patnum; i++) {
-		for (j = 0; j < m - B + 1; j++) {
-			HASH h = php_strtr_hash(&S(&patterns[i].pat)[j], B) & shift->table_mask;
-			assert((long long) m - (long long) j - B >= 0);
-			shift->entries[h] = MIN(shift->entries[h], m - j - B);
-		}
-	}
+	return f->h > s->h ? -1 : 1;
 }
 /* }}} */
-/* {{{ php_strtr_compare_hash_suffix */
-static int php_strtr_compare_hash_suffix(const void *a, const void *b TSRMLS_DC, void *ctx_g)
+
+/* {{{ php_strtr_array */
+static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *pats TSRMLS_DC)
 {
-	const PPRES		*res = ctx_g;
-	const PATNREPL	*pnr_a = a,
-					*pnr_b = b;
-	HASH			hash_a = php_strtr_hash(&S(&pnr_a->pat)[res->m - res->B], res->B)
-								& res->hash->table_mask,
-					hash_b = php_strtr_hash(&S(&pnr_b->pat)[res->m - res->B], res->B)
-								& res->hash->table_mask;
-	/* TODO: don't recalculate the hashes all the time */
-	if (hash_a > hash_b) {
-		return 1;
-	} else if (hash_a < hash_b) {
-		return -1;
-	} else {
-		/* longer patterns must be sorted first */
-		if (L(&pnr_a->pat) > L(&pnr_b->pat)) {
-			return -1;
-		} else if (L(&pnr_a->pat) < L(&pnr_b->pat)) {
-			return 1;
+	ulong num_key;
+	zend_string *str_key;
+	int len, pos, found;
+	int num_keys = 0;
+	int minlen = 128*1024;
+	int maxlen = 0;
+	HashTable str_hash, num_hash;
+	zval *entry, tmp, dummy;
+	char *key;
+	smart_str result = {0};
+
+	/* we will collect all possible key lenghts */
+	ZVAL_NULL(&dummy);
+	zend_hash_init(&num_hash, 8, NULL, NULL, 0);
+
+	/* check if original array has numeric keys */
+	ZEND_HASH_FOREACH_KEY(pats, num_key, str_key) {
+		if (UNEXPECTED(!str_key)) {
+			num_keys = 1;
 		} else {
-			return 0;
-		}
-	}
-}
-/* }}} */
-/* {{{ php_strtr_free_strp */
-static void php_strtr_free_strp(void *strp)
-{
-	STR_FREE(*(char**)strp);
-}
-/* }}} */
-/* {{{ php_strtr_array_prepare_repls */
-static PATNREPL *php_strtr_array_prepare_repls(int slen, HashTable *pats, zend_llist **allocs, int *outsize)
-{
-	PATNREPL		*patterns;
-	HashPosition	hpos;
-	zval			**entry;
-	int				num_pats = zend_hash_num_elements(pats),
-					i;
-
-	patterns = safe_emalloc(num_pats, sizeof(*patterns), 0);
-	*allocs = emalloc(sizeof **allocs);
-	zend_llist_init(*allocs, sizeof(void*), &php_strtr_free_strp, 0);
-
-	for (i = 0, zend_hash_internal_pointer_reset_ex(pats, &hpos);
-			zend_hash_get_current_data_ex(pats, (void **)&entry, &hpos) == SUCCESS;
-			zend_hash_move_forward_ex(pats, &hpos)) {
-		char	*string_key;
-		uint  	string_key_len;
-		ulong	num_key;
-		zval	*tzv = NULL;
-
-		switch (zend_hash_get_current_key_ex(pats, &string_key, &string_key_len, &num_key, 0, &hpos)) {
-		case HASH_KEY_IS_LONG:
-			string_key_len = 1 + zend_spprintf(&string_key, 0, "%ld", (long)num_key);
-			zend_llist_add_element(*allocs, &string_key);
-			/* break missing intentionally */
-
-		case HASH_KEY_IS_STRING:
-			string_key_len--; /* exclude final '\0' */
-			if (string_key_len == 0) { /* empty string given as pattern */
-				efree(patterns);
-				zend_llist_destroy(*allocs);
-				efree(*allocs);
-				*allocs = NULL;
-				return NULL;
-			}
-			if (string_key_len > slen) { /* this pattern can never match */
+			len = str_key->len;
+			if (UNEXPECTED(len < 1)) {
+				RETURN_FALSE;
+			} else if (UNEXPECTED(len > slen)) {
+				/* skip long patterns */
 				continue;
 			}
-
-			if (Z_TYPE_PP(entry) != IS_STRING) {
-				tzv = *entry;
-				zval_addref_p(tzv);
-				SEPARATE_ZVAL(&tzv);
-				convert_to_string(tzv);
-				entry = &tzv;
-				zend_llist_add_element(*allocs, &Z_STRVAL_PP(entry));
-			}
-
-			S(&patterns[i].pat) = string_key;
-			L(&patterns[i].pat) = string_key_len;
-			S(&patterns[i].repl) = Z_STRVAL_PP(entry);
-			L(&patterns[i].repl) = Z_STRLEN_PP(entry);
-			i++;
-
-			if (tzv) {
-				efree(tzv);
+			if (len > maxlen) {
+				maxlen = len;
 			}
-		}
-	}
-
-	*outsize = i;
-	return patterns;
-}
-/* }}} */
-
-/* {{{ PPRES *php_strtr_array_prepare(STR *text, PATNREPL *patterns, int patnum, int B, int Bp) */
-static PPRES *php_strtr_array_prepare(STR *text, PATNREPL *patterns, int patnum, int B, int Bp)
-{
-	int		i;
-	PPRES	*res = emalloc(sizeof *res);
-
-	res->m = (STRLEN)-1;
-	for (i = 0; i < patnum; i++) {
-		if (L(&patterns[i].pat) < res->m) {
-			res->m = L(&patterns[i].pat);
-		}
-	}
-	assert(res->m > 0);
-	res->B	= B		= MIN(B, res->m);
-	res->Bp	= Bp	= MIN(Bp, res->m);
-
-	res->shift = safe_emalloc(SHIFT_TAB_SIZE, sizeof(*res->shift->entries), sizeof(*res->shift));
-	res->shift->table_mask = SHIFT_TAB_SIZE - 1;
-	php_strtr_populate_shift(patterns, patnum, B, res->m, res->shift);
-
-	res->hash = safe_emalloc(HASH_TAB_SIZE, sizeof(*res->hash->entries), sizeof(*res->hash));
-	res->hash->table_mask = HASH_TAB_SIZE - 1;
-
-	res->patterns = safe_emalloc(patnum, sizeof(*res->patterns), 0);
-	memcpy(res->patterns, patterns, sizeof(*patterns) * patnum);
-#ifdef ZTS
-	zend_qsort_r(res->patterns, patnum, sizeof(*res->patterns),
-			php_strtr_compare_hash_suffix, res, NULL); /* tsrmls not needed */
-#else
-	zend_qsort_r(res->patterns, patnum, sizeof(*res->patterns),
-			php_strtr_compare_hash_suffix, res);
-#endif
-
-	res->prefix = safe_emalloc(patnum, sizeof(*res->prefix), 0);
-	for (i = 0; i < patnum; i++) {
-		res->prefix[i] = php_strtr_hash(S(&res->patterns[i].pat), Bp);
-	}
-
-	/* Initialize the rest of ->hash */
-	for (i = 0; i < HASH_TAB_SIZE; i++) {
-		res->hash->entries[i] = -1;
-	}
-	{
-		HASH last_h = -1; /* assumes not all bits are used in res->hash */
-		/* res->patterns is already ordered by hash.
-		 * Make res->hash->entries[h] de index of the first pattern in
-		 * res->patterns that has hash h */
-		for (i = 0; i < patnum; i++) {
-			HASH h = php_strtr_hash(&S(&res->patterns[i].pat)[res->m - res->B], res->B)
-						& res->hash->table_mask;
-			if (h != last_h) {
-				res->hash->entries[h] = i;
-				last_h = h;
+			if (len < minlen) {
+				minlen = len;
 			}
-		}
-	}
-	res->hash->entries[HASH_TAB_SIZE] = patnum; /* OK, we effectively allocated SIZE+1 */
-	for (i = HASH_TAB_SIZE - 1; i >= 0; i--) {
-		if (res->hash->entries[i] == -1) {
-			res->hash->entries[i] = res->hash->entries[i + 1];
-		}
-	}
-
-	res->patnum	= patnum;
-
-	return res;
-}
-/* }}} */
-/* {{{ php_strtr_array_destroy_ppres(PPRES *d) */
-static void php_strtr_array_destroy_ppres(PPRES *d)
-{
-	efree(d->shift);
-	efree(d->hash);
-	efree(d->prefix);
-	efree(d->patterns);
-	efree(d);
-}
-/* }}} */
-
-/* {{{ php_strtr_array_do_repl(STR *text, PPRES *d, zval *return_value) */
-static void php_strtr_array_do_repl(STR *text, PPRES *d, zval *return_value)
-{
-	STRLEN		pos = 0,
-				nextwpos = 0,
-				lastpos	= L(text) - d->m;
-	smart_str	result = {0};
-
-	while (pos <= lastpos) {
-		HASH	h		= php_strtr_hash(&S(text)[pos + d->m - d->B], d->B) & d->shift->table_mask;
-		STRLEN	shift	= d->shift->entries[h];
-
-		if (shift > 0) {
-			pos += shift;
-		} else {
-			HASH	h2				= h & d->hash->table_mask,
-					prefix_h		= php_strtr_hash(&S(text)[pos], d->Bp);
-
-			int		offset_start	= d->hash->entries[h2],
-					offset_end		= d->hash->entries[h2 + 1], /* exclusive */
-					i				= 0;
-
-			for (i = offset_start; i < offset_end; i++) {
-				PATNREPL *pnr;
-				if (d->prefix[i] != prefix_h)
+			/* remember possible key lenght */
+			zend_hash_index_add(&num_hash, len, &dummy);
+		}
+	} ZEND_HASH_FOREACH_END();
+
+	if (num_keys) {
+		/* we have to rebuild HashTable with numeric keys */
+		zend_hash_init(&str_hash, zend_hash_num_elements(pats), NULL, NULL, 0);
+		ZEND_HASH_FOREACH_KEY_VAL(pats, num_key, str_key, entry) {
+			if (UNEXPECTED(!str_key)) {
+				ZVAL_LONG(&tmp, num_key);
+				convert_to_string(&tmp);
+				str_key = Z_STR(tmp);
+				len = str_key->len;
+				if (UNEXPECTED(len > slen)) {
+					/* skip long patterns */
+					zval_dtor(&tmp);
 					continue;
-
-				pnr = &d->patterns[i];
-				if (L(&pnr->pat) > L(text) - pos ||
-						memcmp(S(&pnr->pat), &S(text)[pos], L(&pnr->pat)) != 0)
+				}
+				if (len > maxlen) {
+					maxlen = len;
+				}
+				if (len < minlen) {
+					minlen = len;
+				}
+				/* remember possible key lenght */
+				zend_hash_index_add(&num_hash, len, &dummy);
+			} else {
+				len = str_key->len;
+				if (UNEXPECTED(len > slen)) {
+					/* skip long patterns */
 					continue;
-
-				smart_str_appendl(&result, &S(text)[nextwpos], pos - nextwpos);
-				smart_str_appendl(&result, S(&pnr->repl), L(&pnr->repl));
-				pos += L(&pnr->pat);
-				nextwpos = pos;
-				goto end_outer_loop;
+				}
+			}
+			zend_hash_add(&str_hash, str_key, entry);
+			if (str_key == Z_STR(tmp)) {
+				zval_dtor(&tmp);
+			}
+		} ZEND_HASH_FOREACH_END();
+		pats = &str_hash;
+	}
+
+	if (UNEXPECTED(minlen > maxlen)) {
+		/* return the original string */
+		if (pats == &str_hash) {
+			zend_hash_destroy(&str_hash);
+		}
+		zend_hash_destroy(&num_hash);
+		RETURN_STRINGL(str, slen);
+	}
+	/* select smart or simple algorithm */
+	// TODO: tune the condition ???
+	len = zend_hash_num_elements(&num_hash);
+	if ((maxlen - (minlen - 1) - len > 0) &&
+		/* smart algorithm, sort key lengths first */
+		zend_hash_sort(&num_hash, zend_qsort, php_strtr_key_compare, 0 TSRMLS_CC) == SUCCESS) {
+
+		pos = 0;
+		while (pos <= slen - minlen) {
+			found = 0;
+			key = str + pos;
+			ZEND_HASH_FOREACH_NUM_KEY(&num_hash, len) {
+				if (len > slen - pos) continue;
+				entry = zend_hash_str_find(pats, key, len);
+				if (entry != NULL) {
+					if (UNEXPECTED(Z_TYPE_P(entry) != IS_STRING)) {
+						ZVAL_DUP(&tmp, entry);
+						convert_to_string(&tmp);
+						entry = &tmp;
+					}
+					smart_str_appendl(&result, Z_STRVAL_P(entry), Z_STRLEN_P(entry));
+					pos += len;
+					if (entry == &tmp) {
+						zval_dtor(&tmp);
+					}
+					found = 1;
+					break;
+				} 
+			} ZEND_HASH_FOREACH_END();
+			if (!found) {
+				smart_str_appendc(&result, str[pos++]);
 			}
-
-			pos++;
-end_outer_loop: ;
 		}
-	}
-
-	smart_str_appendl(&result, &S(text)[nextwpos], L(text) - nextwpos);
-
-	if (result.c != NULL) {
-		smart_str_0(&result);
-		RETVAL_STRINGL(result.c, result.len, 0);
+		smart_str_appendl(&result, str + pos, slen - pos);
 	} else {
-		RETURN_EMPTY_STRING();
+		/* use simple algorithm */
+		pos = 0;
+		while (pos <= slen - minlen) {
+			if (maxlen > slen - pos) {
+				maxlen = slen - pos;
+			}
+			found = 0;
+			key = str + pos;
+			for (len = maxlen; len >= minlen; len--) {
+				entry = zend_hash_str_find(pats, key, len);
+				if (entry != NULL) {
+					if (UNEXPECTED(Z_TYPE_P(entry) != IS_STRING)) {
+						ZVAL_DUP(&tmp, entry);
+						convert_to_string(&tmp);
+						entry = &tmp;
+					}
+					smart_str_appendl(&result, Z_STRVAL_P(entry), Z_STRLEN_P(entry));
+					pos += len;
+					if (entry == &tmp) {
+						zval_dtor(&tmp);
+					}
+					found = 1;
+					break;
+				} 
+			}
+			if (!found) {
+				smart_str_appendc(&result, str[pos++]);
+			}
+		}
+		smart_str_appendl(&result, str + pos, slen - pos);
 	}
-}
-/* }}} */
 
-/* {{{ php_strtr_array */
-static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *pats)
-{
-	PPRES		*data;
-	STR			text;
-	PATNREPL	*patterns;
-	int			patterns_len;
-	zend_llist	*allocs;
-
-	S(&text) = str;
-	L(&text) = slen;
-
-	patterns = php_strtr_array_prepare_repls(slen, pats, &allocs, &patterns_len);
-	if (patterns == NULL) {
-		RETURN_FALSE;
+	if (pats == &str_hash) {
+		zend_hash_destroy(&str_hash);
 	}
-	data = php_strtr_array_prepare(&text, patterns, patterns_len, 2, 2);
-	efree(patterns);
-	php_strtr_array_do_repl(&text, data, return_value);
-	php_strtr_array_destroy_ppres(data);
-	zend_llist_destroy(allocs);
-	efree(allocs);
+	zend_hash_destroy(&num_hash);
+	smart_str_0(&result);
+	RETURN_STR(result.s);
 }
 /* }}} */
 
@@ -3121,16 +2935,16 @@ static void php_strtr_array(zval *return_value, char *str, int slen, HashTable *
    Translates characters in str using given translation tables */
 PHP_FUNCTION(strtr)
 {
-	zval **from;
+	zval *from;
 	char *str, *to = NULL;
 	int str_len, to_len = 0;
 	int ac = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sZ|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz|s", &str, &str_len, &from, &to, &to_len) == FAILURE) {
 		return;
 	}
 
-	if (ac == 2 && Z_TYPE_PP(from) != IS_ARRAY) {
+	if (ac == 2 && Z_TYPE_P(from) != IS_ARRAY) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "The second argument is not an array");
 		RETURN_FALSE;
 	}
@@ -3141,17 +2955,17 @@ PHP_FUNCTION(strtr)
 	}
 
 	if (ac == 2) {
-		php_strtr_array(return_value, str, str_len, HASH_OF(*from));
+		php_strtr_array(return_value, str, str_len, HASH_OF(from) TSRMLS_CC);
 	} else {
 		convert_to_string_ex(from);
 
-		ZVAL_STRINGL(return_value, str, str_len, 1);
+		ZVAL_STRINGL(return_value, str, str_len);
 
 		php_strtr(Z_STRVAL_P(return_value),
 				  Z_STRLEN_P(return_value),
-				  Z_STRVAL_PP(from),
+				  Z_STRVAL_P(from),
 				  to,
-				  MIN(Z_STRLEN_PP(from),
+				  MIN(Z_STRLEN_P(from),
 				  to_len));
 	}
 }
@@ -3162,15 +2976,16 @@ PHP_FUNCTION(strtr)
 PHP_FUNCTION(strrev)
 {
 	char *str;
-	char *e, *n, *p;
+	char *e, *p;
 	int  str_len;
+	zend_string *n;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &str, &str_len) == FAILURE) {
 		return;
 	}
 
-	n = emalloc(str_len+1);
-	p = n;
+	n = STR_ALLOC(str_len, 0);
+	p = n->val;
 
 	e = str + str_len;
 
@@ -3180,7 +2995,7 @@ PHP_FUNCTION(strrev)
 
 	*p = '\0';
 
-	RETVAL_STRINGL(n, str_len, 0);
+	RETVAL_NEW_STR(n);
 }
 /* }}} */
 
@@ -3235,22 +3050,23 @@ static int php_similar_char(const char *txt1, int len1, const char *txt2, int le
 PHP_FUNCTION(similar_text)
 {
 	char *t1, *t2;
-	zval **percent = NULL;
+	zval *percent = NULL;
 	int ac = ZEND_NUM_ARGS();
 	int sim;
 	int t1_len, t2_len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|Z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|z", &t1, &t1_len, &t2, &t2_len, &percent) == FAILURE) {
 		return;
 	}
 
 	if (ac > 2) {
+		percent = Z_REFVAL_P(percent);
 		convert_to_double_ex(percent);
 	}
 
 	if (t1_len + t2_len == 0) {
 		if (ac > 2) {
-			Z_DVAL_PP(percent) = 0;
+			Z_DVAL_P(percent) = 0;
 		}
 
 		RETURN_LONG(0);
@@ -3259,7 +3075,7 @@ PHP_FUNCTION(similar_text)
 	sim = php_similar_char(t1, t1_len, t2, t2_len);
 
 	if (ac > 2) {
-		Z_DVAL_PP(percent) = sim * 200.0 / (t1_len + t2_len);
+		Z_DVAL_P(percent) = sim * 200.0 / (t1_len + t2_len);
 	}
 
 	RETURN_LONG(sim);
@@ -3325,11 +3141,10 @@ PHP_FUNCTION(addcslashes)
 	}
 
 	if (what_len == 0) {
-		RETURN_STRINGL(str, str_len, 1);
+		RETURN_STRINGL(str, str_len);
 	}
 
-	Z_STRVAL_P(return_value) = php_addcslashes(str, str_len, &Z_STRLEN_P(return_value), 0, what, what_len TSRMLS_CC);
-	RETURN_STRINGL(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), 0);
+	RETURN_STR(php_addcslashes(str, str_len, 0, what, what_len TSRMLS_CC));
 }
 /* }}} */
 
@@ -3348,10 +3163,7 @@ PHP_FUNCTION(addslashes)
 		RETURN_EMPTY_STRING();
 	}
 
-	RETURN_STRING(php_addslashes(str,
-	                             str_len,
-	                             &Z_STRLEN_P(return_value), 0
-	                             TSRMLS_CC), 0);
+	RETURN_STR(php_addslashes(str, str_len, 0 TSRMLS_CC));
 }
 /* }}} */
 
@@ -3366,7 +3178,7 @@ PHP_FUNCTION(stripcslashes)
 		return;
 	}
 
-	ZVAL_STRINGL(return_value, str, str_len, 1);
+	ZVAL_STRINGL(return_value, str, str_len);
 	php_stripcslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value));
 }
 /* }}} */
@@ -3382,7 +3194,7 @@ PHP_FUNCTION(stripslashes)
 		return;
 	}
 
-	ZVAL_STRINGL(return_value, str, str_len, 1);
+	ZVAL_STRINGL(return_value, str, str_len);
 	php_stripslashes(Z_STRVAL_P(return_value), &Z_STRLEN_P(return_value) TSRMLS_CC);
 }
 /* }}} */
@@ -3471,14 +3283,14 @@ PHPAPI void php_stripcslashes(char *str, int *len)
 
 /* {{{ php_addcslashes
  */
-PHPAPI char *php_addcslashes(const char *str, int length, int *new_length, int should_free, char *what, int wlength TSRMLS_DC)
+PHPAPI zend_string *php_addcslashes(const char *str, int length, int should_free, char *what, int wlength TSRMLS_DC)
 {
 	char flags[256];
-	char *new_str = safe_emalloc(4, (length?length:(length=strlen(str))), 1);
 	char *source, *target;
 	char *end;
 	char c;
 	int  newlen;
+	zend_string *new_str = STR_ALLOC(4 * (length? length : (length = strlen(str))), 0);
 
 	if (!wlength) {
 		wlength = strlen(what);
@@ -3486,7 +3298,7 @@ PHPAPI char *php_addcslashes(const char *str, int length, int *new_length, int s
 
 	php_charmask((unsigned char *)what, wlength, flags TSRMLS_CC);
 
-	for (source = (char*)str, end = source + length, target = new_str; source < end; source++) {
+	for (source = (char*)str, end = source + length, target = new_str->val; source < end; source++) {
 		c = *source;
 		if (flags[(unsigned char)c]) {
 			if ((unsigned char) c < 32 || (unsigned char) c > 126) {
@@ -3508,15 +3320,12 @@ PHPAPI char *php_addcslashes(const char *str, int length, int *new_length, int s
 		*target++ = c;
 	}
 	*target = 0;
-	newlen = target - new_str;
-	if (target - new_str < length * 4) {
-		new_str = erealloc(new_str, newlen + 1);
-	}
-	if (new_length) {
-		*new_length = newlen;
+	newlen = target - new_str->val;
+	if (newlen < length * 4) {
+		new_str = STR_REALLOC(new_str, newlen, 0);
 	}
 	if (should_free) {
-		STR_FREE((char*)str);
+//???		STR_FREE((char*)str);
 	}
 	return new_str;
 }
@@ -3524,25 +3333,21 @@ PHPAPI char *php_addcslashes(const char *str, int length, int *new_length, int s
 
 /* {{{ php_addslashes
  */
-PHPAPI char *php_addslashes(char *str, int length, int *new_length, int should_free TSRMLS_DC)
+PHPAPI zend_string *php_addslashes(char *str, int length, int should_free TSRMLS_DC)
 {
 	/* maximum string length, worst case situation */
-	char *new_str;
 	char *source, *target;
 	char *end;
-	int local_new_length;
+	zend_string *new_str;
 
-	if (!new_length) {
-		new_length = &local_new_length;
-	}
 	if (!str) {
-		*new_length = 0;
-		return str;
+		return STR_EMPTY_ALLOC();
 	}
-	new_str = (char *) safe_emalloc(2, (length ? length : (length = strlen(str))), 1);
+
+	new_str = STR_ALLOC(2 * (length ? length : (length = strlen(str))), 0);
 	source = str;
 	end = source + length;
-	target = new_str;
+	target = new_str->val;
 
 	while (source < end) {
 		switch (*source) {
@@ -3564,11 +3369,11 @@ PHPAPI char *php_addslashes(char *str, int length, int *new_length, int should_f
 	}
 
 	*target = 0;
-	*new_length = target - new_str;
 	if (should_free) {
-		STR_FREE(str);
+//???		STR_FREE(str);
 	}
-	new_str = (char *) erealloc(new_str, *new_length + 1);
+	new_str = STR_REALLOC(new_str, target - new_str->val, 0);
+
 	return new_str;
 }
 /* }}} */
@@ -3602,13 +3407,16 @@ PHPAPI int php_char_to_str_ex(char *str, uint len, char from, char *to, int to_l
 	}
 
 	if (char_count == 0 && case_sensitivity) {
-		ZVAL_STRINGL(result, str, len, 1);
+		ZVAL_STRINGL(result, str, len);
 		return 0;
 	}
 
-	Z_STRLEN_P(result) = len + (char_count * (to_len - 1));
-	Z_STRVAL_P(result) = target = safe_emalloc(char_count, to_len, len + 1);
-	Z_TYPE_P(result) = IS_STRING;
+	if (to_len > 0) {
+		ZVAL_NEW_STR(result, STR_SAFE_ALLOC(char_count, to_len - 1, len, 0));
+	} else {
+		ZVAL_NEW_STR(result, STR_ALLOC(len - char_count, 0));
+	}
+	target = Z_STRVAL_P(result);
 
 	if (case_sensitivity) {
 		char *p = str, *e = p + len, *s = str;
@@ -3659,22 +3467,21 @@ PHPAPI int php_char_to_str(char *str, uint len, char from, char *to, int to_len,
 
 /* {{{ php_str_to_str_ex
  */
-PHPAPI char *php_str_to_str_ex(char *haystack, int length,
-	char *needle, int needle_len, char *str, int str_len, int *_new_length, int case_sensitivity, int *replace_count)
+PHPAPI zend_string *php_str_to_str_ex(char *haystack, int length,
+	char *needle, int needle_len, char *str, int str_len, int case_sensitivity, int *replace_count)
 {
-	char *new_str;
+	zend_string *new_str;
 
 	if (needle_len < length) {
 		char *end, *haystack_dup = NULL, *needle_dup = NULL;
 		char *e, *s, *p, *r;
 
 		if (needle_len == str_len) {
-			new_str = estrndup(haystack, length);
-			*_new_length = length;
+			new_str = STR_INIT(haystack, length, 0);
 
 			if (case_sensitivity) {
-				end = new_str + length;
-				for (p = new_str; (r = php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
+				end = new_str->val + length;
+				for (p = new_str->val; (r = (char*)php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
 					memcpy(r, str, str_len);
 					if (replace_count) {
 						(*replace_count)++;
@@ -3686,8 +3493,8 @@ PHPAPI char *php_str_to_str_ex(char *haystack, int length,
 				php_strtolower(haystack_dup, length);
 				php_strtolower(needle_dup, needle_len);
 				end = haystack_dup + length;
-				for (p = haystack_dup; (r = php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
-					memcpy(new_str + (r - haystack_dup), str, str_len);
+				for (p = haystack_dup; (r = (char*)php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
+					memcpy(new_str->val + (r - haystack_dup), str, str_len);
 					if (replace_count) {
 						(*replace_count)++;
 					}
@@ -3705,7 +3512,7 @@ PHPAPI char *php_str_to_str_ex(char *haystack, int length,
 			}
 
 			if (str_len < needle_len) {
-				new_str = emalloc(length + 1);
+				new_str = STR_ALLOC(length, 0);
 			} else {
 				int count = 0;
 				char *o, *n, *endp;
@@ -3719,7 +3526,7 @@ PHPAPI char *php_str_to_str_ex(char *haystack, int length,
 				}
 				endp = o + length;
 
-				while ((o = php_memnstr(o, n, needle_len, endp))) {
+				while ((o = (char*)php_memnstr(o, n, needle_len, endp))) {
 					o += needle_len;
 					count++;
 				}
@@ -3731,21 +3538,18 @@ PHPAPI char *php_str_to_str_ex(char *haystack, int length,
 					if (needle_dup) {
 						efree(needle_dup);
 					}
-					new_str = estrndup(haystack, length);
-					if (_new_length) {
-						*_new_length = length;
-					}
+					new_str = STR_INIT(haystack, length, 0);
 					return new_str;
 				} else {
-					new_str = safe_emalloc(count, str_len - needle_len, length + 1);
+					new_str = STR_ALLOC(count * (str_len - needle_len) + length, 0);
 				}
 			}
 
-			e = s = new_str;
+			e = s = new_str->val;
 
 			if (case_sensitivity) {
 				end = haystack + length;
-				for (p = haystack; (r = php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
+				for (p = haystack; (r = (char*)php_memnstr(p, needle, needle_len, end)); p = r + needle_len) {
 					memcpy(e, p, r - p);
 					e += r - p;
 					memcpy(e, str, str_len);
@@ -3762,7 +3566,7 @@ PHPAPI char *php_str_to_str_ex(char *haystack, int length,
 			} else {
 				end = haystack_dup + length;
 
-				for (p = haystack_dup; (r = php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
+				for (p = haystack_dup; (r = (char*)php_memnstr(p, needle_dup, needle_len, end)); p = r + needle_len) {
 					memcpy(e, haystack + (p - haystack_dup), r - p);
 					e += r - p;
 					memcpy(e, str, str_len);
@@ -3786,15 +3590,13 @@ PHPAPI char *php_str_to_str_ex(char *haystack, int length,
 			}
 
 			*e = '\0';
-			*_new_length = e - s;
 
-			new_str = erealloc(new_str, *_new_length + 1);
+			new_str = STR_REALLOC(new_str, e - s, 0);
 			return new_str;
 		}
 	} else if (needle_len > length) {
 nothing_todo:
-		*_new_length = length;
-		new_str = estrndup(haystack, length);
+		new_str = STR_INIT(haystack, length, 0);
 		return new_str;
 	} else {
 		if (case_sensitivity && memcmp(haystack, needle, length)) {
@@ -3817,8 +3619,7 @@ nothing_todo:
 			efree(l_needle);
 		}
 
-		*_new_length = str_len;
-		new_str = estrndup(str, str_len);
+		new_str = STR_INIT(str, str_len, 0);
 
 		if (replace_count) {
 			(*replace_count)++;
@@ -3831,37 +3632,44 @@ nothing_todo:
 
 /* {{{ php_str_to_str
  */
-PHPAPI char *php_str_to_str(char *haystack, int length,
-	char *needle, int needle_len, char *str, int str_len, int *_new_length)
+PHPAPI zend_string *php_str_to_str(char *haystack, int length, char *needle, int needle_len, char *str, int str_len)
 {
-	return php_str_to_str_ex(haystack, length, needle, needle_len, str, str_len, _new_length, 1, NULL);
+	return php_str_to_str_ex(haystack, length, needle, needle_len, str, str_len, 1, NULL);
 }
 /* }}} */
 
 /* {{{ php_str_replace_in_subject
  */
-static void php_str_replace_in_subject(zval *search, zval *replace, zval **subject, zval *result, int case_sensitivity, int *replace_count)
+static void php_str_replace_in_subject(zval *search, zval *replace, zval *subject, zval *result, int case_sensitivity, int *replace_count TSRMLS_DC)
 {
-	zval		**search_entry,
-				**replace_entry = NULL,
-				  temp_result;
+	zval		*search_entry,
+				*replace_entry = NULL,
+				 temp_result,
+				 tmp_subject;
 	char		*replace_value = NULL;
 	int			 replace_len = 0;
 
 	/* Make sure we're dealing with strings. */
-	convert_to_string_ex(subject);
-	Z_TYPE_P(result) = IS_STRING;
-	if (Z_STRLEN_PP(subject) == 0) {
-		ZVAL_STRINGL(result, "", 0, 1);
+	if (Z_ISREF_P(subject)) {
+		subject = Z_REFVAL_P(subject);
+	}
+	ZVAL_UNDEF(&tmp_subject);
+	if (Z_TYPE_P(subject) != IS_STRING) {
+		ZVAL_DUP(&tmp_subject, subject);
+		convert_to_string_ex(&tmp_subject);
+		subject = &tmp_subject;
+	}
+	if (Z_STRLEN_P(subject) == 0) {
+		zval_ptr_dtor(&tmp_subject);
+		ZVAL_EMPTY_STRING(result);
 		return;
 	}
+//???	Z_TYPE_P(result) = IS_STRING;
 
 	/* If search is an array */
 	if (Z_TYPE_P(search) == IS_ARRAY) {
 		/* Duplicate subject string for repeated replacement */
-		MAKE_COPY_ZVAL(subject, result);
-
-		zend_hash_internal_pointer_reset(Z_ARRVAL_P(search));
+		ZVAL_DUP(result, subject);
 
 		if (Z_TYPE_P(replace) == IS_ARRAY) {
 			zend_hash_internal_pointer_reset(Z_ARRVAL_P(replace));
@@ -3872,12 +3680,11 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
 		}
 
 		/* For each entry in the search array, get the entry */
-		while (zend_hash_get_current_data(Z_ARRVAL_P(search), (void **) &search_entry) == SUCCESS) {
+		ZEND_HASH_FOREACH_VAL(Z_ARRVAL_P(search), search_entry) {
 			/* Make sure we're dealing with strings. */
 			SEPARATE_ZVAL(search_entry);
-			convert_to_string(*search_entry);
-			if (Z_STRLEN_PP(search_entry) == 0) {
-				zend_hash_move_forward(Z_ARRVAL_P(search));
+			convert_to_string(search_entry);
+			if (Z_STRLEN_P(search_entry) == 0) {
 				if (Z_TYPE_P(replace) == IS_ARRAY) {
 					zend_hash_move_forward(Z_ARRVAL_P(replace));
 				}
@@ -3887,13 +3694,13 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
 			/* If replace is an array. */
 			if (Z_TYPE_P(replace) == IS_ARRAY) {
 				/* Get current entry */
-				if (zend_hash_get_current_data(Z_ARRVAL_P(replace), (void **)&replace_entry) == SUCCESS) {
+				if ((replace_entry = zend_hash_get_current_data(Z_ARRVAL_P(replace))) != NULL) {
 					/* Make sure we're dealing with strings. */
 					convert_to_string_ex(replace_entry);
 
 					/* Set replacement value to the one we got from array */
-					replace_value = Z_STRVAL_PP(replace_entry);
-					replace_len = Z_STRLEN_PP(replace_entry);
+					replace_value = Z_STRVAL_P(replace_entry);
+					replace_len = Z_STRLEN_P(replace_entry);
 
 					zend_hash_move_forward(Z_ARRVAL_P(replace));
 				} else {
@@ -3903,35 +3710,34 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
 				}
 			}
 
-			if (Z_STRLEN_PP(search_entry) == 1) {
+			if (Z_STRLEN_P(search_entry) == 1) {
 				php_char_to_str_ex(Z_STRVAL_P(result),
 								Z_STRLEN_P(result),
-								Z_STRVAL_PP(search_entry)[0],
+								Z_STRVAL_P(search_entry)[0],
 								replace_value,
 								replace_len,
 								&temp_result,
 								case_sensitivity,
 								replace_count);
-			} else if (Z_STRLEN_PP(search_entry) > 1) {
-				Z_STRVAL(temp_result) = php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result),
-														   Z_STRVAL_PP(search_entry), Z_STRLEN_PP(search_entry),
-														   replace_value, replace_len, &Z_STRLEN(temp_result), case_sensitivity, replace_count);
+			} else if (Z_STRLEN_P(search_entry) > 1) {
+				ZVAL_STR(&temp_result, php_str_to_str_ex(Z_STRVAL_P(result), Z_STRLEN_P(result),
+							Z_STRVAL_P(search_entry), Z_STRLEN_P(search_entry),
+							replace_value, replace_len, case_sensitivity, replace_count));
 			}
 
-           str_efree(Z_STRVAL_P(result));
-			Z_STRVAL_P(result) = Z_STRVAL(temp_result);
-			Z_STRLEN_P(result) = Z_STRLEN(temp_result);
+			STR_FREE(Z_STR_P(result));
+			Z_STR_P(result) = Z_STR(temp_result);
+			Z_TYPE_INFO_P(result) = Z_TYPE_INFO(temp_result);
 
 			if (Z_STRLEN_P(result) == 0) {
+				zval_ptr_dtor(&tmp_subject);
 				return;
 			}
-
-			zend_hash_move_forward(Z_ARRVAL_P(search));
-		}
+		} ZEND_HASH_FOREACH_END();
 	} else {
 		if (Z_STRLEN_P(search) == 1) {
-			php_char_to_str_ex(Z_STRVAL_PP(subject),
-							Z_STRLEN_PP(subject),
+			php_char_to_str_ex(Z_STRVAL_P(subject),
+							Z_STRLEN_P(subject),
 							Z_STRVAL_P(search)[0],
 							Z_STRVAL_P(replace),
 							Z_STRLEN_P(replace),
@@ -3939,13 +3745,14 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
 							case_sensitivity,
 							replace_count);
 		} else if (Z_STRLEN_P(search) > 1) {
-			Z_STRVAL_P(result) = php_str_to_str_ex(Z_STRVAL_PP(subject), Z_STRLEN_PP(subject),
-													Z_STRVAL_P(search), Z_STRLEN_P(search),
-													Z_STRVAL_P(replace), Z_STRLEN_P(replace), &Z_STRLEN_P(result), case_sensitivity, replace_count);
+			ZVAL_STR(result, php_str_to_str_ex(Z_STRVAL_P(subject), Z_STRLEN_P(subject),
+						Z_STRVAL_P(search), Z_STRLEN_P(search),
+						Z_STRVAL_P(replace), Z_STRLEN_P(replace), case_sensitivity, replace_count));
 		} else {
-			MAKE_COPY_ZVAL(subject, result);
+			ZVAL_DUP(result, subject);
 		}
 	}
+	zval_ptr_dtor(&tmp_subject);
 }
 /* }}} */
 
@@ -3953,67 +3760,55 @@ static void php_str_replace_in_subject(zval *search, zval *replace, zval **subje
  */
 static void php_str_replace_common(INTERNAL_FUNCTION_PARAMETERS, int case_sensitivity)
 {
-	zval **subject, **search, **replace, **subject_entry, **zcount = NULL;
-	zval *result;
-	char *string_key;
-	uint string_key_len;
+	zval *subject, *search, *replace, *subject_entry, *zcount = NULL;
+	zval result;
+	zend_string *string_key;
 	ulong num_key;
 	int count = 0;
 	int argc = ZEND_NUM_ARGS();
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ZZZ|Z", &search, &replace, &subject, &zcount) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zzz|z", &search, &replace, &subject, &zcount) == FAILURE) {
 		return;
 	}
 
-	SEPARATE_ZVAL(search);
-	SEPARATE_ZVAL(replace);
-	SEPARATE_ZVAL(subject);
-
 	/* Make sure we're dealing with strings and do the replacement. */
-	if (Z_TYPE_PP(search) != IS_ARRAY) {
+	if (Z_TYPE_P(search) != IS_ARRAY) {
+		SEPARATE_ZVAL(search);
 		convert_to_string_ex(search);
-		convert_to_string_ex(replace);
-	} else if (Z_TYPE_PP(replace) != IS_ARRAY) {
+		if (Z_TYPE_P(replace) != IS_STRING) {
+			convert_to_string_ex(replace);
+			SEPARATE_ZVAL(replace);
+		}
+	} else if (Z_TYPE_P(replace) != IS_ARRAY) {
+		SEPARATE_ZVAL(replace);
 		convert_to_string_ex(replace);
 	}
 
 	/* if subject is an array */
-	if (Z_TYPE_PP(subject) == IS_ARRAY) {
+	if (Z_TYPE_P(subject) == IS_ARRAY) {
 		array_init(return_value);
-		zend_hash_internal_pointer_reset(Z_ARRVAL_PP(subject));
 
 		/* For each subject entry, convert it to string, then perform replacement
 		   and add the result to the return_value array. */
-		while (zend_hash_get_current_data(Z_ARRVAL_PP(subject), (void **)&subject_entry) == SUCCESS) {
-			if (Z_TYPE_PP(subject_entry) != IS_ARRAY && Z_TYPE_PP(subject_entry) != IS_OBJECT) {
-				MAKE_STD_ZVAL(result);
-				SEPARATE_ZVAL(subject_entry);
-				php_str_replace_in_subject(*search, *replace, subject_entry, result, case_sensitivity, (argc > 3) ? &count : NULL);
+		ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(subject), num_key, string_key, subject_entry) {
+			if (Z_TYPE_P(subject_entry) != IS_ARRAY && Z_TYPE_P(subject_entry) != IS_OBJECT) {
+				php_str_replace_in_subject(search, replace, subject_entry, &result, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC);
 			} else {
-				ALLOC_ZVAL(result);
-				Z_ADDREF_P(*subject_entry);
-				COPY_PZVAL_TO_ZVAL(*result, *subject_entry);
+				ZVAL_COPY(&result, subject_entry);
 			}
 			/* Add to return array */
-			switch (zend_hash_get_current_key_ex(Z_ARRVAL_PP(subject), &string_key,
-												&string_key_len, &num_key, 0, NULL)) {
-				case HASH_KEY_IS_STRING:
-					add_assoc_zval_ex(return_value, string_key, string_key_len, result);
-					break;
-
-				case HASH_KEY_IS_LONG:
-					add_index_zval(return_value, num_key, result);
-					break;
+			if (string_key) {
+				zend_hash_update(Z_ARRVAL_P(return_value), string_key, &result);
+			} else {
+				add_index_zval(return_value, num_key, &result);
 			}
-
-			zend_hash_move_forward(Z_ARRVAL_PP(subject));
-		}
+		} ZEND_HASH_FOREACH_END();
 	} else {	/* if subject is not an array */
-		php_str_replace_in_subject(*search, *replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL);
+		php_str_replace_in_subject(search, replace, subject, return_value, case_sensitivity, (argc > 3) ? &count : NULL TSRMLS_CC);
 	}
 	if (argc > 3) {
-		zval_dtor(*zcount);
-		ZVAL_LONG(*zcount, count);
+		zval_dtor(Z_REFVAL_P(zcount));
+		ZVAL_LONG(Z_REFVAL_P(zcount), count);
 	}
 }
 /* }}} */
@@ -4042,11 +3837,12 @@ PHP_FUNCTION(str_ireplace)
 static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines)
 {
 	char *str;
-	char *heb_str, *tmp, *target, *broken_str;
+	char *heb_str, *tmp, *target;
 	int block_start, block_end, block_type, block_length, i;
 	long max_chars=0;
 	int begin, end, char_count, orig_begin;
 	int str_len;
+	zend_string *broken_str;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|l", &str, &str_len, &max_chars) == FAILURE) {
 		return;
@@ -4138,9 +3934,9 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines)
 	} while (block_end < str_len-1);
 
 
-	broken_str = (char *) emalloc(str_len+1);
-	begin=end=str_len-1;
-	target = broken_str;
+	broken_str = STR_ALLOC(str_len, 0);
+	begin = end = str_len-1;
+	target = broken_str->val;
 
 	while (1) {
 		char_count=0;
@@ -4197,12 +3993,10 @@ static void php_hebrev(INTERNAL_FUNCTION_PARAMETERS, int convert_newlines)
 	efree(heb_str);
 
 	if (convert_newlines) {
-		php_char_to_str(broken_str, str_len,'\n', "<br />\n", 7, return_value);
-		efree(broken_str);
+		php_char_to_str(broken_str->val, broken_str->len,'\n', "<br />\n", 7, return_value);
+		STR_FREE(broken_str);
 	} else {
-		Z_STRVAL_P(return_value) = broken_str;
-		Z_STRLEN_P(return_value) = str_len;
-		Z_TYPE_P(return_value) = IS_STRING;
+		RETURN_NEW_STR(broken_str);
 	}
 }
 /* }}} */
@@ -4228,12 +4022,12 @@ PHP_FUNCTION(hebrevc)
 PHP_FUNCTION(nl2br)
 {
 	/* in brief this inserts <br /> or <br> before matched regexp \n\r?|\r\n? */
-	char		*tmp, *str;
-	int		new_length;
-	char		*end, *target;
+	char	*tmp, *str;
+	char	*end, *target;
 	int		repl_cnt = 0;
 	int		str_len;
 	zend_bool	is_xhtml = 1;
+	zend_string *result;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|b", &str, &str_len, &is_xhtml) == FAILURE) {
 		return;
@@ -4261,14 +4055,14 @@ PHP_FUNCTION(nl2br)
 	}
 
 	if (repl_cnt == 0) {
-		RETURN_STRINGL(str, str_len, 1);
+		RETURN_STRINGL(str, str_len);
 	}
 
 	{
 		size_t repl_len = is_xhtml ? (sizeof("<br />") - 1) : (sizeof("<br>") - 1);
 
-		new_length = str_len + repl_cnt * repl_len;
-		tmp = target = safe_emalloc(repl_cnt, repl_len, str_len + 1);
+		result = STR_ALLOC(repl_cnt * repl_len + str_len, 0);
+		target = result->val;
 	}
 
 	while (str < end) {
@@ -4299,7 +4093,7 @@ PHP_FUNCTION(nl2br)
 
 	*target = '\0';
 
-	RETURN_STRINGL(tmp, new_length, 0);
+	RETURN_NEW_STR(result);
 }
 /* }}} */
 
@@ -4307,28 +4101,38 @@ PHP_FUNCTION(nl2br)
    Strips HTML and PHP tags from a string */
 PHP_FUNCTION(strip_tags)
 {
-	char *buf;
+	zend_string *buf;
 	char *str;
-	zval **allow=NULL;
+	zval *allow=NULL;
 	char *allowed_tags=NULL;
 	int allowed_tags_len=0;
 	int str_len;
-	size_t retval_len;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|Z", &str, &str_len, &allow) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s|z", &str, &str_len, &allow) == FAILURE) {
 		return;
 	}
 
 	/* To maintain a certain BC, we allow anything for the second parameter and return original string */
 	if (allow != NULL) {
 		convert_to_string_ex(allow);
-		allowed_tags = Z_STRVAL_PP(allow);
-		allowed_tags_len = Z_STRLEN_PP(allow);
+// TODO: reimplement to avoid reallocation ???
+		if (IS_INTERNED(Z_STR_P(allow))) {
+			allowed_tags = estrndup(Z_STRVAL_P(allow), Z_STRLEN_P(allow));
+			allowed_tags_len = Z_STRLEN_P(allow);
+		} else {
+			allowed_tags = Z_STRVAL_P(allow);
+			allowed_tags_len = Z_STRLEN_P(allow);
+		}
 	}
 
-	buf = estrndup(str, str_len);
-	retval_len = php_strip_tags_ex(buf, str_len, NULL, allowed_tags, allowed_tags_len, 0);
-	RETURN_STRINGL(buf, retval_len, 0);
+	buf = STR_INIT(str, str_len, 0);
+	buf->len = php_strip_tags_ex(buf->val, str_len, NULL, allowed_tags, allowed_tags_len, 0);
+
+// TODO: reimplement to avoid reallocation ???
+	if (allow && IS_INTERNED(Z_STR_P(allow))) {
+		efree(allowed_tags);
+	}
+	RETURN_STR(buf);
 }
 /* }}} */
 
@@ -4336,27 +4140,28 @@ PHP_FUNCTION(strip_tags)
    Set locale information */
 PHP_FUNCTION(setlocale)
 {
-	zval ***args = NULL;
-	zval **pcategory, **plocale;
+	zval *args = NULL;
+	zval *pcategory, *plocale;
 	int num_args, cat, i = 0;
 	char *loc, *retval;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z+", &pcategory, &args, &num_args) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z+", &pcategory, &args, &num_args) == FAILURE) {
 		return;
 	}
 
 #ifdef HAVE_SETLOCALE
-	if (Z_TYPE_PP(pcategory) == IS_LONG) {
-		convert_to_long_ex(pcategory);
-		cat = Z_LVAL_PP(pcategory);
+	if (Z_TYPE_P(pcategory) == IS_LONG) {
+		cat = Z_LVAL_P(pcategory);
 	} else {
 		/* FIXME: The following behaviour should be removed. */
 		char *category;
+		zval tmp;
 
 		php_error_docref(NULL TSRMLS_CC, E_DEPRECATED, "Passing locale category name as string is deprecated. Use the LC_* -constants instead");
 
-		convert_to_string_ex(pcategory);
-		category = Z_STRVAL_PP(pcategory);
+		ZVAL_DUP(&tmp, pcategory);
+		convert_to_string_ex(&tmp);
+		category = Z_STRVAL(tmp);
 
 		if (!strcasecmp("LC_ALL", category)) {
 			cat = LC_ALL;
@@ -4377,35 +4182,39 @@ PHP_FUNCTION(setlocale)
 		} else {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid locale category name %s, must be one of LC_ALL, LC_COLLATE, LC_CTYPE, LC_MONETARY, LC_NUMERIC, or LC_TIME", category);
 
-			if (args) {
-				efree(args);
-			}
+			zval_dtor(&tmp);
 			RETURN_FALSE;
 		}
+		zval_dtor(&tmp);
 	}
 
-	if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
-		zend_hash_internal_pointer_reset(Z_ARRVAL_PP(args[0]));
+	if (Z_TYPE(args[0]) == IS_ARRAY) {
+		zend_hash_internal_pointer_reset(Z_ARRVAL(args[0]));
 	}
 
 	while (1) {
-		if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
-			if (!zend_hash_num_elements(Z_ARRVAL_PP(args[0]))) {
+		zval tmp;
+		if (Z_TYPE(args[0]) == IS_ARRAY) {
+			if (!zend_hash_num_elements(Z_ARRVAL(args[0]))) {
+				break;
+			}
+			if ((plocale = zend_hash_get_current_data(Z_ARRVAL(args[0]))) == NULL) {
 				break;
 			}
-			zend_hash_get_current_data(Z_ARRVAL_PP(args[0]), (void **)&plocale);
 		} else {
-			plocale = args[i];
+			plocale = &args[i];
 		}
 
-		convert_to_string_ex(plocale);
+		ZVAL_DUP(&tmp, plocale);
+		convert_to_string(&tmp);
 
-		if (!strcmp ("0", Z_STRVAL_PP(plocale))) {
+		if (!strcmp ("0", Z_STRVAL(tmp))) {
 			loc = NULL;
 		} else {
-			loc = Z_STRVAL_PP(plocale);
-			if (Z_STRLEN_PP(plocale) >= 255) {
+			loc = Z_STRVAL(tmp);
+			if (Z_STRLEN(tmp) >= 255) {
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Specified locale name is too long");
+				zval_dtor(&tmp);
 				break;
 			}
 		}
@@ -4415,27 +4224,26 @@ PHP_FUNCTION(setlocale)
 		if (retval) {
 			/* Remember if locale was changed */
 			if (loc) {
-				STR_FREE(BG(locale_string));
+//???			STR_FREE(BG(locale_string));
+				if (BG(locale_string)) {
+					efree(BG(locale_string));
+				}
 				BG(locale_string) = estrdup(retval);
 			}
 
-			if (args) {
-				efree(args);
-			}
-			RETURN_STRING(retval, 1);
+			zval_dtor(&tmp);
+			RETURN_STRING(retval);
 		}
+		zval_dtor(&tmp);
 
-		if (Z_TYPE_PP(args[0]) == IS_ARRAY) {
-			if (zend_hash_move_forward(Z_ARRVAL_PP(args[0])) == FAILURE) break;
+		if (Z_TYPE(args[0]) == IS_ARRAY) {
+			if (zend_hash_move_forward(Z_ARRVAL(args[0])) == FAILURE) break;
 		} else {
 			if (++i >= num_args) break;
 		}
 	}
 
 #endif
-	if (args) {
-		efree(args);
-	}
 	RETURN_FALSE;
 }
 /* }}} */
@@ -4461,7 +4269,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;
@@ -4469,6 +4277,7 @@ 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. */
+		ZVAL_DEREF(arrayArg);
 		zval_dtor(arrayArg);
 		ZVAL_COPY_VALUE(arrayArg, &ret);
 	}
@@ -4584,12 +4393,12 @@ PHPAPI size_t php_strip_tags_ex(char *rbuf, int len, int *stateptr, char *allow,
 	rp = rbuf;
 	br = 0;
 	if (allow) {
-		if (IS_INTERNED(allow)) {
-			allow_free = allow = zend_str_tolower_dup(allow, allow_len);
-		} else {
+//???		if (IS_INTERNED(allow)) {
+//???			allow_free = allow = zend_str_tolower_dup(allow, allow_len);
+//???		} else {
 			allow_free = NULL;
 			php_strtolower(allow, allow_len);
-		}
+//???		}
 		tbuf = emalloc(PHP_TAG_BUF_SIZE + 1);
 		tp = tbuf;
 	} else {
@@ -4869,7 +4678,7 @@ PHP_FUNCTION(str_repeat)
 	char		*input_str;		/* Input string */
 	int 		input_len;
 	long 		mult;			/* Multiplier */
-	char		*result;		/* Resulting string */
+	zend_string	*result;		/* Resulting string */
 	size_t		result_len;		/* Length of the resulting string */
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl", &input_str, &input_len, &mult) == FAILURE) {
@@ -4887,19 +4696,19 @@ PHP_FUNCTION(str_repeat)
 		RETURN_EMPTY_STRING();
 
 	/* Initialize the result string */
+	result = STR_SAFE_ALLOC(input_len, mult, 0, 0);
 	result_len = input_len * mult;
-	result = (char *)safe_emalloc(input_len, mult, 1);
 
 	/* Heavy optimization for situations where input string is 1 byte long */
 	if (input_len == 1) {
-		memset(result, *(input_str), mult);
+		memset(result->val, *(input_str), mult);
 	} else {
 		char *s, *e, *ee;
 		int l=0;
-		memcpy(result, input_str, input_len);
-		s = result;
-		e = result + input_len;
-		ee = result + result_len;
+		memcpy(result->val, input_str, input_len);
+		s = result->val;
+		e = result->val + input_len;
+		ee = result->val + result_len;
 
 		while (e<ee) {
 			l = (e-s) < (ee-e) ? (e-s) : (ee-e);
@@ -4908,9 +4717,9 @@ PHP_FUNCTION(str_repeat)
 		}
 	}
 
-	result[result_len] = '\0';
+	result->val[result_len] = '\0';
 
-	RETURN_STRINGL(result, result_len, 0);
+	RETURN_NEW_STR(result);
 }
 /* }}} */
 
@@ -4977,7 +4786,7 @@ PHP_FUNCTION(count_chars)
 	}
 
 	if (mymode >= 3 && mymode <= 4) {
-		RETURN_STRINGL(retstr, retlen, 1);
+		RETURN_STRINGL(retstr, retlen);
 	}
 }
 /* }}} */
@@ -5001,31 +4810,13 @@ static void php_strnatcmp(INTERNAL_FUNCTION_PARAMETERS, int fold_case)
 
 PHPAPI int string_natural_compare_function_ex(zval *result, zval *op1, zval *op2, zend_bool case_insensitive TSRMLS_DC) /* {{{ */
 {
-	zval op1_copy, op2_copy;
-	int use_copy1 = 0, use_copy2 = 0;
-
-	if (Z_TYPE_P(op1) != IS_STRING) {
-		zend_make_printable_zval(op1, &op1_copy, &use_copy1);
-	}
-	if (Z_TYPE_P(op2) != IS_STRING) {
-		zend_make_printable_zval(op2, &op2_copy, &use_copy2);
-	}
-
-	if (use_copy1) {
-		op1 = &op1_copy;
-	}
-	if (use_copy2) {
-		op2 = &op2_copy;
-	}
+	zend_string *str1 = zval_get_string(op1);
+	zend_string *str2 = zval_get_string(op2);
 
-	ZVAL_LONG(result, strnatcmp_ex(Z_STRVAL_P(op1), Z_STRLEN_P(op1), Z_STRVAL_P(op2), Z_STRLEN_P(op2), case_insensitive));
+	ZVAL_LONG(result, strnatcmp_ex(str1->val, str1->len, str2->val, str2->len, case_insensitive));
 
-	if (use_copy1) {
-		zval_dtor(op1);
-	}
-	if (use_copy2) {
-		zval_dtor(op2);
-	}
+	STR_RELEASE(str1);
+	STR_RELEASE(str2);
 	return SUCCESS;
 }
 /* }}} */
@@ -5054,7 +4845,7 @@ PHP_FUNCTION(strnatcmp)
    Returns numeric formatting information based on the current locale */
 PHP_FUNCTION(localeconv)
 {
-	zval *grouping, *mon_grouping;
+	zval grouping, mon_grouping;
 	int len, i;
 
 	/* We don't need no stinkin' parameters... */
@@ -5062,12 +4853,9 @@ PHP_FUNCTION(localeconv)
 		return;
 	}
 
-	MAKE_STD_ZVAL(grouping);
-	MAKE_STD_ZVAL(mon_grouping);
-
 	array_init(return_value);
-	array_init(grouping);
-	array_init(mon_grouping);
+	array_init(&grouping);
+	array_init(&mon_grouping);
 
 #ifdef HAVE_LOCALECONV
 	{
@@ -5079,60 +4867,60 @@ PHP_FUNCTION(localeconv)
 		len = strlen(currlocdata.grouping);
 
 		for (i = 0; i < len; i++) {
-			add_index_long(grouping, i, currlocdata.grouping[i]);
+			add_index_long(&grouping, i, currlocdata.grouping[i]);
 		}
 
 		/* Grab the monetary grouping data out of the array */
 		len = strlen(currlocdata.mon_grouping);
 
 		for (i = 0; i < len; i++) {
-			add_index_long(mon_grouping, i, currlocdata.mon_grouping[i]);
-		}
-
-		add_assoc_string(return_value, "decimal_point",     currlocdata.decimal_point,     1);
-		add_assoc_string(return_value, "thousands_sep",     currlocdata.thousands_sep,     1);
-		add_assoc_string(return_value, "int_curr_symbol",   currlocdata.int_curr_symbol,   1);
-		add_assoc_string(return_value, "currency_symbol",   currlocdata.currency_symbol,   1);
-		add_assoc_string(return_value, "mon_decimal_point", currlocdata.mon_decimal_point, 1);
-		add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep, 1);
-		add_assoc_string(return_value, "positive_sign",     currlocdata.positive_sign,     1);
-		add_assoc_string(return_value, "negative_sign",     currlocdata.negative_sign,     1);
-		add_assoc_long(  return_value, "int_frac_digits",   currlocdata.int_frac_digits     );
-		add_assoc_long(  return_value, "frac_digits",       currlocdata.frac_digits         );
-		add_assoc_long(  return_value, "p_cs_precedes",     currlocdata.p_cs_precedes       );
-		add_assoc_long(  return_value, "p_sep_by_space",    currlocdata.p_sep_by_space      );
-		add_assoc_long(  return_value, "n_cs_precedes",     currlocdata.n_cs_precedes       );
-		add_assoc_long(  return_value, "n_sep_by_space",    currlocdata.n_sep_by_space      );
-		add_assoc_long(  return_value, "p_sign_posn",       currlocdata.p_sign_posn         );
-		add_assoc_long(  return_value, "n_sign_posn",       currlocdata.n_sign_posn         );
+			add_index_long(&mon_grouping, i, currlocdata.mon_grouping[i]);
+		}
+
+		add_assoc_string(return_value, "decimal_point",     currlocdata.decimal_point);
+		add_assoc_string(return_value, "thousands_sep",     currlocdata.thousands_sep);
+		add_assoc_string(return_value, "int_curr_symbol",   currlocdata.int_curr_symbol);
+		add_assoc_string(return_value, "currency_symbol",   currlocdata.currency_symbol);
+		add_assoc_string(return_value, "mon_decimal_point", currlocdata.mon_decimal_point);
+		add_assoc_string(return_value, "mon_thousands_sep", currlocdata.mon_thousands_sep);
+		add_assoc_string(return_value, "positive_sign",     currlocdata.positive_sign);
+		add_assoc_string(return_value, "negative_sign",     currlocdata.negative_sign);
+		add_assoc_long(  return_value, "int_frac_digits",   currlocdata.int_frac_digits);
+		add_assoc_long(  return_value, "frac_digits",       currlocdata.frac_digits);
+		add_assoc_long(  return_value, "p_cs_precedes",     currlocdata.p_cs_precedes);
+		add_assoc_long(  return_value, "p_sep_by_space",    currlocdata.p_sep_by_space);
+		add_assoc_long(  return_value, "n_cs_precedes",     currlocdata.n_cs_precedes);
+		add_assoc_long(  return_value, "n_sep_by_space",    currlocdata.n_sep_by_space);
+		add_assoc_long(  return_value, "p_sign_posn",       currlocdata.p_sign_posn);
+		add_assoc_long(  return_value, "n_sign_posn",       currlocdata.n_sign_posn);
 	}
 #else
 	/* Ok, it doesn't look like we have locale info floating around, so I guess it
 	   wouldn't hurt to just go ahead and return the POSIX locale information?  */
 
-	add_index_long(grouping, 0, -1);
-	add_index_long(mon_grouping, 0, -1);
-
-	add_assoc_string(return_value, "decimal_point",     "\x2E", 1);
-	add_assoc_string(return_value, "thousands_sep",     "",     1);
-	add_assoc_string(return_value, "int_curr_symbol",   "",     1);
-	add_assoc_string(return_value, "currency_symbol",   "",     1);
-	add_assoc_string(return_value, "mon_decimal_point", "\x2E", 1);
-	add_assoc_string(return_value, "mon_thousands_sep", "",     1);
-	add_assoc_string(return_value, "positive_sign",     "",     1);
-	add_assoc_string(return_value, "negative_sign",     "",     1);
-	add_assoc_long(  return_value, "int_frac_digits",   CHAR_MAX );
-	add_assoc_long(  return_value, "frac_digits",       CHAR_MAX );
-	add_assoc_long(  return_value, "p_cs_precedes",     CHAR_MAX );
-	add_assoc_long(  return_value, "p_sep_by_space",    CHAR_MAX );
-	add_assoc_long(  return_value, "n_cs_precedes",     CHAR_MAX );
-	add_assoc_long(  return_value, "n_sep_by_space",    CHAR_MAX );
-	add_assoc_long(  return_value, "p_sign_posn",       CHAR_MAX );
-	add_assoc_long(  return_value, "n_sign_posn",       CHAR_MAX );
+	add_index_long(&grouping, 0, -1);
+	add_index_long(&mon_grouping, 0, -1);
+
+	add_assoc_string(return_value, "decimal_point",     "\x2E");
+	add_assoc_string(return_value, "thousands_sep",     "");
+	add_assoc_string(return_value, "int_curr_symbol",   "");
+	add_assoc_string(return_value, "currency_symbol",   "");
+	add_assoc_string(return_value, "mon_decimal_point", "\x2E");
+	add_assoc_string(return_value, "mon_thousands_sep", "");
+	add_assoc_string(return_value, "positive_sign",     "");
+	add_assoc_string(return_value, "negative_sign",     "");
+	add_assoc_long(  return_value, "int_frac_digits",   CHAR_MAX);
+	add_assoc_long(  return_value, "frac_digits",       CHAR_MAX);
+	add_assoc_long(  return_value, "p_cs_precedes",     CHAR_MAX);
+	add_assoc_long(  return_value, "p_sep_by_space",    CHAR_MAX);
+	add_assoc_long(  return_value, "n_cs_precedes",     CHAR_MAX);
+	add_assoc_long(  return_value, "n_sep_by_space",    CHAR_MAX);
+	add_assoc_long(  return_value, "p_sign_posn",       CHAR_MAX);
+	add_assoc_long(  return_value, "n_sign_posn",       CHAR_MAX);
 #endif
 
-	zend_hash_update(Z_ARRVAL_P(return_value), "grouping", 9, &grouping, sizeof(zval *), NULL);
-	zend_hash_update(Z_ARRVAL_P(return_value), "mon_grouping", 13, &mon_grouping, sizeof(zval *), NULL);
+	zend_hash_str_update(Z_ARRVAL_P(return_value), "grouping", sizeof("grouping")-1, &grouping);
+	zend_hash_str_update(Z_ARRVAL_P(return_value), "mon_grouping", sizeof("mon_grouping")-1, &mon_grouping);
 }
 /* }}} */
 
@@ -5199,7 +4987,7 @@ PHP_FUNCTION(substr_count)
 			p++;
 		}
 	} else {
-		while ((p = php_memnstr(p, needle, needle_len, endp))) {
+		while ((p = (char*)php_memnstr(p, needle, needle_len, endp))) {
 			p += needle_len;
 			count++;
 		}
@@ -5219,13 +5007,12 @@ PHP_FUNCTION(str_pad)
 	long pad_length;			/* Length to pad to */
 
 	/* Helper variables */
-	size_t	   num_pad_chars;		/* Number of padding characters (total - input size) */
-	char  *result = NULL;		/* Resulting string */
-	int	   result_len = 0;		/* Length of the resulting string */
+	size_t num_pad_chars;		/* Number of padding characters (total - input size) */
 	char  *pad_str_val = " ";	/* Pointer to padding string */
 	int    pad_str_len = 1;		/* Length of the padding string */
 	long   pad_type_val = STR_PAD_RIGHT; /* The padding type value */
 	int	   i, left_pad=0, right_pad=0;
+	zend_string *result = NULL;	/* Resulting string */
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sl|sl", &input, &input_len, &pad_length,
 																  &pad_str_val, &pad_str_len, &pad_type_val) == FAILURE) {
@@ -5235,7 +5022,7 @@ PHP_FUNCTION(str_pad)
 	/* If resulting string turns out to be shorter than input string,
 	   we simply copy the input and return. */
 	if (pad_length <= 0 || (pad_length - input_len) <= 0) {
-		RETURN_STRINGL(input, input_len, 1);
+		RETURN_STRINGL(input, input_len);
 	}
 
 	if (pad_str_len == 0) {
@@ -5253,7 +5040,9 @@ PHP_FUNCTION(str_pad)
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Padding length is too long");
 		return;
 	}
-	result = (char *)emalloc(input_len + num_pad_chars + 1);
+
+	result = STR_ALLOC(input_len + num_pad_chars, 0);
+	result->len = 0;
 
 	/* We need to figure out the left/right padding lengths. */
 	switch (pad_type_val) {
@@ -5275,19 +5064,19 @@ PHP_FUNCTION(str_pad)
 
 	/* First we pad on the left. */
 	for (i = 0; i < left_pad; i++)
-		result[result_len++] = pad_str_val[i % pad_str_len];
+		result->val[result->len++] = pad_str_val[i % pad_str_len];
 
 	/* Then we copy the input string. */
-	memcpy(result + result_len, input, input_len);
-	result_len += input_len;
+	memcpy(result->val + result->len, input, input_len);
+	result->len += input_len;
 
 	/* Finally, we pad on the right. */
 	for (i = 0; i < right_pad; i++)
-		result[result_len++] = pad_str_val[i % pad_str_len];
+		result->val[result->len++] = pad_str_val[i % pad_str_len];
 
-	result[result_len] = '\0';
+	result->val[result->len] = '\0';
 
-	RETURN_STRINGL(result, result_len, 0);
+	RETURN_NEW_STR(result);
 }
 /* }}} */
 
@@ -5295,7 +5084,7 @@ PHP_FUNCTION(str_pad)
    Implements an ANSI C compatible sscanf */
 PHP_FUNCTION(sscanf)
 {
-	zval ***args = NULL;
+	zval *args = NULL;
 	char *str, *format;
 	int str_len, format_len, result, num_args = 0;
 
@@ -5304,11 +5093,7 @@ PHP_FUNCTION(sscanf)
 		return;
 	}
 
-	result = php_sscanf_internal(str, format, num_args, args, 0, &return_value TSRMLS_CC);
-
-	if (args) {
-		efree(args);
-	}
+	result = php_sscanf_internal(str, format, num_args, args, 0, return_value TSRMLS_CC);
 
 	if (SCAN_ERROR_WRONG_PARAM_COUNT == result) {
 		WRONG_PARAM_COUNT;
@@ -5330,7 +5115,7 @@ PHP_FUNCTION(str_rot13)
 		return;
 	}
 
-	RETVAL_STRINGL(arg, arglen, 1);
+	RETVAL_STRINGL(arg, arglen);
 
 	php_strtr(Z_STRVAL_P(return_value), Z_STRLEN_P(return_value), rot13_from, rot13_to, 52);
 }
@@ -5373,7 +5158,7 @@ PHP_FUNCTION(str_shuffle)
 		return;
 	}
 
-	RETVAL_STRINGL(arg, arglen, 1);
+	RETVAL_STRINGL(arg, arglen);
 	if (Z_STRLEN_P(return_value) > 1) {
 		php_string_shuffle(Z_STRVAL_P(return_value), (long) Z_STRLEN_P(return_value) TSRMLS_CC);
 	}
@@ -5393,7 +5178,7 @@ PHP_FUNCTION(str_shuffle)
 */
 PHP_FUNCTION(str_word_count)
 {
-	char *buf, *str, *char_list = NULL, *p, *e, *s, ch[256];
+	char *str, *char_list = NULL, *p, *e, *s, ch[256];
 	int str_len, char_list_len = 0, word_count = 0;
 	long type = 0;
 
@@ -5445,12 +5230,10 @@ PHP_FUNCTION(str_word_count)
 			switch (type)
 			{
 				case 1:
-					buf = estrndup(s, (p-s));
-					add_next_index_stringl(return_value, buf, (p-s), 0);
+					add_next_index_stringl(return_value, s, p - s);
 					break;
 				case 2:
-					buf = estrndup(s, (p-s));
-					add_index_stringl(return_value, (s - str), buf, p-s, 0);
+					add_index_stringl(return_value, (s - str), s, p - s);
 					break;
 				default:
 					word_count++;
@@ -5472,10 +5255,11 @@ PHP_FUNCTION(str_word_count)
    Convert monetary value(s) to string */
 PHP_FUNCTION(money_format)
 {
-	int format_len = 0, str_len;
-	char *format, *str, *p, *e;
+	int format_len = 0;
+	char *format, *p, *e;
 	double value;
 	zend_bool check = 0;
+	zend_string *str;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sd", &format, &format_len, &value) == FAILURE) {
 		return;
@@ -5495,15 +5279,14 @@ PHP_FUNCTION(money_format)
 		}
 	}
 
-	str_len = format_len + 1024;
-	str = emalloc(str_len);
-	if ((str_len = strfmon(str, str_len, format, value)) < 0) {
-		efree(str);
+	str = STR_ALLOC(format_len + 1024, 0);
+	if ((str->len = strfmon(str->val, str->len, format, value)) < 0) {
+		STR_FREE(str);
 		RETURN_FALSE;
 	}
-	str[str_len] = 0;
+	str->val[str->len] = '\0';
 
-	RETURN_STRINGL(erealloc(str, str_len + 1), str_len, 0);
+	RETURN_NEW_STR(STR_REALLOC(str, str->len, 0));
 }
 /* }}} */
 #endif
@@ -5530,7 +5313,7 @@ PHP_FUNCTION(str_split)
 	array_init_size(return_value, ((str_len - 1) / split_length) + 1);
 
 	if (split_length >= str_len) {
-		add_next_index_stringl(return_value, str, str_len, 1);
+		add_next_index_stringl(return_value, str, str_len);
 		return;
 	}
 
@@ -5538,12 +5321,12 @@ PHP_FUNCTION(str_split)
 	p = str;
 
 	while (n_reg_segments-- > 0) {
-		add_next_index_stringl(return_value, p, split_length, 1);
+		add_next_index_stringl(return_value, p, split_length);
 		p += split_length;
 	}
 
 	if (p != (str + str_len)) {
-		add_next_index_stringl(return_value, p, (str + str_len - p), 1);
+		add_next_index_stringl(return_value, p, (str + str_len - p));
 	}
 }
 /* }}} */
@@ -5568,7 +5351,7 @@ PHP_FUNCTION(strpbrk)
 	for (haystack_ptr = haystack; haystack_ptr < (haystack + haystack_len); ++haystack_ptr) {
 		for (cl_ptr = char_list; cl_ptr < (char_list + char_list_len); ++cl_ptr) {
 			if (*cl_ptr == *haystack_ptr) {
-				RETURN_STRINGL(haystack_ptr, (haystack + haystack_len - haystack_ptr), 1);
+				RETURN_STRINGL(haystack_ptr, (haystack + haystack_len - haystack_ptr));
 			}
 		}
 	}
diff --git a/ext/standard/tests/array/bug24766.phpt b/ext/standard/tests/array/bug24766.phpt
index d6f82f3b16..65d80fa79d 100644
--- a/ext/standard/tests/array/bug24766.phpt
+++ b/ext/standard/tests/array/bug24766.phpt
@@ -19,27 +19,27 @@ var_dump($b[$i]);
 --EXPECT--
 array(2) refcount(2){
   [1]=>
-  long(18) refcount(1)
+  long(18)
   [2]=>
-  long(52) refcount(1)
+  long(52)
 }
 array(2) refcount(2){
   [1]=>
-  long(18) refcount(1)
+  long(18)
   [2]=>
-  long(52) refcount(1)
+  long(52)
 }
 array(2) refcount(2){
   [0]=>
-  long(1) refcount(1)
+  long(1)
   [1]=>
-  long(2) refcount(1)
+  long(2)
 }
 array(2) refcount(2){
   [0]=>
-  long(1) refcount(1)
+  long(1)
   [1]=>
-  long(2) refcount(1)
+  long(2)
 }
 int(18)
 int(18)
diff --git a/ext/standard/tests/array/bug25708.phpt b/ext/standard/tests/array/bug25708.phpt
index d3da3e3399..784f111064 100644
--- a/ext/standard/tests/array/bug25708.phpt
+++ b/ext/standard/tests/array/bug25708.phpt
@@ -66,158 +66,158 @@ foo(true, false);
 
 debug_zval_dump($_a, $_b);
 ?>
---EXPECT--
-NULL refcount(2)
-NULL refcount(2)
-long(1) refcount(3)
-long(2) refcount(3)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(3) refcount(1)
-long(1) refcount(1)
-long(3) refcount(1)
---
-long(4) refcount(1)
-long(3) refcount(1)
-long(4) refcount(1)
-long(3) refcount(1)
---
-long(3) refcount(1)
-long(3) refcount(1)
-long(3) refcount(2)
---
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(3) refcount(2)
---
-long(1) refcount(2)
-long(2) refcount(2)
+--EXPECTF--
+NULL
+NULL
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(3)
+long(1)
+long(3)
+--
+long(4)
+long(3)
+long(4)
+long(3)
+--
+long(3)
+long(3)
+long(3)
+--
+long(4)
+string(1) "x" refcount(%d)
+long(4)
+string(1) "x" refcount(%d)
+long(3)
+--
+long(1)
+long(2)
 ----a
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(3) refcount(1)
-long(1) refcount(1)
-long(3) refcount(1)
---
-long(4) refcount(1)
-long(3) refcount(1)
-long(4) refcount(1)
-long(3) refcount(1)
---
-long(3) refcount(1)
-long(3) refcount(1)
-long(3) refcount(2)
---
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(3) refcount(2)
---
-long(1) refcount(2)
-long(2) refcount(2)
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(3)
+long(1)
+long(3)
+--
+long(4)
+long(3)
+long(4)
+long(3)
+--
+long(3)
+long(3)
+long(3)
+--
+long(4)
+string(1) "x" refcount(%d)
+long(4)
+string(1) "x" refcount(%d)
+long(3)
+--
+long(1)
+long(2)
 ----ra
-NULL refcount(2)
-NULL refcount(2)
-long(1) refcount(3)
-long(2) refcount(3)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(3) refcount(1)
-long(1) refcount(1)
-long(3) refcount(1)
---
-long(4) refcount(1)
-long(3) refcount(1)
-long(4) refcount(1)
-long(3) refcount(1)
---
-long(3) refcount(1)
-long(3) refcount(1)
-long(3) refcount(2)
---
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(3) refcount(2)
---
-long(1) refcount(2)
-long(2) refcount(2)
+NULL
+NULL
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(3)
+long(1)
+long(3)
+--
+long(4)
+long(3)
+long(4)
+long(3)
+--
+long(3)
+long(3)
+long(3)
+--
+long(4)
+string(1) "x" refcount(%d)
+long(4)
+string(1) "x" refcount(%d)
+long(3)
+--
+long(1)
+long(2)
 ----
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(2) refcount(1)
-long(1) refcount(1)
-long(2) refcount(1)
---
-long(1) refcount(1)
-long(3) refcount(1)
-long(1) refcount(1)
-long(3) refcount(1)
---
-long(4) refcount(1)
-long(3) refcount(1)
-long(4) refcount(1)
-long(3) refcount(1)
---
-long(3) refcount(1)
-long(3) refcount(1)
-long(3) refcount(2)
---
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(4) refcount(1)
-string(1) "x" refcount(1)
-long(3) refcount(2)
---
-long(1) refcount(2)
-long(2) refcount(2)
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(2)
+long(1)
+long(2)
+--
+long(1)
+long(3)
+long(1)
+long(3)
+--
+long(4)
+long(3)
+long(4)
+long(3)
+--
+long(3)
+long(3)
+long(3)
+--
+long(4)
+string(1) "x" refcount(%d)
+long(4)
+string(1) "x" refcount(%d)
+long(3)
+--
+long(1)
+long(2)
 ----r
-string(2) "ok" refcount(2)
-string(2) "ok" refcount(2)
+string(2) "ok" refcount(%d)
+string(2) "ok" refcount(%d)
diff --git a/ext/standard/tests/array/extract_safety.phpt b/ext/standard/tests/array/extract_safety.phpt
index d5d0763be0..046ef5e2e2 100644
--- a/ext/standard/tests/array/extract_safety.phpt
+++ b/ext/standard/tests/array/extract_safety.phpt
@@ -17,8 +17,8 @@ echo "\nDone";
 ?>
 
 --EXPECTF--
-string(4) "John" refcount(2)
+string(4) "John" refcount(%d)
 int(0)
-string(4) "John" refcount(2)
+string(4) "John" refcount(%d)
 
 Done
\ No newline at end of file
diff --git a/ext/standard/tests/array/extract_variation1.phpt b/ext/standard/tests/array/extract_variation1.phpt
index 1b2ea193f4..d102534a08 100644
--- a/ext/standard/tests/array/extract_variation1.phpt
+++ b/ext/standard/tests/array/extract_variation1.phpt
@@ -18,10 +18,10 @@ echo "\nDone";
 ?>
 
 --EXPECTF--
-long(4) refcount(2)
-string(4) "John" refcount(2)
+long(4)
+string(4) "John" refcount(%d)
 int(%d)
-long(4) refcount(2)
-string(4) "John" refcount(2)
+long(4)
+string(4) "John" refcount(%d)
 
 Done
diff --git a/ext/standard/tests/dir/closedir_variation2.phpt b/ext/standard/tests/dir/closedir_variation2.phpt
index 015176c84d..2437868d62 100644
--- a/ext/standard/tests/dir/closedir_variation2.phpt
+++ b/ext/standard/tests/dir/closedir_variation2.phpt
@@ -45,7 +45,7 @@ Directory Handle: resource(%d) of type (Unknown)
 
 -- Close directory handle second time: --
 
-Warning: closedir(): %d is not a valid Directory resource in %s on line %d
+Warning: closedir(): supplied resource is not a valid Directory resource in %s on line %d
 bool(false)
 Directory Handle: resource(%d) of type (Unknown)
 ===DONE===
diff --git a/ext/standard/tests/dir/dir_basic.phpt b/ext/standard/tests/dir/dir_basic.phpt
index dba49dba08..da364b9b60 100644
--- a/ext/standard/tests/dir/dir_basic.phpt
+++ b/ext/standard/tests/dir/dir_basic.phpt
@@ -81,6 +81,6 @@ object(Directory)#%d (2) {
 }
 
 Test read after closing the dir:
-Warning: Directory::read(): %d is not a valid Directory resource in %s on line %d
+Warning: Directory::read(): supplied resource is not a valid Directory resource in %s on line %d
 bool(false)
-Done
\ No newline at end of file
+Done
diff --git a/ext/standard/tests/dir/rewinddir_variation2.phpt b/ext/standard/tests/dir/rewinddir_variation2.phpt
index 7594cc220e..6b06a56d95 100644
--- a/ext/standard/tests/dir/rewinddir_variation2.phpt
+++ b/ext/standard/tests/dir/rewinddir_variation2.phpt
@@ -40,6 +40,6 @@ string(%d) "%s"
 
 -- Call to rewinddir() --
 
-Warning: rewinddir(): %d is not a valid Directory resource in %s on line %d
+Warning: rewinddir(): supplied resource is not a valid Directory resource in %s on line %d
 bool(false)
 ===DONE===
diff --git a/ext/standard/tests/file/007_basic.phpt b/ext/standard/tests/file/007_basic.phpt
index eafadf7c55..ceb9b29943 100644
--- a/ext/standard/tests/file/007_basic.phpt
+++ b/ext/standard/tests/file/007_basic.phpt
@@ -98,10 +98,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'wb' --
@@ -111,10 +111,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'wt' --
@@ -124,10 +124,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'w+' --
@@ -137,10 +137,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'w+b' --
@@ -150,10 +150,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'w+t' --
@@ -163,10 +163,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'r' --
@@ -176,10 +176,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'rb' --
@@ -189,10 +189,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'rt' --
@@ -202,10 +202,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'r+' --
@@ -215,10 +215,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'r+b' --
@@ -228,10 +228,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'r+t' --
@@ -241,10 +241,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'a' --
@@ -254,10 +254,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'ab' --
@@ -267,10 +267,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'at' --
@@ -280,10 +280,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'a+' --
@@ -293,10 +293,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'a+t' --
@@ -306,10 +306,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'a+b' --
@@ -319,10 +319,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 -- Iteration with mode 'x' --
@@ -332,10 +332,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 resource(%d) of type (Unknown)
 
@@ -346,10 +346,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 resource(%d) of type (Unknown)
 
@@ -360,10 +360,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 resource(%d) of type (Unknown)
 
@@ -374,10 +374,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 resource(%d) of type (Unknown)
 
@@ -388,10 +388,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 resource(%d) of type (Unknown)
 
@@ -402,10 +402,10 @@ bool(false)
 bool(true)
 resource(%d) of type (Unknown)
 
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 resource(%d) of type (Unknown)
 
diff --git a/ext/standard/tests/file/007_error.phpt b/ext/standard/tests/file/007_error.phpt
index 112beb3059..1d692b0b6f 100644
--- a/ext/standard/tests/file/007_error.phpt
+++ b/ext/standard/tests/file/007_error.phpt
@@ -76,7 +76,7 @@ bool(false)
 Warning: fopen() expects at least 2 parameters, 0 given in %s on line %d
 bool(false)
 
-Warning: fclose(): %d is not a valid stream resource in %s on line %d
+Warning: fclose(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: fclose() expects parameter 1 to be resource, string given in %s on line %d
@@ -85,7 +85,7 @@ bool(false)
 Warning: fclose() expects exactly 1 parameter, 0 given in %s on line %d
 bool(false)
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: feof() expects parameter 1 to be resource, string given in %s on line %d
diff --git a/ext/standard/tests/file/bug27508.phpt b/ext/standard/tests/file/bug27508.phpt
index 7f012bd8f4..188080aa25 100644
--- a/ext/standard/tests/file/bug27508.phpt
+++ b/ext/standard/tests/file/bug27508.phpt
@@ -72,9 +72,9 @@ fclose($fp);
 unlink($tn);
 ?>
 --EXPECT--
-bool(false) refcount(1)
+bool(false)
 0
-bool(false) refcount(1)
+bool(false)
 line1
 line2
 line3
diff --git a/ext/standard/tests/file/fclose_variation1.phpt b/ext/standard/tests/file/fclose_variation1.phpt
index 43a6c343d0..ba3631e50d 100644
--- a/ext/standard/tests/file/fclose_variation1.phpt
+++ b/ext/standard/tests/file/fclose_variation1.phpt
@@ -10,6 +10,6 @@ fclose($s);
 echo fread($s2, strlen("<?php"));
 echo "\nDone.\n";
 --EXPECTF--
-Warning: fread(): %d is not a valid stream resource in %s on line %d
+Warning: fread(): supplied resource is not a valid stream resource in %s on line %d
 
 Done.
diff --git a/ext/standard/tests/file/feof_basic.phpt b/ext/standard/tests/file/feof_basic.phpt
index ff1d179f6f..78774e58e9 100644
--- a/ext/standard/tests/file/feof_basic.phpt
+++ b/ext/standard/tests/file/feof_basic.phpt
@@ -97,5 +97,5 @@ bool(false)
 bool(false)
 *** closing file, testing eof ***
 
-Warning: feof(): %d is not a valid stream resource in %s on line %d
+Warning: feof(): supplied resource is not a valid stream resource in %s on line %d
 Done
diff --git a/ext/standard/tests/file/fgetc_variation2.phpt b/ext/standard/tests/file/fgetc_variation2.phpt
index 380c1aa268..169f00ac2c 100644
--- a/ext/standard/tests/file/fgetc_variation2.phpt
+++ b/ext/standard/tests/file/fgetc_variation2.phpt
@@ -41,7 +41,7 @@ echo "Done";
 *** Testing fgetc() : usage variations ***
 -- Testing fgetc() with closed handle --
 
-Warning: fgetc(): %d is not a valid stream resource in %s on line %d
+Warning: fgetc(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 -- Testing fgetc() with unset handle --
 
diff --git a/ext/standard/tests/file/fgets_error.phpt b/ext/standard/tests/file/fgets_error.phpt
index 51ae3c6a37..5ab32820ca 100644
--- a/ext/standard/tests/file/fgets_error.phpt
+++ b/ext/standard/tests/file/fgets_error.phpt
@@ -99,7 +99,7 @@ bool(false)
 Warning: fgets() expects parameter 1 to be resource, object given in %s on line %d
 bool(false)
 -- Testing fgets() with closed/unset file handle --
-Warning: fgets(): %d is not a valid stream resource in %s on line %d
+Warning: fgets(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: fgets() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/file/fgets_variation2.phpt b/ext/standard/tests/file/fgets_variation2.phpt
index 964216bf8c..201755b69c 100644
--- a/ext/standard/tests/file/fgets_variation2.phpt
+++ b/ext/standard/tests/file/fgets_variation2.phpt
@@ -43,10 +43,10 @@ echo "Done";
 *** Testing fgets() : usage variations ***
 -- Testing fgets() with closed handle --
 
-Warning: fgets(): %d is not a valid stream resource in %s on line %d
+Warning: fgets(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
-Warning: fgets(): %d is not a valid stream resource in %s on line %d
+Warning: fgets(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 -- Testing fgets() with unset handle --
 
diff --git a/ext/standard/tests/file/fgetss.phpt b/ext/standard/tests/file/fgetss.phpt
index b4ac21167b..2e2bb6b71c 100644
--- a/ext/standard/tests/file/fgetss.phpt
+++ b/ext/standard/tests/file/fgetss.phpt
@@ -78,6 +78,6 @@ bool(false)
 Warning: fgetss(): Length parameter must be greater than 0 in %s on line %d
 bool(false)
 
-Warning: fgetss(): %d is not a valid stream resource in %s on line %d
+Warning: fgetss(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 Done
diff --git a/ext/standard/tests/file/fgetss_error.phpt b/ext/standard/tests/file/fgetss_error.phpt
index 2b4ad68125..1671662584 100644
--- a/ext/standard/tests/file/fgetss_error.phpt
+++ b/ext/standard/tests/file/fgetss_error.phpt
@@ -98,7 +98,7 @@ bool(false)
 Warning: fgetss() expects parameter 1 to be resource, object given in %s on line %d
 bool(false)
 -- Testing fgetss() with closed/unset file handle --
-Warning: fgetss(): %d is not a valid stream resource in %s on line %d
+Warning: fgetss(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: fgetss() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/file/flock.phpt b/ext/standard/tests/file/flock.phpt
index efc059cff5..55aae4ab5a 100644
--- a/ext/standard/tests/file/flock.phpt
+++ b/ext/standard/tests/file/flock.phpt
@@ -43,7 +43,7 @@ NULL
 Warning: flock() expects parameter 1 to be resource, string given in %s on line %d
 NULL
 
-Warning: flock(): %d is not a valid stream resource in %s on line %d
+Warning: flock(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 bool(true)
 bool(true)
diff --git a/ext/standard/tests/file/flock_error.phpt b/ext/standard/tests/file/flock_error.phpt
index fe61e2a173..4fa1094967 100644
--- a/ext/standard/tests/file/flock_error.phpt
+++ b/ext/standard/tests/file/flock_error.phpt
@@ -94,7 +94,7 @@ NULL
 Warning: flock() expects parameter 2 to be long, string given in %s on line %d
 NULL
 
-Warning: flock(): %d is not a valid stream resource in %s on line %d
+Warning: flock(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: flock() expects parameter 1 to be resource, string given in %s on line %d
diff --git a/ext/standard/tests/file/fread_error.phpt b/ext/standard/tests/file/fread_error.phpt
index 45a5ad1aa9..16c828ec51 100644
--- a/ext/standard/tests/file/fread_error.phpt
+++ b/ext/standard/tests/file/fread_error.phpt
@@ -103,7 +103,7 @@ bool(false)
 
 Notice: Undefined variable: file_content_type in %s on line %d
 
-Warning: fread(): %d is not a valid stream resource in %s on line %d
+Warning: fread(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: fread() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/file/fscanf_error.phpt b/ext/standard/tests/file/fscanf_error.phpt
index 85c0ac4bf6..f93d1b2a57 100644
--- a/ext/standard/tests/file/fscanf_error.phpt
+++ b/ext/standard/tests/file/fscanf_error.phpt
@@ -70,7 +70,7 @@ NULL
 Warning: fscanf() expects at least 2 parameters, 1 given in %s on line %d
 NULL
 
-Warning: fscanf(): %d is not a valid File-Handle resource in %s on line %d
+Warning: fscanf(): supplied resource is not a valid File-Handle resource in %s on line %d
 bool(false)
 
 Warning: fscanf(): Different numbers of variable names and field specifiers in %s on line %d
diff --git a/ext/standard/tests/file/fseek_ftell_rewind_error1.phpt b/ext/standard/tests/file/fseek_ftell_rewind_error1.phpt
index 1779383044..d955340581 100644
--- a/ext/standard/tests/file/fseek_ftell_rewind_error1.phpt
+++ b/ext/standard/tests/file/fseek_ftell_rewind_error1.phpt
@@ -91,7 +91,7 @@ bool(false)
 Warning: fseek() expects parameter 1 to be resource, object given in %s on line %d
 bool(false)
 -- Testing fseek() with closed/unset file handle --
-Warning: fseek(): %d is not a valid stream resource in %s on line %d
+Warning: fseek(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: fseek() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/file/fseek_ftell_rewind_error2.phpt b/ext/standard/tests/file/fseek_ftell_rewind_error2.phpt
index 1f28abc99c..d297d6c7cb 100644
--- a/ext/standard/tests/file/fseek_ftell_rewind_error2.phpt
+++ b/ext/standard/tests/file/fseek_ftell_rewind_error2.phpt
@@ -87,7 +87,7 @@ bool(false)
 Warning: ftell() expects parameter 1 to be resource, object given in %s on line %d
 bool(false)
 -- Testing ftell with closed/unset file handle --
-Warning: ftell(): %d is not a valid stream resource in %s on line %d
+Warning: ftell(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: ftell() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/file/fseek_ftell_rewind_error3.phpt b/ext/standard/tests/file/fseek_ftell_rewind_error3.phpt
index 3c928e6465..16a4a0f9dd 100644
--- a/ext/standard/tests/file/fseek_ftell_rewind_error3.phpt
+++ b/ext/standard/tests/file/fseek_ftell_rewind_error3.phpt
@@ -87,7 +87,7 @@ bool(false)
 Warning: rewind() expects parameter 1 to be resource, object given in %s on line %d
 bool(false)
 -- Testing rewind() with closed/unset file handle --
-Warning: rewind(): %d is not a valid stream resource in %s on line %d
+Warning: rewind(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: rewind() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/file/fstat.phpt b/ext/standard/tests/file/fstat.phpt
index e1ae3e20bc..96924af077 100644
--- a/ext/standard/tests/file/fstat.phpt
+++ b/ext/standard/tests/file/fstat.phpt
@@ -69,6 +69,6 @@ array(26) {
   int(%i)
 }
 
-Warning: fstat(): %d is not a valid stream resource in %s on line %d
+Warning: fstat(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 Done
diff --git a/ext/standard/tests/file/ftruncate_error.phpt b/ext/standard/tests/file/ftruncate_error.phpt
index 254ad7688d..4823a7739b 100644
--- a/ext/standard/tests/file/ftruncate_error.phpt
+++ b/ext/standard/tests/file/ftruncate_error.phpt
@@ -114,7 +114,7 @@ Warning: ftruncate() expects parameter 1 to be resource, object given in %s on l
 bool(false)
 -- Testing ftruncate() with closed/unset file handle --
 
-Warning: ftruncate(): %d is not a valid stream resource in %s on line %d
+Warning: ftruncate(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 int(36)
 
diff --git a/ext/standard/tests/file/fwrite_error.phpt b/ext/standard/tests/file/fwrite_error.phpt
index 988d618c66..2b28429362 100644
--- a/ext/standard/tests/file/fwrite_error.phpt
+++ b/ext/standard/tests/file/fwrite_error.phpt
@@ -112,7 +112,7 @@ Warning: fwrite() expects parameter 1 to be resource, object given in %s on line
 bool(false)
 -- Testing fwrite() with closed/unset file handle --
 
-Warning: fwrite(): %d is not a valid stream resource in %s on line %d
+Warning: fwrite(): supplied resource is not a valid stream resource in %s on line %d
 bool(false)
 
 Warning: fwrite() expects parameter 1 to be resource, null given in %s on line %d
diff --git a/ext/standard/tests/general_functions/bug29038.phpt b/ext/standard/tests/general_functions/bug29038.phpt
index 0f79229994..d0c87fb199 100644
--- a/ext/standard/tests/general_functions/bug29038.phpt
+++ b/ext/standard/tests/general_functions/bug29038.phpt
@@ -2,37 +2,41 @@
 Bug #29038 (extract(), EXTR_PREFIX_SAME option prefixes empty strings)
 --FILE--
 <?php
+function my_print_r($a) {
+	ksort($a);
+	print_r($a);
+}
 function f1() {
   $c = extract(array("" => 1),EXTR_PREFIX_SAME,"prefix");
   echo "Extracted:";
   var_dump($c);
-  print_r(get_defined_vars());
+  my_print_r(get_defined_vars());
 }
 function f2() {
   $a = 1;
   $c = extract(array("a" => 1),EXTR_PREFIX_SAME,"prefix");
   echo "Extracted:";
   var_dump($c);
-  print_r(get_defined_vars());
+  my_print_r(get_defined_vars());
 }
 function f3() {
   $a = 1;
   $c = extract(array("a" => 1),EXTR_PREFIX_ALL,"prefix");
   echo "Extracted:";
   var_dump($c);
-  print_r(get_defined_vars());
+  my_print_r(get_defined_vars());
 }
 function f4() {
   $c = extract(array("" => 1),EXTR_PREFIX_ALL,"prefix");
   echo "Extracted:";
   var_dump($c);
-  print_r(get_defined_vars());
+  my_print_r(get_defined_vars());
 }
 function f5() {
   $c = extract(array("111" => 1),EXTR_PREFIX_ALL,"prefix");
   echo "Extracted:";
   var_dump($c);
-  print_r(get_defined_vars());
+  my_print_r(get_defined_vars());
 }
 
 f1();
@@ -51,15 +55,15 @@ Extracted:int(1)
 Array
 (
     [a] => 1
-    [prefix_a] => 1
     [c] => 1
+    [prefix_a] => 1
 )
 Extracted:int(1)
 Array
 (
     [a] => 1
-    [prefix_a] => 1
     [c] => 1
+    [prefix_a] => 1
 )
 Extracted:int(0)
 Array
@@ -69,6 +73,6 @@ Array
 Extracted:int(1)
 Array
 (
-    [prefix_111] => 1
     [c] => 1
+    [prefix_111] => 1
 )
diff --git a/ext/standard/tests/general_functions/call_user_func_return.phpt b/ext/standard/tests/general_functions/call_user_func_return.phpt
index 929fdd7e35..cb0f6998dc 100644
--- a/ext/standard/tests/general_functions/call_user_func_return.phpt
+++ b/ext/standard/tests/general_functions/call_user_func_return.phpt
@@ -34,11 +34,11 @@ test('test2');
 ===DONE===
 --EXPECTF--
 Direct Call
-string(5) "test1" refcount(1)
+string(5) "test1" refcount(%d)
 User Func
-string(5) "test1" refcount(1)
+string(5) "test1" refcount(%d)
 Direct Call
-string(5) "test2" refcount(2)
+string(5) "test2" refcount(%d)
 User Func
-string(5) "test2" refcount(1)
+string(5) "test2" refcount(%d)
 ===DONE===
diff --git a/ext/standard/tests/general_functions/debug_zval_dump_b.phpt b/ext/standard/tests/general_functions/debug_zval_dump_b.phpt
index e83cdbf540..00ec7a88a4 100644
--- a/ext/standard/tests/general_functions/debug_zval_dump_b.phpt
+++ b/ext/standard/tests/general_functions/debug_zval_dump_b.phpt
diff --git a/ext/standard/tests/general_functions/debug_zval_dump_o.phpt b/ext/standard/tests/general_functions/debug_zval_dump_o.phpt
index 78f0f03003..4f286ec606 100644
--- a/ext/standard/tests/general_functions/debug_zval_dump_o.phpt
+++ b/ext/standard/tests/general_functions/debug_zval_dump_o.phpt
@@ -118,613 +118,613 @@ echo "Done\n";
 --EXPECTF--
 *** Testing debug_zval_dump() on objects ***
 -- Iteration 1 --
-object(object_class)#%d (6) refcount(5){
+object(object_class)#%d (6) refcount(%d){
   ["value1"]=>
-  long(5) refcount(1)
+  long(5)
   ["value2":"object_class":private]=>
-  long(10) refcount(5)
+  long(10)
   ["value3":protected]=>
-  long(20) refcount(5)
+  long(20)
   ["value4"]=>
-  long(30) refcount(7)
+  long(30)
   ["array_var"]=>
-  array(2) refcount(5){
+  array(2) refcount(%d){
     ["key1"]=>
-    long(1) refcount(1)
+    long(1)
     ["key2 "]=>
-    long(3) refcount(1)
+    long(3)
   }
   ["object_class1"]=>
-  object(object_class)#%d (6) refcount(5){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
     *RECURSION*
   }
 }
 -- Iteration 2 --
-object(no_member_class)#%d (0) refcount(4){
+object(no_member_class)#%d (0) refcount(%d){
 }
 -- Iteration 3 --
-object(contains_object_class)#%d (9) refcount(4){
+object(contains_object_class)#%d (9) refcount(%d){
   ["p"]=>
-  long(30) refcount(2)
+  long(30)
   ["p1":protected]=>
-  long(40) refcount(2)
+  long(40)
   ["p2":"contains_object_class":private]=>
-  long(50) refcount(2)
+  long(50)
   ["class_object1"]=>
-  object(object_class)#%d (6) refcount(7){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
       *RECURSION*
     }
   }
   ["class_object2"]=>
-  object(object_class)#%d (6) refcount(7){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
       *RECURSION*
     }
   }
   ["class_object3":"contains_object_class":private]=>
-  object(object_class)#%d (6) refcount(7){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
       *RECURSION*
     }
   }
   ["class_object4":protected]=>
-  object(object_class)#%d (6) refcount(7){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
       *RECURSION*
     }
   }
   ["no_member_class_object"]=>
-  object(no_member_class)#%d (0) refcount(3){
+  object(no_member_class)#%d (0) refcount(%d){
   }
   ["class_object5"]=>
-  object(contains_object_class)#%d (9) refcount(1){
+  object(contains_object_class)#%d (9) refcount(%d){
     ["p"]=>
-    long(30) refcount(2)
+    long(30)
     ["p1":protected]=>
-    long(40) refcount(2)
+    long(40)
     ["p2":"contains_object_class":private]=>
-    long(50) refcount(2)
+    long(50)
     ["class_object1"]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
-      object(object_class)#%d (6) refcount(7){
+      object(object_class)#%d (6) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(5)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(5)
+        long(20)
         ["value4"]=>
-        long(30) refcount(7)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(5){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
       }
     }
     ["class_object2"]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
-      object(object_class)#%d (6) refcount(7){
+      object(object_class)#%d (6) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(5)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(5)
+        long(20)
         ["value4"]=>
-        long(30) refcount(7)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(5){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
       }
     }
     ["class_object3":"contains_object_class":private]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
-      object(object_class)#%d (6) refcount(7){
+      object(object_class)#%d (6) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(5)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(5)
+        long(20)
         ["value4"]=>
-        long(30) refcount(7)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(5){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
       }
     }
     ["class_object4":protected]=>
-    object(object_class)#%d (6) refcount(7){
+    object(object_class)#%d (6) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(5)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(5)
+      long(20)
       ["value4"]=>
-      long(30) refcount(7)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(5){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
-      object(object_class)#%d (6) refcount(7){
+      object(object_class)#%d (6) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(5)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(5)
+        long(20)
         ["value4"]=>
-        long(30) refcount(7)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(5){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
       }
     }
     ["no_member_class_object"]=>
-    object(no_member_class)#%d (0) refcount(3){
+    object(no_member_class)#%d (0) refcount(%d){
     }
     ["class_object5"]=>
     *RECURSION*
   }
 }
 -- Iteration 4 --
-object(object_class)#%d (6) refcount(9){
+object(object_class)#%d (6) refcount(%d){
   ["value1"]=>
-  long(5) refcount(1)
+  long(5)
   ["value2":"object_class":private]=>
-  long(10) refcount(5)
+  long(10)
   ["value3":protected]=>
-  long(20) refcount(5)
+  long(20)
   ["value4"]=>
-  long(30) refcount(7)
+  long(30)
   ["array_var"]=>
-  array(2) refcount(5){
+  array(2) refcount(%d){
     ["key1"]=>
-    long(1) refcount(1)
+    long(1)
     ["key2 "]=>
-    long(3) refcount(1)
+    long(3)
   }
   ["object_class1"]=>
-  object(object_class)#%d (6) refcount(9){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
     *RECURSION*
   }
 }
 -- Iteration 5 --
-object(object_class)#%d (6) refcount(9){
+object(object_class)#%d (6) refcount(%d){
   ["value1"]=>
-  long(5) refcount(1)
+  long(5)
   ["value2":"object_class":private]=>
-  long(10) refcount(5)
+  long(10)
   ["value3":protected]=>
-  long(20) refcount(5)
+  long(20)
   ["value4"]=>
-  long(30) refcount(7)
+  long(30)
   ["array_var"]=>
-  array(2) refcount(5){
+  array(2) refcount(%d){
     ["key1"]=>
-    long(1) refcount(1)
+    long(1)
     ["key2 "]=>
-    long(3) refcount(1)
+    long(3)
   }
   ["object_class1"]=>
-  object(object_class)#%d (6) refcount(9){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
     *RECURSION*
   }
 }
 -- Iteration 6 --
-object(no_member_class)#%d (0) refcount(5){
+object(no_member_class)#%d (0) refcount(%d){
 }
 -- Iteration 7 --
-NULL refcount(1)
+NULL
 -- Iteration 8 --
-object(object_class)#%d (6) refcount(9){
+object(object_class)#%d (6) refcount(%d){
   ["value1"]=>
-  long(5) refcount(1)
+  long(5)
   ["value2":"object_class":private]=>
-  long(10) refcount(5)
+  long(10)
   ["value3":protected]=>
-  long(20) refcount(5)
+  long(20)
   ["value4"]=>
-  long(30) refcount(7)
+  long(30)
   ["array_var"]=>
-  array(2) refcount(5){
+  array(2) refcount(%d){
     ["key1"]=>
-    long(1) refcount(1)
+    long(1)
     ["key2 "]=>
-    long(3) refcount(1)
+    long(3)
   }
   ["object_class1"]=>
-  object(object_class)#%d (6) refcount(9){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
     *RECURSION*
   }
 }
 -- Iteration 9 --
-object(object_class)#%d (6) refcount(9){
+object(object_class)#%d (6) refcount(%d){
   ["value1"]=>
-  long(5) refcount(1)
+  long(5)
   ["value2":"object_class":private]=>
-  long(10) refcount(5)
+  long(10)
   ["value3":protected]=>
-  long(20) refcount(5)
+  long(20)
   ["value4"]=>
-  long(30) refcount(7)
+  long(30)
   ["array_var"]=>
-  array(2) refcount(5){
+  array(2) refcount(%d){
     ["key1"]=>
-    long(1) refcount(1)
+    long(1)
     ["key2 "]=>
-    long(3) refcount(1)
+    long(3)
   }
   ["object_class1"]=>
-  object(object_class)#%d (6) refcount(9){
+  object(object_class)#%d (6) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(5)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(5)
+    long(20)
     ["value4"]=>
-    long(30) refcount(7)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(5){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
     *RECURSION*
   }
 }
 -- Iteration 10 --
-long(30) refcount(9)
+long(30)
 -- Iteration 11 --
-NULL refcount(1)
+NULL
 
 -- Testing debug_zval_dump() on overwritten object variables --
-long(500) refcount(1)
-long(500) refcount(1)
-long(500) refcount(1)
-long(500) refcount(1)
+long(500)
+long(500)
+long(500)
+long(500)
 
 -- Testing debug_zval_dump() on objects having circular reference --
-object(object_class)#%d (7) refcount(1){
+object(object_class)#%d (7) refcount(%d){
   ["value1"]=>
-  long(5) refcount(1)
+  long(5)
   ["value2":"object_class":private]=>
-  long(10) refcount(7)
+  long(10)
   ["value3":protected]=>
-  long(20) refcount(7)
+  long(20)
   ["value4"]=>
-  long(30) refcount(8)
+  long(30)
   ["array_var"]=>
-  array(2) refcount(7){
+  array(2) refcount(%d){
     ["key1"]=>
-    long(1) refcount(1)
+    long(1)
     ["key2 "]=>
-    long(3) refcount(1)
+    long(3)
   }
   ["object_class1"]=>
-  object(object_class)#%d (7) refcount(1){
+  object(object_class)#%d (7) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(7)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(7)
+    long(20)
     ["value4"]=>
-    long(30) refcount(8)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(7){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
     *RECURSION*
     ["obj"]=>
-    &object(object_class)#%d (7) refcount(2){
+    &object(object_class)#%d (7) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(7)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(7)
+      long(20)
       ["value4"]=>
-      long(30) refcount(8)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(7){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
-      object(object_class)#%d (7) refcount(1){
+      object(object_class)#%d (7) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(7)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(7)
+        long(20)
         ["value4"]=>
-        long(30) refcount(8)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(7){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
@@ -736,57 +736,57 @@ object(object_class)#%d (7) refcount(1){
     }
   }
   ["obj"]=>
-  &object(object_class)#%d (7) refcount(2){
+  &object(object_class)#%d (7) refcount(%d){
     ["value1"]=>
-    long(5) refcount(1)
+    long(5)
     ["value2":"object_class":private]=>
-    long(10) refcount(7)
+    long(10)
     ["value3":protected]=>
-    long(20) refcount(7)
+    long(20)
     ["value4"]=>
-    long(30) refcount(8)
+    long(30)
     ["array_var"]=>
-    array(2) refcount(7){
+    array(2) refcount(%d){
       ["key1"]=>
-      long(1) refcount(1)
+      long(1)
       ["key2 "]=>
-      long(3) refcount(1)
+      long(3)
     }
     ["object_class1"]=>
-    object(object_class)#%d (7) refcount(1){
+    object(object_class)#%d (7) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(7)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(7)
+      long(20)
       ["value4"]=>
-      long(30) refcount(8)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(7){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
       *RECURSION*
       ["obj"]=>
-      &object(object_class)#%d (7) refcount(2){
+      &object(object_class)#%d (7) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(7)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(7)
+        long(20)
         ["value4"]=>
-        long(30) refcount(8)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(7){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
@@ -795,40 +795,40 @@ object(object_class)#%d (7) refcount(1){
       }
     }
     ["obj"]=>
-    &object(object_class)#%d (7) refcount(2){
+    &object(object_class)#%d (7) refcount(%d){
       ["value1"]=>
-      long(5) refcount(1)
+      long(5)
       ["value2":"object_class":private]=>
-      long(10) refcount(7)
+      long(10)
       ["value3":protected]=>
-      long(20) refcount(7)
+      long(20)
       ["value4"]=>
-      long(30) refcount(8)
+      long(30)
       ["array_var"]=>
-      array(2) refcount(7){
+      array(2) refcount(%d){
         ["key1"]=>
-        long(1) refcount(1)
+        long(1)
         ["key2 "]=>
-        long(3) refcount(1)
+        long(3)
       }
       ["object_class1"]=>
       *RECURSION*
       ["obj"]=>
-      &object(object_class)#%d (7) refcount(2){
+      &object(object_class)#%d (7) refcount(%d){
         ["value1"]=>
-        long(5) refcount(1)
+        long(5)
         ["value2":"object_class":private]=>
-        long(10) refcount(7)
+        long(10)
         ["value3":protected]=>
-        long(20) refcount(7)
+        long(20)
         ["value4"]=>
-        long(30) refcount(8)
+        long(30)
         ["array_var"]=>
-        array(2) refcount(7){
+        array(2) refcount(%d){
           ["key1"]=>
-          long(1) refcount(1)
+          long(1)
           ["key2 "]=>
-          long(3) refcount(1)
+          long(3)
         }
         ["object_class1"]=>
         *RECURSION*
diff --git a/ext/standard/tests/general_functions/debug_zval_dump_v.phpt b/ext/standard/tests/general_functions/debug_zval_dump_v.phpt
index 82ee2a63d5..f4b768a77e 100644
--- a/ext/standard/tests/general_functions/debug_zval_dump_v.phpt
+++ b/ext/standard/tests/general_functions/debug_zval_dump_v.phpt
@@ -124,81 +124,81 @@ echo "Done\n";
 --- Variation 1: global variable inside a function ---
 
 -- Value of global variable, before calling dump_globalvar() --
-long(10) refcount(2)
+long(10)
 
 -- Value of local variable inside dump_globalvar() --
-long(10) refcount(1)
+long(10)
 
 -- Value of global variable inside dump_globalvar() --
-long(10) refcount(1)
+long(10)
 
 -- Value of global variable, after exiting dump_globalvar() --
-long(10) refcount(2)
+long(10)
 
 --- Variation 2: one variable references another ---
 
 -- Value of $first_var: --
-long(10) refcount(2)
+long(10)
 
 -- Value of $ref_first_var --
-NULL refcount(1)
+NULL
 
 -- Value of $first_var --
-long(10) refcount(2)
+long(10)
 
 -- Value of $ref_first_var --
 
 Notice: Undefined variable: ref_first_var in %s on line %d
-NULL refcount(1)
+NULL
 
 -- Value of $first_var --
-long(10) refcount(2)
+long(10)
 
 --- Variation 3: multiple references of variables ---
 
 -- Value of $var_1: (before referencing) --
-long(10) refcount(1)
+long(10)
 
 -- Value of $var_2: (referencing var_1) --
-long(10) refcount(1)
+long(10)
 
 -- Value of $var_3: (referencing var_2) --
-long(10) refcount(1)
+long(10)
 
 -- Value of $var_3: (after unsetting var_3) --
 
 Notice: Undefined variable: var_3 in %s on line %d
-NULL refcount(1)
+NULL
 
 -- Value of $var_2: --
-long(10) refcount(1)
+long(10)
 
 -- Value of $var_3: --
-long(10) refcount(1)
+long(10)
 
 -- Value of $var_1: (after unsetting variable_1) --
 
 Notice: Undefined variable: var_1 in %s on line %d
-NULL refcount(1)
+NULL
 
 -- Value of $var_2: --
-long(10) refcount(2)
+long(10)
 
 *** Testing debug_zval_dump() on miscelleneous input arguments ***
 -- Iteration 1 --
-NULL refcount(3)
+NULL
 -- Iteration 2 --
-NULL refcount(3)
+NULL
 -- Iteration 3 --
-NULL refcount(1)
+NULL
 -- Iteration 4 --
-NULL refcount(1)
+NULL
 -- Iteration 5 --
-string(7) "TRUE123" refcount(3)
+string(7) "TRUE123" refcount(%d)
 -- Iteration 6 --
-string(9) "123string" refcount(3)
+string(9) "123string" refcount(%d)
 -- Iteration 7 --
-string(9) "string123" refcount(3)
+string(9) "string123" refcount(%d)
 -- Iteration 8 --
-string(10) "NULLstring" refcount(3)
+string(10) "NULLstring" refcount(%d)
 Done
diff --git a/ext/standard/tests/general_functions/ini_get_all.phpt b/ext/standard/tests/general_functions/ini_get_all.phpt
index 60cd38a723..806831edfc 100644
--- a/ext/standard/tests/general_functions/ini_get_all.phpt
+++ b/ext/standard/tests/general_functions/ini_get_all.phpt
@@ -30,7 +30,7 @@ Warning: ini_get_all(): Unable to find extension 'nosuchextension' in %s on line
 bool(false)
 array(0) {
 }
-array(2) {
+array(3) {
   ["pcre.backtrack_limit"]=>
   array(3) {
     ["global_value"]=>
@@ -40,6 +40,15 @@ array(2) {
     ["access"]=>
     int(7)
   }
+  ["pcre.jit"]=>
+  array(3) {
+    ["global_value"]=>
+    string(1) "1"
+    ["local_value"]=>
+    string(1) "1"
+    ["access"]=>
+    int(7)
+  }
   ["pcre.recursion_limit"]=>
   array(3) {
     ["global_value"]=>
@@ -50,9 +59,11 @@ array(2) {
     int(7)
   }
 }
-array(2) {
+array(3) {
   ["pcre.backtrack_limit"]=>
   string(7) "1000000"
+  ["pcre.jit"]=>
+  string(1) "1"
   ["pcre.recursion_limit"]=>
   string(6) "100000"
 }
diff --git a/ext/standard/tests/streams/bug54623.phpt b/ext/standard/tests/streams/bug54623.phpt
index 43bcb09a42..c21dc82019 100644
--- a/ext/standard/tests/streams/bug54623.phpt
+++ b/ext/standard/tests/streams/bug54623.phpt
@@ -14,4 +14,4 @@ fwrite($sock, "3");
 int(%d)
 int(%d)
 
-Warning: fwrite(): %d is not a valid stream resource in %s on line %d
+Warning: fwrite(): supplied resource is not a valid stream resource in %s on line %d
diff --git a/ext/standard/tests/streams/stream_get_meta_data_file_error.phpt b/ext/standard/tests/streams/stream_get_meta_data_file_error.phpt
index 390694a062..c2532c714a 100644
--- a/ext/standard/tests/streams/stream_get_meta_data_file_error.phpt
+++ b/ext/standard/tests/streams/stream_get_meta_data_file_error.phpt
@@ -52,6 +52,6 @@ NULL
 
 -- Testing stream_get_meta_data() function with closed stream resource --
 
-Warning: stream_get_meta_data(): %i is not a valid stream resource in %s on line %i
+Warning: stream_get_meta_data(): supplied resource is not a valid stream resource in %s on line %i
 bool(false)
 Done
diff --git a/ext/standard/tests/streams/stream_set_timeout_error.phpt b/ext/standard/tests/streams/stream_set_timeout_error.phpt
index 814257dd93..b40b6616cf 100644
--- a/ext/standard/tests/streams/stream_set_timeout_error.phpt
+++ b/ext/standard/tests/streams/stream_set_timeout_error.phpt
@@ -67,7 +67,7 @@ NULL
 
 -- Testing stream_set_timeout() function with a closed socket --
 
-Warning: stream_set_timeout(): %i is not a valid stream resource in %s on line %i
+Warning: stream_set_timeout(): supplied resource is not a valid stream resource in %s on line %i
 bool(false)
 
 -- Testing stream_set_timeout() function with an invalid stream --
diff --git a/ext/standard/tests/strings/str_pad_variation5.phpt b/ext/standard/tests/strings/str_pad_variation5.phpt
index cd979a1c8b..d050ae80e8 100644
--- a/ext/standard/tests/strings/str_pad_variation5.phpt
+++ b/ext/standard/tests/strings/str_pad_variation5.phpt
@@ -24,7 +24,7 @@ echo "*** Testing str_pad() function: with large value for for 'pad_length' argu
 
 //defining '$input' argument
 $input = "Test string";
-$pad_length = PHP_INT_MAX;
+$pad_length = PHP_INT_MAX - 16; /* zend_string header is 16 bytes */
 var_dump( str_pad($input, $pad_length) );
 
 ?>
diff --git a/ext/standard/type.c b/ext/standard/type.c
index 15bdbb06c2..1e3572c22f 100644
--- a/ext/standard/type.c
+++ b/ext/standard/type.c
@@ -25,39 +25,39 @@
    Returns the type of the variable */
 PHP_FUNCTION(gettype)
 {
-	zval **arg;
+	zval *arg;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 
-	switch (Z_TYPE_PP(arg)) {
+	switch (Z_TYPE_P(arg)) {
 		case IS_NULL:
-			RETVAL_STRING("NULL", 1);
+			RETVAL_STRING("NULL");
 			break;
 
 		case IS_BOOL:
-			RETVAL_STRING("boolean", 1);
+			RETVAL_STRING("boolean");
 			break;
 
 		case IS_LONG:
-			RETVAL_STRING("integer", 1);
+			RETVAL_STRING("integer");
 			break;
 
 		case IS_DOUBLE:
-			RETVAL_STRING("double", 1);
+			RETVAL_STRING("double");
 			break;
 	
 		case IS_STRING:
-			RETVAL_STRING("string", 1);
+			RETVAL_STRING("string");
 			break;
 	
 		case IS_ARRAY:
-			RETVAL_STRING("array", 1);
+			RETVAL_STRING("array");
 			break;
 
 		case IS_OBJECT:
-			RETVAL_STRING("object", 1);
+			RETVAL_STRING("object");
 		/*
 		   {
 		   char *result;
@@ -72,16 +72,16 @@ PHP_FUNCTION(gettype)
 
 		case IS_RESOURCE:
 			{
-				const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
+				const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg) TSRMLS_CC);
 
 				if (type_name) {
-					RETVAL_STRING("resource", 1);
+					RETVAL_STRING("resource");
 					break;
 				}
 			}
 
 		default:
-			RETVAL_STRING("unknown type", 1);
+			RETVAL_STRING("unknown type");
 	}
 }
 /* }}} */
@@ -90,34 +90,35 @@ PHP_FUNCTION(gettype)
    Set the type of the variable */
 PHP_FUNCTION(settype)
 {
-	zval **var;
+	zval *var;
 	char *type;
 	int type_len = 0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zs", &var, &type, &type_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zs", &var, &type, &type_len) == FAILURE) {
 		return;
 	}
 
+	ZVAL_DEREF(var);
 	if (!strcasecmp(type, "integer")) {
-		convert_to_long(*var);
+		convert_to_long(var);
 	} else if (!strcasecmp(type, "int")) {
-		convert_to_long(*var);
+		convert_to_long(var);
 	} else if (!strcasecmp(type, "float")) {
-		convert_to_double(*var);
+		convert_to_double(var);
 	} else if (!strcasecmp(type, "double")) { /* deprecated */
-		convert_to_double(*var);
+		convert_to_double(var);
 	} else if (!strcasecmp(type, "string")) {
-		convert_to_string(*var);
+		convert_to_string(var);
 	} else if (!strcasecmp(type, "array")) {
-		convert_to_array(*var);
+		convert_to_array(var);
 	} else if (!strcasecmp(type, "object")) {
-		convert_to_object(*var);
+		convert_to_object(var);
 	} else if (!strcasecmp(type, "bool")) {
-		convert_to_boolean(*var);
+		convert_to_boolean(var);
 	} else if (!strcasecmp(type, "boolean")) {
-		convert_to_boolean(*var);
+		convert_to_boolean(var);
 	} else if (!strcasecmp(type, "null")) {
-		convert_to_null(*var);
+		convert_to_null(var);
 	} else if (!strcasecmp(type, "resource")) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Cannot convert to resource type");
 		RETURN_FALSE;
@@ -133,20 +134,20 @@ PHP_FUNCTION(settype)
    Get the integer value of a variable using the optional base for the conversion */
 PHP_FUNCTION(intval)
 {
-	zval **num;
+	zval *num;
 	long arg_base;
 	int base;
 
 	switch (ZEND_NUM_ARGS()) {
 		case 1:
-			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
+			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &num) == FAILURE) {
 				return;
 			}
 			base = 10;
 			break;
 
 		case 2:
-			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Zl", &num, &arg_base) == FAILURE) {
+			if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "zl", &num, &arg_base) == FAILURE) {
 				return;
 			}
 			base = arg_base;
@@ -156,7 +157,7 @@ PHP_FUNCTION(intval)
 			WRONG_PARAM_COUNT;
 	}
 
-	RETVAL_ZVAL(*num, 1, 0);
+	RETVAL_ZVAL(num, 1, 0);
 	convert_to_long_base(return_value, base);
 }
 /* }}} */
@@ -165,13 +166,13 @@ PHP_FUNCTION(intval)
    Get the float value of a variable */
 PHP_FUNCTION(floatval)
 {
-	zval **num;
+	zval *num;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &num) == FAILURE) {
 		return;
 	}
 
-	RETVAL_ZVAL(*num, 1, 0);
+	RETVAL_ZVAL(num, 1, 0);
 	convert_to_double(return_value);
 }
 /* }}} */
@@ -180,13 +181,13 @@ PHP_FUNCTION(floatval)
    Get the boolean value of a variable */
 PHP_FUNCTION(boolval)
 {
-	zval **val;
+	zval *val;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &val) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &val) == FAILURE) {
 		return;
 	}
 
-	RETURN_BOOL(zend_is_true(*val TSRMLS_CC));
+	RETURN_BOOL(zend_is_true(val TSRMLS_CC));
 }
 /* }}} */
 
@@ -194,46 +195,38 @@ PHP_FUNCTION(boolval)
    Get the string value of a variable */
 PHP_FUNCTION(strval)
 {
-	zval **num, *tmp;
-	zval expr_copy;
-	int use_copy;
-
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &num) == FAILURE) {
+	zval *num;
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &num) == FAILURE) {
 		return;
 	}
 
-	zend_make_printable_zval(*num, &expr_copy, &use_copy);
-	if (use_copy) {
-		tmp = &expr_copy;
-		RETVAL_ZVAL(tmp, 0, 0);
-	} else {
-		RETVAL_ZVAL(*num, 1, 0);
-	}
+	RETVAL_STR(zval_get_string(num));
 }
 /* }}} */
 
 static void php_is_type(INTERNAL_FUNCTION_PARAMETERS, int type)
 {
-	zval **arg;
+	zval *arg;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		RETURN_FALSE;
 	}
 
-	if (Z_TYPE_PP(arg) == type) {
+	ZVAL_DEREF(arg);
+	if (Z_TYPE_P(arg) == type) {
 		if (type == IS_OBJECT) {
 			zend_class_entry *ce;
-			if(Z_OBJ_HT_PP(arg)->get_class_entry == NULL) {
+			if(Z_OBJ_HT_P(arg)->get_class_entry == NULL) {
 			/* if there's no get_class_entry it's not a PHP object, so it can't be INCOMPLETE_CLASS */
 				RETURN_TRUE;
 			}
-			ce = Z_OBJCE_PP(arg);
-			if (!strcmp(ce->name, INCOMPLETE_CLASS)) {
+			ce = Z_OBJCE_P(arg);
+			if (!strcmp(ce->name->val, INCOMPLETE_CLASS)) {
 				RETURN_FALSE;
 			}
 		}
 		if (type == IS_RESOURCE) {
-			const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(arg) TSRMLS_CC);
+			const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(arg) TSRMLS_CC);
 			if (!type_name) {
 				RETURN_FALSE;
 			}
@@ -313,20 +306,20 @@ PHP_FUNCTION(is_object)
    Returns true if value is a number or a numeric string */
 PHP_FUNCTION(is_numeric)
 {
-	zval **arg;
+	zval *arg;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 
-	switch (Z_TYPE_PP(arg)) {
+	switch (Z_TYPE_P(arg)) {
 		case IS_LONG:
 		case IS_DOUBLE:
 			RETURN_TRUE;
 			break;
 
 		case IS_STRING:
-			if (is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), NULL, NULL, 0)) {
+			if (is_numeric_string(Z_STRVAL_P(arg), Z_STRLEN_P(arg), NULL, NULL, 0)) {
 				RETURN_TRUE;
 			} else {
 				RETURN_FALSE;
@@ -344,13 +337,13 @@ PHP_FUNCTION(is_numeric)
    Returns true if value is a scalar */
 PHP_FUNCTION(is_scalar)
 {
-	zval **arg;
+	zval *arg;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &arg) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
 		return;
 	}
 
-	switch (Z_TYPE_PP(arg)) {
+	switch (Z_TYPE_P(arg)) {
 		case IS_BOOL:
 		case IS_DOUBLE:
 		case IS_LONG:
@@ -369,14 +362,14 @@ PHP_FUNCTION(is_scalar)
    Returns true if var is callable. */
 PHP_FUNCTION(is_callable)
 {
-	zval *var, **callable_name = NULL;
-	char *name;
+	zval *var, *callable_name = NULL;
+	zend_string *name;
 	char *error;
 	zend_bool retval;
 	zend_bool syntax_only = 0;
 	int check_flags = 0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bZ", &var,
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z|bz", &var,
 							  &syntax_only, &callable_name) == FAILURE) {
 		return;
 	}
@@ -385,11 +378,18 @@ PHP_FUNCTION(is_callable)
 		check_flags |= IS_CALLABLE_CHECK_SYNTAX_ONLY;
 	}
 	if (ZEND_NUM_ARGS() > 2) {
-		retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, NULL, &error TSRMLS_CC);
-		zval_dtor(*callable_name);
-		ZVAL_STRING(*callable_name, name, 0);
+		ZVAL_DEREF(callable_name);
+		retval = zend_is_callable_ex(var, NULL, check_flags, &name, NULL, &error TSRMLS_CC);
+		zval_dtor(callable_name);
+		//??? is it necessary to be consistent with old PHP ("\0" support)
+		if (UNEXPECTED(name->len) != strlen(name->val)) {
+			ZVAL_STRINGL(callable_name, name->val, strlen(name->val));
+			STR_RELEASE(name);
+		} else {
+			ZVAL_STR(callable_name, name);
+		}
 	} else {
-		retval = zend_is_callable_ex(var, NULL, check_flags, NULL, NULL, NULL, &error TSRMLS_CC);
+		retval = zend_is_callable_ex(var, NULL, check_flags, NULL, NULL, &error TSRMLS_CC);
 	}
 	if (error) {
 		/* ignore errors */
diff --git a/ext/standard/uniqid.c b/ext/standard/uniqid.c
index a87bdb9c52..610fb2809c 100644
--- a/ext/standard/uniqid.c
+++ b/ext/standard/uniqid.c
@@ -81,7 +81,9 @@ PHP_FUNCTION(uniqid)
 		spprintf(&uniqid, 0, "%s%08x%05x", prefix, sec, usec);
 	}
 
-	RETURN_STRING(uniqid, 0);
+	// TODO: avoid reallocation ???
+	RETVAL_STRING(uniqid);
+	efree(uniqid);
 }
 #endif
 /* }}} */
diff --git a/ext/standard/url.c b/ext/standard/url.c
index d8271a18ed..a18c035151 100644
--- a/ext/standard/url.c
+++ b/ext/standard/url.c
@@ -193,12 +193,12 @@ PHPAPI php_url *php_url_parse_ex(char const *str, int length)
 			if (port > 0 && port <= 65535) {
 				ret->port = (unsigned short) port;
 			} else {
-				STR_FREE(ret->scheme);
+				if (ret->scheme) efree(ret->scheme);
 				efree(ret);
 				return NULL;
 			}
 		} else if (p == pp && *pp == '\0') {
-			STR_FREE(ret->scheme);
+			if (ret->scheme) efree(ret->scheme);
 			efree(ret);
 			return NULL;
 		} else if (*s == '/' && *(s+1) == '/') { /* relative-scheme URL */
@@ -274,9 +274,9 @@ PHPAPI php_url *php_url_parse_ex(char const *str, int length)
 		if (!ret->port) {
 			p++;
 			if (e-p > 5) { /* port cannot be longer then 5 characters */
-				STR_FREE(ret->scheme);
-				STR_FREE(ret->user);
-				STR_FREE(ret->pass);
+				if (ret->scheme) efree(ret->scheme);
+				if (ret->user) efree(ret->user);
+				if (ret->pass) efree(ret->pass);
 				efree(ret);
 				return NULL;
 			} else if (e - p > 0) {
@@ -287,9 +287,9 @@ PHPAPI php_url *php_url_parse_ex(char const *str, int length)
 				if (port > 0 && port <= 65535) {
 					ret->port = (unsigned short)port;
 				} else {
-					STR_FREE(ret->scheme);
-					STR_FREE(ret->user);
-					STR_FREE(ret->pass);
+					if (ret->scheme) efree(ret->scheme);
+					if (ret->user) efree(ret->user);
+					if (ret->pass) efree(ret->pass);
 					efree(ret);
 					return NULL;
 				}
@@ -302,9 +302,9 @@ PHPAPI php_url *php_url_parse_ex(char const *str, int length)
 	
 	/* check if we have a valid host, if we don't reject the string as url */
 	if ((p-s) < 1) {
-		STR_FREE(ret->scheme);
-		STR_FREE(ret->user);
-		STR_FREE(ret->pass);
+		if (ret->scheme) efree(ret->scheme);
+		if (ret->user) efree(ret->user);
+		if (ret->pass) efree(ret->pass);
 		efree(ret);
 		return NULL;
 	}
@@ -392,28 +392,28 @@ PHP_FUNCTION(parse_url)
 	if (key > -1) {
 		switch (key) {
 			case PHP_URL_SCHEME:
-				if (resource->scheme != NULL) RETVAL_STRING(resource->scheme, 1);
+				if (resource->scheme != NULL) RETVAL_STRING(resource->scheme);
 				break;
 			case PHP_URL_HOST:
-				if (resource->host != NULL) RETVAL_STRING(resource->host, 1);
+				if (resource->host != NULL) RETVAL_STRING(resource->host);
 				break;
 			case PHP_URL_PORT:
 				if (resource->port != 0) RETVAL_LONG(resource->port);
 				break;
 			case PHP_URL_USER:
-				if (resource->user != NULL) RETVAL_STRING(resource->user, 1);
+				if (resource->user != NULL) RETVAL_STRING(resource->user);
 				break;
 			case PHP_URL_PASS:
-				if (resource->pass != NULL) RETVAL_STRING(resource->pass, 1);
+				if (resource->pass != NULL) RETVAL_STRING(resource->pass);
 				break;
 			case PHP_URL_PATH:
-				if (resource->path != NULL) RETVAL_STRING(resource->path, 1);
+				if (resource->path != NULL) RETVAL_STRING(resource->path);
 				break;
 			case PHP_URL_QUERY:
-				if (resource->query != NULL) RETVAL_STRING(resource->query, 1);
+				if (resource->query != NULL) RETVAL_STRING(resource->query);
 				break;
 			case PHP_URL_FRAGMENT:
-				if (resource->fragment != NULL) RETVAL_STRING(resource->fragment, 1);
+				if (resource->fragment != NULL) RETVAL_STRING(resource->fragment);
 				break;
 			default:
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid URL component identifier %ld", key);
@@ -427,21 +427,21 @@ PHP_FUNCTION(parse_url)
 
     /* add the various elements to the array */
 	if (resource->scheme != NULL)
-		add_assoc_string(return_value, "scheme", resource->scheme, 1);
+		add_assoc_string(return_value, "scheme", resource->scheme);
 	if (resource->host != NULL)
-		add_assoc_string(return_value, "host", resource->host, 1);
+		add_assoc_string(return_value, "host", resource->host);
 	if (resource->port != 0)
 		add_assoc_long(return_value, "port", resource->port);
 	if (resource->user != NULL)
-		add_assoc_string(return_value, "user", resource->user, 1);
+		add_assoc_string(return_value, "user", resource->user);
 	if (resource->pass != NULL)
-		add_assoc_string(return_value, "pass", resource->pass, 1);
+		add_assoc_string(return_value, "pass", resource->pass);
 	if (resource->path != NULL)
-		add_assoc_string(return_value, "path", resource->path, 1);
+		add_assoc_string(return_value, "path", resource->path);
 	if (resource->query != NULL)
-		add_assoc_string(return_value, "query", resource->query, 1);
+		add_assoc_string(return_value, "query", resource->query);
 	if (resource->fragment != NULL)
-		add_assoc_string(return_value, "fragment", resource->fragment, 1);
+		add_assoc_string(return_value, "fragment", resource->fragment);
 done:	
 	php_url_free(resource);
 }
@@ -485,15 +485,17 @@ static unsigned char hexchars[] = "0123456789ABCDEF";
 
 /* {{{ php_url_encode
  */
-PHPAPI char *php_url_encode(char const *s, int len, int *new_length)
+PHPAPI zend_string *php_url_encode(char const *s, int len)
 {
 	register unsigned char c;
-	unsigned char *to, *start;
+	unsigned char *to;
 	unsigned char const *from, *end;
+	zend_string *start;
 	
 	from = (unsigned char *)s;
 	end = (unsigned char *)s + len;
-	start = to = (unsigned char *) safe_emalloc(3, len, 1);
+	start = STR_ALLOC(3 * len, 0);
+	to = (unsigned char*)start->val;
 
 	while (from < end) {
 		c = *from++;
@@ -521,11 +523,11 @@ PHPAPI char *php_url_encode(char const *s, int len, int *new_length)
 			*to++ = c;
 		}
 	}
-	*to = 0;
-	if (new_length) {
-		*new_length = to - start;
-	}
-	return (char *) start;
+	*to = '\0';
+
+	start = STR_REALLOC(start, to - (unsigned char*)start->val, 0);
+
+	return start;
 }
 /* }}} */
 
@@ -533,16 +535,13 @@ PHPAPI char *php_url_encode(char const *s, int len, int *new_length)
    URL-encodes string */
 PHP_FUNCTION(urlencode)
 {
-	char *in_str, *out_str;
-	int in_str_len, out_str_len;
+	zend_string *in_str;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &in_str,
-							  &in_str_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
 		return;
 	}
 
-	out_str = php_url_encode(in_str, in_str_len, &out_str_len);
-	RETURN_STRINGL(out_str, out_str_len, 0);
+	RETURN_STR(php_url_encode(in_str->val, in_str->len));
 }
 /* }}} */
 
@@ -550,18 +549,16 @@ PHP_FUNCTION(urlencode)
    Decodes URL-encoded string */
 PHP_FUNCTION(urldecode)
 {
-	char *in_str, *out_str;
-	int in_str_len, out_str_len;
+	zend_string *in_str, *out_str;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &in_str,
-							  &in_str_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
 		return;
 	}
 
-	out_str = estrndup(in_str, in_str_len);
-	out_str_len = php_url_decode(out_str, in_str_len);
+	out_str = STR_INIT(in_str->val, in_str->len, 0);
+	out_str->len = php_url_decode(out_str->val, out_str->len);
 
-    RETURN_STRINGL(out_str, out_str_len, 0);
+    RETURN_NEW_STR(out_str);
 }
 /* }}} */
 
@@ -598,35 +595,34 @@ PHPAPI int php_url_decode(char *str, int len)
 
 /* {{{ php_raw_url_encode
  */
-PHPAPI char *php_raw_url_encode(char const *s, int len, int *new_length)
+PHPAPI zend_string *php_raw_url_encode(char const *s, int len)
 {
 	register int x, y;
-	unsigned char *str;
+	zend_string *str;
 
-	str = (unsigned char *) safe_emalloc(3, len, 1);
+	str = STR_ALLOC(3 * len, 0);
 	for (x = 0, y = 0; len--; x++, y++) {
-		str[y] = (unsigned char) s[x];
+		str->val[y] = (unsigned char) s[x];
 #ifndef CHARSET_EBCDIC
-		if ((str[y] < '0' && str[y] != '-' && str[y] != '.') ||
-			(str[y] < 'A' && str[y] > '9') ||
-			(str[y] > 'Z' && str[y] < 'a' && str[y] != '_') ||
-			(str[y] > 'z' && str[y] != '~')) {
-			str[y++] = '%';
-			str[y++] = hexchars[(unsigned char) s[x] >> 4];
-			str[y] = hexchars[(unsigned char) s[x] & 15];
+		if ((str->val[y] < '0' && str->val[y] != '-' && str->val[y] != '.') ||
+			(str->val[y] < 'A' && str->val[y] > '9') ||
+			(str->val[y] > 'Z' && str->val[y] < 'a' && str->val[y] != '_') ||
+			(str->val[y] > 'z' && str->val[y] != '~')) {
+			str->val[y++] = '%';
+			str->val[y++] = hexchars[(unsigned char) s[x] >> 4];
+			str->val[y] = hexchars[(unsigned char) s[x] & 15];
 #else /*CHARSET_EBCDIC*/
-		if (!isalnum(str[y]) && strchr("_-.~", str[y]) != NULL) {
-			str[y++] = '%';
-			str[y++] = hexchars[os_toascii[(unsigned char) s[x]] >> 4];
-			str[y] = hexchars[os_toascii[(unsigned char) s[x]] & 15];
+		if (!isalnum(str->val[y]) && str->valchr("_-.~", str->val[y]) != NULL) {
+			str->val[y++] = '%';
+			str->val[y++] = hexchars[os_toascii[(unsigned char) s[x]] >> 4];
+			str->val[y] = hexchars[os_toascii[(unsigned char) s[x]] & 15];
 #endif /*CHARSET_EBCDIC*/
 		}
 	}
-	str[y] = '\0';
-	if (new_length) {
-		*new_length = y;
-	}
-	return ((char *) str);
+	str->val[y] = '\0';
+	str = STR_REALLOC(str, y, 0);
+
+	return str;
 }
 /* }}} */
 
@@ -634,16 +630,13 @@ PHPAPI char *php_raw_url_encode(char const *s, int len, int *new_length)
    URL-encodes string */
 PHP_FUNCTION(rawurlencode)
 {
-	char *in_str, *out_str;
-	int in_str_len, out_str_len;
+	zend_string *in_str;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &in_str,
-							  &in_str_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
 		return;
 	}
 
-	out_str = php_raw_url_encode(in_str, in_str_len, &out_str_len);
-	RETURN_STRINGL(out_str, out_str_len, 0);
+	RETURN_STR(php_raw_url_encode(in_str->val, in_str->len));
 }
 /* }}} */
 
@@ -651,18 +644,16 @@ PHP_FUNCTION(rawurlencode)
    Decodes URL-encodes string */
 PHP_FUNCTION(rawurldecode)
 {
-	char *in_str, *out_str;
-	int in_str_len, out_str_len;
+	zend_string *in_str, *out_str;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &in_str,
-							  &in_str_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &in_str) == FAILURE) {
 		return;
 	}
 
-	out_str = estrndup(in_str, in_str_len);
-	out_str_len = php_raw_url_decode(out_str, in_str_len);
+	out_str = STR_INIT(in_str->val, in_str->len, 0);
+	out_str->len = php_raw_url_decode(out_str->val, out_str->len);
 
-    RETURN_STRINGL(out_str, out_str_len, 0);
+    RETURN_NEW_STR(out_str);
 }
 /* }}} */
 
@@ -702,8 +693,7 @@ PHP_FUNCTION(get_headers)
 	int url_len;
 	php_stream_context *context;
 	php_stream *stream;
-	zval **prev_val, **hdr = NULL, **h;
-	HashPosition pos;
+	zval *prev_val, *hdr = NULL, *h;
 	HashTable *hashT;
 	long format = 0;
                 
@@ -716,7 +706,7 @@ PHP_FUNCTION(get_headers)
 		RETURN_FALSE;
 	}
 
-	if (!stream->wrapperdata || Z_TYPE_P(stream->wrapperdata) != IS_ARRAY) {
+	if (Z_TYPE(stream->wrapperdata) != IS_ARRAY) {
 		php_stream_close(stream);
 		RETURN_FALSE;
 	}
@@ -724,31 +714,29 @@ PHP_FUNCTION(get_headers)
 	array_init(return_value);
 
 	/* check for curl-wrappers that provide headers via a special "headers" element */
-	if (zend_hash_find(HASH_OF(stream->wrapperdata), "headers", sizeof("headers"), (void **)&h) != FAILURE && Z_TYPE_PP(h) == IS_ARRAY) {
+	if ((h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1)) != NULL && Z_TYPE_P(h) == IS_ARRAY) {
 		/* curl-wrappers don't load data until the 1st read */ 
-		if (!Z_ARRVAL_PP(h)->nNumOfElements) {
+		if (!Z_ARRVAL_P(h)->nNumOfElements) {
 			php_stream_getc(stream);
 		}
-		zend_hash_find(HASH_OF(stream->wrapperdata), "headers", sizeof("headers"), (void **)&h);
-		hashT = Z_ARRVAL_PP(h);	
+		h = zend_hash_str_find(HASH_OF(&stream->wrapperdata), "headers", sizeof("headers")-1);
+		hashT = Z_ARRVAL_P(h);	
 	} else {
-		hashT = HASH_OF(stream->wrapperdata);
+		hashT = HASH_OF(&stream->wrapperdata);
 	}
 
-	zend_hash_internal_pointer_reset_ex(hashT, &pos);
-	while (zend_hash_get_current_data_ex(hashT, (void**)&hdr, &pos) != FAILURE) {
-		if (!hdr || Z_TYPE_PP(hdr) != IS_STRING) {
-			zend_hash_move_forward_ex(hashT, &pos);
+	ZEND_HASH_FOREACH_VAL(hashT, hdr) {
+		if (Z_TYPE_P(hdr) != IS_STRING) {
 			continue;
 		}
 		if (!format) {
 no_name_header:
-			add_next_index_stringl(return_value, Z_STRVAL_PP(hdr), Z_STRLEN_PP(hdr), 1);
+			add_next_index_str(return_value, STR_COPY(Z_STR_P(hdr)));
 		} else {
 			char c;
 			char *s, *p;
 
-			if ((p = strchr(Z_STRVAL_PP(hdr), ':'))) {
+			if ((p = strchr(Z_STRVAL_P(hdr), ':'))) {
 				c = *p;
 				*p = '\0';
 				s = p + 1;
@@ -756,11 +744,11 @@ no_name_header:
 					s++;
 				}
 
-				if (zend_hash_find(HASH_OF(return_value), Z_STRVAL_PP(hdr), (p - Z_STRVAL_PP(hdr) + 1), (void **) &prev_val) == FAILURE) {
-					add_assoc_stringl_ex(return_value, Z_STRVAL_PP(hdr), (p - Z_STRVAL_PP(hdr) + 1), s, (Z_STRLEN_PP(hdr) - (s - Z_STRVAL_PP(hdr))), 1);
+				if ((prev_val = zend_hash_str_find(HASH_OF(return_value), Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr)))) == NULL) {
+					add_assoc_stringl_ex(return_value, Z_STRVAL_P(hdr), (p - Z_STRVAL_P(hdr) + 1), s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
 				} else { /* some headers may occur more then once, therefor we need to remake the string into an array */
-					convert_to_array(*prev_val);
-					add_next_index_stringl(*prev_val, s, (Z_STRLEN_PP(hdr) - (s - Z_STRVAL_PP(hdr))), 1);
+					convert_to_array(prev_val);
+					add_next_index_stringl(prev_val, s, (Z_STRLEN_P(hdr) - (s - Z_STRVAL_P(hdr))));
 				}
 
 				*p = c;
@@ -768,8 +756,7 @@ no_name_header:
 				goto no_name_header;
 			}
 		}
-		zend_hash_move_forward_ex(hashT, &pos);
-	}
+	} ZEND_HASH_FOREACH_END();
 
 	php_stream_close(stream);
 }
diff --git a/ext/standard/url.h b/ext/standard/url.h
index 89b4b39cf9..d23f0a1f17 100644
--- a/ext/standard/url.h
+++ b/ext/standard/url.h
@@ -36,8 +36,8 @@ PHPAPI php_url *php_url_parse(char const *str);
 PHPAPI php_url *php_url_parse_ex(char const *str, int length);
 PHPAPI int php_url_decode(char *str, int len); /* return value: length of decoded string */
 PHPAPI int php_raw_url_decode(char *str, int len); /* return value: length of decoded string */
-PHPAPI char *php_url_encode(char const *s, int len, int *new_length);
-PHPAPI char *php_raw_url_encode(char const *s, int len, int *new_length);
+PHPAPI zend_string *php_url_encode(char const *s, int len);
+PHPAPI zend_string *php_raw_url_encode(char const *s, int len);
 
 PHP_FUNCTION(parse_url);
 PHP_FUNCTION(urlencode);
diff --git a/ext/standard/url_scanner_ex.c b/ext/standard/url_scanner_ex.c
index 8a5409341b..23b1f3fb70 100644
--- a/ext/standard/url_scanner_ex.c
+++ b/ext/standard/url_scanner_ex.c
@@ -4,7 +4,7 @@
   +----------------------------------------------------------------------+
   | PHP Version 5                                                        |
   +----------------------------------------------------------------------+
-  | Copyright (c) 1997-2014 The PHP Group                                |
+  | Copyright (c) 1997-2013 The PHP Group                                |
   +----------------------------------------------------------------------+
   | This source file is subject to version 3.01 of the PHP license,      |
   | that is bundled with this package in the file LICENSE, and is        |
@@ -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;
@@ -82,7 +87,7 @@ static PHP_INI_MH(OnUpdateTags)
 			keylen = q - key;
 			/* key is stored withOUT NUL
 			   val is stored WITH    NUL */
-			zend_hash_add(ctx->tags, key, keylen, val, strlen(val)+1, NULL);
+			zend_hash_str_add_mem(ctx->tags, key, keylen, val, strlen(val)+1);
 		}
 	}
 
@@ -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
@@ -110,11 +115,11 @@ static inline void append_modified_url(smart_str *url, smart_str *dest, smart_st
 	const char *bash = NULL;
 	const char *sep = "?";
 	
-	q = (p = url->c) + url->len;
+	q = (p = url->s->val) + url->s->len;
 
 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,22 +185,22 @@ 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:
 	
 	/* Don't modify URLs of the format "#mark" */
-	if (bash && bash - url->c == 0) {
+	if (bash && bash - url->s->val == 0) {
 		smart_str_append(dest, url);
 		return;
 	}
 
 	if (bash)
-		smart_str_appendl(dest, url->c, bash - url->c);
+		smart_str_appendl(dest, url->s->val, bash - url->s->val);
 	else
 		smart_str_append(dest, url);
 
@@ -217,7 +222,7 @@ static inline void tag_arg(url_adapt_state_ex_t *ctx, char quotes, char type TSR
 {
 	char f = 0;
 
-	if (strncasecmp(ctx->arg.c, ctx->lookup_data, ctx->arg.len) == 0)
+	if (strncasecmp(ctx->arg.s->val, ctx->lookup_data, ctx->arg.s->len) == 0)
 		f = 1;
 
 	if (quotes)
@@ -271,18 +276,18 @@ static void handle_form(STD_PARA)
 {
 	int doit = 0;
 
-	if (ctx->form_app.len > 0) {
-		switch (ctx->tag.len) {
+	if (ctx->form_app.s->len > 0) {
+		switch (ctx->tag.s->len) {
 			case sizeof("form") - 1:
-				if (!strncasecmp(ctx->tag.c, "form", sizeof("form") - 1)) {
+				if (!strncasecmp(ctx->tag.s->val, "form", sizeof("form") - 1)) {
 					doit = 1;		
 				}
-				if (doit && ctx->val.c && ctx->lookup_data && *ctx->lookup_data) {
-					char *e, *p = zend_memnstr(ctx->val.c, "://", sizeof("://") - 1, ctx->val.c + ctx->val.len);
+				if (doit && ctx->val.s && ctx->lookup_data && *ctx->lookup_data) {
+					char *e, *p = (char *)zend_memnstr(ctx->val.s->val, "://", sizeof("://") - 1, ctx->val.s->val + ctx->val.s->len);
 					if (p) {
-						e = memchr(p, '/', (ctx->val.c + ctx->val.len) - p);
+						e = memchr(p, '/', (ctx->val.s->val + ctx->val.s->len) - p);
 						if (!e) {
-							e = ctx->val.c + ctx->val.len;
+							e = ctx->val.s->val + ctx->val.s->len;
 						}
 						if ((e - p) && strncasecmp(p, ctx->lookup_data, (e - p))) {
 							doit = 0;
@@ -292,7 +297,7 @@ static void handle_form(STD_PARA)
 				break;
 
 			case sizeof("fieldset") - 1:
-				if (!strncasecmp(ctx->tag.c, "fieldset", sizeof("fieldset") - 1)) {
+				if (!strncasecmp(ctx->tag.s->val, "fieldset", sizeof("fieldset") - 1)) {
 					doit = 1;		
 				}
 				break;
@@ -315,18 +320,23 @@ static inline void handle_tag(STD_PARA)
 	int ok = 0;
 	unsigned int i;
 
-	ctx->tag.len = 0;
+	if (ctx->tag.s) {
+		ctx->tag.s->len = 0;
+	}
 	smart_str_appendl(&ctx->tag, start, YYCURSOR - start);
-	for (i = 0; i < ctx->tag.len; i++)
-		ctx->tag.c[i] = tolower((int)(unsigned char)ctx->tag.c[i]);
-	if (zend_hash_find(ctx->tags, ctx->tag.c, ctx->tag.len, (void **) &ctx->lookup_data) == SUCCESS)
+	for (i = 0; i < ctx->tag.s->len; i++)
+		ctx->tag.s->val[i] = tolower((int)(unsigned char)ctx->tag.s->val[i]);
+    /* intentionally using str_find here, in case the hash value is set, but the string val is changed later */
+	if ((ctx->lookup_data = zend_hash_str_find_ptr(ctx->tags, ctx->tag.s->val, ctx->tag.s->len)) != NULL)
 		ok = 1;
 	STATE = ok ? STATE_NEXT_ARG : STATE_PLAIN;
 }
 
 static inline void handle_arg(STD_PARA) 
 {
-	ctx->arg.len = 0;
+	if (ctx->arg.s) {
+		ctx->arg.s->len = 0;
+	}
 	smart_str_appendl(&ctx->arg, start, YYCURSOR - start);
 }
 
@@ -345,8 +355,8 @@ static inline void xx_mainloop(url_adapt_state_ex_t *ctx, const char *newdata, s
 
 	smart_str_appendl(&ctx->buf, newdata, newlen);
 	
-	YYCURSOR = ctx->buf.c;
-	YYLIMIT = ctx->buf.c + ctx->buf.len;
+	YYCURSOR = ctx->buf.s->val;
+	YYLIMIT = ctx->buf.s->val + ctx->buf.s->len;
 
 	switch (STATE) {
 		case STATE_PLAIN: goto state_plain;
@@ -364,7 +374,7 @@ state_plain_begin:
 state_plain:
 	start = YYCURSOR;
 
-#line 368 "ext/standard/url_scanner_ex.c"
+#line 378 "ext/standard/url_scanner_ex.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -407,9 +417,9 @@ state_plain:
 		goto yy15;
 	}
 	++YYCURSOR;
-#line 303 "ext/standard/url_scanner_ex.re"
+#line 313 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); STATE = STATE_TAG; goto state_tag; }
-#line 413 "ext/standard/url_scanner_ex.c"
+#line 423 "ext/standard/url_scanner_ex.c"
 yy15:
 	++YYCURSOR;
 	if (YYLIMIT <= YYCURSOR) YYFILL(1);
@@ -417,17 +427,17 @@ yy15:
 	if (yybm[0+yych] & 128) {
 		goto yy15;
 	}
-#line 304 "ext/standard/url_scanner_ex.re"
+#line 314 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); goto state_plain; }
-#line 423 "ext/standard/url_scanner_ex.c"
+#line 433 "ext/standard/url_scanner_ex.c"
 }
-#line 305 "ext/standard/url_scanner_ex.re"
+#line 315 "ext/standard/url_scanner_ex.re"
 
 
 state_tag:	
 	start = YYCURSOR;
 
-#line 431 "ext/standard/url_scanner_ex.c"
+#line 441 "ext/standard/url_scanner_ex.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -478,14 +488,14 @@ yy20:
 	yych = *YYCURSOR;
 	goto yy25;
 yy21:
-#line 310 "ext/standard/url_scanner_ex.re"
+#line 320 "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 494 "ext/standard/url_scanner_ex.c"
 yy22:
 	++YYCURSOR;
-#line 311 "ext/standard/url_scanner_ex.re"
+#line 321 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); goto state_plain_begin; }
-#line 489 "ext/standard/url_scanner_ex.c"
+#line 499 "ext/standard/url_scanner_ex.c"
 yy24:
 	++YYCURSOR;
 	if (YYLIMIT <= YYCURSOR) YYFILL(1);
@@ -496,7 +506,7 @@ yy25:
 	}
 	goto yy21;
 }
-#line 312 "ext/standard/url_scanner_ex.re"
+#line 322 "ext/standard/url_scanner_ex.re"
 
 
 state_next_arg_begin:
@@ -505,7 +515,7 @@ state_next_arg_begin:
 state_next_arg:
 	start = YYCURSOR;
 
-#line 509 "ext/standard/url_scanner_ex.c"
+#line 519 "ext/standard/url_scanner_ex.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -570,28 +580,28 @@ yy28:
 	++YYCURSOR;
 	if ((yych = *YYCURSOR) == '>') goto yy39;
 yy29:
-#line 323 "ext/standard/url_scanner_ex.re"
+#line 333 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); goto state_plain_begin; }
-#line 576 "ext/standard/url_scanner_ex.c"
+#line 586 "ext/standard/url_scanner_ex.c"
 yy30:
 	++YYCURSOR;
 yy31:
-#line 320 "ext/standard/url_scanner_ex.re"
+#line 330 "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 592 "ext/standard/url_scanner_ex.c"
 yy32:
 	++YYCURSOR;
 	yych = *YYCURSOR;
 	goto yy38;
 yy33:
-#line 321 "ext/standard/url_scanner_ex.re"
+#line 331 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); goto state_next_arg; }
-#line 590 "ext/standard/url_scanner_ex.c"
+#line 600 "ext/standard/url_scanner_ex.c"
 yy34:
 	++YYCURSOR;
-#line 322 "ext/standard/url_scanner_ex.re"
+#line 332 "ext/standard/url_scanner_ex.re"
 	{ --YYCURSOR; STATE = STATE_ARG; goto state_arg; }
-#line 595 "ext/standard/url_scanner_ex.c"
+#line 605 "ext/standard/url_scanner_ex.c"
 yy36:
 	yych = *++YYCURSOR;
 	goto yy29;
@@ -609,13 +619,13 @@ yy39:
 	yych = *YYCURSOR;
 	goto yy31;
 }
-#line 324 "ext/standard/url_scanner_ex.re"
+#line 334 "ext/standard/url_scanner_ex.re"
 
 
 state_arg:
 	start = YYCURSOR;
 
-#line 619 "ext/standard/url_scanner_ex.c"
+#line 629 "ext/standard/url_scanner_ex.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -663,14 +673,14 @@ yy42:
 	yych = *YYCURSOR;
 	goto yy47;
 yy43:
-#line 329 "ext/standard/url_scanner_ex.re"
+#line 339 "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 679 "ext/standard/url_scanner_ex.c"
 yy44:
 	++YYCURSOR;
-#line 330 "ext/standard/url_scanner_ex.re"
+#line 340 "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 684 "ext/standard/url_scanner_ex.c"
 yy46:
 	++YYCURSOR;
 	if (YYLIMIT <= YYCURSOR) YYFILL(1);
@@ -681,13 +691,13 @@ yy47:
 	}
 	goto yy43;
 }
-#line 331 "ext/standard/url_scanner_ex.re"
+#line 341 "ext/standard/url_scanner_ex.re"
 
 
 state_before_val:
 	start = YYCURSOR;
 
-#line 691 "ext/standard/url_scanner_ex.c"
+#line 701 "ext/standard/url_scanner_ex.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -734,17 +744,17 @@ yy50:
 	if (yych == ' ') goto yy57;
 	if (yych == '=') goto yy55;
 yy51:
-#line 337 "ext/standard/url_scanner_ex.re"
+#line 347 "ext/standard/url_scanner_ex.re"
 	{ --YYCURSOR; goto state_next_arg_begin; }
-#line 740 "ext/standard/url_scanner_ex.c"
+#line 750 "ext/standard/url_scanner_ex.c"
 yy52:
 	++YYCURSOR;
 	yych = *YYCURSOR;
 	goto yy56;
 yy53:
-#line 336 "ext/standard/url_scanner_ex.re"
+#line 346 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); STATE = STATE_VAL; goto state_val; }
-#line 748 "ext/standard/url_scanner_ex.c"
+#line 758 "ext/standard/url_scanner_ex.c"
 yy54:
 	yych = *++YYCURSOR;
 	goto yy51;
@@ -766,14 +776,14 @@ yy57:
 	YYCURSOR = YYMARKER;
 	goto yy51;
 }
-#line 338 "ext/standard/url_scanner_ex.re"
+#line 348 "ext/standard/url_scanner_ex.re"
 
 
 
 state_val:
 	start = YYCURSOR;
 
-#line 777 "ext/standard/url_scanner_ex.c"
+#line 787 "ext/standard/url_scanner_ex.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -834,9 +844,9 @@ state_val:
 	yych = *(YYMARKER = ++YYCURSOR);
 	if (yych != '>') goto yy76;
 yy63:
-#line 347 "ext/standard/url_scanner_ex.re"
+#line 357 "ext/standard/url_scanner_ex.re"
 	{ passthru(STD_ARGS); goto state_next_arg_begin; }
-#line 840 "ext/standard/url_scanner_ex.c"
+#line 850 "ext/standard/url_scanner_ex.c"
 yy64:
 	yych = *(YYMARKER = ++YYCURSOR);
 	if (yych == '>') goto yy63;
@@ -846,9 +856,9 @@ yy65:
 	yych = *YYCURSOR;
 	goto yy69;
 yy66:
-#line 346 "ext/standard/url_scanner_ex.re"
+#line 356 "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 862 "ext/standard/url_scanner_ex.c"
 yy67:
 	yych = *++YYCURSOR;
 	goto yy63;
@@ -875,9 +885,9 @@ yy72:
 	goto yy63;
 yy73:
 	++YYCURSOR;
-#line 345 "ext/standard/url_scanner_ex.re"
+#line 355 "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 891 "ext/standard/url_scanner_ex.c"
 yy75:
 	++YYCURSOR;
 	if (YYLIMIT <= YYCURSOR) YYFILL(1);
@@ -888,11 +898,11 @@ yy76:
 	}
 	if (yych >= '>') goto yy72;
 	++YYCURSOR;
-#line 344 "ext/standard/url_scanner_ex.re"
+#line 354 "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 904 "ext/standard/url_scanner_ex.c"
 }
-#line 348 "ext/standard/url_scanner_ex.re"
+#line 358 "ext/standard/url_scanner_ex.re"
 
 
 stop:
@@ -901,12 +911,13 @@ stop:
 	/* XXX: Crash avoidance. Need to work with reporter to figure out what goes wrong */	
 	if (rest < 0) rest = 0;
 	
-	if (rest) memmove(ctx->buf.c, start, rest);
-	ctx->buf.len = rest;
+	if (rest) memmove(ctx->buf.s->val, start, rest);
+	ctx->buf.s->len = rest;
 }
 
 char *php_url_scanner_adapt_single_url(const char *url, size_t urllen, const char *name, const char *value, size_t *newlen TSRMLS_DC)
 {
+	char *result;
 	smart_str surl = {0};
 	smart_str buf = {0};
 	smart_str url_app = {0};
@@ -920,11 +931,13 @@ char *php_url_scanner_adapt_single_url(const char *url, size_t urllen, const cha
 	append_modified_url(&surl, &buf, &url_app, PG(arg_separator).output);
 
 	smart_str_0(&buf);
-	if (newlen) *newlen = buf.len;
+	if (newlen) *newlen = buf.s->len;
+	result = estrndup(buf.s->val, buf.s->len);
 
 	smart_str_free(&url_app);
+	smart_str_free(&buf);
 
-	return buf.c;
+	return result;
 }
 
 
@@ -937,19 +950,21 @@ static char *url_adapt_ext(const char *src, size_t srclen, size_t *newlen, zend_
 
 	xx_mainloop(ctx, src, srclen TSRMLS_CC);
 
-	*newlen = ctx->result.len;
-	if (!ctx->result.c) {
+	if (!ctx->result.s) {
 		smart_str_appendl(&ctx->result, "", 0);
+		*newlen = 0;
+	} else {
+		*newlen = ctx->result.s->len;
 	}
 	smart_str_0(&ctx->result);
 	if (do_flush) {
-		smart_str_appendl(&ctx->result, ctx->buf.c, ctx->buf.len);
-		*newlen += ctx->buf.len;
+		smart_str_appendl(&ctx->result, ctx->buf.s->val, ctx->buf.s->len);
+		*newlen += ctx->buf.s->len;
 		smart_str_free(&ctx->buf);
+		smart_str_free(&ctx->val);
 	}
-	retval = ctx->result.c;
-	ctx->result.c = NULL;
-	ctx->result.len = 0;
+	retval = estrndup(ctx->result.s->val, ctx->result.s->len);
+	smart_str_free(&ctx->result);
 	return retval;
 }
 
@@ -982,25 +997,24 @@ static void php_url_scanner_output_handler(char *output, uint output_len, char *
 {
 	size_t len;
 
-	if (BG(url_adapt_state_ex).url_app.len != 0) {
+	if (BG(url_adapt_state_ex).url_app.s->len != 0) {
 		*handled_output = url_adapt_ext(output, output_len, &len, (zend_bool) (mode & (PHP_OUTPUT_HANDLER_END | PHP_OUTPUT_HANDLER_CONT | PHP_OUTPUT_HANDLER_FLUSH | PHP_OUTPUT_HANDLER_FINAL) ? 1 : 0) TSRMLS_CC);
 		if (sizeof(uint) < sizeof(size_t)) {
 			if (len > UINT_MAX)
 				len = UINT_MAX;
 		}
 		*handled_output_len = len;
-	} else if (BG(url_adapt_state_ex).url_app.len == 0) {
+	} else if (BG(url_adapt_state_ex).url_app.s->len == 0) {
 		url_adapt_state_ex_t *ctx = &BG(url_adapt_state_ex);
-		if (ctx->buf.len) {
-			smart_str_appendl(&ctx->result, ctx->buf.c, ctx->buf.len);
+		if (ctx->buf.s && ctx->buf.s->len) {
+			smart_str_appendl(&ctx->result, ctx->buf.s->val, ctx->buf.s->len);
 			smart_str_appendl(&ctx->result, output, output_len);
 
-			*handled_output = ctx->result.c;
-			*handled_output_len = ctx->buf.len + output_len;
+			*handled_output = estrndup(ctx->result.s->val, ctx->result.s->len);
+			*handled_output_len = ctx->buf.s->len + output_len;
 
-			ctx->result.c = NULL;
-			ctx->result.len = 0;
 			smart_str_free(&ctx->buf);
+			smart_str_free(&ctx->result);
 		} else {
 			*handled_output = estrndup(output, *handled_output_len = output_len);
 		}
@@ -1011,24 +1025,23 @@ static void php_url_scanner_output_handler(char *output, uint output_len, char *
 
 PHPAPI int php_url_scanner_add_var(char *name, int name_len, char *value, int value_len, int urlencode TSRMLS_DC)
 {
-	char *encoded = NULL;
-	int encoded_len;
-	smart_str val;
+	smart_str val = {0};
+	zend_string *encoded;
 	
-	if (! BG(url_adapt_state_ex).active) {
+	if (!BG(url_adapt_state_ex).active) {
 		php_url_scanner_ex_activate(TSRMLS_C);
 		php_output_start_internal(ZEND_STRL("URL-Rewriter"), php_url_scanner_output_handler, 0, PHP_OUTPUT_HANDLER_STDFLAGS TSRMLS_CC);
 		BG(url_adapt_state_ex).active = 1;
 	}
 
 
-	if (BG(url_adapt_state_ex).url_app.len != 0) {
+	if (BG(url_adapt_state_ex).url_app.s && BG(url_adapt_state_ex).url_app.s->len != 0) {
 		smart_str_appends(&BG(url_adapt_state_ex).url_app, PG(arg_separator).output);
 	}
 
 	if (urlencode) {
-		encoded = php_url_encode(value, value_len, &encoded_len);
-		smart_str_setl(&val, encoded, encoded_len);
+		encoded = php_url_encode(value, value_len);
+		smart_str_setl(&val, encoded->val, encoded->len);
 	} else {
 		smart_str_setl(&val, value, value_len);
 	}
@@ -1043,16 +1056,22 @@ PHPAPI int php_url_scanner_add_var(char *name, int name_len, char *value, int va
 	smart_str_append(&BG(url_adapt_state_ex).form_app, &val);
 	smart_str_appends(&BG(url_adapt_state_ex).form_app, "\" />");
 
-	if (urlencode)
-		efree(encoded);
+	if (urlencode) {
+		STR_FREE(encoded);
+	}
+	smart_str_free(&val);
 
 	return SUCCESS;
 }
 
 PHPAPI int php_url_scanner_reset_vars(TSRMLS_D)
 {
-	BG(url_adapt_state_ex).form_app.len = 0;
-	BG(url_adapt_state_ex).url_app.len = 0;
+	if (BG(url_adapt_state_ex).form_app.s) {
+		BG(url_adapt_state_ex).form_app.s->len = 0;
+	}
+	if (BG(url_adapt_state_ex).url_app.s) {
+		BG(url_adapt_state_ex).url_app.s->len = 0;
+	}
 
 	return SUCCESS;
 }
@@ -1061,8 +1080,7 @@ PHP_MINIT_FUNCTION(url_scanner)
 {
 	BG(url_adapt_state_ex).tags = NULL;
 
-	BG(url_adapt_state_ex).form_app.c = BG(url_adapt_state_ex).url_app.c = 0;
-	BG(url_adapt_state_ex).form_app.len = BG(url_adapt_state_ex).url_app.len = 0;
+	BG(url_adapt_state_ex).form_app.s = BG(url_adapt_state_ex).url_app.s = NULL;
 
 	REGISTER_INI_ENTRIES();
 	return SUCCESS;
diff --git a/ext/standard/url_scanner_ex.re b/ext/standard/url_scanner_ex.re
index ecacb76f94..38ed0633c3 100644
--- a/ext/standard/url_scanner_ex.re
+++ b/ext/standard/url_scanner_ex.re
@@ -42,6 +42,11 @@
 
 #include "php_smart_str.h"
 
+static void tag_dtor(zval *zv)
+{
+	free(Z_PTR_P(zv));
+}
+
 static PHP_INI_MH(OnUpdateTags)
 {
 	url_adapt_state_ex_t *ctx;
@@ -62,7 +67,7 @@ static PHP_INI_MH(OnUpdateTags)
 		}
 	}
 
-	zend_hash_init(ctx->tags, 0, NULL, NULL, 1);
+	zend_hash_init(ctx->tags, 0, NULL, tag_dtor, 1);
 	
 	for (key = php_strtok_r(tmp, ",", &lasts);
 			key;
@@ -80,7 +85,7 @@ static PHP_INI_MH(OnUpdateTags)
 			keylen = q - key;
 			/* key is stored withOUT NUL
 			   val is stored WITH    NUL */
-			zend_hash_add(ctx->tags, key, keylen, val, strlen(val)+1, NULL);
+			zend_hash_str_add_mem(ctx->tags, key, keylen, val, strlen(val)+1);
 		}
 	}
 
@@ -113,7 +118,7 @@ static inline void append_modified_url(smart_str *url, smart_str *dest, smart_st
 	const char *bash = NULL;
 	const char *sep = "?";
 	
-	q = (p = url->c) + url->len;
+	q = (p = url->s->val) + url->s->len;
 
 scan:
 /*!re2c
@@ -125,13 +130,13 @@ scan:
 done:
 	
 	/* Don't modify URLs of the format "#mark" */
-	if (bash && bash - url->c == 0) {
+	if (bash && bash - url->s->val == 0) {
 		smart_str_append(dest, url);
 		return;
 	}
 
 	if (bash)
-		smart_str_appendl(dest, url->c, bash - url->c);
+		smart_str_appendl(dest, url->s->val, bash - url->s->val);
 	else
 		smart_str_append(dest, url);
 
@@ -153,7 +158,7 @@ static inline void tag_arg(url_adapt_state_ex_t *ctx, char quotes, char type TSR
 {
 	char f = 0;
 
-	if (strncasecmp(ctx->arg.c, ctx->lookup_data, ctx->arg.len) == 0)
+	if (strncasecmp(ctx->arg.s->val, ctx->lookup_data, ctx->arg.s->len) == 0)
 		f = 1;
 
 	if (quotes)
@@ -207,18 +212,18 @@ static void handle_form(STD_PARA)
 {
 	int doit = 0;
 
-	if (ctx->form_app.len > 0) {
-		switch (ctx->tag.len) {
+	if (ctx->form_app.s->len > 0) {
+		switch (ctx->tag.s->len) {
 			case sizeof("form") - 1:
-				if (!strncasecmp(ctx->tag.c, "form", sizeof("form") - 1)) {
+				if (!strncasecmp(ctx->tag.s->val, "form", sizeof("form") - 1)) {
 					doit = 1;		
 				}
-				if (doit && ctx->val.c && ctx->lookup_data && *ctx->lookup_data) {
-					char *e, *p = zend_memnstr(ctx->val.c, "://", sizeof("://") - 1, ctx->val.c + ctx->val.len);
+				if (doit && ctx->val.s && ctx->lookup_data && *ctx->lookup_data) {
+					char *e, *p = (char *)zend_memnstr(ctx->val.s->val, "://", sizeof("://") - 1, ctx->val.s->val + ctx->val.s->len);
 					if (p) {
-						e = memchr(p, '/', (ctx->val.c + ctx->val.len) - p);
+						e = memchr(p, '/', (ctx->val.s->val + ctx->val.s->len) - p);
 						if (!e) {
-							e = ctx->val.c + ctx->val.len;
+							e = ctx->val.s->val + ctx->val.s->len;
 						}
 						if ((e - p) && strncasecmp(p, ctx->lookup_data, (e - p))) {
 							doit = 0;
@@ -228,7 +233,7 @@ static void handle_form(STD_PARA)
 				break;
 
 			case sizeof("fieldset") - 1:
-				if (!strncasecmp(ctx->tag.c, "fieldset", sizeof("fieldset") - 1)) {
+				if (!strncasecmp(ctx->tag.s->val, "fieldset", sizeof("fieldset") - 1)) {
 					doit = 1;		
 				}
 				break;
@@ -251,18 +256,23 @@ static inline void handle_tag(STD_PARA)
 	int ok = 0;
 	unsigned int i;
 
-	ctx->tag.len = 0;
+	if (ctx->tag.s) {
+		ctx->tag.s->len = 0;
+	}
 	smart_str_appendl(&ctx->tag, start, YYCURSOR - start);
-	for (i = 0; i < ctx->tag.len; i++)
-		ctx->tag.c[i] = tolower((int)(unsigned char)ctx->tag.c[i]);
-	if (zend_hash_find(ctx->tags, ctx->tag.c, ctx->tag.len, (void **) &ctx->lookup_data) == SUCCESS)
+	for (i = 0; i < ctx->tag.s->len; i++)
+		ctx->tag.s->val[i] = tolower((int)(unsigned char)ctx->tag.s->val[i]);
+    /* intentionally using str_find here, in case the hash value is set, but the string val is changed later */
+	if ((ctx->lookup_data = zend_hash_str_find_ptr(ctx->tags, ctx->tag.s->val, ctx->tag.s->len)) != NULL)
 		ok = 1;
 	STATE = ok ? STATE_NEXT_ARG : STATE_PLAIN;
 }
 
 static inline void handle_arg(STD_PARA) 
 {
-	ctx->arg.len = 0;
+	if (ctx->arg.s) {
+		ctx->arg.s->len = 0;
+	}
 	smart_str_appendl(&ctx->arg, start, YYCURSOR - start);
 }
 
@@ -281,8 +291,8 @@ static inline void xx_mainloop(url_adapt_state_ex_t *ctx, const char *newdata, s
 
 	smart_str_appendl(&ctx->buf, newdata, newlen);
 	
-	YYCURSOR = ctx->buf.c;
-	YYLIMIT = ctx->buf.c + ctx->buf.len;
+	YYCURSOR = ctx->buf.s->val;
+	YYLIMIT = ctx->buf.s->val + ctx->buf.s->len;
 
 	switch (STATE) {
 		case STATE_PLAIN: goto state_plain;
@@ -353,12 +363,13 @@ stop:
 	/* XXX: Crash avoidance. Need to work with reporter to figure out what goes wrong */	
 	if (rest < 0) rest = 0;
 	
-	if (rest) memmove(ctx->buf.c, start, rest);
-	ctx->buf.len = rest;
+	if (rest) memmove(ctx->buf.s->val, start, rest);
+	ctx->buf.s->len = rest;
 }
 
 char *php_url_scanner_adapt_single_url(const char *url, size_t urllen, const char *name, const char *value, size_t *newlen TSRMLS_DC)
 {
+	char *result;
 	smart_str surl = {0};
 	smart_str buf = {0};
 	smart_str url_app = {0};
@@ -372,11 +383,13 @@ char *php_url_scanner_adapt_single_url(const char *url, size_t urllen, const cha
 	append_modified_url(&surl, &buf, &url_app, PG(arg_separator).output);
 
 	smart_str_0(&buf);
-	if (newlen) *newlen = buf.len;
+	if (newlen) *newlen = buf.s->len;
+	result = estrndup(buf.s->val, buf.s->len);
 
 	smart_str_free(&url_app);
+	smart_str_free(&buf);
 
-	return buf.c;
+	return result;
 }
 
 
@@ -389,19 +402,21 @@ static char *url_adapt_ext(const char *src, size_t srclen, size_t *newlen, zend_
 
 	xx_mainloop(ctx, src, srclen TSRMLS_CC);
 
-	*newlen = ctx->result.len;
-	if (!ctx->result.c) {
+	if (!ctx->result.s) {
 		smart_str_appendl(&ctx->result, "", 0);
+		*newlen = 0;
+	} else {
+		*newlen = ctx->result.s->len;
 	}
 	smart_str_0(&ctx->result);
 	if (do_flush) {
-		smart_str_appendl(&ctx->result, ctx->buf.c, ctx->buf.len);
-		*newlen += ctx->buf.len;
+		smart_str_appendl(&ctx->result, ctx->buf.s->val, ctx->buf.s->len);
+		*newlen += ctx->buf.s->len;
 		smart_str_free(&ctx->buf);
+		smart_str_free(&ctx->val);
 	}
-	retval = ctx->result.c;
-	ctx->result.c = NULL;
-	ctx->result.len = 0;
+	retval = estrndup(ctx->result.s->val, ctx->result.s->len);
+	smart_str_free(&ctx->result);
 	return retval;
 }
 
@@ -434,25 +449,24 @@ static void php_url_scanner_output_handler(char *output, uint output_len, char *
 {
 	size_t len;
 
-	if (BG(url_adapt_state_ex).url_app.len != 0) {
+	if (BG(url_adapt_state_ex).url_app.s->len != 0) {
 		*handled_output = url_adapt_ext(output, output_len, &len, (zend_bool) (mode & (PHP_OUTPUT_HANDLER_END | PHP_OUTPUT_HANDLER_CONT | PHP_OUTPUT_HANDLER_FLUSH | PHP_OUTPUT_HANDLER_FINAL) ? 1 : 0) TSRMLS_CC);
 		if (sizeof(uint) < sizeof(size_t)) {
 			if (len > UINT_MAX)
 				len = UINT_MAX;
 		}
 		*handled_output_len = len;
-	} else if (BG(url_adapt_state_ex).url_app.len == 0) {
+	} else if (BG(url_adapt_state_ex).url_app.s->len == 0) {
 		url_adapt_state_ex_t *ctx = &BG(url_adapt_state_ex);
-		if (ctx->buf.len) {
-			smart_str_appendl(&ctx->result, ctx->buf.c, ctx->buf.len);
+		if (ctx->buf.s && ctx->buf.s->len) {
+			smart_str_appendl(&ctx->result, ctx->buf.s->val, ctx->buf.s->len);
 			smart_str_appendl(&ctx->result, output, output_len);
 
-			*handled_output = ctx->result.c;
-			*handled_output_len = ctx->buf.len + output_len;
+			*handled_output = estrndup(ctx->result.s->val, ctx->result.s->len);
+			*handled_output_len = ctx->buf.s->len + output_len;
 
-			ctx->result.c = NULL;
-			ctx->result.len = 0;
 			smart_str_free(&ctx->buf);
+			smart_str_free(&ctx->result);
 		} else {
 			*handled_output = estrndup(output, *handled_output_len = output_len);
 		}
@@ -463,24 +477,23 @@ static void php_url_scanner_output_handler(char *output, uint output_len, char *
 
 PHPAPI int php_url_scanner_add_var(char *name, int name_len, char *value, int value_len, int urlencode TSRMLS_DC)
 {
-	char *encoded = NULL;
-	int encoded_len;
-	smart_str val;
+	smart_str val = {0};
+	zend_string *encoded;
 	
-	if (! BG(url_adapt_state_ex).active) {
+	if (!BG(url_adapt_state_ex).active) {
 		php_url_scanner_ex_activate(TSRMLS_C);
 		php_output_start_internal(ZEND_STRL("URL-Rewriter"), php_url_scanner_output_handler, 0, PHP_OUTPUT_HANDLER_STDFLAGS TSRMLS_CC);
 		BG(url_adapt_state_ex).active = 1;
 	}
 
 
-	if (BG(url_adapt_state_ex).url_app.len != 0) {
+	if (BG(url_adapt_state_ex).url_app.s && BG(url_adapt_state_ex).url_app.s->len != 0) {
 		smart_str_appends(&BG(url_adapt_state_ex).url_app, PG(arg_separator).output);
 	}
 
 	if (urlencode) {
-		encoded = php_url_encode(value, value_len, &encoded_len);
-		smart_str_setl(&val, encoded, encoded_len);
+		encoded = php_url_encode(value, value_len);
+		smart_str_setl(&val, encoded->val, encoded->len);
 	} else {
 		smart_str_setl(&val, value, value_len);
 	}
@@ -495,16 +508,22 @@ PHPAPI int php_url_scanner_add_var(char *name, int name_len, char *value, int va
 	smart_str_append(&BG(url_adapt_state_ex).form_app, &val);
 	smart_str_appends(&BG(url_adapt_state_ex).form_app, "\" />");
 
-	if (urlencode)
-		efree(encoded);
+	if (urlencode) {
+		STR_FREE(encoded);
+	}
+	smart_str_free(&val);
 
 	return SUCCESS;
 }
 
 PHPAPI int php_url_scanner_reset_vars(TSRMLS_D)
 {
-	BG(url_adapt_state_ex).form_app.len = 0;
-	BG(url_adapt_state_ex).url_app.len = 0;
+	if (BG(url_adapt_state_ex).form_app.s) {
+		BG(url_adapt_state_ex).form_app.s->len = 0;
+	}
+	if (BG(url_adapt_state_ex).url_app.s) {
+		BG(url_adapt_state_ex).url_app.s->len = 0;
+	}
 
 	return SUCCESS;
 }
@@ -513,8 +532,7 @@ PHP_MINIT_FUNCTION(url_scanner)
 {
 	BG(url_adapt_state_ex).tags = NULL;
 
-	BG(url_adapt_state_ex).form_app.c = BG(url_adapt_state_ex).url_app.c = 0;
-	BG(url_adapt_state_ex).form_app.len = BG(url_adapt_state_ex).url_app.len = 0;
+	BG(url_adapt_state_ex).form_app.s = BG(url_adapt_state_ex).url_app.s = NULL;
 
 	REGISTER_INI_ENTRIES();
 	return SUCCESS;
diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c
index 1f745b574a..6945315903 100644
--- a/ext/standard/user_filters.c
+++ b/ext/standard/user_filters.c
@@ -32,7 +32,7 @@
 struct php_user_filter_data {
 	zend_class_entry *ce;
 	/* variable length; this *must* be last in the structure */
-	char classname[1];
+	zend_string *classname;
 };
 
 /* to provide context for calling into the next filter from user-space */
@@ -78,7 +78,7 @@ static zend_class_entry user_filter_class_entry;
 
 static ZEND_RSRC_DTOR_FUNC(php_bucket_dtor)
 {
-	php_stream_bucket *bucket = (php_stream_bucket *)rsrc->ptr;
+	php_stream_bucket *bucket = (php_stream_bucket *)res->ptr;
 	if (bucket) {
 		php_stream_bucket_delref(bucket TSRMLS_CC);
 		bucket = NULL;
@@ -137,29 +137,29 @@ PHP_RSHUTDOWN_FUNCTION(user_filters)
 
 static void userfilter_dtor(php_stream_filter *thisfilter TSRMLS_DC)
 {
-	zval *obj = (zval*)thisfilter->abstract;
+	zval *obj = &thisfilter->abstract;
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 
 	if (obj == NULL) {
 		/* If there's no object associated then there's nothing to dispose of */
 		return;
 	}
 
-	ZVAL_STRINGL(&func_name, "onclose", sizeof("onclose")-1, 0);
+	ZVAL_STRINGL(&func_name, "onclose", sizeof("onclose")-1);
 
 	call_user_function_ex(NULL,
-			&obj,
+			obj,
 			&func_name,
 			&retval,
 			0, NULL,
 			0, NULL TSRMLS_CC);
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	/* kill the object */
-	zval_ptr_dtor(&obj);
+	zval_ptr_dtor(obj);
 }
 
 php_stream_filter_status_t userfilter_filter(
@@ -172,11 +172,10 @@ php_stream_filter_status_t userfilter_filter(
 			TSRMLS_DC)
 {
 	int ret = PSFS_ERR_FATAL;
-	zval *obj = (zval*)thisfilter->abstract;
+	zval *obj = &thisfilter->abstract;
 	zval func_name;
-	zval *retval = NULL;
-	zval **args[4];
-	zval *zclosing, *zconsumed, *zin, *zout, *zstream;
+	zval retval;
+	zval args[4];
 	zval zpropname;
 	int call_result;
 
@@ -185,59 +184,50 @@ php_stream_filter_status_t userfilter_filter(
 		return ret;
 	}
 
-	if (FAILURE == zend_hash_find(Z_OBJPROP_P(obj), "stream", sizeof("stream"), (void**)&zstream)) {
+	if (!zend_hash_str_exists(Z_OBJPROP_P(obj), "stream", sizeof("stream")-1)) {
+		zval tmp;
+
 		/* Give the userfilter class a hook back to the stream */
-		ALLOC_INIT_ZVAL(zstream);
-		php_stream_to_zval(stream, zstream);
-		zval_copy_ctor(zstream);
-		add_property_zval(obj, "stream", zstream);
+		php_stream_to_zval(stream, &tmp);
+		zval_copy_ctor(&tmp);
+		add_property_zval(obj, "stream", &tmp);
 		/* add_property_zval increments the refcount which is unwanted here */
-		zval_ptr_dtor(&zstream);
+		zval_ptr_dtor(&tmp);
 	}
 
-	ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1, 0);
+	ZVAL_STRINGL(&func_name, "filter", sizeof("filter")-1);
 
 	/* Setup calling arguments */
-	ALLOC_INIT_ZVAL(zin);
-	ZEND_REGISTER_RESOURCE(zin, buckets_in, le_bucket_brigade);
-	args[0] = &zin;
+	ZEND_REGISTER_RESOURCE(&args[0], buckets_in, le_bucket_brigade);
 
-	ALLOC_INIT_ZVAL(zout);
-	ZEND_REGISTER_RESOURCE(zout, buckets_out, le_bucket_brigade);
-	args[1] = &zout;
+	ZEND_REGISTER_RESOURCE(&args[1], buckets_out, le_bucket_brigade);
 
-	ALLOC_INIT_ZVAL(zconsumed);
 	if (bytes_consumed) {
-		ZVAL_LONG(zconsumed, *bytes_consumed);
+		ZVAL_LONG(&args[2], *bytes_consumed);
 	} else {
-		ZVAL_NULL(zconsumed);
+		ZVAL_NULL(&args[2]);
 	}
-	args[2] = &zconsumed;
 
-	ALLOC_INIT_ZVAL(zclosing);
-	ZVAL_BOOL(zclosing, flags & PSFS_FLAG_FLUSH_CLOSE);
-	args[3] = &zclosing;
+	ZVAL_BOOL(&args[3], flags & PSFS_FLAG_FLUSH_CLOSE);
 
 	call_result = call_user_function_ex(NULL,
-			&obj,
+			obj,
 			&func_name,
 			&retval,
 			4, args,
 			0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL) {
-		convert_to_long(retval);
-		ret = Z_LVAL_P(retval);
+	zval_ptr_dtor(&func_name);
+
+	if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		convert_to_long(&retval);
+		ret = Z_LVAL(retval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "failed to call filter function");
 	}
 
 	if (bytes_consumed) {
-		*bytes_consumed = Z_LVAL_P(zconsumed);
-	}
-
-	if (retval) {
-		zval_ptr_dtor(&retval);
+		*bytes_consumed = Z_LVAL_P(&args[2]);
 	}
 
 	if (buckets_in->head) {
@@ -262,14 +252,14 @@ php_stream_filter_status_t userfilter_filter(
 	/* filter resources are cleaned up by the stream destructor,
 	 * keeping a reference to the stream resource here would prevent it
 	 * from being destroyed properly */
-	INIT_ZVAL(zpropname);
-	ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1, 0);
-	Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, 0 TSRMLS_CC);
+	ZVAL_STRINGL(&zpropname, "stream", sizeof("stream")-1);
+	Z_OBJ_HANDLER_P(obj, unset_property)(obj, &zpropname, -1 TSRMLS_CC);
+	zval_ptr_dtor(&zpropname);
 
-	zval_ptr_dtor(&zclosing);
-	zval_ptr_dtor(&zconsumed);
-	zval_ptr_dtor(&zout);
-	zval_ptr_dtor(&zin);
+	zval_ptr_dtor(&args[3]);
+	zval_ptr_dtor(&args[2]);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 }
@@ -285,9 +275,9 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 {
 	struct php_user_filter_data *fdat = NULL;
 	php_stream_filter *filter;
-	zval *obj, *zfilter;
+	zval obj, zfilter;
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int len;
 	
 	/* some sanity checks */
@@ -300,7 +290,7 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 	len = strlen(filtername);
 
 	/* determine the classname/class entry */
-	if (FAILURE == zend_hash_find(BG(user_filter_map), (char*)filtername, len + 1, (void**)&fdat)) {
+	if (NULL == (fdat = zend_hash_str_find_ptr(BG(user_filter_map), (char*)filtername, len))) {
 		char *period;
 
 		/* Userspace Filters using ambiguous wildcards could cause problems.
@@ -317,7 +307,7 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 			while (period) {
 				*period = '\0';
 				strncat(wildcard, ".*", 2);
-				if (SUCCESS == zend_hash_find(BG(user_filter_map), wildcard, strlen(wildcard) + 1, (void**)&fdat)) {
+				if (NULL != (fdat = zend_hash_str_find_ptr(BG(user_filter_map), wildcard, strlen(wildcard)))) {
 					period = NULL;
 				} else {
 					*period = '\0';
@@ -335,15 +325,12 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 
 	/* bind the classname to the actual class */
 	if (fdat->ce == NULL) {
-		if (FAILURE == zend_lookup_class(fdat->classname, strlen(fdat->classname),
-					(zend_class_entry ***)&fdat->ce TSRMLS_CC)) {
+		if (NULL == (fdat->ce = zend_lookup_class(fdat->classname TSRMLS_CC))) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING,
 					"user-filter \"%s\" requires class \"%s\", but that class is not defined",
-					filtername, fdat->classname);
+					filtername, fdat->classname->val);
 			return NULL;
 		}
-		fdat->ce = *(zend_class_entry**)fdat->ce;
-
 	}
 
 	filter = php_stream_filter_alloc(&userfilter_ops, NULL, 0);
@@ -352,23 +339,21 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 	}
 
 	/* create the object */
-	ALLOC_ZVAL(obj);
-	object_init_ex(obj, fdat->ce);
-	Z_SET_REFCOUNT_P(obj, 1);
-	Z_SET_ISREF_P(obj);
+	object_init_ex(&obj, fdat->ce);
+//???	Z_SET_ISREF_P(obj);
 
 	/* filtername */
-	add_property_string(obj, "filtername", (char*)filtername, 1);
+	add_property_string(&obj, "filtername", (char*)filtername);
 	
 	/* and the parameters, if any */
 	if (filterparams) {
-		add_property_zval(obj, "params", filterparams);
+		add_property_zval(&obj, "params", filterparams);
 	} else {
-		add_property_null(obj, "params");
+		add_property_null(&obj, "params");
 	}
 
 	/* invoke the constructor */
-	ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1, 0);
+	ZVAL_STRINGL(&func_name, "oncreate", sizeof("oncreate")-1);
 
 	call_user_function_ex(NULL,
 			&obj,
@@ -377,13 +362,13 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 			0, NULL,
 			0, NULL TSRMLS_CC);
 
-	if (retval) {
-		if (Z_TYPE_P(retval) == IS_BOOL && Z_LVAL_P(retval) == 0) {
+	if (Z_TYPE(retval) != IS_UNDEF) {
+		if (Z_TYPE(retval) == IS_BOOL && Z_LVAL(retval) == 0) {
 			/* User reported filter creation error "return false;" */
 			zval_ptr_dtor(&retval);
 
 			/* Kill the filter (safely) */
-			filter->abstract = NULL;
+			ZVAL_UNDEF(&filter->abstract);
 			php_stream_filter_free(filter TSRMLS_CC);
 
 			/* Kill the object */
@@ -394,12 +379,12 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
 		}			
 		zval_ptr_dtor(&retval);
 	}
+	zval_ptr_dtor(&func_name);
 
 	/* set the filter property, this will be used during cleanup */
-	ALLOC_INIT_ZVAL(zfilter);
-	ZEND_REGISTER_RESOURCE(zfilter, filter, le_userfilters);
-	filter->abstract = obj;
-	add_property_zval(obj, "filter", zfilter);
+	ZEND_REGISTER_RESOURCE(&zfilter, filter, le_userfilters);
+	ZVAL_COPY_VALUE(&filter->abstract, &obj);
+	add_property_zval(&obj, "filter", &zfilter);
 	/* add_property_zval increments the refcount which is unwanted here */
 	zval_ptr_dtor(&zfilter);
 
@@ -410,15 +395,18 @@ static php_stream_filter_factory user_filter_factory = {
 	user_filter_factory_create
 };
 
-static void filter_item_dtor(struct php_user_filter_data *fdat)
+static void filter_item_dtor(zval *zv)
 {
+	struct php_user_filter_data *fdat = Z_PTR_P(zv);
+	STR_RELEASE(fdat->classname);
+	efree(fdat);
 }
 
 /* {{{ proto object stream_bucket_make_writeable(resource brigade)
    Return a bucket object from the brigade for operating on */
 PHP_FUNCTION(stream_bucket_make_writeable)
 {
-	zval *zbrigade, *zbucket;
+	zval *zbrigade, zbucket;
 	php_stream_bucket_brigade *brigade;
 	php_stream_bucket *bucket;
 
@@ -426,18 +414,17 @@ PHP_FUNCTION(stream_bucket_make_writeable)
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, &zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade); 
+	ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade); 
 
 	ZVAL_NULL(return_value);
 
 	if (brigade->head && (bucket = php_stream_bucket_make_writeable(brigade->head TSRMLS_CC))) {
-		ALLOC_INIT_ZVAL(zbucket);
-		ZEND_REGISTER_RESOURCE(zbucket, bucket, le_bucket);
+		ZEND_REGISTER_RESOURCE(&zbucket, bucket, le_bucket);
 		object_init(return_value);
-		add_property_zval(return_value, "bucket", zbucket);
+		add_property_zval(return_value, "bucket", &zbucket);
 		/* add_property_zval increments the refcount which is unwanted here */
 		zval_ptr_dtor(&zbucket);
-		add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
+		add_property_stringl(return_value, "data", bucket->buf, bucket->buflen);
 		add_property_long(return_value, "datalen", bucket->buflen);
 	}
 }
@@ -447,7 +434,7 @@ PHP_FUNCTION(stream_bucket_make_writeable)
 static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS)
 {
 	zval *zbrigade, *zobject;
-	zval **pzbucket, **pzdata;
+	zval *pzbucket, *pzdata;
 	php_stream_bucket_brigade *brigade;
 	php_stream_bucket *bucket;
 
@@ -455,23 +442,23 @@ static void php_stream_bucket_attach(int append, INTERNAL_FUNCTION_PARAMETERS)
 		RETURN_FALSE;
 	}
 
-	if (FAILURE == zend_hash_find(Z_OBJPROP_P(zobject), "bucket", 7, (void**)&pzbucket)) {
+	if (NULL == (pzbucket = zend_hash_str_find(Z_OBJPROP_P(zobject), "bucket", sizeof("bucket")-1))) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Object has no bucket property");
 		RETURN_FALSE;
 	}
 
-	ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, &zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade);
+	ZEND_FETCH_RESOURCE(brigade, php_stream_bucket_brigade *, zbrigade, -1, PHP_STREAM_BRIGADE_RES_NAME, le_bucket_brigade);
 	ZEND_FETCH_RESOURCE(bucket, php_stream_bucket *, pzbucket, -1, PHP_STREAM_BUCKET_RES_NAME, le_bucket);
 
-	if (SUCCESS == zend_hash_find(Z_OBJPROP_P(zobject), "data", 5, (void**)&pzdata) && (*pzdata)->type == IS_STRING) {
+	if (NULL != (pzdata = zend_hash_str_find(Z_OBJPROP_P(zobject), "data", sizeof("data")-1)) && Z_TYPE_P(pzdata) == IS_STRING) {
 		if (!bucket->own_buf) {
 			bucket = php_stream_bucket_make_writeable(bucket TSRMLS_CC);
 		}
-		if ((int)bucket->buflen != Z_STRLEN_PP(pzdata)) {
-			bucket->buf = perealloc(bucket->buf, Z_STRLEN_PP(pzdata), bucket->is_persistent);
-			bucket->buflen = Z_STRLEN_PP(pzdata);
+		if ((int)bucket->buflen != Z_STRLEN_P(pzdata)) {
+			bucket->buf = perealloc(bucket->buf, Z_STRLEN_P(pzdata), bucket->is_persistent);
+			bucket->buflen = Z_STRLEN_P(pzdata);
 		}
-		memcpy(bucket->buf, Z_STRVAL_PP(pzdata), bucket->buflen);
+		memcpy(bucket->buf, Z_STRVAL_P(pzdata), bucket->buflen);
 	}
 
 	if (append) {
@@ -508,7 +495,7 @@ PHP_FUNCTION(stream_bucket_append)
    Create a new bucket for use on the current stream */
 PHP_FUNCTION(stream_bucket_new)
 {
-	zval *zstream, *zbucket;
+	zval *zstream, zbucket;
 	php_stream *stream;
 	char *buffer;
 	char *pbuffer;
@@ -519,7 +506,7 @@ PHP_FUNCTION(stream_bucket_new)
 		RETURN_FALSE;
 	}
 
-	php_stream_from_zval(stream, &zstream);
+	php_stream_from_zval(stream, zstream);
 
 	if (!(pbuffer = pemalloc(buffer_len, php_stream_is_persistent(stream)))) {
 		RETURN_FALSE;
@@ -533,13 +520,12 @@ PHP_FUNCTION(stream_bucket_new)
 		RETURN_FALSE;
 	}
 
-	ALLOC_INIT_ZVAL(zbucket);
-	ZEND_REGISTER_RESOURCE(zbucket, bucket, le_bucket);
+	ZEND_REGISTER_RESOURCE(&zbucket, bucket, le_bucket);
 	object_init(return_value);
-	add_property_zval(return_value, "bucket", zbucket);
+	add_property_zval(return_value, "bucket", &zbucket);
 	/* add_property_zval increments the refcount which is unwanted here */
 	zval_ptr_dtor(&zbucket);
-	add_property_stringl(return_value, "data", bucket->buf, bucket->buflen, 1);
+	add_property_stringl(return_value, "data", bucket->buf, bucket->buflen);
 	add_property_long(return_value, "datalen", bucket->buflen);
 }
 /* }}} */
@@ -548,11 +534,8 @@ PHP_FUNCTION(stream_bucket_new)
    Returns a list of registered filters */
 PHP_FUNCTION(stream_get_filters)
 {
-	char *filter_name;
-	int key_flags;
-	uint filter_name_len = 0;
+	zend_string *filter_name;
 	HashTable *filters_hash;
-	ulong num_key;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -563,12 +546,11 @@ PHP_FUNCTION(stream_get_filters)
 	filters_hash = php_get_stream_filters_hash();
 
 	if (filters_hash) {
-		for(zend_hash_internal_pointer_reset(filters_hash);
-			(key_flags = zend_hash_get_current_key_ex(filters_hash, &filter_name, &filter_name_len, &num_key, 0, NULL)) != HASH_KEY_NON_EXISTENT;
-			zend_hash_move_forward(filters_hash))
-				if (key_flags == HASH_KEY_IS_STRING) {
-					add_next_index_stringl(return_value, filter_name, filter_name_len - 1, 1);
-				}
+		ZEND_HASH_FOREACH_STR_KEY(filters_hash, filter_name) {
+			if (filter_name) {
+				add_next_index_str(return_value, STR_COPY(filter_name));
+			}
+		} ZEND_HASH_FOREACH_END();
 	}
 	/* It's okay to return an empty array if no filters are registered */
 }
@@ -578,42 +560,40 @@ PHP_FUNCTION(stream_get_filters)
    Registers a custom filter handler class */
 PHP_FUNCTION(stream_filter_register)
 {
-	char *filtername, *classname;
-	int filtername_len, classname_len;
+	zend_string *filtername, *classname;
 	struct php_user_filter_data *fdat;
 	
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss", &filtername, &filtername_len,
-				&classname, &classname_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS", &filtername, &classname) == FAILURE) {
 		RETURN_FALSE;
 	}
 
 	RETVAL_FALSE;
 
-	if (!filtername_len) {
+	if (!filtername->len) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Filter name cannot be empty");
 		return;
 	}
 
-	if (!classname_len) {
+	if (!classname->len) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Class name cannot be empty");
 		return;
 	}
 
 	if (!BG(user_filter_map)) {
 		BG(user_filter_map) = (HashTable*) emalloc(sizeof(HashTable));
-		zend_hash_init(BG(user_filter_map), 5, NULL, (dtor_func_t) filter_item_dtor, 0);
+		zend_hash_init(BG(user_filter_map), 8, NULL, (dtor_func_t) filter_item_dtor, 0);
 	}
 
-	fdat = ecalloc(1, sizeof(struct php_user_filter_data) + classname_len);
-	memcpy(fdat->classname, classname, classname_len);
+	fdat = ecalloc(1, sizeof(struct php_user_filter_data));
+	fdat->classname = STR_COPY(classname);
 
-	if (zend_hash_add(BG(user_filter_map), filtername, filtername_len + 1, (void*)fdat,
-				sizeof(*fdat) + classname_len, NULL) == SUCCESS &&
-			php_stream_filter_register_factory_volatile(filtername, &user_filter_factory TSRMLS_CC) == SUCCESS) {
+	if (zend_hash_add_ptr(BG(user_filter_map), filtername, fdat) != NULL &&
+			php_stream_filter_register_factory_volatile(filtername->val, &user_filter_factory TSRMLS_CC) == SUCCESS) {
 		RETVAL_TRUE;
+	} else {
+		STR_RELEASE(classname);
+		efree(fdat);
 	}
-
-	efree(fdat);
 }
 /* }}} */
 
diff --git a/ext/standard/uuencode.c b/ext/standard/uuencode.c
index 52e892ed9e..2a1de6ed46 100644
--- a/ext/standard/uuencode.c
+++ b/ext/standard/uuencode.c
@@ -65,13 +65,15 @@
 
 #define PHP_UU_DEC(c) (((c) - ' ') & 077)
 
-PHPAPI int php_uuencode(char *src, int src_len, char **dest) /* {{{ */
+PHPAPI zend_string *php_uuencode(char *src, int src_len) /* {{{ */
 {
 	int len = 45;
 	char *p, *s, *e, *ee;
+	zend_string *dest;
 
 	/* encoded length is ~ 38% greater than the original */
-	p = *dest = safe_emalloc((size_t) ceil(src_len * 1.38), 1, 46);
+	dest = STR_ALLOC((size_t)ceil(src_len * 1.38) + 46, 0);
+	p = dest->val;
 	s = src;
 	e = src + src_len;
 
@@ -120,16 +122,19 @@ PHPAPI int php_uuencode(char *src, int src_len, char **dest) /* {{{ */
 	*p++ = '\n';
 	*p = '\0';
 
-	return (p - *dest);
+	dest = STR_REALLOC(dest, p - dest->val, 0);
+	return dest;
 }
 /* }}} */
 
-PHPAPI int php_uudecode(char *src, int src_len, char **dest) /* {{{ */
+PHPAPI zend_string *php_uudecode(char *src, int src_len) /* {{{ */
 {
 	int len, total_len=0;
 	char *s, *e, *p, *ee;
+	zend_string *dest;
 
-	p = *dest = safe_emalloc((size_t) ceil(src_len * 0.75), 1, 1);
+	dest = STR_ALLOC((size_t) ceil(src_len * 0.75), 0);
+	p = dest->val;
 	s = src;
 	e = src + src_len;
 
@@ -165,7 +170,7 @@ PHPAPI int php_uudecode(char *src, int src_len, char **dest) /* {{{ */
 		s++;
 	}
 
-	if ((len = total_len > (p - *dest))) {
+	if ((len = total_len > (p - dest->val))) {
 		*p++ = PHP_UU_DEC(*s) << 2 | PHP_UU_DEC(*(s + 1)) >> 4;
 		if (len > 1) {
 			*p++ = PHP_UU_DEC(*(s + 1)) << 4 | PHP_UU_DEC(*(s + 2)) >> 2;
@@ -175,13 +180,15 @@ PHPAPI int php_uudecode(char *src, int src_len, char **dest) /* {{{ */
 		}
 	}
 
-	*(*dest + total_len) = '\0';
+	dest->len = total_len;
+	dest->val[dest->len] = '\0';
 
-	return total_len;
+	return dest;
 
 err:
-	efree(*dest);
-	return -1;
+	STR_FREE(dest);
+
+	return NULL;
 }
 /* }}} */
 
@@ -189,16 +196,14 @@ err:
    uuencode a string */
 PHP_FUNCTION(convert_uuencode)
 {
-	char *src, *dst;
-	int src_len, dst_len;
+	char *src;
+	int src_len;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &src, &src_len) == FAILURE || src_len < 1) {
 		RETURN_FALSE;
 	}
 
-	dst_len = php_uuencode(src, src_len, &dst);
-
-	RETURN_STRINGL(dst, dst_len, 0);
+	RETURN_STR(php_uuencode(src, src_len));
 }
 /* }}} */
 
@@ -206,20 +211,20 @@ PHP_FUNCTION(convert_uuencode)
    decode a uuencoded string */
 PHP_FUNCTION(convert_uudecode)
 {
-	char *src, *dst;
-	int src_len, dst_len;
+	char *src;
+	int src_len;
+	zend_string *dest;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &src, &src_len) == FAILURE || src_len < 1) {
 		RETURN_FALSE;
 	}
 
-	dst_len = php_uudecode(src, src_len, &dst);
-	if (dst_len < 0) {
+	if ((dest = php_uudecode(src, src_len)) == NULL) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "The given parameter is not a valid uuencoded string");
 		RETURN_FALSE;
 	}
 
-	RETURN_STRINGL(dst, dst_len, 0);
+	RETURN_STR(dest);
 }
 /* }}} */
 
diff --git a/ext/standard/var.c b/ext/standard/var.c
index 930edd6877..3dbd71abd5 100644
--- a/ext/standard/var.c
+++ b/ext/standard/var.c
@@ -32,20 +32,45 @@
 #include "basic_functions.h"
 #include "php_incomplete_class.h"
 
-#define COMMON (Z_ISREF_PP(struc) ? "&" : "")
+#define COMMON (is_ref ? "&" : "")
 /* }}} */
 
-static int php_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static uint zend_obj_num_elements(HashTable *ht)
+{
+	Bucket *p;
+	uint idx;
+	uint num;
+
+	num = ht->nNumOfElements;
+	for (idx = 0; idx < ht->nNumUsed; idx++) {
+		p = ht->arData + idx;
+		if (Z_TYPE(p->val) == IS_UNDEF) continue;
+		if (Z_TYPE(p->val) == IS_INDIRECT) {
+			if (Z_TYPE_P(Z_INDIRECT(p->val)) == IS_UNDEF) {
+				num--;
+			}			
+		}
+	}
+	return num;
+}
+
+static int php_array_element_dump(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	int level;
 
 	level = va_arg(args, int);
 
-	if (hash_key->nKeyLength == 0) { /* numeric key */
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+		if (Z_TYPE_P(zv) == IS_UNDEF) {
+			return 0;
+		}
+	}
+	if (hash_key->key == NULL) { /* numeric key */
 		php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
 	} else { /* string key */
 		php_printf("%*c[\"", level + 1, ' ');
-		PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
+		PHPWRITE(hash_key->key->val, hash_key->key->len);
 		php_printf("\"]=>\n");
 	}
 	php_var_dump(zv, level + 2 TSRMLS_CC);
@@ -53,17 +78,23 @@ static int php_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list arg
 }
 /* }}} */
 
-static int php_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int php_object_property_dump(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	int level;
 	const char *prop_name, *class_name;
 
 	level = va_arg(args, int);
 
-	if (hash_key->nKeyLength == 0) { /* numeric key */
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+		if (Z_TYPE_P(zv) == IS_UNDEF) {
+			return 0;
+		}
+	}
+	if (hash_key->key == NULL) { /* numeric key */
 		php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
 	} else { /* string key */
-		int unmangle = zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
+		int unmangle = zend_unmangle_property_name(hash_key->key->val, hash_key->key->len, &class_name, &prop_name);
 		php_printf("%*c[", level + 1, ' ');
 
 		if (class_name && unmangle == SUCCESS) {
@@ -74,7 +105,7 @@ static int php_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list a
 			}
 		} else {
 			php_printf("\"");
-			PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
+			PHPWRITE(hash_key->key->val, hash_key->key->len);
 			php_printf("\"");
 		}
 		ZEND_PUTS("]=>\n");
@@ -84,85 +115,94 @@ static int php_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list a
 }
 /* }}} */
 
-PHPAPI void php_var_dump(zval **struc, int level TSRMLS_DC) /* {{{ */
+PHPAPI void php_var_dump(zval *struc, int level TSRMLS_DC) /* {{{ */
 {
 	HashTable *myht;
-	const char *class_name;
-	zend_uint class_name_len;
-	int (*php_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
+	zend_string *class_name;
+	int (*php_element_dump_func)(zval* TSRMLS_DC, int, va_list, zend_hash_key*);
 	int is_temp;
+	int is_ref = 0;
 
 	if (level > 1) {
 		php_printf("%*c", level - 1, ' ');
 	}
 
-	switch (Z_TYPE_PP(struc)) {
-	case IS_BOOL:
-		php_printf("%sbool(%s)\n", COMMON, Z_LVAL_PP(struc) ? "true" : "false");
-		break;
-	case IS_NULL:
-		php_printf("%sNULL\n", COMMON);
-		break;
-	case IS_LONG:
-		php_printf("%sint(%ld)\n", COMMON, Z_LVAL_PP(struc));
-		break;
-	case IS_DOUBLE:
-		php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc));
-		break;
-	case IS_STRING:
-		php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
-		PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
-		PUTS("\"\n");
-		break;
-	case IS_ARRAY:
-		myht = Z_ARRVAL_PP(struc);
-		if (++myht->nApplyCount > 1) {
-			PUTS("*RECURSION*\n");
-			--myht->nApplyCount;
-			return;
-		}
-		php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht));
-		php_element_dump_func = php_array_element_dump;
-		is_temp = 0;
-		goto head_done;
-	case IS_OBJECT:
-		myht = Z_OBJDEBUG_PP(struc, is_temp);
-		if (myht && ++myht->nApplyCount > 1) {
-			PUTS("*RECURSION*\n");
-			--myht->nApplyCount;
-			return;
-		}
+again:
+	switch (Z_TYPE_P(struc)) {
+		case IS_BOOL:
+			php_printf("%sbool(%s)\n", COMMON, Z_LVAL_P(struc) ? "true" : "false");
+			break;
+		case IS_NULL:
+			php_printf("%sNULL\n", COMMON);
+			break;
+		case IS_LONG:
+			php_printf("%sint(%ld)\n", COMMON, Z_LVAL_P(struc));
+			break;
+		case IS_DOUBLE:
+			php_printf("%sfloat(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc));
+			break;
+		case IS_STRING:
+			php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc));
+			PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
+			PUTS("\"\n");
+			break;
+		case IS_ARRAY:
+			myht = Z_ARRVAL_P(struc);
+			if (++myht->u.v.nApplyCount > 1) {
+				PUTS("*RECURSION*\n");
+				--myht->u.v.nApplyCount;
+				return;
+			}
+			php_printf("%sarray(%d) {\n", COMMON, zend_hash_num_elements(myht));
+			php_element_dump_func = php_array_element_dump;
+			is_temp = 0;
+			goto head_done;
+		case IS_OBJECT:
+			myht = Z_OBJDEBUG_P(struc, is_temp);
+			if (myht && ++myht->u.v.nApplyCount > 1) {
+				PUTS("*RECURSION*\n");
+				--myht->u.v.nApplyCount;
+				return;
+			}
 
-		if (Z_OBJ_HANDLER(**struc, get_class_name)) {
-			Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
-			php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0);
-			efree((char*)class_name);
-		} else {
-			php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0);
-		}
-		php_element_dump_func = php_object_property_dump;
-head_done:
-		if (myht) {
-			zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level);
-			--myht->nApplyCount;
-			if (is_temp) {
-				zend_hash_destroy(myht);
-				efree(myht);
+			if (Z_OBJ_HANDLER_P(struc, get_class_name)) {
+				class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc), 0 TSRMLS_CC);
+				php_printf("%sobject(%s)#%d (%d) {\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0);
+				STR_RELEASE(class_name);
+			} else {
+				php_printf("%sobject(unknown class)#%d (%d) {\n", COMMON, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0);
 			}
+			php_element_dump_func = php_object_property_dump;
+	head_done:
+			if (myht) {
+				zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_element_dump_func, 1, level);
+				--myht->u.v.nApplyCount;
+				if (is_temp) {
+					zend_hash_destroy(myht);
+					efree(myht);
+				}
+			}
+			if (level > 1) {
+				php_printf("%*c", level-1, ' ');
+			}
+			PUTS("}\n");
+			break;
+		case IS_RESOURCE: {
+			const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(struc) TSRMLS_CC);
+			php_printf("%sresource(%ld) of type (%s)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown");
+			break;
 		}
-		if (level > 1) {
-			php_printf("%*c", level-1, ' ');
-		}
-		PUTS("}\n");
-		break;
-	case IS_RESOURCE: {
-		const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
-		php_printf("%sresource(%ld) of type (%s)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown");
-		break;
-	}
-	default:
-		php_printf("%sUNKNOWN:0\n", COMMON);
-		break;
+		case IS_REFERENCE:
+			//??? hide references with refcount==1 (for compatibility)
+			if (Z_REFCOUNT_P(struc) > 1) {
+				is_ref = 1;
+			}
+			struc = Z_REFVAL_P(struc);
+			goto again;
+			break;
+		default:
+			php_printf("%sUNKNOWN:0\n", COMMON);
+			break;
 	}
 }
 /* }}} */
@@ -171,7 +211,7 @@ head_done:
    Dumps a string representation of variable to output */
 PHP_FUNCTION(var_dump)
 {
-	zval ***args;
+	zval *args;
 	int argc;
 	int	i;
 
@@ -180,29 +220,34 @@ PHP_FUNCTION(var_dump)
 	}
 
 	for (i = 0; i < argc; i++) {
-		php_var_dump(args[i], 1 TSRMLS_CC);
+		php_var_dump(&args[i], 1 TSRMLS_CC);
 	}
-	efree(args);
 }
 /* }}} */
 
-static int zval_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int zval_array_element_dump(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	int level;
 
 	level = va_arg(args, int);
 
-	if (hash_key->nKeyLength == 0) { /* numeric key */
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+		if (Z_TYPE_P(zv) == IS_UNDEF) {
+			return 0;
+		}
+	}
+	if (hash_key->key == NULL) { /* numeric key */
 		php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
 	} else { /* string key */
 		/* XXX: perphaps when we are inside the class we should permit access to
 		 * private & protected values
 		 */
-		if (va_arg(args, int) && hash_key->arKey[0] == '\0') {
+		if (va_arg(args, int) && hash_key->key->val[0] == '\0') {
 			return 0;
 		}
 		php_printf("%*c[\"", level + 1, ' ');
-		PHPWRITE(hash_key->arKey, hash_key->nKeyLength - 1);
+		PHPWRITE(hash_key->key->val, hash_key->key->len);
 		php_printf("\"]=>\n");
 	}
 	php_debug_zval_dump(zv, level + 2 TSRMLS_CC);
@@ -210,17 +255,23 @@ static int zval_array_element_dump(zval **zv TSRMLS_DC, int num_args, va_list ar
 }
 /* }}} */
 
-static int zval_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int zval_object_property_dump(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	int level;
 	const char *prop_name, *class_name;
 
 	level = va_arg(args, int);
 
-	if (hash_key->nKeyLength == 0) { /* numeric key */
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+		if (Z_TYPE_P(zv) == IS_UNDEF) {
+			return 0;
+		}
+	}
+	if (hash_key->key == NULL) { /* numeric key */
 		php_printf("%*c[%ld]=>\n", level + 1, ' ', hash_key->h);
 	} else { /* string key */
-		zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1, &class_name, &prop_name);
+		zend_unmangle_property_name(hash_key->key->val, hash_key->key->len, &class_name, &prop_name);
 		php_printf("%*c[", level + 1, ' ');
 
 		if (class_name) {
@@ -239,58 +290,59 @@ static int zval_object_property_dump(zval **zv TSRMLS_DC, int num_args, va_list
 }
 /* }}} */
 
-PHPAPI void php_debug_zval_dump(zval **struc, int level TSRMLS_DC) /* {{{ */
+PHPAPI void php_debug_zval_dump(zval *struc, int level TSRMLS_DC) /* {{{ */
 {
 	HashTable *myht = NULL;
-	const char *class_name;
-	zend_uint class_name_len;
-	int (*zval_element_dump_func)(zval** TSRMLS_DC, int, va_list, zend_hash_key*);
+	zend_string *class_name;
+	int (*zval_element_dump_func)(zval* TSRMLS_DC, int, va_list, zend_hash_key*);
 	int is_temp = 0;
+	int is_ref = 0;
 
 	if (level > 1) {
 		php_printf("%*c", level - 1, ' ');
 	}
 
-	switch (Z_TYPE_PP(struc)) {
+again:
+	switch (Z_TYPE_P(struc)) {
 	case IS_BOOL:
-		php_printf("%sbool(%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc)?"true":"false", Z_REFCOUNT_PP(struc));
+		php_printf("%sbool(%s)\n", COMMON, Z_LVAL_P(struc)?"true":"false");
 		break;
 	case IS_NULL:
-		php_printf("%sNULL refcount(%u)\n", COMMON, Z_REFCOUNT_PP(struc));
+		php_printf("%sNULL\n", COMMON);
 		break;
 	case IS_LONG:
-		php_printf("%slong(%ld) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), Z_REFCOUNT_PP(struc));
+		php_printf("%slong(%ld)\n", COMMON, Z_LVAL_P(struc));
 		break;
 	case IS_DOUBLE:
-		php_printf("%sdouble(%.*G) refcount(%u)\n", COMMON, (int) EG(precision), Z_DVAL_PP(struc), Z_REFCOUNT_PP(struc));
+		php_printf("%sdouble(%.*G)\n", COMMON, (int) EG(precision), Z_DVAL_P(struc));
 		break;
 	case IS_STRING:
-		php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_PP(struc));
-		PHPWRITE(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc));
-		php_printf("\" refcount(%u)\n", Z_REFCOUNT_PP(struc));
+		php_printf("%sstring(%d) \"", COMMON, Z_STRLEN_P(struc));
+		PHPWRITE(Z_STRVAL_P(struc), Z_STRLEN_P(struc));
+		php_printf("\" refcount(%u)\n", IS_INTERNED(Z_STR_P(struc)) ? 1 : Z_REFCOUNT_P(struc));
 		break;
 	case IS_ARRAY:
-		myht = Z_ARRVAL_PP(struc);
-		if (myht->nApplyCount > 1) {
+		myht = Z_ARRVAL_P(struc);
+		if (myht->u.v.nApplyCount > 1) {
 			PUTS("*RECURSION*\n");
 			return;
 		}
-		php_printf("%sarray(%d) refcount(%u){\n", COMMON, zend_hash_num_elements(myht), Z_REFCOUNT_PP(struc));
+		php_printf("%sarray(%d) refcount(%u){\n", COMMON, zend_hash_num_elements(myht), Z_REFCOUNT_P(struc));
 		zval_element_dump_func = zval_array_element_dump;
 		goto head_done;
 	case IS_OBJECT:
-		myht = Z_OBJDEBUG_PP(struc, is_temp);
-		if (myht && myht->nApplyCount > 1) {
+		myht = Z_OBJDEBUG_P(struc, is_temp);
+		if (myht && myht->u.v.nApplyCount > 1) {
 			PUTS("*RECURSION*\n");
 			return;
 		}
-		Z_OBJ_HANDLER_PP(struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
-		php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name, Z_OBJ_HANDLE_PP(struc), myht ? zend_hash_num_elements(myht) : 0, Z_REFCOUNT_PP(struc));
-		efree((char*)class_name);
+		class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc), 0 TSRMLS_CC);
+		php_printf("%sobject(%s)#%d (%d) refcount(%u){\n", COMMON, class_name->val, Z_OBJ_HANDLE_P(struc), myht ? zend_obj_num_elements(myht) : 0, Z_REFCOUNT_P(struc));
+		STR_RELEASE(class_name);
 		zval_element_dump_func = zval_object_property_dump;
 head_done:
 		if (myht) {
-			zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) zval_element_dump_func, 1, level, (Z_TYPE_PP(struc) == IS_ARRAY ? 0 : 1));
+			zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) zval_element_dump_func, 1, level, (Z_TYPE_P(struc) == IS_ARRAY ? 0 : 1));
 			if (is_temp) {
 				zend_hash_destroy(myht);
 				efree(myht);
@@ -302,10 +354,17 @@ head_done:
 		PUTS("}\n");
 		break;
 	case IS_RESOURCE: {
-		const char *type_name = zend_rsrc_list_get_rsrc_type(Z_LVAL_PP(struc) TSRMLS_CC);
-		php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_LVAL_PP(struc), type_name ? type_name : "Unknown", Z_REFCOUNT_PP(struc));
+		const char *type_name = zend_rsrc_list_get_rsrc_type(Z_RES_P(struc) TSRMLS_CC);
+		php_printf("%sresource(%ld) of type (%s) refcount(%u)\n", COMMON, Z_RES_P(struc)->handle, type_name ? type_name : "Unknown", Z_REFCOUNT_P(struc));
 		break;
 	}
+	case IS_REFERENCE:
+		//??? hide references with refcount==1 (for compatibility)
+		if (Z_REFCOUNT_P(struc) > 1) {
+			is_ref = 1;
+		}
+		struc = Z_REFVAL_P(struc);
+		goto again;
 	default:
 		php_printf("%sUNKNOWN:0\n", COMMON);
 		break;
@@ -317,7 +376,7 @@ head_done:
    Dumps a string representation of an internal zend value to output. */
 PHP_FUNCTION(debug_zval_dump)
 {
-	zval ***args;
+	zval *args;
 	int argc;
 	int	i;
 
@@ -326,9 +385,8 @@ PHP_FUNCTION(debug_zval_dump)
 	}
 
 	for (i = 0; i < argc; i++) {
-		php_debug_zval_dump(args[i], 1 TSRMLS_CC);
+		php_debug_zval_dump(&args[i], 1 TSRMLS_CC);
 	}
-	efree(args);
 }
 /* }}} */
 
@@ -341,7 +399,7 @@ PHP_FUNCTION(debug_zval_dump)
 		efree(tmp_spaces); \
 	} while(0);
 
-static int php_array_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int php_array_element_export(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	int level;
 	smart_str *buf;
@@ -349,25 +407,30 @@ static int php_array_element_export(zval **zv TSRMLS_DC, int num_args, va_list a
 	level = va_arg(args, int);
 	buf = va_arg(args, smart_str *);
 
-	if (hash_key->nKeyLength == 0) { /* numeric key */
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+		if (Z_TYPE_P(zv) == IS_UNDEF) {
+			return 0;
+		}
+	}
+	if (hash_key->key == NULL) { /* numeric key */
 		buffer_append_spaces(buf, level+1);
 		smart_str_append_long(buf, (long) hash_key->h);
 		smart_str_appendl(buf, " => ", 4);
 
 	} else { /* string key */
-		char *key, *tmp_str;
-		int key_len, tmp_len;
-		key = php_addcslashes(hash_key->arKey, hash_key->nKeyLength - 1, &key_len, 0, "'\\", 2 TSRMLS_CC);
-		tmp_str = php_str_to_str_ex(key, key_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len, 0, NULL);
+		zend_string *tmp_str;
+		zend_string *key = php_addcslashes(hash_key->key->val, hash_key->key->len, 0, "'\\", 2 TSRMLS_CC);
+		tmp_str = php_str_to_str_ex(key->val, key->len, "\0", 1, "' . \"\\0\" . '", 12, 0, NULL);
 
 		buffer_append_spaces(buf, level + 1);
 
 		smart_str_appendc(buf, '\'');
-		smart_str_appendl(buf, tmp_str, tmp_len);
+		smart_str_appendl(buf, tmp_str->val, tmp_str->len);
 		smart_str_appendl(buf, "' => ", 5);
 
-		efree(key);
-		efree(tmp_str);
+		STR_FREE(key);
+		STR_FREE(tmp_str);
 	}
 	php_var_export_ex(zv, level + 2, buf TSRMLS_CC);
 
@@ -378,7 +441,7 @@ static int php_array_element_export(zval **zv TSRMLS_DC, int num_args, va_list a
 }
 /* }}} */
 
-static int php_object_element_export(zval **zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
+static int php_object_element_export(zval *zv TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */
 {
 	int level;
 	smart_str *buf;
@@ -386,22 +449,27 @@ static int php_object_element_export(zval **zv TSRMLS_DC, int num_args, va_list
 	level = va_arg(args, int);
 	buf = va_arg(args, smart_str *);
 
+	if (Z_TYPE_P(zv) == IS_INDIRECT) {
+		zv = Z_INDIRECT_P(zv);
+		if (Z_TYPE_P(zv) == IS_UNDEF) {
+			return 0;
+		}
+	}
+
 	buffer_append_spaces(buf, level + 2);
-	if (hash_key->nKeyLength != 0) {
+	if (hash_key->key != NULL) {
 		const char *class_name; /* ignored, but must be passed to unmangle */
 		const char *pname;
-		char *pname_esc;
-		int  pname_esc_len;
+		zend_string *pname_esc;
 		
-		zend_unmangle_property_name(hash_key->arKey, hash_key->nKeyLength - 1,
+		zend_unmangle_property_name(hash_key->key->val, hash_key->key->len,
 				&class_name, &pname);
-		pname_esc = php_addcslashes(pname, strlen(pname), &pname_esc_len, 0,
-			"'\\", 2 TSRMLS_CC);
+		pname_esc = php_addcslashes(pname, strlen(pname), 0, "'\\", 2 TSRMLS_CC);
 
 		smart_str_appendc(buf, '\'');
-		smart_str_appendl(buf, pname_esc, pname_esc_len);
+		smart_str_appendl(buf, pname_esc->val, pname_esc->len);
 		smart_str_appendc(buf, '\'');
-		efree(pname_esc);
+		STR_RELEASE(pname_esc);
 	} else {
 		smart_str_append_long(buf, (long) hash_key->h);
 	}
@@ -413,105 +481,110 @@ static int php_object_element_export(zval **zv TSRMLS_DC, int num_args, va_list
 }
 /* }}} */
 
-PHPAPI void php_var_export_ex(zval **struc, int level, smart_str *buf TSRMLS_DC) /* {{{ */
+PHPAPI void php_var_export_ex(zval *struc, int level, smart_str *buf TSRMLS_DC) /* {{{ */
 {
 	HashTable *myht;
-	char *tmp_str, *tmp_str2;
-	int tmp_len, tmp_len2;
-	const char *class_name;
-	zend_uint class_name_len;
+	char *tmp_str;
+	int tmp_len;
+	zend_string *class_name;
+	zend_string *ztmp, *ztmp2;
 
-	switch (Z_TYPE_PP(struc)) {
-	case IS_BOOL:
-		if (Z_LVAL_PP(struc)) {
-			smart_str_appendl(buf, "true", 4);
-		} else {
-			smart_str_appendl(buf, "false", 5);
-		}
-		break;
-	case IS_NULL:
-		smart_str_appendl(buf, "NULL", 4);
-		break;
-	case IS_LONG:
-		smart_str_append_long(buf, Z_LVAL_PP(struc));
-		break;
-	case IS_DOUBLE:
-		tmp_len = spprintf(&tmp_str, 0,"%.*H", PG(serialize_precision), Z_DVAL_PP(struc));
-		smart_str_appendl(buf, tmp_str, tmp_len);
-		efree(tmp_str);
-		break;
-	case IS_STRING:
-		tmp_str = php_addcslashes(Z_STRVAL_PP(struc), Z_STRLEN_PP(struc), &tmp_len, 0, "'\\", 2 TSRMLS_CC);
-		tmp_str2 = php_str_to_str_ex(tmp_str, tmp_len, "\0", 1, "' . \"\\0\" . '", 12, &tmp_len2, 0, NULL);
-
-		smart_str_appendc(buf, '\'');
-		smart_str_appendl(buf, tmp_str2, tmp_len2);
-		smart_str_appendc(buf, '\'');
-
-		efree(tmp_str2);
-		efree(tmp_str);
-		break;
-	case IS_ARRAY:
-		myht = Z_ARRVAL_PP(struc);
-		if (myht->nApplyCount > 0){
+again:
+	switch (Z_TYPE_P(struc)) {
+		case IS_BOOL:
+			if (Z_LVAL_P(struc)) {
+				smart_str_appendl(buf, "true", 4);
+			} else {
+				smart_str_appendl(buf, "false", 5);
+			}
+			break;
+		case IS_NULL:
 			smart_str_appendl(buf, "NULL", 4);
-			zend_error(E_WARNING, "var_export does not handle circular references");
-			return;
-		}
-		if (level > 1) {
-			smart_str_appendc(buf, '\n');
-			buffer_append_spaces(buf, level - 1);
-		}
-		smart_str_appendl(buf, "array (\n", 8);
-		zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_array_element_export, 2, level, buf);
+			break;
+		case IS_LONG:
+			smart_str_append_long(buf, Z_LVAL_P(struc));
+			break;
+		case IS_DOUBLE:
+			tmp_len = spprintf(&tmp_str, 0,"%.*H", PG(serialize_precision), Z_DVAL_P(struc));
+			smart_str_appendl(buf, tmp_str, tmp_len);
+			efree(tmp_str);
+			break;
+		case IS_STRING:
+			ztmp = php_addcslashes(Z_STRVAL_P(struc), Z_STRLEN_P(struc), 0, "'\\", 2 TSRMLS_CC);
+			ztmp2 = php_str_to_str_ex(ztmp->val, ztmp->len, "\0", 1, "' . \"\\0\" . '", 12, 0, NULL);
+
+			smart_str_appendc(buf, '\'');
+			smart_str_appendl(buf, ztmp2->val, ztmp2->len);
+			smart_str_appendc(buf, '\'');
+
+			STR_FREE(ztmp);
+			STR_FREE(ztmp2);
+			break;
+		case IS_ARRAY:
+			myht = Z_ARRVAL_P(struc);
+			if (myht->u.v.nApplyCount > 0){
+				smart_str_appendl(buf, "NULL", 4);
+				zend_error(E_WARNING, "var_export does not handle circular references");
+				return;
+			}
+			if (level > 1) {
+				smart_str_appendc(buf, '\n');
+				buffer_append_spaces(buf, level - 1);
+			}
+			smart_str_appendl(buf, "array (\n", 8);
+			zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_array_element_export, 2, level, buf);
 
-		if (level > 1) {
-			buffer_append_spaces(buf, level - 1);
-		}
-		smart_str_appendc(buf, ')');
-    
-		break;
+			if (level > 1) {
+				buffer_append_spaces(buf, level - 1);
+			}
+			smart_str_appendc(buf, ')');
+		
+			break;
 
-	case IS_OBJECT:
-		myht = Z_OBJPROP_PP(struc);
-		if(myht && myht->nApplyCount > 0){
-			smart_str_appendl(buf, "NULL", 4);
-			zend_error(E_WARNING, "var_export does not handle circular references");
-			return;
-		}
-		if (level > 1) {
-			smart_str_appendc(buf, '\n');
-			buffer_append_spaces(buf, level - 1);
-		}
-		Z_OBJ_HANDLER(**struc, get_class_name)(*struc, &class_name, &class_name_len, 0 TSRMLS_CC);
+		case IS_OBJECT:
+			myht = Z_OBJPROP_P(struc);
+			if(myht && myht->u.v.nApplyCount > 0){
+				smart_str_appendl(buf, "NULL", 4);
+				zend_error(E_WARNING, "var_export does not handle circular references");
+				return;
+			}
+			if (level > 1) {
+				smart_str_appendc(buf, '\n');
+				buffer_append_spaces(buf, level - 1);
+			}
+			class_name = Z_OBJ_HANDLER_P(struc, get_class_name)(Z_OBJ_P(struc), 0 TSRMLS_CC);
 
-		smart_str_appendl(buf, class_name, class_name_len);
-		smart_str_appendl(buf, "::__set_state(array(\n", 21);
+			smart_str_appendl(buf, class_name->val, class_name->len);
+			smart_str_appendl(buf, "::__set_state(array(\n", 21);
 
-		efree((char*)class_name);
-		if (myht) {
-			zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_object_element_export, 1, level, buf);
-		}
-		if (level > 1) {
-			buffer_append_spaces(buf, level - 1);
-		}
-		smart_str_appendl(buf, "))", 2);
+			STR_RELEASE(class_name);
+			if (myht) {
+				zend_hash_apply_with_arguments(myht TSRMLS_CC, (apply_func_args_t) php_object_element_export, 1, level, buf);
+			}
+			if (level > 1) {
+				buffer_append_spaces(buf, level - 1);
+			}
+			smart_str_appendl(buf, "))", 2);
 
-		break;
-	default:
-		smart_str_appendl(buf, "NULL", 4);
-		break;
+			break;
+		case IS_REFERENCE:
+			struc = Z_REFVAL_P(struc);
+			goto again;
+			break;
+		default:
+			smart_str_appendl(buf, "NULL", 4);
+			break;
 	}
 }
 /* }}} */
 
 /* FOR BC reasons, this will always perform and then print */
-PHPAPI void php_var_export(zval **struc, int level TSRMLS_DC) /* {{{ */
+PHPAPI void php_var_export(zval *struc, int level TSRMLS_DC) /* {{{ */
 {
 	smart_str buf = {0};
 	php_var_export_ex(struc, level, &buf TSRMLS_CC);
-	smart_str_0 (&buf);
-	PHPWRITE(buf.c, buf.len);
+	smart_str_0(&buf);
+	PHPWRITE(buf.s->val, buf.s->len);
 	smart_str_free(&buf);
 }
 /* }}} */
@@ -529,42 +602,52 @@ PHP_FUNCTION(var_export)
 		return;
 	}
 
-	php_var_export_ex(&var, 1, &buf TSRMLS_CC);
+	php_var_export_ex(var, 1, &buf TSRMLS_CC);
 	smart_str_0 (&buf);
 
 	if (return_output) {
-		RETVAL_STRINGL(buf.c, buf.len, 1);
+		RETURN_STR(buf.s);
 	} else {
-		PHPWRITE(buf.c, buf.len);
+		PHPWRITE(buf.s->val, buf.s->len);
+		smart_str_free(&buf);
 	}
-	smart_str_free(&buf);
 }
 /* }}} */
 
 static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC);
 
-static inline int php_add_var_hash(HashTable *var_hash, zval *var, void *var_old TSRMLS_DC) /* {{{ */
+static inline int php_add_var_hash(HashTable *var_hash, zval *var_ptr, zval *var_old TSRMLS_DC) /* {{{ */
 {
-	ulong var_no;
+	zval var_no, *zv;
 	char id[32], *p;
 	register int len;
+	zval *var = var_ptr;
 
+	if (Z_ISREF_P(var)) {
+		var = Z_REFVAL_P(var);
+	}
 	if ((Z_TYPE_P(var) == IS_OBJECT) && Z_OBJ_HT_P(var)->get_class_entry) {
 		p = smart_str_print_long(id + sizeof(id) - 1,
-				(long) zend_objects_get_address(var TSRMLS_CC));
+				(long) Z_OBJ_P(var));
 		*(--p) = 'O';
 		len = id + sizeof(id) - 1 - p;
+	} else if (var_ptr != var) {
+		p = smart_str_print_long(id + sizeof(id) - 1,
+				(long) Z_REF_P(var_ptr));
+		*(--p) = 'R';
+		len = id + sizeof(id) - 1 - p;
 	} else {
 		p = smart_str_print_long(id + sizeof(id) - 1, (long) var);
 		len = id + sizeof(id) - 1 - p;
 	}
 
-	if (var_old && zend_hash_find(var_hash, p, len, var_old) == SUCCESS) {
-		if (!Z_ISREF_P(var)) {
+	if ((zv = zend_hash_str_find(var_hash, p, len)) != NULL) {
+		ZVAL_COPY_VALUE(var_old, zv);
+		if (var == var_ptr) {
 			/* we still need to bump up the counter, since non-refs will
 			 * be counted separately by unserializer */
-			var_no = -1;
-			zend_hash_next_index_insert(var_hash, &var_no, sizeof(var_no), NULL);
+			ZVAL_LONG(&var_no, -1);
+			zend_hash_next_index_insert(var_hash, &var_no);
 		}
 #if 0
 		fprintf(stderr, "- had var (%d): %lu\n", Z_TYPE_P(var), **(ulong**)var_old);
@@ -573,10 +656,10 @@ static inline int php_add_var_hash(HashTable *var_hash, zval *var, void *var_old
 	}
 
 	/* +1 because otherwise hash will think we are trying to store NULL pointer */
-	var_no = zend_hash_num_elements(var_hash) + 1;
-	zend_hash_add(var_hash, p, len, &var_no, sizeof(var_no), NULL);
+	ZVAL_LONG(&var_no, zend_hash_num_elements(var_hash) + 1);
+	zend_hash_str_add(var_hash, p, len, &var_no);
 #if 0
-	fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), var_no);
+	fprintf(stderr, "+ add var (%d): %lu\n", Z_TYPE_P(var), Z_LVAL(var_no));
 #endif
 	return SUCCESS;
 }
@@ -606,9 +689,9 @@ static inline zend_bool php_var_serialize_class_name(smart_str *buf, zval *struc
 
 	PHP_SET_CLASS_ATTRIBUTES(struc);
 	smart_str_appendl(buf, "O:", 2);
-	smart_str_append_long(buf, (int)name_len);
+	smart_str_append_long(buf, (int)class_name->len);
 	smart_str_appendl(buf, ":\"", 2);
-	smart_str_appendl(buf, class_name, name_len);
+	smart_str_appendl(buf, class_name->val, class_name->len);
 	smart_str_appendl(buf, "\":", 2);
 	PHP_CLEANUP_CLASS_ATTRIBUTES();
 	return incomplete_class;
@@ -631,32 +714,23 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt
 	smart_str_appendl(buf, ":{", 2);
 
 	if (count > 0) {
-		char *key;
-		zval **d, **name;
+		zend_string *key;
+		zval *d, *name;
 		ulong index;
-		HashPosition pos;
 		int i;
 		zval nval, *nvalp;
-		HashTable *propers;
+		HashTable *propers, *ht;
 
 		ZVAL_NULL(&nval);
 		nvalp = &nval;
 
-		zend_hash_internal_pointer_reset_ex(HASH_OF(retval_ptr), &pos);
-
-		for (;; zend_hash_move_forward_ex(HASH_OF(retval_ptr), &pos)) {
-			i = zend_hash_get_current_key_ex(HASH_OF(retval_ptr), &key, NULL, &index, 0, &pos);
-
-			if (i == HASH_KEY_NON_EXISTENT) {
-				break;
-			}
-
-			if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
+		ht = HASH_OF(retval_ptr);
+		ZEND_HASH_FOREACH_KEY_VAL(ht, index, key, name) {
+			if (incomplete_class && strcmp(key->val, MAGIC_MEMBER) == 0) {
 				continue;
 			}
-			zend_hash_get_current_data_ex(HASH_OF(retval_ptr), (void **) &name, &pos);
 
-			if (Z_TYPE_PP(name) != IS_STRING) {
+			if (Z_TYPE_P(name) != IS_STRING) {
 				php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize.");
 				/* we should still add element even if it's not OK,
 				 * since we already wrote the length of the array before */
@@ -664,43 +738,62 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt
 				continue;
 			}
 			propers = Z_OBJPROP_P(struc);
-			if (zend_hash_find(propers, Z_STRVAL_PP(name), Z_STRLEN_PP(name) + 1, (void *) &d) == SUCCESS) {
-				php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
-				php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
+			if ((d = zend_hash_find(propers, Z_STR_P(name))) != NULL) {
+				if (Z_TYPE_P(d) == IS_INDIRECT) {
+					d = Z_INDIRECT_P(d);
+					if (Z_TYPE_P(d) == IS_UNDEF) {
+						continue;
+					}
+				}
+				php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name));
+				php_var_serialize_intern(buf, d, var_hash TSRMLS_CC);
 			} else {
 				zend_class_entry *ce;
-				ce = zend_get_class_entry(struc TSRMLS_CC);
+				ce = zend_get_class_entry(Z_OBJ_P(struc) TSRMLS_CC);
 				if (ce) {
-					char *prot_name, *priv_name;
-					int prop_name_length;
+					zend_string *prot_name, *priv_name;
 
 					do {
-						zend_mangle_property_name(&priv_name, &prop_name_length, ce->name, ce->name_length, Z_STRVAL_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
-						if (zend_hash_find(propers, priv_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
-							php_var_serialize_string(buf, priv_name, prop_name_length);
-							pefree(priv_name, ce->type & ZEND_INTERNAL_CLASS);
-							php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
+						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) {
+							if (Z_TYPE_P(d) == IS_INDIRECT) {
+								d = Z_INDIRECT_P(d);
+								if (Z_TYPE_P(d) == IS_UNDEF) {
+									STR_FREE(prot_name);
+									break;
+								}
+							}
+							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_PP(name), Z_STRLEN_PP(name), ce->type & ZEND_INTERNAL_CLASS);
-						if (zend_hash_find(propers, prot_name, prop_name_length + 1, (void *) &d) == SUCCESS) {
-							php_var_serialize_string(buf, prot_name, prop_name_length);
-							pefree(prot_name, ce->type & ZEND_INTERNAL_CLASS);
-							php_var_serialize_intern(buf, *d, var_hash TSRMLS_CC);
+						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) {
+							if (Z_TYPE_P(d) == IS_INDIRECT) {
+								d = Z_INDIRECT_P(d);
+								if (Z_TYPE_P(d) == IS_UNDEF) {
+									STR_FREE(prot_name);
+									break;
+								}
+							}
+							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);
-						php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
+						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_PP(name));
+						php_error_docref(NULL TSRMLS_CC, E_NOTICE, "\"%s\" returned as member variable from __sleep() but does not exist", Z_STRVAL_P(name));
 					} while (0);
 				} else {
-					php_var_serialize_string(buf, Z_STRVAL_PP(name), Z_STRLEN_PP(name));
+					php_var_serialize_string(buf, Z_STRVAL_P(name), Z_STRLEN_P(name));
 					php_var_serialize_intern(buf, nvalp, var_hash TSRMLS_CC);
 				}
 			}
-		}
+		} ZEND_HASH_FOREACH_END();
 	}
 	smart_str_appendc(buf, '}');
 }
@@ -709,27 +802,31 @@ static void php_var_serialize_class(smart_str *buf, zval *struc, zval *retval_pt
 static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var_hash TSRMLS_DC) /* {{{ */
 {
 	int i;
-	ulong *var_already;
+	zval var_already;
 	HashTable *myht;
 
 	if (EG(exception)) {
 		return;
 	}
 
-	if (var_hash && php_add_var_hash(var_hash, struc, (void *) &var_already TSRMLS_CC) == FAILURE) {
+	ZVAL_UNDEF(&var_already);
+
+	if (var_hash &&
+		php_add_var_hash(var_hash, struc, &var_already TSRMLS_CC) == FAILURE) {
 		if (Z_ISREF_P(struc)) {
 			smart_str_appendl(buf, "R:", 2);
-			smart_str_append_long(buf, (long)*var_already);
+			smart_str_append_long(buf, Z_LVAL(var_already));
 			smart_str_appendc(buf, ';');
 			return;
 		} else if (Z_TYPE_P(struc) == IS_OBJECT) {
 			smart_str_appendl(buf, "r:", 2);
-			smart_str_append_long(buf, (long)*var_already);
+			smart_str_append_long(buf, Z_LVAL(var_already));
 			smart_str_appendc(buf, ';');
 			return;
 		}
 	}
 
+again:
 	switch (Z_TYPE_P(struc)) {
 		case IS_BOOL:
 			smart_str_appendl(buf, "b:", 2);
@@ -762,7 +859,7 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
 			return;
 
 		case IS_OBJECT: {
-				zval *retval_ptr = NULL;
+				zval retval;
 				zval fname;
 				int res;
 				zend_class_entry *ce = NULL;
@@ -778,9 +875,9 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
 
 					if (ce->serialize(struc, &serialized_data, &serialized_length, (zend_serialize_data *)var_hash TSRMLS_CC) == SUCCESS) {
 						smart_str_appendl(buf, "C:", 2);
-						smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name_length);
+						smart_str_append_long(buf, (int)Z_OBJCE_P(struc)->name->len);
 						smart_str_appendl(buf, ":\"", 2);
-						smart_str_appendl(buf, Z_OBJCE_P(struc)->name, Z_OBJCE_P(struc)->name_length);
+						smart_str_appendl(buf, Z_OBJCE_P(struc)->name->val, Z_OBJCE_P(struc)->name->len);
 						smart_str_appendl(buf, "\":", 2);
 
 						smart_str_append_long(buf, (int)serialized_length);
@@ -796,39 +893,35 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
 					return;
 				}
 
-				if (ce && ce != PHP_IC_ENTRY && zend_hash_exists(&ce->function_table, "__sleep", sizeof("__sleep"))) {
-					INIT_PZVAL(&fname);
-					ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1, 0);
+				if (ce && ce != PHP_IC_ENTRY && zend_hash_str_exists(&ce->function_table, "__sleep", sizeof("__sleep")-1)) {
+					ZVAL_STRINGL(&fname, "__sleep", sizeof("__sleep") - 1);
 					BG(serialize_lock)++;
-					res = call_user_function_ex(CG(function_table), &struc, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
+					res = call_user_function_ex(CG(function_table), struc, &fname, &retval, 0, 0, 1, NULL TSRMLS_CC);
 					BG(serialize_lock)--;
+					zval_dtor(&fname);
                     
 					if (EG(exception)) {
-						if (retval_ptr) {
-							zval_ptr_dtor(&retval_ptr);
-						}
+						zval_ptr_dtor(&retval);
 						return;
 					}
 
 					if (res == SUCCESS) {
-						if (retval_ptr) {
-							if (HASH_OF(retval_ptr)) {
-								php_var_serialize_class(buf, struc, retval_ptr, var_hash TSRMLS_CC);
+						if (Z_TYPE(retval) != IS_UNDEF) {
+							if (HASH_OF(&retval)) {
+								php_var_serialize_class(buf, struc, &retval, var_hash TSRMLS_CC);
 							} else {
 								php_error_docref(NULL TSRMLS_CC, E_NOTICE, "__sleep should return an array only containing the names of instance-variables to serialize");
 								/* we should still add element even if it's not OK,
 								 * since we already wrote the length of the array before */
 								smart_str_appendl(buf,"N;", 2);
 							}
-							zval_ptr_dtor(&retval_ptr);
+							zval_ptr_dtor(&retval);
 						}
 						return;
 					}
+					zval_ptr_dtor(&retval);
 				}
 
-				if (retval_ptr) {
-					zval_ptr_dtor(&retval_ptr);
-				}
 				/* fall-through */
 			}
 		case IS_ARRAY: {
@@ -849,53 +942,45 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
 			smart_str_append_long(buf, i);
 			smart_str_appendl(buf, ":{", 2);
 			if (i > 0) {
-				char *key;
-				zval **data;
+				zend_string *key;
+				zval *data;
 				ulong index;
-				uint key_len;
-				HashPosition pos;
-
-				zend_hash_internal_pointer_reset_ex(myht, &pos);
-				for (;; zend_hash_move_forward_ex(myht, &pos)) {
-					i = zend_hash_get_current_key_ex(myht, &key, &key_len, &index, 0, &pos);
-					if (i == HASH_KEY_NON_EXISTENT) {
-						break;
-					}
-					if (incomplete_class && strcmp(key, MAGIC_MEMBER) == 0) {
+
+				ZEND_HASH_FOREACH_KEY_VAL_IND(myht, index, key, data) {
+
+					if (incomplete_class && strcmp(key->val, MAGIC_MEMBER) == 0) {
 						continue;
 					}
 
-					switch (i) {
-						case HASH_KEY_IS_LONG:
-							php_var_serialize_long(buf, index);
-							break;
-						case HASH_KEY_IS_STRING:
-							php_var_serialize_string(buf, key, key_len - 1);
-							break;
+					if (!key) {
+						php_var_serialize_long(buf, index);
+					} else {
+						php_var_serialize_string(buf, key->val, key->len);
 					}
 
 					/* we should still add element even if it's not OK,
 					 * since we already wrote the length of the array before */
-					if (zend_hash_get_current_data_ex(myht, (void **) &data, &pos) != SUCCESS
-						|| !data
-						|| data == &struc
-						|| (Z_TYPE_PP(data) == IS_ARRAY && Z_ARRVAL_PP(data)->nApplyCount > 1)
+					if ((Z_TYPE_P(data) == IS_ARRAY && Z_TYPE_P(struc) == IS_ARRAY && Z_ARR_P(data) == Z_ARR_P(struc))
+						|| (Z_TYPE_P(data) == IS_ARRAY && Z_ARRVAL_P(data)->u.v.nApplyCount > 1)
 					) {
 						smart_str_appendl(buf, "N;", 2);
 					} else {
-						if (Z_TYPE_PP(data) == IS_ARRAY) {
-							Z_ARRVAL_PP(data)->nApplyCount++;
+						if (Z_TYPE_P(data) == IS_ARRAY) {
+							Z_ARRVAL_P(data)->u.v.nApplyCount++;
 						}
-						php_var_serialize_intern(buf, *data, var_hash TSRMLS_CC);
-						if (Z_TYPE_PP(data) == IS_ARRAY) {
-							Z_ARRVAL_PP(data)->nApplyCount--;
+						php_var_serialize_intern(buf, data, var_hash TSRMLS_CC);
+						if (Z_TYPE_P(data) == IS_ARRAY) {
+							Z_ARRVAL_P(data)->u.v.nApplyCount--;
 						}
 					}
-				}
+				} ZEND_HASH_FOREACH_END();
 			}
 			smart_str_appendc(buf, '}');
 			return;
 		}
+		case IS_REFERENCE:
+			struc = Z_REFVAL_P(struc);
+			goto again;
 		default:
 			smart_str_appendl(buf, "i:0;", 4);
 			return;
@@ -903,9 +988,9 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
 }
 /* }}} */
 
-PHPAPI void php_var_serialize(smart_str *buf, zval **struc, php_serialize_data_t *var_hash TSRMLS_DC) /* {{{ */
+PHPAPI void php_var_serialize(smart_str *buf, zval *struc, php_serialize_data_t *var_hash TSRMLS_DC) /* {{{ */
 {
-	php_var_serialize_intern(buf, *struc, *var_hash TSRMLS_CC);
+	php_var_serialize_intern(buf, struc, *var_hash TSRMLS_CC);
 	smart_str_0(buf);
 }
 /* }}} */
@@ -914,18 +999,14 @@ PHPAPI void php_var_serialize(smart_str *buf, zval **struc, php_serialize_data_t
    Returns a string representation of variable (which can later be unserialized) */
 PHP_FUNCTION(serialize)
 {
-	zval **struc;
+	zval *struc;
 	php_serialize_data_t var_hash;
 	smart_str buf = {0};
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Z", &struc) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &struc) == FAILURE) {
 		return;
 	}
 
-	Z_TYPE_P(return_value) = IS_STRING;
-	Z_STRVAL_P(return_value) = NULL;
-	Z_STRLEN_P(return_value) = 0;
-
 	PHP_VAR_SERIALIZE_INIT(var_hash);
 	php_var_serialize(&buf, struc, &var_hash TSRMLS_CC);
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
@@ -935,8 +1016,8 @@ PHP_FUNCTION(serialize)
 		RETURN_FALSE;
 	}
 
-	if (buf.c) {
-		RETURN_STRINGL(buf.c, buf.len, 0);
+	if (buf.s) {
+		RETURN_STR(buf.s);
 	} else {
 		RETURN_NULL();
 	}
@@ -963,7 +1044,7 @@ PHP_FUNCTION(unserialize)
 
 	p = (const unsigned char*) buf;
 	PHP_VAR_UNSERIALIZE_INIT(var_hash);
-	if (!php_var_unserialize(&return_value, &p, p + buf_len, &var_hash TSRMLS_CC)) {
+	if (!php_var_unserialize(return_value, &p, p + buf_len, &var_hash TSRMLS_CC)) {
 		PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
 		zval_dtor(return_value);
 		if (!EG(exception)) {
@@ -973,9 +1054,9 @@ PHP_FUNCTION(unserialize)
 	}
 	PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
 
-	if (consumed) {
-		zval_dtor(consumed);
-		ZVAL_LONG(consumed, ((char*)p) - buf);
+	if (consumed && Z_ISREF_P(consumed)) {
+		zval_dtor(Z_REFVAL_P(consumed));
+		ZVAL_LONG(Z_REFVAL_P(consumed), ((char*)p) - buf);
 	}
 }
 /* }}} */
diff --git a/ext/standard/var_unserializer.c b/ext/standard/var_unserializer.c
index 003bac9547..e1d899587c 100644
--- a/ext/standard/var_unserializer.c
+++ b/ext/standard/var_unserializer.c
@@ -1,4 +1,4 @@
-/* Generated by re2c 0.13.5 on Fri Apr 18 15:07:27 2014 */
+/* Generated by re2c 0.13.5 */
 #line 1 "ext/standard/var_unserializer.re"
 /*
   +----------------------------------------------------------------------+
@@ -34,7 +34,13 @@ typedef struct {
 	void *next;
 } var_entries;
 
-static inline void var_push(php_unserialize_data_t *var_hashx, zval **rval)
+typedef struct {
+	zval data[VAR_ENTRIES_MAX];
+	long used_slots;
+	void *next;
+} var_dtor_entries;
+
+static inline void var_push(php_unserialize_data_t *var_hashx, zval *rval)
 {
 	var_entries *var_hash = (*var_hashx)->last;
 #if VAR_ENTRIES_DBG
@@ -55,18 +61,18 @@ static inline void var_push(php_unserialize_data_t *var_hashx, zval **rval)
 		(*var_hashx)->last = var_hash;
 	}
 
-	var_hash->data[var_hash->used_slots++] = *rval;
+	var_hash->data[var_hash->used_slots++] = rval;
 }
 
-PHPAPI void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
+PHPAPI void var_push_dtor(php_unserialize_data_t *var_hashx, zval *rval)
 {
-	var_entries *var_hash = (*var_hashx)->last_dtor;
+	var_dtor_entries *var_hash = (*var_hashx)->last_dtor;
 #if VAR_ENTRIES_DBG
 	fprintf(stderr, "var_push_dtor(%ld): %d\n", var_hash?var_hash->used_slots:-1L, Z_TYPE_PP(rval));
 #endif
 
 	if (!var_hash || var_hash->used_slots == VAR_ENTRIES_MAX) {
-		var_hash = emalloc(sizeof(var_entries));
+		var_hash = emalloc(sizeof(var_dtor_entries));
 		var_hash->used_slots = 0;
 		var_hash->next = 0;
 
@@ -79,19 +85,21 @@ PHPAPI void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
 		(*var_hashx)->last_dtor = var_hash;
 	}
 
-	Z_ADDREF_PP(rval);
-	var_hash->data[var_hash->used_slots++] = *rval;
+	ZVAL_COPY(&var_hash->data[var_hash->used_slots], rval);
+	var_hash->used_slots++;
 }
 
-PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval **rval)
+//???
+#if 0
+PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval *rval)
 {
-	var_entries *var_hash = (*var_hashx)->last_dtor;
+	var_dtor_entries *var_hash = (*var_hashx)->last_dtor;
 #if VAR_ENTRIES_DBG
 	fprintf(stderr, "var_push_dtor_no_addref(%ld): %d (%d)\n", var_hash?var_hash->used_slots:-1L, Z_TYPE_PP(rval), Z_REFCOUNT_PP(rval));
 #endif
 
 	if (!var_hash || var_hash->used_slots == VAR_ENTRIES_MAX) {
-		var_hash = emalloc(sizeof(var_entries));
+		var_hash = emalloc(sizeof(var_dtor_entries));
 		var_hash->used_slots = 0;
 		var_hash->next = 0;
 
@@ -104,10 +112,12 @@ PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval **rv
 		(*var_hashx)->last_dtor = var_hash;
 	}
 
-	var_hash->data[var_hash->used_slots++] = *rval;
+	ZVAL_COPY_VALUE(&var_hash->data[var_hash->used_slots], rval);
+	var_hash->used_slots++;
 }
+#endif
 
-PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **nzval)
+PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval *nzval)
 {
 	long i;
 	var_entries *var_hash = (*var_hashx)->first;
@@ -118,7 +128,7 @@ PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **n
 	while (var_hash) {
 		for (i = 0; i < var_hash->used_slots; i++) {
 			if (var_hash->data[i] == ozval) {
-				var_hash->data[i] = *nzval;
+				var_hash->data[i] = nzval;
 				/* do not break here */
 			}
 		}
@@ -126,7 +136,7 @@ PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **n
 	}
 }
 
-static int var_access(php_unserialize_data_t *var_hashx, long id, zval ***store)
+static zval *var_access(php_unserialize_data_t *var_hashx, long id)
 {
 	var_entries *var_hash = (*var_hashx)->first;
 #if VAR_ENTRIES_DBG
@@ -138,13 +148,11 @@ static int var_access(php_unserialize_data_t *var_hashx, long id, zval ***store)
 		id -= VAR_ENTRIES_MAX;
 	}
 
-	if (!var_hash) return !SUCCESS;
-
-	if (id < 0 || id >= var_hash->used_slots) return !SUCCESS;
+	if (!var_hash) return NULL;
 
-	*store = &var_hash->data[id];
+	if (id < 0 || id >= var_hash->used_slots) return NULL;
 
-	return SUCCESS;
+	return var_hash->data[id];
 }
 
 PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
@@ -152,6 +160,7 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
 	void *next;
 	long i;
 	var_entries *var_hash = (*var_hashx)->first;
+	var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
 #if VAR_ENTRIES_DBG
 	fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
 #endif
@@ -162,15 +171,13 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
 		var_hash = next;
 	}
 
-	var_hash = (*var_hashx)->first_dtor;
-	
-	while (var_hash) {
-		for (i = 0; i < var_hash->used_slots; i++) {
-			zval_ptr_dtor(&var_hash->data[i]);
+	while (var_dtor_hash) {
+		for (i = 0; i < var_dtor_hash->used_slots; i++) {
+			zval_ptr_dtor(&var_dtor_hash->data[i]);
 		}
-		next = var_hash->next;
-		efree(var_hash);
-		var_hash = next;
+		next = var_dtor_hash->next;
+		efree(var_dtor_hash);
+		var_dtor_hash = next;
 	}
 }
 
@@ -226,7 +233,7 @@ static char *unserialize_str(const unsigned char **p, size_t *len, size_t maxlen
 #define YYMARKER marker
 
 
-#line 234 "ext/standard/var_unserializer.re"
+#line 241 "ext/standard/var_unserializer.re"
 
 
 
@@ -286,62 +293,70 @@ static inline size_t parse_uiv(const unsigned char *p)
 	return result;
 }
 
-#define UNSERIALIZE_PARAMETER zval **rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC
+#define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC
 #define UNSERIALIZE_PASSTHRU rval, p, max, var_hash TSRMLS_CC
 
 static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops)
 {
 	while (elements-- > 0) {
-		zval *key, *data, **old_data;
-
-		ALLOC_INIT_ZVAL(key);
+		zval key, *data, d, *old_data;
 
+		ZVAL_UNDEF(&key);
 		if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
-			zval_dtor(key);
-			FREE_ZVAL(key);
+			zval_dtor(&key);
 			return 0;
 		}
 
-		if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {
-			zval_dtor(key);
-			FREE_ZVAL(key);
+		if (Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING) {
+			zval_dtor(&key);
 			return 0;
 		}
 
-		ALLOC_INIT_ZVAL(data);
-
-		if (!php_var_unserialize(&data, p, max, var_hash TSRMLS_CC)) {
-			zval_dtor(key);
-			FREE_ZVAL(key);
-			zval_dtor(data);
-			FREE_ZVAL(data);
-			return 0;
-		}
+		data = NULL;
+		ZVAL_UNDEF(&d);
 
 		if (!objprops) {
-			switch (Z_TYPE_P(key)) {
+			switch (Z_TYPE(key)) {
 			case IS_LONG:
-				if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {
+				if ((old_data = zend_hash_index_find(ht, Z_LVAL(key))) != NULL) {
+					//??? update hash
 					var_push_dtor(var_hash, old_data);
 				}
-				zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);
+				data = zend_hash_index_update(ht, Z_LVAL(key), &d);
 				break;
 			case IS_STRING:
-				if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
+				if ((old_data = zend_symtable_find(ht, Z_STR(key))) != NULL) {
+					//??? update hash
 					var_push_dtor(var_hash, old_data);
 				}
-				zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);
+				data = zend_symtable_update(ht, Z_STR(key), &d);
 				break;
 			}
 		} else {
 			/* object properties should include no integers */
-			convert_to_string(key);
-			zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data,
-					sizeof data, NULL);
+			convert_to_string(&key);
+//???
+#if 1
+			data = zend_hash_update_ind(ht, Z_STR(key), &d);
+#else
+			if ((data = zend_hash_find(ht, Z_STR(key))) != NULL) {
+				if (Z_TYPE_P(data) == IS_INDIRECT) {
+					data = Z_INDIRECT_P(data);
+				}
+				zval_ptr_dtor(data);
+//???				var_push_dtor(var_hash, data);
+				ZVAL_UNDEF(data);
+			} else {
+				data = zend_hash_update(ht, Z_STR(key), &d);
+			}
+#endif
 		}
 		
-		zval_dtor(key);
-		FREE_ZVAL(key);
+		zval_dtor(&key);
+
+		if (!php_var_unserialize(data, p, max, var_hash TSRMLS_CC)) {
+			return 0;
+		}
 
 		if (elements && *(*p-1) != ';' && *(*p-1) != '}') {
 			(*p)--;
@@ -377,8 +392,8 @@ static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
 	}
 
 	if (ce->unserialize == NULL) {
-		zend_error(E_WARNING, "Class %s has no unserializer", ce->name);
-		object_init_ex(*rval, ce);
+		zend_error(E_WARNING, "Class %s has no unserializer", ce->name->val);
+		object_init_ex(rval, ce);
 	} else if (ce->unserialize(rval, ce, (const unsigned char*)*p, datalen, (zend_unserialize_data *)var_hash TSRMLS_CC) != SUCCESS) {
 		return 0;
 	}
@@ -397,11 +412,11 @@ static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
 	(*p) += 2;
 	
 	if (ce->serialize == NULL) {
-		object_init_ex(*rval, ce);
+		object_init_ex(rval, ce);
 	} else {
 		/* If this class implements Serializable, it should not land here but in object_custom(). The passed string
 		obviously doesn't descend from the regular serializer. */
-		zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ce->name);
+		zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ce->name->val);
 		return 0;
 	}
 
@@ -413,28 +428,27 @@ static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
 #endif
 static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
 {
-	zval *retval_ptr = NULL;
+	zval retval;
 	zval fname;
 
-	if (Z_TYPE_PP(rval) != IS_OBJECT) {
+	if (Z_TYPE_P(rval) != IS_OBJECT) {
 		return 0;
 	}
 
-	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_PP(rval), elements, 1)) {
+	//??? TODO: resize before
+	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_P(rval), elements, 1)) {
 		return 0;
 	}
 
-	if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
-		zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
-		INIT_PZVAL(&fname);
-		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
+	ZVAL_DEREF(rval);
+	if (Z_OBJCE_P(rval) != PHP_IC_ENTRY &&
+		zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) {
+		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1);
 		BG(serialize_lock)++;
-		call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
+		call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL TSRMLS_CC);
 		BG(serialize_lock)--;
-	}
-
-	if (retval_ptr) {
-		zval_ptr_dtor(&retval_ptr);
+		zval_dtor(&fname);
+		zval_dtor(&retval);
 	}
 
 	if (EG(exception)) {
@@ -451,7 +465,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
 PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 {
 	const unsigned char *cursor, *limit, *marker, *start;
-	zval **rval_ref;
+	zval *rval_ref;
 
 	limit = max;
 	cursor = *p;
@@ -460,16 +474,14 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 		return 0;
 	}
 	
-	if (var_hash && cursor[0] != 'R') {
+	if (var_hash && (*p)[0] != 'R') {
 		var_push(var_hash, rval);
 	}
 
 	start = cursor;
 
-	
-	
 
-#line 473 "ext/standard/var_unserializer.c"
+#line 485 "ext/standard/var_unserializer.c"
 {
 	YYCTYPE yych;
 	static const unsigned char yybm[] = {
@@ -529,9 +541,9 @@ yy2:
 	yych = *(YYMARKER = ++YYCURSOR);
 	if (yych == ':') goto yy95;
 yy3:
-#line 824 "ext/standard/var_unserializer.re"
+#line 829 "ext/standard/var_unserializer.re"
 	{ return 0; }
-#line 535 "ext/standard/var_unserializer.c"
+#line 547 "ext/standard/var_unserializer.c"
 yy4:
 	yych = *(YYMARKER = ++YYCURSOR);
 	if (yych == ':') goto yy89;
@@ -574,13 +586,13 @@ yy13:
 	goto yy3;
 yy14:
 	++YYCURSOR;
-#line 818 "ext/standard/var_unserializer.re"
+#line 823 "ext/standard/var_unserializer.re"
 	{
 	/* this is the case where we have less data than planned */
 	php_error_docref(NULL TSRMLS_CC, E_NOTICE, "Unexpected end of serialized data");
 	return 0; /* not sure if it should be 0 or 1 here? */
 }
-#line 584 "ext/standard/var_unserializer.c"
+#line 596 "ext/standard/var_unserializer.c"
 yy16:
 	yych = *++YYCURSOR;
 	goto yy3;
@@ -610,27 +622,26 @@ yy20:
 	yych = *++YYCURSOR;
 	if (yych != '"') goto yy18;
 	++YYCURSOR;
-#line 672 "ext/standard/var_unserializer.re"
+#line 684 "ext/standard/var_unserializer.re"
 	{
 	size_t len, len2, len3, maxlen;
 	long elements;
-	char *class_name;
+	char *str;
+	zend_string *class_name;
 	zend_class_entry *ce;
-	zend_class_entry **pce;
 	int incomplete_class = 0;
 
 	int custom_object = 0;
 
-	zval *user_func;
-	zval *retval_ptr;
-	zval **args[1];
-	zval *arg_func_name;
+	zval user_func;
+	zval retval;
+	zval args[1];
 
 	if (*start == 'C') {
 		custom_object = 1;
 	}
 	
-	INIT_PZVAL(*rval);
+//???	INIT_PZVAL(rval);
 	len2 = len = parse_uiv(start + 2);
 	maxlen = max - YYCURSOR;
 	if (maxlen < len || len == 0) {
@@ -638,7 +649,7 @@ yy20:
 		return 0;
 	}
 
-	class_name = (char*)YYCURSOR;
+	str = (char*)YYCURSOR;
 
 	YYCURSOR += len;
 
@@ -651,31 +662,31 @@ yy20:
 		return 0;
 	}
 
-	len3 = strspn(class_name, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\");
+	len3 = strspn(str, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\");
 	if (len3 != len)
 	{
 		*p = YYCURSOR + len3 - len;
 		return 0;
 	}
 
-	class_name = estrndup(class_name, len);
+	class_name = STR_INIT(str, len, 0);
 
 	do {
 		/* Try to find class directly */
 		BG(serialize_lock)++;
-		if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
+		ce = zend_lookup_class(class_name TSRMLS_CC);
+		if (ce) {
 			BG(serialize_lock)--;
 			if (EG(exception)) {
-				efree(class_name);
+				STR_RELEASE(class_name);
 				return 0;
 			}
-			ce = *pce;
 			break;
 		}
 		BG(serialize_lock)--;
 
 		if (EG(exception)) {
-			efree(class_name);
+			STR_RELEASE(class_name);
 			return 0;
 		}
 		
@@ -687,49 +698,43 @@ yy20:
 		}
 		
 		/* Call unserialize callback */
-		MAKE_STD_ZVAL(user_func);
-		ZVAL_STRING(user_func, PG(unserialize_callback_func), 1);
-		args[0] = &arg_func_name;
-		MAKE_STD_ZVAL(arg_func_name);
-		ZVAL_STRING(arg_func_name, class_name, 1);
+		ZVAL_STRING(&user_func, PG(unserialize_callback_func));
+		
+		ZVAL_STR(&args[0], STR_COPY(class_name));
 		BG(serialize_lock)++;
-		if (call_user_function_ex(CG(function_table), NULL, user_func, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) != SUCCESS) {
+		if (call_user_function_ex(CG(function_table), NULL, &user_func, &retval, 1, args, 0, NULL TSRMLS_CC) != SUCCESS) {
 			BG(serialize_lock)--;
 			if (EG(exception)) {
-				efree(class_name);
+				STR_RELEASE(class_name);
 				zval_ptr_dtor(&user_func);
-				zval_ptr_dtor(&arg_func_name);
+				zval_ptr_dtor(&args[0]);
 				return 0;
 			}
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "defined (%s) but not found", user_func->value.str.val);
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "defined (%s) but not found", Z_STRVAL(user_func));
 			incomplete_class = 1;
 			ce = PHP_IC_ENTRY;
 			zval_ptr_dtor(&user_func);
-			zval_ptr_dtor(&arg_func_name);
+			zval_ptr_dtor(&args[0]);
 			break;
 		}
 		BG(serialize_lock)--;
-		if (retval_ptr) {
-			zval_ptr_dtor(&retval_ptr);
-		}
+		zval_ptr_dtor(&retval);
 		if (EG(exception)) {
-			efree(class_name);
+			STR_RELEASE(class_name);
 			zval_ptr_dtor(&user_func);
-			zval_ptr_dtor(&arg_func_name);
+			zval_ptr_dtor(&args[0]);
 			return 0;
 		}
 		
 		/* The callback function may have defined the class */
-		if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
-			ce = *pce;
-		} else {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function %s() hasn't defined the class it was called for", user_func->value.str.val);
+		if ((ce = zend_lookup_class(class_name TSRMLS_CC)) == NULL) {
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function %s() hasn't defined the class it was called for", Z_STRVAL(user_func));
 			incomplete_class = 1;
 			ce = PHP_IC_ENTRY;
 		}
 
 		zval_ptr_dtor(&user_func);
-		zval_ptr_dtor(&arg_func_name);
+		zval_ptr_dtor(&args[0]);
 		break;
 	} while (1);
 
@@ -741,22 +746,22 @@ yy20:
 		ret = object_custom(UNSERIALIZE_PASSTHRU, ce);
 
 		if (ret && incomplete_class) {
-			php_store_class_name(*rval, class_name, len2);
+			php_store_class_name(rval, class_name->val, len2);
 		}
-		efree(class_name);
+		STR_RELEASE(class_name);
 		return ret;
 	}
 	
 	elements = object_common1(UNSERIALIZE_PASSTHRU, ce);
 
 	if (incomplete_class) {
-		php_store_class_name(*rval, class_name, len2);
+		php_store_class_name(rval, class_name->val, len2);
 	}
-	efree(class_name);
+	STR_RELEASE(class_name);
 
 	return object_common2(UNSERIALIZE_PASSTHRU, elements);
 }
-#line 760 "ext/standard/var_unserializer.c"
+#line 765 "ext/standard/var_unserializer.c"
 yy25:
 	yych = *++YYCURSOR;
 	if (yych <= ',') {
@@ -781,15 +786,15 @@ yy27:
 	yych = *++YYCURSOR;
 	if (yych != '"') goto yy18;
 	++YYCURSOR;
-#line 664 "ext/standard/var_unserializer.re"
+#line 676 "ext/standard/var_unserializer.re"
 	{
 
-	INIT_PZVAL(*rval);
+//???	INIT_PZVAL(rval);
 	
 	return object_common2(UNSERIALIZE_PASSTHRU,
 			object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
 }
-#line 793 "ext/standard/var_unserializer.c"
+#line 798 "ext/standard/var_unserializer.c"
 yy32:
 	yych = *++YYCURSOR;
 	if (yych == '+') goto yy33;
@@ -810,7 +815,7 @@ yy34:
 	yych = *++YYCURSOR;
 	if (yych != '{') goto yy18;
 	++YYCURSOR;
-#line 644 "ext/standard/var_unserializer.re"
+#line 655 "ext/standard/var_unserializer.re"
 	{
 	long elements = parse_iv(start + 2);
 	/* use iv() not uiv() in order to check data range */
@@ -820,17 +825,18 @@ yy34:
 		return 0;
 	}
 
-	INIT_PZVAL(*rval);
-
-	array_init_size(*rval, elements);
+	array_init_size(rval, elements);
+//??? we can't convert from packed to hash during unserialization, becaue
+//??? reference to some zvals might be keept in var_hash (to support references)
+	zend_hash_real_init(Z_ARRVAL_P(rval), 0);
 
-	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_PP(rval), elements, 0)) {
+	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_P(rval), elements, 0)) {
 		return 0;
 	}
 
 	return finish_nested_data(UNSERIALIZE_PASSTHRU);
 }
-#line 834 "ext/standard/var_unserializer.c"
+#line 840 "ext/standard/var_unserializer.c"
 yy39:
 	yych = *++YYCURSOR;
 	if (yych == '+') goto yy40;
@@ -851,9 +857,10 @@ yy41:
 	yych = *++YYCURSOR;
 	if (yych != '"') goto yy18;
 	++YYCURSOR;
-#line 615 "ext/standard/var_unserializer.re"
+#line 625 "ext/standard/var_unserializer.re"
 	{
 	size_t len, maxlen;
+//??? TODO: use zend_string* instead of char*
 	char *str;
 
 	len = parse_uiv(start + 2);
@@ -876,11 +883,11 @@ yy41:
 	YYCURSOR += 2;
 	*p = YYCURSOR;
 
-	INIT_PZVAL(*rval);
-	ZVAL_STRINGL(*rval, str, len, 0);
+	ZVAL_STRINGL(rval, str, len);
+	efree(str);
 	return 1;
 }
-#line 884 "ext/standard/var_unserializer.c"
+#line 891 "ext/standard/var_unserializer.c"
 yy46:
 	yych = *++YYCURSOR;
 	if (yych == '+') goto yy47;
@@ -901,7 +908,7 @@ yy48:
 	yych = *++YYCURSOR;
 	if (yych != '"') goto yy18;
 	++YYCURSOR;
-#line 587 "ext/standard/var_unserializer.re"
+#line 598 "ext/standard/var_unserializer.re"
 	{
 	size_t len, maxlen;
 	char *str;
@@ -925,11 +932,10 @@ yy48:
 	YYCURSOR += 2;
 	*p = YYCURSOR;
 
-	INIT_PZVAL(*rval);
-	ZVAL_STRINGL(*rval, str, len, 1);
+	ZVAL_STRINGL(rval, str, len);
 	return 1;
 }
-#line 933 "ext/standard/var_unserializer.c"
+#line 939 "ext/standard/var_unserializer.c"
 yy53:
 	yych = *++YYCURSOR;
 	if (yych <= '/') {
@@ -1017,17 +1023,16 @@ yy61:
 	}
 yy63:
 	++YYCURSOR;
-#line 577 "ext/standard/var_unserializer.re"
+#line 589 "ext/standard/var_unserializer.re"
 	{
 #if SIZEOF_LONG == 4
 use_double:
 #endif
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_DOUBLE(*rval, zend_strtod((const char *)start + 2, NULL));
+	ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL));
 	return 1;
 }
-#line 1031 "ext/standard/var_unserializer.c"
+#line 1036 "ext/standard/var_unserializer.c"
 yy65:
 	yych = *++YYCURSOR;
 	if (yych <= ',') {
@@ -1086,22 +1091,23 @@ yy73:
 	yych = *++YYCURSOR;
 	if (yych != ';') goto yy18;
 	++YYCURSOR;
-#line 562 "ext/standard/var_unserializer.re"
+#line 573 "ext/standard/var_unserializer.re"
 	{
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-
-	if (!strncmp(start + 2, "NAN", 3)) {
-		ZVAL_DOUBLE(*rval, php_get_nan());
-	} else if (!strncmp(start + 2, "INF", 3)) {
-		ZVAL_DOUBLE(*rval, php_get_inf());
-	} else if (!strncmp(start + 2, "-INF", 4)) {
-		ZVAL_DOUBLE(*rval, -php_get_inf());
+
+	if (!strncmp((char*)start + 2, "NAN", 3)) {
+		ZVAL_DOUBLE(rval, php_get_nan());
+	} else if (!strncmp((char*)start + 2, "INF", 3)) {
+		ZVAL_DOUBLE(rval, php_get_inf());
+	} else if (!strncmp((char*)start + 2, "-INF", 4)) {
+		ZVAL_DOUBLE(rval, -php_get_inf());
+	} else {
+		ZVAL_NULL(rval);
 	}
 
 	return 1;
 }
-#line 1105 "ext/standard/var_unserializer.c"
+#line 1111 "ext/standard/var_unserializer.c"
 yy76:
 	yych = *++YYCURSOR;
 	if (yych == 'N') goto yy73;
@@ -1128,7 +1134,7 @@ yy79:
 	if (yych <= '9') goto yy79;
 	if (yych != ';') goto yy18;
 	++YYCURSOR;
-#line 535 "ext/standard/var_unserializer.re"
+#line 547 "ext/standard/var_unserializer.re"
 	{
 #if SIZEOF_LONG == 4
 	int digits = YYCURSOR - start - 3;
@@ -1140,7 +1146,7 @@ yy79:
 	/* Use double for large long values that were serialized on a 64-bit system */
 	if (digits >= MAX_LENGTH_OF_LONG - 1) {
 		if (digits == MAX_LENGTH_OF_LONG - 1) {
-			int cmp = strncmp(YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1);
+			int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1);
 
 			if (!(cmp < 0 || (cmp == 0 && start[2] == '-'))) {
 				goto use_double;
@@ -1151,11 +1157,10 @@ yy79:
 	}
 #endif
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_LONG(*rval, parse_iv(start + 2));
+	ZVAL_LONG(rval, parse_iv(start + 2));
 	return 1;
 }
-#line 1159 "ext/standard/var_unserializer.c"
+#line 1164 "ext/standard/var_unserializer.c"
 yy83:
 	yych = *++YYCURSOR;
 	if (yych <= '/') goto yy18;
@@ -1163,24 +1168,22 @@ yy83:
 	yych = *++YYCURSOR;
 	if (yych != ';') goto yy18;
 	++YYCURSOR;
-#line 528 "ext/standard/var_unserializer.re"
+#line 541 "ext/standard/var_unserializer.re"
 	{
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_BOOL(*rval, parse_iv(start + 2));
+	ZVAL_BOOL(rval, parse_iv(start + 2));
 	return 1;
 }
-#line 1174 "ext/standard/var_unserializer.c"
+#line 1178 "ext/standard/var_unserializer.c"
 yy87:
 	++YYCURSOR;
-#line 521 "ext/standard/var_unserializer.re"
+#line 535 "ext/standard/var_unserializer.re"
 	{
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_NULL(*rval);
+	ZVAL_NULL(rval);
 	return 1;
 }
-#line 1184 "ext/standard/var_unserializer.c"
+#line 1187 "ext/standard/var_unserializer.c"
 yy89:
 	yych = *++YYCURSOR;
 	if (yych <= ',') {
@@ -1203,7 +1206,7 @@ yy91:
 	if (yych <= '9') goto yy91;
 	if (yych != ';') goto yy18;
 	++YYCURSOR;
-#line 498 "ext/standard/var_unserializer.re"
+#line 512 "ext/standard/var_unserializer.re"
 	{
 	long id;
 
@@ -1211,22 +1214,22 @@ yy91:
 	if (!var_hash) return 0;
 
 	id = parse_iv(start + 2) - 1;
-	if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
+	if (id == -1 || (rval_ref = var_access(var_hash, id)) == NULL) {
 		return 0;
 	}
 
-	if (*rval == *rval_ref) return 0;
+//???
+//???	if (rval == rval_ref) return 0;
 
-	if (*rval != NULL) {
-		var_push_dtor_no_addref(var_hash, rval);
-	}
-	*rval = *rval_ref;
-	Z_ADDREF_PP(rval);
-	Z_UNSET_ISREF_PP(rval);
+//???	if (!ZVAL_IS_UNDEF(rval)) {
+//???		var_push_dtor_no_addref(var_hash, rval);
+//???	}
+	ZVAL_COPY(rval, rval_ref);
+//???	Z_UNSET_ISREF_PP(rval);
 	
 	return 1;
 }
-#line 1230 "ext/standard/var_unserializer.c"
+#line 1233 "ext/standard/var_unserializer.c"
 yy95:
 	yych = *++YYCURSOR;
 	if (yych <= ',') {
@@ -1249,7 +1252,7 @@ yy97:
 	if (yych <= '9') goto yy97;
 	if (yych != ';') goto yy18;
 	++YYCURSOR;
-#line 477 "ext/standard/var_unserializer.re"
+#line 489 "ext/standard/var_unserializer.re"
 	{
 	long id;
 
@@ -1257,22 +1260,24 @@ yy97:
 	if (!var_hash) return 0;
 
 	id = parse_iv(start + 2) - 1;
-	if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
+	if (id == -1 || (rval_ref = var_access(var_hash, id)) == NULL) {
 		return 0;
 	}
 
-	if (*rval != NULL) {
-		zval_ptr_dtor(rval);
+	zval_ptr_dtor(rval);
+	if (Z_ISREF_P(rval_ref)) {
+		ZVAL_COPY(rval, rval_ref);
+	} else {
+		ZVAL_NEW_REF(rval_ref, rval_ref);
+		ZVAL_COPY(rval, rval_ref);
 	}
-	*rval = *rval_ref;
-	Z_ADDREF_PP(rval);
-	Z_SET_ISREF_PP(rval);
+//???	Z_SET_ISREF_PP(rval);
 	
 	return 1;
 }
-#line 1274 "ext/standard/var_unserializer.c"
+#line 1279 "ext/standard/var_unserializer.c"
 }
-#line 826 "ext/standard/var_unserializer.re"
+#line 831 "ext/standard/var_unserializer.re"
 
 
 	return 0;
diff --git a/ext/standard/var_unserializer.re b/ext/standard/var_unserializer.re
index b3f5d29ca2..70bff6704b 100644
--- a/ext/standard/var_unserializer.re
+++ b/ext/standard/var_unserializer.re
@@ -32,7 +32,13 @@ typedef struct {
 	void *next;
 } var_entries;
 
-static inline void var_push(php_unserialize_data_t *var_hashx, zval **rval)
+typedef struct {
+	zval data[VAR_ENTRIES_MAX];
+	long used_slots;
+	void *next;
+} var_dtor_entries;
+
+static inline void var_push(php_unserialize_data_t *var_hashx, zval *rval)
 {
 	var_entries *var_hash = (*var_hashx)->last;
 #if VAR_ENTRIES_DBG
@@ -53,18 +59,18 @@ static inline void var_push(php_unserialize_data_t *var_hashx, zval **rval)
 		(*var_hashx)->last = var_hash;
 	}
 
-	var_hash->data[var_hash->used_slots++] = *rval;
+	var_hash->data[var_hash->used_slots++] = rval;
 }
 
-PHPAPI void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
+PHPAPI void var_push_dtor(php_unserialize_data_t *var_hashx, zval *rval)
 {
-	var_entries *var_hash = (*var_hashx)->last_dtor;
+	var_dtor_entries *var_hash = (*var_hashx)->last_dtor;
 #if VAR_ENTRIES_DBG
 	fprintf(stderr, "var_push_dtor(%ld): %d\n", var_hash?var_hash->used_slots:-1L, Z_TYPE_PP(rval));
 #endif
 
 	if (!var_hash || var_hash->used_slots == VAR_ENTRIES_MAX) {
-		var_hash = emalloc(sizeof(var_entries));
+		var_hash = emalloc(sizeof(var_dtor_entries));
 		var_hash->used_slots = 0;
 		var_hash->next = 0;
 
@@ -77,19 +83,21 @@ PHPAPI void var_push_dtor(php_unserialize_data_t *var_hashx, zval **rval)
 		(*var_hashx)->last_dtor = var_hash;
 	}
 
-	Z_ADDREF_PP(rval);
-	var_hash->data[var_hash->used_slots++] = *rval;
+	ZVAL_COPY(&var_hash->data[var_hash->used_slots], rval);
+	var_hash->used_slots++;
 }
 
-PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval **rval)
+//???
+#if 0
+PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval *rval)
 {
-	var_entries *var_hash = (*var_hashx)->last_dtor;
+	var_dtor_entries *var_hash = (*var_hashx)->last_dtor;
 #if VAR_ENTRIES_DBG
 	fprintf(stderr, "var_push_dtor_no_addref(%ld): %d (%d)\n", var_hash?var_hash->used_slots:-1L, Z_TYPE_PP(rval), Z_REFCOUNT_PP(rval));
 #endif
 
 	if (!var_hash || var_hash->used_slots == VAR_ENTRIES_MAX) {
-		var_hash = emalloc(sizeof(var_entries));
+		var_hash = emalloc(sizeof(var_dtor_entries));
 		var_hash->used_slots = 0;
 		var_hash->next = 0;
 
@@ -102,10 +110,12 @@ PHPAPI void var_push_dtor_no_addref(php_unserialize_data_t *var_hashx, zval **rv
 		(*var_hashx)->last_dtor = var_hash;
 	}
 
-	var_hash->data[var_hash->used_slots++] = *rval;
+	ZVAL_COPY_VALUE(&var_hash->data[var_hash->used_slots], rval);
+	var_hash->used_slots++;
 }
+#endif
 
-PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **nzval)
+PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval *nzval)
 {
 	long i;
 	var_entries *var_hash = (*var_hashx)->first;
@@ -116,7 +126,7 @@ PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **n
 	while (var_hash) {
 		for (i = 0; i < var_hash->used_slots; i++) {
 			if (var_hash->data[i] == ozval) {
-				var_hash->data[i] = *nzval;
+				var_hash->data[i] = nzval;
 				/* do not break here */
 			}
 		}
@@ -124,7 +134,7 @@ PHPAPI void var_replace(php_unserialize_data_t *var_hashx, zval *ozval, zval **n
 	}
 }
 
-static int var_access(php_unserialize_data_t *var_hashx, long id, zval ***store)
+static zval *var_access(php_unserialize_data_t *var_hashx, long id)
 {
 	var_entries *var_hash = (*var_hashx)->first;
 #if VAR_ENTRIES_DBG
@@ -136,13 +146,11 @@ static int var_access(php_unserialize_data_t *var_hashx, long id, zval ***store)
 		id -= VAR_ENTRIES_MAX;
 	}
 
-	if (!var_hash) return !SUCCESS;
-
-	if (id < 0 || id >= var_hash->used_slots) return !SUCCESS;
+	if (!var_hash) return NULL;
 
-	*store = &var_hash->data[id];
+	if (id < 0 || id >= var_hash->used_slots) return NULL;
 
-	return SUCCESS;
+	return var_hash->data[id];
 }
 
 PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
@@ -150,6 +158,7 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
 	void *next;
 	long i;
 	var_entries *var_hash = (*var_hashx)->first;
+	var_dtor_entries *var_dtor_hash = (*var_hashx)->first_dtor;
 #if VAR_ENTRIES_DBG
 	fprintf(stderr, "var_destroy(%ld)\n", var_hash?var_hash->used_slots:-1L);
 #endif
@@ -160,15 +169,13 @@ PHPAPI void var_destroy(php_unserialize_data_t *var_hashx)
 		var_hash = next;
 	}
 
-	var_hash = (*var_hashx)->first_dtor;
-	
-	while (var_hash) {
-		for (i = 0; i < var_hash->used_slots; i++) {
-			zval_ptr_dtor(&var_hash->data[i]);
+	while (var_dtor_hash) {
+		for (i = 0; i < var_dtor_hash->used_slots; i++) {
+			zval_ptr_dtor(&var_dtor_hash->data[i]);
 		}
-		next = var_hash->next;
-		efree(var_hash);
-		var_hash = next;
+		next = var_dtor_hash->next;
+		efree(var_dtor_hash);
+		var_dtor_hash = next;
 	}
 }
 
@@ -290,62 +297,70 @@ static inline size_t parse_uiv(const unsigned char *p)
 	return result;
 }
 
-#define UNSERIALIZE_PARAMETER zval **rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC
+#define UNSERIALIZE_PARAMETER zval *rval, const unsigned char **p, const unsigned char *max, php_unserialize_data_t *var_hash TSRMLS_DC
 #define UNSERIALIZE_PASSTHRU rval, p, max, var_hash TSRMLS_CC
 
 static inline int process_nested_data(UNSERIALIZE_PARAMETER, HashTable *ht, long elements, int objprops)
 {
 	while (elements-- > 0) {
-		zval *key, *data, **old_data;
-
-		ALLOC_INIT_ZVAL(key);
+		zval key, *data, d, *old_data;
 
+		ZVAL_UNDEF(&key);
 		if (!php_var_unserialize(&key, p, max, NULL TSRMLS_CC)) {
-			zval_dtor(key);
-			FREE_ZVAL(key);
+			zval_dtor(&key);
 			return 0;
 		}
 
-		if (Z_TYPE_P(key) != IS_LONG && Z_TYPE_P(key) != IS_STRING) {
-			zval_dtor(key);
-			FREE_ZVAL(key);
+		if (Z_TYPE(key) != IS_LONG && Z_TYPE(key) != IS_STRING) {
+			zval_dtor(&key);
 			return 0;
 		}
 
-		ALLOC_INIT_ZVAL(data);
-
-		if (!php_var_unserialize(&data, p, max, var_hash TSRMLS_CC)) {
-			zval_dtor(key);
-			FREE_ZVAL(key);
-			zval_dtor(data);
-			FREE_ZVAL(data);
-			return 0;
-		}
+		data = NULL;
+		ZVAL_UNDEF(&d);
 
 		if (!objprops) {
-			switch (Z_TYPE_P(key)) {
+			switch (Z_TYPE(key)) {
 			case IS_LONG:
-				if (zend_hash_index_find(ht, Z_LVAL_P(key), (void **)&old_data)==SUCCESS) {
+				if ((old_data = zend_hash_index_find(ht, Z_LVAL(key))) != NULL) {
+					//??? update hash
 					var_push_dtor(var_hash, old_data);
 				}
-				zend_hash_index_update(ht, Z_LVAL_P(key), &data, sizeof(data), NULL);
+				data = zend_hash_index_update(ht, Z_LVAL(key), &d);
 				break;
 			case IS_STRING:
-				if (zend_symtable_find(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, (void **)&old_data)==SUCCESS) {
+				if ((old_data = zend_symtable_find(ht, Z_STR(key))) != NULL) {
+					//??? update hash
 					var_push_dtor(var_hash, old_data);
 				}
-				zend_symtable_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data, sizeof(data), NULL);
+				data = zend_symtable_update(ht, Z_STR(key), &d);
 				break;
 			}
 		} else {
 			/* object properties should include no integers */
-			convert_to_string(key);
-			zend_hash_update(ht, Z_STRVAL_P(key), Z_STRLEN_P(key) + 1, &data,
-					sizeof data, NULL);
+			convert_to_string(&key);
+//???
+#if 1
+			data = zend_hash_update_ind(ht, Z_STR(key), &d);
+#else
+			if ((data = zend_hash_find(ht, Z_STR(key))) != NULL) {
+				if (Z_TYPE_P(data) == IS_INDIRECT) {
+					data = Z_INDIRECT_P(data);
+				}
+				zval_ptr_dtor(data);
+//???				var_push_dtor(var_hash, data);
+				ZVAL_UNDEF(data);
+			} else {
+				data = zend_hash_update(ht, Z_STR(key), &d);
+			}
+#endif
 		}
 		
-		zval_dtor(key);
-		FREE_ZVAL(key);
+		zval_dtor(&key);
+
+		if (!php_var_unserialize(data, p, max, var_hash TSRMLS_CC)) {
+			return 0;
+		}
 
 		if (elements && *(*p-1) != ';' && *(*p-1) != '}') {
 			(*p)--;
@@ -381,8 +396,8 @@ static inline int object_custom(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
 	}
 
 	if (ce->unserialize == NULL) {
-		zend_error(E_WARNING, "Class %s has no unserializer", ce->name);
-		object_init_ex(*rval, ce);
+		zend_error(E_WARNING, "Class %s has no unserializer", ce->name->val);
+		object_init_ex(rval, ce);
 	} else if (ce->unserialize(rval, ce, (const unsigned char*)*p, datalen, (zend_unserialize_data *)var_hash TSRMLS_CC) != SUCCESS) {
 		return 0;
 	}
@@ -401,11 +416,11 @@ static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
 	(*p) += 2;
 	
 	if (ce->serialize == NULL) {
-		object_init_ex(*rval, ce);
+		object_init_ex(rval, ce);
 	} else {
 		/* If this class implements Serializable, it should not land here but in object_custom(). The passed string
 		obviously doesn't descend from the regular serializer. */
-		zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ce->name);
+		zend_error(E_WARNING, "Erroneous data format for unserializing '%s'", ce->name->val);
 		return 0;
 	}
 
@@ -417,28 +432,27 @@ static inline long object_common1(UNSERIALIZE_PARAMETER, zend_class_entry *ce)
 #endif
 static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
 {
-	zval *retval_ptr = NULL;
+	zval retval;
 	zval fname;
 
-	if (Z_TYPE_PP(rval) != IS_OBJECT) {
+	if (Z_TYPE_P(rval) != IS_OBJECT) {
 		return 0;
 	}
 
-	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_PP(rval), elements, 1)) {
+	//??? TODO: resize before
+	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_OBJPROP_P(rval), elements, 1)) {
 		return 0;
 	}
 
-	if (Z_OBJCE_PP(rval) != PHP_IC_ENTRY &&
-		zend_hash_exists(&Z_OBJCE_PP(rval)->function_table, "__wakeup", sizeof("__wakeup"))) {
-		INIT_PZVAL(&fname);
-		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1, 0);
+	ZVAL_DEREF(rval);
+	if (Z_OBJCE_P(rval) != PHP_IC_ENTRY &&
+		zend_hash_str_exists(&Z_OBJCE_P(rval)->function_table, "__wakeup", sizeof("__wakeup")-1)) {
+		ZVAL_STRINGL(&fname, "__wakeup", sizeof("__wakeup") - 1);
 		BG(serialize_lock)++;
-		call_user_function_ex(CG(function_table), rval, &fname, &retval_ptr, 0, 0, 1, NULL TSRMLS_CC);
+		call_user_function_ex(CG(function_table), rval, &fname, &retval, 0, 0, 1, NULL TSRMLS_CC);
 		BG(serialize_lock)--;
-	}
-
-	if (retval_ptr) {
-		zval_ptr_dtor(&retval_ptr);
+		zval_dtor(&fname);
+		zval_dtor(&retval);
 	}
 
 	if (EG(exception)) {
@@ -455,7 +469,7 @@ static inline int object_common2(UNSERIALIZE_PARAMETER, long elements)
 PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 {
 	const unsigned char *cursor, *limit, *marker, *start;
-	zval **rval_ref;
+	zval *rval_ref;
 
 	limit = max;
 	cursor = *p;
@@ -464,14 +478,12 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 		return 0;
 	}
 	
-	if (var_hash && cursor[0] != 'R') {
+	if (var_hash && (*p)[0] != 'R') {
 		var_push(var_hash, rval);
 	}
 
 	start = cursor;
 
-	
-	
 /*!re2c
 
 "R:" iv ";"		{
@@ -481,16 +493,18 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 	if (!var_hash) return 0;
 
 	id = parse_iv(start + 2) - 1;
-	if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
+	if (id == -1 || (rval_ref = var_access(var_hash, id)) == NULL) {
 		return 0;
 	}
 
-	if (*rval != NULL) {
-		zval_ptr_dtor(rval);
+	zval_ptr_dtor(rval);
+	if (Z_ISREF_P(rval_ref)) {
+		ZVAL_COPY(rval, rval_ref);
+	} else {
+		ZVAL_NEW_REF(rval_ref, rval_ref);
+		ZVAL_COPY(rval, rval_ref);
 	}
-	*rval = *rval_ref;
-	Z_ADDREF_PP(rval);
-	Z_SET_ISREF_PP(rval);
+//???	Z_SET_ISREF_PP(rval);
 	
 	return 1;
 }
@@ -502,33 +516,31 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 	if (!var_hash) return 0;
 
 	id = parse_iv(start + 2) - 1;
-	if (id == -1 || var_access(var_hash, id, &rval_ref) != SUCCESS) {
+	if (id == -1 || (rval_ref = var_access(var_hash, id)) == NULL) {
 		return 0;
 	}
 
-	if (*rval == *rval_ref) return 0;
+//???
+//???	if (rval == rval_ref) return 0;
 
-	if (*rval != NULL) {
-		var_push_dtor_no_addref(var_hash, rval);
-	}
-	*rval = *rval_ref;
-	Z_ADDREF_PP(rval);
-	Z_UNSET_ISREF_PP(rval);
+//???	if (!ZVAL_IS_UNDEF(rval)) {
+//???		var_push_dtor_no_addref(var_hash, rval);
+//???	}
+	ZVAL_COPY(rval, rval_ref);
+//???	Z_UNSET_ISREF_PP(rval);
 	
 	return 1;
 }
 
 "N;"	{
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_NULL(*rval);
+	ZVAL_NULL(rval);
 	return 1;
 }
 
 "b:" [01] ";"	{
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_BOOL(*rval, parse_iv(start + 2));
+	ZVAL_BOOL(rval, parse_iv(start + 2));
 	return 1;
 }
 
@@ -543,7 +555,7 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 	/* Use double for large long values that were serialized on a 64-bit system */
 	if (digits >= MAX_LENGTH_OF_LONG - 1) {
 		if (digits == MAX_LENGTH_OF_LONG - 1) {
-			int cmp = strncmp(YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1);
+			int cmp = strncmp((char*)YYCURSOR - MAX_LENGTH_OF_LONG, long_min_digits, MAX_LENGTH_OF_LONG - 1);
 
 			if (!(cmp < 0 || (cmp == 0 && start[2] == '-'))) {
 				goto use_double;
@@ -554,21 +566,21 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 	}
 #endif
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_LONG(*rval, parse_iv(start + 2));
+	ZVAL_LONG(rval, parse_iv(start + 2));
 	return 1;
 }
 
 "d:" ("NAN" | "-"? "INF") ";"	{
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
 
-	if (!strncmp(start + 2, "NAN", 3)) {
-		ZVAL_DOUBLE(*rval, php_get_nan());
-	} else if (!strncmp(start + 2, "INF", 3)) {
-		ZVAL_DOUBLE(*rval, php_get_inf());
-	} else if (!strncmp(start + 2, "-INF", 4)) {
-		ZVAL_DOUBLE(*rval, -php_get_inf());
+	if (!strncmp((char*)start + 2, "NAN", 3)) {
+		ZVAL_DOUBLE(rval, php_get_nan());
+	} else if (!strncmp((char*)start + 2, "INF", 3)) {
+		ZVAL_DOUBLE(rval, php_get_inf());
+	} else if (!strncmp((char*)start + 2, "-INF", 4)) {
+		ZVAL_DOUBLE(rval, -php_get_inf());
+	} else {
+		ZVAL_NULL(rval);
 	}
 
 	return 1;
@@ -579,8 +591,7 @@ PHPAPI int php_var_unserialize(UNSERIALIZE_PARAMETER)
 use_double:
 #endif
 	*p = YYCURSOR;
-	INIT_PZVAL(*rval);
-	ZVAL_DOUBLE(*rval, zend_strtod((const char *)start + 2, NULL));
+	ZVAL_DOUBLE(rval, zend_strtod((const char *)start + 2, NULL));
 	return 1;
 }
 
@@ -607,13 +618,13 @@ use_double:
 	YYCURSOR += 2;
 	*p = YYCURSOR;
 
-	INIT_PZVAL(*rval);
-	ZVAL_STRINGL(*rval, str, len, 1);
+	ZVAL_STRINGL(rval, str, len);
 	return 1;
 }
 
 "S:" uiv ":" ["] 	{
 	size_t len, maxlen;
+//??? TODO: use zend_string* instead of char*
 	char *str;
 
 	len = parse_uiv(start + 2);
@@ -636,8 +647,8 @@ use_double:
 	YYCURSOR += 2;
 	*p = YYCURSOR;
 
-	INIT_PZVAL(*rval);
-	ZVAL_STRINGL(*rval, str, len, 0);
+	ZVAL_STRINGL(rval, str, len);
+	efree(str);
 	return 1;
 }
 
@@ -650,11 +661,12 @@ use_double:
 		return 0;
 	}
 
-	INIT_PZVAL(*rval);
+	array_init_size(rval, elements);
+//??? we can't convert from packed to hash during unserialization, becaue
+//??? reference to some zvals might be keept in var_hash (to support references)
+	zend_hash_real_init(Z_ARRVAL_P(rval), 0);
 
-	array_init_size(*rval, elements);
-
-	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_PP(rval), elements, 0)) {
+	if (!process_nested_data(UNSERIALIZE_PASSTHRU, Z_ARRVAL_P(rval), elements, 0)) {
 		return 0;
 	}
 
@@ -663,7 +675,7 @@ use_double:
 
 "o:" iv ":" ["] {
 
-	INIT_PZVAL(*rval);
+//???	INIT_PZVAL(rval);
 	
 	return object_common2(UNSERIALIZE_PASSTHRU,
 			object_common1(UNSERIALIZE_PASSTHRU, ZEND_STANDARD_CLASS_DEF_PTR));
@@ -672,23 +684,22 @@ use_double:
 object ":" uiv ":" ["]	{
 	size_t len, len2, len3, maxlen;
 	long elements;
-	char *class_name;
+	char *str;
+	zend_string *class_name;
 	zend_class_entry *ce;
-	zend_class_entry **pce;
 	int incomplete_class = 0;
 
 	int custom_object = 0;
 
-	zval *user_func;
-	zval *retval_ptr;
-	zval **args[1];
-	zval *arg_func_name;
+	zval user_func;
+	zval retval;
+	zval args[1];
 
 	if (*start == 'C') {
 		custom_object = 1;
 	}
 	
-	INIT_PZVAL(*rval);
+//???	INIT_PZVAL(rval);
 	len2 = len = parse_uiv(start + 2);
 	maxlen = max - YYCURSOR;
 	if (maxlen < len || len == 0) {
@@ -696,7 +707,7 @@ object ":" uiv ":" ["]	{
 		return 0;
 	}
 
-	class_name = (char*)YYCURSOR;
+	str = (char*)YYCURSOR;
 
 	YYCURSOR += len;
 
@@ -709,31 +720,31 @@ object ":" uiv ":" ["]	{
 		return 0;
 	}
 
-	len3 = strspn(class_name, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\");
+	len3 = strspn(str, "0123456789_abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ\177\200\201\202\203\204\205\206\207\210\211\212\213\214\215\216\217\220\221\222\223\224\225\226\227\230\231\232\233\234\235\236\237\240\241\242\243\244\245\246\247\250\251\252\253\254\255\256\257\260\261\262\263\264\265\266\267\270\271\272\273\274\275\276\277\300\301\302\303\304\305\306\307\310\311\312\313\314\315\316\317\320\321\322\323\324\325\326\327\330\331\332\333\334\335\336\337\340\341\342\343\344\345\346\347\350\351\352\353\354\355\356\357\360\361\362\363\364\365\366\367\370\371\372\373\374\375\376\377\\");
 	if (len3 != len)
 	{
 		*p = YYCURSOR + len3 - len;
 		return 0;
 	}
 
-	class_name = estrndup(class_name, len);
+	class_name = STR_INIT(str, len, 0);
 
 	do {
 		/* Try to find class directly */
 		BG(serialize_lock)++;
-		if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
+		ce = zend_lookup_class(class_name TSRMLS_CC);
+		if (ce) {
 			BG(serialize_lock)--;
 			if (EG(exception)) {
-				efree(class_name);
+				STR_RELEASE(class_name);
 				return 0;
 			}
-			ce = *pce;
 			break;
 		}
 		BG(serialize_lock)--;
 
 		if (EG(exception)) {
-			efree(class_name);
+			STR_RELEASE(class_name);
 			return 0;
 		}
 		
@@ -745,49 +756,43 @@ object ":" uiv ":" ["]	{
 		}
 		
 		/* Call unserialize callback */
-		MAKE_STD_ZVAL(user_func);
-		ZVAL_STRING(user_func, PG(unserialize_callback_func), 1);
-		args[0] = &arg_func_name;
-		MAKE_STD_ZVAL(arg_func_name);
-		ZVAL_STRING(arg_func_name, class_name, 1);
+		ZVAL_STRING(&user_func, PG(unserialize_callback_func));
+		
+		ZVAL_STR(&args[0], STR_COPY(class_name));
 		BG(serialize_lock)++;
-		if (call_user_function_ex(CG(function_table), NULL, user_func, &retval_ptr, 1, args, 0, NULL TSRMLS_CC) != SUCCESS) {
+		if (call_user_function_ex(CG(function_table), NULL, &user_func, &retval, 1, args, 0, NULL TSRMLS_CC) != SUCCESS) {
 			BG(serialize_lock)--;
 			if (EG(exception)) {
-				efree(class_name);
+				STR_RELEASE(class_name);
 				zval_ptr_dtor(&user_func);
-				zval_ptr_dtor(&arg_func_name);
+				zval_ptr_dtor(&args[0]);
 				return 0;
 			}
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "defined (%s) but not found", user_func->value.str.val);
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "defined (%s) but not found", Z_STRVAL(user_func));
 			incomplete_class = 1;
 			ce = PHP_IC_ENTRY;
 			zval_ptr_dtor(&user_func);
-			zval_ptr_dtor(&arg_func_name);
+			zval_ptr_dtor(&args[0]);
 			break;
 		}
 		BG(serialize_lock)--;
-		if (retval_ptr) {
-			zval_ptr_dtor(&retval_ptr);
-		}
+		zval_ptr_dtor(&retval);
 		if (EG(exception)) {
-			efree(class_name);
+			STR_RELEASE(class_name);
 			zval_ptr_dtor(&user_func);
-			zval_ptr_dtor(&arg_func_name);
+			zval_ptr_dtor(&args[0]);
 			return 0;
 		}
 		
 		/* The callback function may have defined the class */
-		if (zend_lookup_class(class_name, len2, &pce TSRMLS_CC) == SUCCESS) {
-			ce = *pce;
-		} else {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function %s() hasn't defined the class it was called for", user_func->value.str.val);
+		if ((ce = zend_lookup_class(class_name TSRMLS_CC)) == NULL) {
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Function %s() hasn't defined the class it was called for", Z_STRVAL(user_func));
 			incomplete_class = 1;
 			ce = PHP_IC_ENTRY;
 		}
 
 		zval_ptr_dtor(&user_func);
-		zval_ptr_dtor(&arg_func_name);
+		zval_ptr_dtor(&args[0]);
 		break;
 	} while (1);
 
@@ -799,18 +804,18 @@ object ":" uiv ":" ["]	{
 		ret = object_custom(UNSERIALIZE_PASSTHRU, ce);
 
 		if (ret && incomplete_class) {
-			php_store_class_name(*rval, class_name, len2);
+			php_store_class_name(rval, class_name->val, len2);
 		}
-		efree(class_name);
+		STR_RELEASE(class_name);
 		return ret;
 	}
 	
 	elements = object_common1(UNSERIALIZE_PASSTHRU, ce);
 
 	if (incomplete_class) {
-		php_store_class_name(*rval, class_name, len2);
+		php_store_class_name(rval, class_name->val, len2);
 	}
-	efree(class_name);
+	STR_RELEASE(class_name);
 
 	return object_common2(UNSERIALIZE_PASSTHRU, elements);
 }
diff --git a/ext/sybase_ct/php_sybase_ct.c b/ext/sybase_ct/php_sybase_ct.c
index 73db73e984..d1c7267454 100644
--- a/ext/sybase_ct/php_sybase_ct.c
+++ b/ext/sybase_ct/php_sybase_ct.c
@@ -2001,11 +2001,11 @@ PHP_FUNCTION(sybase_fetch_field)
 
 	object_init(return_value);
 
-	add_property_string(return_value, "name", result->fields[field_offset].name, 1);
+	add_property_string(return_value, "name", result->fields[field_offset].name);
 	add_property_long(return_value, "max_length", result->fields[field_offset].max_length);
-	add_property_string(return_value, "column_source", result->fields[field_offset].column_source, 1);
+	add_property_string(return_value, "column_source", result->fields[field_offset].column_source);
 	add_property_long(return_value, "numeric", result->fields[field_offset].numeric);
-	add_property_string(return_value, "type", php_sybase_get_field_name(Z_TYPE(result->fields[field_offset])), 1);
+	add_property_string(return_value, "type", php_sybase_get_field_name(Z_TYPE(result->fields[field_offset])));
 }
 /* }}} */
 
diff --git a/ext/tidy/tidy.c b/ext/tidy/tidy.c
index 14aff36094..b214467632 100644
--- a/ext/tidy/tidy.c
+++ b/ext/tidy/tidy.c
@@ -92,7 +92,7 @@
 		zend_class_entry ce; \
 		INIT_CLASS_ENTRY(ce, # classname, tidy_funcs_ ## name); \
 		ce.create_object = tidy_object_new_ ## name; \
-		tidy_ce_ ## name = zend_register_internal_class_ex(&ce, parent, NULL TSRMLS_CC); \
+		tidy_ce_ ## name = zend_register_internal_class_ex(&ce, parent TSRMLS_CC); \
 		tidy_ce_ ## name->ce_flags |= __flags;  \
 		memcpy(&tidy_object_handlers_ ## name, zend_get_std_object_handlers(), sizeof(zend_object_handlers)); \
 		tidy_object_handlers_ ## name.clone_obj = NULL; \
@@ -890,7 +890,7 @@ static void tidy_add_default_properties(PHPTidyObj *obj, tidy_obj_type type TSRM
 					name = (char *)tidyAttrName(tempattr);
 					val = (char *)tidyAttrValue(tempattr);
 					if (name && val) {
-						add_assoc_string(attribute, name, val, TRUE);
+						add_assoc_string(attribute, name, val);
 					}
 				} while((tempattr = tidyAttrNext(tempattr)));
 			} else {
@@ -1425,7 +1425,9 @@ static PHP_FUNCTION(tidy_get_config)
 		opt_value = php_tidy_get_opt_val(obj->ptdoc, opt, &optt TSRMLS_CC);
 		switch (optt) {
 			case TidyString:
-				add_assoc_string(return_value, opt_name, (char*)opt_value, 0);
+				// TODO: avoid reallocation ???
+				add_assoc_string(return_value, opt_name, (char*)opt_value);
+				efree(opt_value);
 				break;
 
 			case TidyInteger:
diff --git a/ext/tokenizer/tokenizer.c b/ext/tokenizer/tokenizer.c
index 8e2aaab923..1a5411ca27 100644
--- a/ext/tokenizer/tokenizer.c
+++ b/ext/tokenizer/tokenizer.c
@@ -104,7 +104,7 @@ PHP_MINFO_FUNCTION(tokenizer)
 static void tokenize(zval *return_value TSRMLS_DC)
 {
 	zval token;
-	zval *keyword;
+	zval keyword;
 	int token_type;
 	zend_bool destroy;
 	int token_line = 1;
@@ -130,20 +130,19 @@ static void tokenize(zval *return_value TSRMLS_DC)
 		}
 
 		if (token_type >= 256) {
-			MAKE_STD_ZVAL(keyword);
-			array_init(keyword);
-			add_next_index_long(keyword, token_type);
+			array_init(&keyword);
+			add_next_index_long(&keyword, token_type);
 			if (token_type == T_END_HEREDOC) {
 				if (CG(increment_lineno)) {
 					token_line = ++CG(zend_lineno);
 					CG(increment_lineno) = 0;
 				}
 			}
-			add_next_index_stringl(keyword, (char *)zendtext, zendleng, 1);
-			add_next_index_long(keyword, token_line);
-			add_next_index_zval(return_value, keyword);
+			add_next_index_stringl(&keyword, (char *)zendtext, zendleng);
+			add_next_index_long(&keyword, token_line);
+			add_next_index_zval(return_value, &keyword);
 		} else {
-			add_next_index_stringl(return_value, (char *)zendtext, zendleng, 1);
+			add_next_index_stringl(return_value, (char *)zendtext, zendleng);
 		}
 		if (destroy && Z_TYPE(token) != IS_NULL) {
 			zval_dtor(&token);
@@ -158,12 +157,11 @@ static void tokenize(zval *return_value TSRMLS_DC)
 			) {
 				// fetch the rest into a T_INLINE_HTML
 				if (zendcursor != zendlimit) {
-					MAKE_STD_ZVAL(keyword);
-					array_init(keyword);
-					add_next_index_long(keyword, T_INLINE_HTML);
-					add_next_index_stringl(keyword, (char *)zendcursor, zendlimit - zendcursor, 1);
-					add_next_index_long(keyword, token_line);
-					add_next_index_zval(return_value, keyword);
+					array_init(&keyword);
+					add_next_index_long(&keyword, T_INLINE_HTML);
+					add_next_index_stringl(&keyword, (char *)zendcursor, zendlimit - zendcursor);
+					add_next_index_long(&keyword, token_line);
+					add_next_index_zval(return_value, &keyword);
 				}
 				break;
 			}
@@ -179,20 +177,18 @@ static void tokenize(zval *return_value TSRMLS_DC)
  */
 PHP_FUNCTION(token_get_all)
 {
-	char *source = NULL;
-	int argc = ZEND_NUM_ARGS();
-	int source_len;
-	zval source_z;
+	zend_string *source;
+	zval source_zval;
 	zend_lex_state original_lex_state;
 
-	if (zend_parse_parameters(argc TSRMLS_CC, "s", &source, &source_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &source) == FAILURE) {
 		return;
 	}
 
-	ZVAL_STRINGL(&source_z, source, source_len, 1);
+	ZVAL_STR(&source_zval, STR_COPY(source));
 	zend_save_lexical_state(&original_lex_state TSRMLS_CC);
 
-	if (zend_prepare_string_for_scanning(&source_z, "" TSRMLS_CC) == FAILURE) {
+	if (zend_prepare_string_for_scanning(&source_zval, "" TSRMLS_CC) == FAILURE) {
 		zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
 		RETURN_FALSE;
 	}
@@ -202,7 +198,7 @@ PHP_FUNCTION(token_get_all)
 	tokenize(return_value TSRMLS_CC);
 	
 	zend_restore_lexical_state(&original_lex_state TSRMLS_CC);
-	zval_dtor(&source_z);
+	zval_dtor(&source_zval);
 }
 /* }}} */
 
@@ -210,13 +206,13 @@ PHP_FUNCTION(token_get_all)
  */
 PHP_FUNCTION(token_name)
 {
-	int argc = ZEND_NUM_ARGS();
 	long type;
 
-	if (zend_parse_parameters(argc TSRMLS_CC, "l", &type) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &type) == FAILURE) {
 		return;
 	}
-	RETVAL_STRING(get_token_type_name(type), 1);
+
+	RETVAL_STRING(get_token_type_name(type));
 }
 /* }}} */
 
diff --git a/ext/xml/xml.c b/ext/xml/xml.c
index a881d910b4..845cde426e 100644
--- a/ext/xml/xml.c
+++ b/ext/xml/xml.c
@@ -792,7 +792,9 @@ void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Ch
 				att = _xml_decode_tag(parser, attributes[0]);
 				val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
 
-				add_assoc_stringl(args[2], att, val, val_len, 0);
+				// TODO: avoid reallocation ???
+				add_assoc_stringl(args[2], att, val, val_len);
+				efree(val);
 
 				attributes += 2;
 
@@ -817,8 +819,8 @@ void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Ch
 
 				_xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
 
-				add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset,1); /* cast to avoid gcc-warning */
-				add_assoc_string(tag,"type","open",1);
+				add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset); /* cast to avoid gcc-warning */
+				add_assoc_string(tag,"type","open");
 				add_assoc_long(tag,"level",parser->level);
 
 				parser->ltags[parser->level-1] = estrdup(tag_name);
@@ -830,7 +832,9 @@ void _xml_startElementHandler(void *userData, const XML_Char *name, const XML_Ch
 					att = _xml_decode_tag(parser, attributes[0]);
 					val = xml_utf8_decode(attributes[1], strlen(attributes[1]), &val_len, parser->target_encoding);
 
-					add_assoc_stringl(atr,att,val,val_len,0);
+					// TODO: avoid reallocation ???
+					add_assoc_stringl(atr,att,val,val_len);
+					efree(val);
 
 					atcnt++;
 					attributes += 2;
@@ -880,7 +884,7 @@ void _xml_endElementHandler(void *userData, const XML_Char *name)
 			zval *tag;
 
 			if (parser->lastwasopen) {
-				add_assoc_string(*(parser->ctag),"type","complete",1);
+				add_assoc_string(*(parser->ctag),"type","complete");
 			} else {
 				MAKE_STD_ZVAL(tag);
 
@@ -888,8 +892,8 @@ void _xml_endElementHandler(void *userData, const XML_Char *name)
 				  
 				_xml_add_to_info(parser,((char *) tag_name) + parser->toffset);
 
-				add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset,1); /* cast to avoid gcc-warning */
-				add_assoc_string(tag,"type","close",1);
+				add_assoc_string(tag,"tag",((char *) tag_name) + parser->toffset); /* cast to avoid gcc-warning */
+				add_assoc_string(tag,"type","close");
 				add_assoc_long(tag,"level",parser->level);
 				  
 				zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
@@ -959,7 +963,9 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
 						Z_STRLEN_PP(myval) += decoded_len;
 						efree(decoded_value);
 					} else {
-						add_assoc_string(*(parser->ctag),"value",decoded_value,0);
+						// TODO: avoid reallocation ???
+						add_assoc_string(*(parser->ctag),"value",decoded_value);
+						efree(decoded_value);
 					}
 					
 				} else {
@@ -991,9 +997,11 @@ void _xml_characterDataHandler(void *userData, const XML_Char *s, int len)
 
 						_xml_add_to_info(parser,parser->ltags[parser->level-1] + parser->toffset);
 
-						add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset,1);
-						add_assoc_string(tag,"value",decoded_value,0);
-						add_assoc_string(tag,"type","cdata",1);
+						add_assoc_string(tag,"tag",parser->ltags[parser->level-1] + parser->toffset);
+						// TODO: avoid reallocation ???
+						add_assoc_string(tag,"value",decoded_value);
+						efree(decoded_value);
+						add_assoc_string(tag,"type","cdata");
 						add_assoc_long(tag,"level",parser->level);
 
 						zend_hash_next_index_insert(Z_ARRVAL_P(parser->data),&tag,sizeof(zval*),NULL);
diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index 763ff69404..0d5d8b9d4c 100644
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -326,14 +326,14 @@ static int add_double(zval* list, char* id, double num) {
 	else   return add_next_index_double(list, num);
 }
 
-static int add_string(zval* list, char* id, char* string, int duplicate) {
-	if(id) return add_assoc_string(list, id, string, duplicate);
-	else   return add_next_index_string(list, string, duplicate);
+static int add_string(zval* list, char* id, char* string) {
+	if(id) return add_assoc_string(list, id, string);
+	else   return add_next_index_string(list, string);
 }
 
-static int add_stringl(zval* list, char* id, char* string, uint length, int duplicate) {
-	if(id) return add_assoc_stringl(list, id, string, length, duplicate);
-	else   return add_next_index_stringl(list, string, length, duplicate);
+static int add_stringl(zval* list, char* id, char* string, uint length) {
+	if(id) return add_assoc_stringl(list, id, string, length);
+	else   return add_next_index_stringl(list, string, length);
 }
 
 #endif
diff --git a/ext/xsl/php_xsl.h b/ext/xsl/php_xsl.h
index a457856815..1e054b348d 100644
--- a/ext/xsl/php_xsl.h
+++ b/ext/xsl/php_xsl.h
@@ -79,7 +79,7 @@ void xsl_ext_function_object_php(xmlXPathParserContextPtr ctxt, int nargs);
 #define REGISTER_XSL_CLASS(ce, name, parent_ce, funcs, entry) \
 INIT_CLASS_ENTRY(ce, name, funcs); \
 ce.create_object = xsl_objects_new; \
-entry = zend_register_internal_class_ex(&ce, parent_ce, NULL TSRMLS_CC);
+entry = zend_register_internal_class_ex(&ce, parent_ce TSRMLS_CC);
 
 #define XSL_DOMOBJ_NEW(zval, obj, ret) \
 	if (NULL == (zval = php_xsl_create_object(obj, ret, zval, return_value TSRMLS_CC))) { \
diff --git a/ext/xsl/xsltprocessor.c b/ext/xsl/xsltprocessor.c
index 67c90f501f..699475d1f2 100644
--- a/ext/xsl/xsltprocessor.c
+++ b/ext/xsl/xsltprocessor.c
@@ -794,7 +794,8 @@ PHP_FUNCTION(xsl_xsltprocessor_set_parameter)
 			
 			ALLOC_ZVAL(new_string);
 			Z_ADDREF_PP(entry);
-			COPY_PZVAL_TO_ZVAL(*new_string, *entry);
+			ZVAL_COPY_VALUE(new_string, *entry);
+//???			COPY_PZVAL_TO_ZVAL(*new_string, *entry);
 			
 			zend_hash_update(intern->parameter, string_key, string_key_len, &new_string, sizeof(zval*), NULL);
 			zend_hash_move_forward(Z_ARRVAL_P(array_value));
diff --git a/ext/zip/php_zip.c b/ext/zip/php_zip.c
index a9db166c83..df6ea03dab 100644
--- a/ext/zip/php_zip.c
+++ b/ext/zip/php_zip.c
@@ -173,12 +173,11 @@ static int php_zip_extract_file(struct zip * za, char *dest, char *file, int fil
 	char *file_dirname_fullpath;
 	char file_dirname[MAXPATHLEN];
 	size_t dir_len;
-	char *file_basename;
-	size_t file_basename_len;
 	int is_dir_only = 0;
 	char *path_cleaned;
 	size_t path_cleaned_len;
 	cwd_state new_state;
+	zend_string *file_basename;
 
 	new_state.cwd = CWD_STATE_ALLOC(1);
 	new_state.cwd[0] = '\0';
@@ -212,11 +211,11 @@ static int php_zip_extract_file(struct zip * za, char *dest, char *file, int fil
 			len = spprintf(&file_dirname_fullpath, 0, "%s/%s", dest, file_dirname);
 		}
 
-		php_basename(path_cleaned, path_cleaned_len, NULL, 0, &file_basename, (size_t *)&file_basename_len TSRMLS_CC);
+		file_basename =	php_basename(path_cleaned, path_cleaned_len, NULL, 0 TSRMLS_CC);
 
 		if (ZIP_OPENBASEDIR_CHECKPATH(file_dirname_fullpath)) {
 			efree(file_dirname_fullpath);
-			efree(file_basename);
+			STR_RELEASE(file_basename);
 			CWD_STATE_FREE(new_state.cwd);
 			return 0;
 		}
@@ -240,7 +239,7 @@ static int php_zip_extract_file(struct zip * za, char *dest, char *file, int fil
 		if (!ret) {
 			efree(file_dirname_fullpath);
 			if (!is_dir_only) {
-				efree(file_basename);
+				STR_RELEASE(file_basename);
 				CWD_STATE_FREE(new_state.cwd);
 			}
 			return 0;
@@ -254,16 +253,16 @@ static int php_zip_extract_file(struct zip * za, char *dest, char *file, int fil
 		return 1;
 	}
 
-	len = spprintf(&fullpath, 0, "%s/%s", file_dirname_fullpath, file_basename);
+	len = spprintf(&fullpath, 0, "%s/%s", file_dirname_fullpath, file_basename->val);
 	if (!len) {
 		efree(file_dirname_fullpath);
-		efree(file_basename);
+		STR_RELEASE(file_basename);
 		CWD_STATE_FREE(new_state.cwd);
 		return 0;
 	} else if (len > MAXPATHLEN) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Full extraction path exceed MAXPATHLEN (%i)", MAXPATHLEN);
 		efree(file_dirname_fullpath);
-		efree(file_basename);
+		STR_RELEASE(file_basename);
 		CWD_STATE_FREE(new_state.cwd);
 		return 0;
 	}
@@ -275,7 +274,7 @@ static int php_zip_extract_file(struct zip * za, char *dest, char *file, int fil
 	if (ZIP_OPENBASEDIR_CHECKPATH(fullpath)) {
 		efree(fullpath);
 		efree(file_dirname_fullpath);
-		efree(file_basename);
+		STR_RELEASE(file_basename);
 		CWD_STATE_FREE(new_state.cwd);
 		return 0;
 	}
@@ -309,7 +308,7 @@ static int php_zip_extract_file(struct zip * za, char *dest, char *file, int fil
 
 done:
 	efree(fullpath);
-	efree(file_basename);
+	STR_RELEASE(file_basename);
 	efree(file_dirname_fullpath);
 	CWD_STATE_FREE(new_state.cwd);
 
@@ -438,7 +437,7 @@ static int php_zip_parse_options(zval *options, long *remove_all_path,
 #define RETURN_SB(sb) \
 	{ \
 		array_init(return_value); \
-		add_ascii_assoc_string(return_value, "name", (char *)(sb)->name, 1); \
+		add_ascii_assoc_string(return_value, "name", (char *)(sb)->name); \
 		add_ascii_assoc_long(return_value, "index", (long) (sb)->index); \
 		add_ascii_assoc_long(return_value, "crc", (long) (sb)->crc); \
 		add_ascii_assoc_long(return_value, "size", (long) (sb)->size); \
@@ -621,7 +620,7 @@ int php_zip_glob(char *pattern, int pattern_len, long flags, zval *return_value
 				continue;
 			}
 		}
-		add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip, 1);
+		add_next_index_string(return_value, globbuf.gl_pathv[n]+cwd_skip);
 	}
 
 	globfree(&globbuf);
@@ -723,7 +722,7 @@ int php_zip_pcre(char *regexp, int regexp_len, char *path, int path_len, zval *r
 				continue;
 			}
 
-			add_next_index_string(return_value, fullpath, 1);
+			add_next_index_string(return_value, fullpath);
 			efree(namelist[i]);
 		}
 		efree(namelist);
@@ -1773,13 +1772,14 @@ static void php_zip_add_from_pattern(INTERNAL_FUNCTION_PARAMETERS, int type) /*
 			char *file_stripped, *entry_name;
 			size_t entry_name_len, file_stripped_len;
 			char entry_name_buf[MAXPATHLEN];
-			char *basename = NULL;
+			zend_string *basename = NULL;
 
 			if (zend_hash_index_find(Z_ARRVAL_P(return_value), i, (void **) &zval_file) == SUCCESS) {
 				if (remove_all_path) {
-					php_basename(Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file), NULL, 0,
-									&basename, (size_t *)&file_stripped_len TSRMLS_CC);
-					file_stripped = basename;
+					basename = php_basename(Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file), NULL, 0,
+									&basename TSRMLS_CC);
+					file_stripped = basename->val;
+					file_stripped_len = basename->len;
 				} else if (remove_path && strstr(Z_STRVAL_PP(zval_file), remove_path) != NULL) {
 					file_stripped = Z_STRVAL_PP(zval_file) + remove_path_len + 1;
 					file_stripped_len = Z_STRLEN_PP(zval_file) - remove_path_len - 1;
@@ -1804,7 +1804,7 @@ static void php_zip_add_from_pattern(INTERNAL_FUNCTION_PARAMETERS, int type) /*
 					entry_name_len = Z_STRLEN_PP(zval_file);
 				}
 				if (basename) {
-					efree(basename);
+					STR_RELEASE(basename);
 					basename = NULL;
 				}
 				if (php_zip_add_file(intern, Z_STRVAL_PP(zval_file), Z_STRLEN_PP(zval_file),
diff --git a/ext/zip/zip_stream.c b/ext/zip/zip_stream.c
index 8d02d89637..956f066064 100644
--- a/ext/zip/zip_stream.c
+++ b/ext/zip/zip_stream.c
@@ -118,13 +118,12 @@ static int php_zip_ops_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_D
 	struct zip_stat sb;
 	const char *path = stream->orig_path;
 	int path_len = strlen(stream->orig_path);
-	char *file_basename;
-	size_t file_basename_len;
 	char file_dirname[MAXPATHLEN];
 	struct zip *za;
 	char *fragment;
 	int fragment_len;
 	int err;
+	zend_string *file_basename;
 
 	fragment = strchr(path, '#');
 	if (!fragment) {
@@ -149,11 +148,11 @@ static int php_zip_ops_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_D
 	memcpy(file_dirname, path, path_len - fragment_len);
 	file_dirname[path_len - fragment_len] = '\0';
 
-	php_basename((char *)path, path_len - fragment_len, NULL, 0, &file_basename, &file_basename_len TSRMLS_CC);
+	file_basename = php_basename((char *)path, path_len - fragment_len, NULL, 0 TSRMLS_CC);
 	fragment++;
 
 	if (ZIP_OPENBASEDIR_CHECKPATH(file_dirname)) {
-		efree(file_basename);
+		STR_RELEASE(file_basename);
 		return -1;
 	}
 
@@ -161,7 +160,7 @@ static int php_zip_ops_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_D
 	if (za) {
 		memset(ssb, 0, sizeof(php_stream_statbuf));
 		if (zip_stat(za, fragment, ZIP_FL_NOCASE, &sb) != 0) {
-			efree(file_basename);
+			STR_RELEASE(file_basename);
 			return -1;
 		}
 		zip_close(za);
@@ -185,7 +184,7 @@ static int php_zip_ops_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_D
 #endif
 		ssb->sb.st_ino = -1;
 	}
-	efree(file_basename);
+	STR_RELEASE(file_basename);
 	return 0;
 }
 /* }}} */
diff --git a/ext/zlib/zlib.c b/ext/zlib/zlib.c
index 705fb5dd5f..3753f98a67 100644
--- a/ext/zlib/zlib.c
+++ b/ext/zlib/zlib.c
@@ -564,7 +564,7 @@ static PHP_FUNCTION(gzfile)
 	memset(buf, 0, sizeof(buf));
 	    
 	while (php_stream_gets(stream, buf, sizeof(buf) - 1) != NULL) {
-		add_index_string(return_value, i++, buf, 1);
+		add_index_string(return_value, i++, buf);
 	}
 	php_stream_close(stream);
 }
diff --git a/main/SAPI.c b/main/SAPI.c
index 8c347cb6d4..4cab4e54ea 100644
--- a/main/SAPI.c
+++ b/main/SAPI.c
@@ -57,10 +57,15 @@ SAPI_API int sapi_globals_id;
 sapi_globals_struct sapi_globals;
 #endif
 
+static void _type_dtor(zval *zv)
+{
+	free(Z_PTR_P(zv));
+}
+
 static void sapi_globals_ctor(sapi_globals_struct *sapi_globals TSRMLS_DC)
 {
 	memset(sapi_globals, 0, sizeof(*sapi_globals));
-	zend_hash_init_ex(&sapi_globals->known_post_content_types, 5, NULL, NULL, 1, 0);
+	zend_hash_init_ex(&sapi_globals->known_post_content_types, 8, NULL, _type_dtor, 1, 0);
 	php_setup_sapi_content_types(TSRMLS_C);
 }
 
@@ -124,26 +129,21 @@ SAPI_API void sapi_free_header(sapi_header_struct *sapi_header)
 PHP_FUNCTION(header_register_callback)
 {
 	zval *callback_func;
-	char *callback_name;
+
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &callback_func) == FAILURE) {
 		return;
 	}
 	
-	if (!zend_is_callable(callback_func, 0, &callback_name TSRMLS_CC)) {
-		efree(callback_name);
+	if (!zend_is_callable(callback_func, 0, NULL TSRMLS_CC)) {
 		RETURN_FALSE;
 	}
 
-	efree(callback_name);
-
-	if (SG(callback_func)) {
+	if (Z_TYPE(SG(callback_func)) != IS_UNDEF) {
 		zval_ptr_dtor(&SG(callback_func));
 		SG(fci_cache) = empty_fcall_info_cache;
 	}
 
-	SG(callback_func) = callback_func;
-
-	Z_ADDREF_P(SG(callback_func));
+	ZVAL_COPY(&SG(callback_func), callback_func);
 
 	RETURN_TRUE;
 }
@@ -153,27 +153,23 @@ static void sapi_run_header_callback(TSRMLS_D)
 {
 	int   error;
 	zend_fcall_info fci;
-	char *callback_name = NULL;
 	char *callback_error = NULL;
-	zval *retval_ptr = NULL;
+	zval retval;
 	
-	if (zend_fcall_info_init(SG(callback_func), 0, &fci, &SG(fci_cache), &callback_name, &callback_error TSRMLS_CC) == SUCCESS) {
-		fci.retval_ptr_ptr = &retval_ptr;
+	if (zend_fcall_info_init(&SG(callback_func), 0, &fci, &SG(fci_cache), NULL, &callback_error TSRMLS_CC) == SUCCESS) {
+		fci.retval = &retval;
 		
 		error = zend_call_function(&fci, &SG(fci_cache) TSRMLS_CC);
 		if (error == FAILURE) {
 			goto callback_failed;
-		} else if (retval_ptr) {
-			zval_ptr_dtor(&retval_ptr);
+		} else {
+			zval_ptr_dtor(&retval);
 		}
 	} else {
 callback_failed:
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not call the sapi_header_callback");
 	}
 	
-	if (callback_name) {
-		efree(callback_name);
-	}
 	if (callback_error) {
 		efree(callback_error);
 	}	
@@ -218,8 +214,8 @@ static void sapi_read_post_data(TSRMLS_D)
 	}
 
 	/* now try to find an appropriate POST content handler */
-	if (zend_hash_find(&SG(known_post_content_types), content_type,
-			content_type_length+1, (void **) &post_entry) == SUCCESS) {
+	if ((post_entry = zend_hash_str_find_ptr(&SG(known_post_content_types), content_type,
+			content_type_length)) != NULL) {
 		/* found one, register it for use */
 		SG(request_info).post_entry = post_entry;
 		post_reader_func = post_entry->post_reader;
@@ -453,7 +449,7 @@ SAPI_API void sapi_activate(TSRMLS_D)
 	SG(sapi_headers).mimetype = NULL;
 	SG(headers_sent) = 0;
 	SG(callback_run) = 0;
-	SG(callback_func) = NULL;
+	ZVAL_UNDEF(&SG(callback_func));
 	SG(read_post_bytes) = 0;
 	SG(request_info).request_body = NULL;
 	SG(request_info).current_user = NULL;
@@ -550,9 +546,7 @@ SAPI_API void sapi_deactivate(TSRMLS_D)
 	SG(sapi_started) = 0;
 	SG(headers_sent) = 0;
 	SG(callback_run) = 0;
-	if (SG(callback_func)) {
-		zval_ptr_dtor(&SG(callback_func));
-	}
+	zval_ptr_dtor(&SG(callback_func));
 	SG(request_info).headers_read = 0;
 	SG(global_request_time) = 0;
 }
@@ -795,7 +789,9 @@ SAPI_API int sapi_header_op(sapi_header_op_enum op, void *arg TSRMLS_DC)
 
 				/* Disable possible output compression for images */
 				if (!strncmp(ptr, "image/", sizeof("image/")-1)) {
-					zend_alter_ini_entry("zlib.output_compression", sizeof("zlib.output_compression"), "0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+					zend_string *key = STR_INIT("zlib.output_compression", sizeof("zlib.output_compression")-1, 0);
+					zend_alter_ini_entry(key, "0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+					STR_RELEASE(key);
 				}
 
 				mimetype = estrdup(ptr);
@@ -821,8 +817,10 @@ SAPI_API int sapi_header_op(sapi_header_op_enum op, void *arg TSRMLS_DC)
 				 * do disable compression altogether. This contributes to making scripts
 				 * portable between setups that have and don't have zlib compression
 				 * enabled globally. See req #44164 */
-				zend_alter_ini_entry("zlib.output_compression", sizeof("zlib.output_compression"),
+				zend_string *key = STR_INIT("zlib.output_compression", sizeof("zlib.output_compression")-1, 0);
+				zend_alter_ini_entry(key,
 					"0", sizeof("0") - 1, PHP_INI_USER, PHP_INI_STAGE_RUNTIME);
+				STR_RELEASE(key);
 			} else if (!STRCASECMP(header_line, "Location")) {
 				if ((SG(sapi_headers).http_response_code < 300 ||
 					SG(sapi_headers).http_response_code > 307) &&
@@ -880,7 +878,7 @@ SAPI_API int sapi_send_headers(TSRMLS_D)
 		SG(sapi_headers).send_default_content_type = 0;
 	}
 
-	if (SG(callback_func) && !SG(callback_run)) {
+	if (Z_TYPE(SG(callback_func)) != IS_UNDEF && !SG(callback_run)) {
 		SG(callback_run) = 1;
 		sapi_run_header_callback(TSRMLS_C);
 	}
@@ -952,9 +950,9 @@ SAPI_API int sapi_register_post_entry(sapi_post_entry *post_entry TSRMLS_DC)
 	if (SG(sapi_started) && EG(in_execution)) {
 		return FAILURE;
 	}
-	return zend_hash_add(&SG(known_post_content_types),
-			post_entry->content_type, post_entry->content_type_len+1,
-			(void *) post_entry, sizeof(sapi_post_entry), NULL);
+	return zend_hash_str_add_mem(&SG(known_post_content_types),
+			post_entry->content_type, post_entry->content_type_len,
+			(void *) post_entry, sizeof(sapi_post_entry)) ? SUCCESS : FAILURE;
 }
 
 SAPI_API void sapi_unregister_post_entry(sapi_post_entry *post_entry TSRMLS_DC)
@@ -962,8 +960,8 @@ SAPI_API void sapi_unregister_post_entry(sapi_post_entry *post_entry TSRMLS_DC)
 	if (SG(sapi_started) && EG(in_execution)) {
 		return;
 	}
-	zend_hash_del(&SG(known_post_content_types), post_entry->content_type,
-			post_entry->content_type_len+1);
+	zend_hash_str_del(&SG(known_post_content_types), post_entry->content_type,
+			post_entry->content_type_len);
 }
 
 
diff --git a/main/SAPI.h b/main/SAPI.h
index ecb1743820..ac3db56bad 100644
--- a/main/SAPI.h
+++ b/main/SAPI.h
@@ -133,7 +133,7 @@ typedef struct _sapi_globals_struct {
 	zend_bool sapi_started;
 	double global_request_time;
 	HashTable known_post_content_types;
-	zval *callback_func;
+	zval callback_func;
 	zend_fcall_info_cache fci_cache;
 	zend_bool callback_run;
 } sapi_globals_struct;
diff --git a/main/fopen_wrappers.c b/main/fopen_wrappers.c
index 3be7b5f206..ad2e8a8d14 100644
--- a/main/fopen_wrappers.c
+++ b/main/fopen_wrappers.c
@@ -433,13 +433,15 @@ PHPAPI int php_fopen_primary_script(zend_file_handle *file_handle TSRMLS_DC)
 
 	if (!resolved_path) {
 		if (SG(request_info).path_translated != filename) {
-			STR_FREE(filename);
+//???			STR_FREE(filename);
+			if (filename) efree(filename);
 		}
 		/* we have to free SG(request_info).path_translated here because
 		 * php_destroy_request_info assumes that it will get
 		 * freed when the include_names hash is emptied, but
 		 * we're not adding it in this case */
-		STR_FREE(SG(request_info).path_translated);
+//???		STR_FREE(SG(request_info).path_translated);
+		if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 		SG(request_info).path_translated = NULL;
 		return FAILURE;
 	}
@@ -450,16 +452,19 @@ PHPAPI int php_fopen_primary_script(zend_file_handle *file_handle TSRMLS_DC)
 	if (zend_stream_open(filename, file_handle TSRMLS_CC) == FAILURE) {
 		PG(display_errors) = orig_display_errors;
 		if (SG(request_info).path_translated != filename) {
-			STR_FREE(filename);
+//???			STR_FREE(filename);
+			if (filename) efree(filename);
 		}
-		STR_FREE(SG(request_info).path_translated);	/* for same reason as above */
+//???		STR_FREE(SG(request_info).path_translated);	/* for same reason as above */
+		if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 		SG(request_info).path_translated = NULL;
 		return FAILURE;
 	}
 	PG(display_errors) = orig_display_errors;
 
 	if (SG(request_info).path_translated != filename) {
-		STR_FREE(SG(request_info).path_translated);	/* for same reason as above */
+//???		STR_FREE(SG(request_info).path_translated);	/* for same reason as above */
+		if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 		SG(request_info).path_translated = filename;
 	}
 
diff --git a/main/getopt.c b/main/getopt.c
index a31a6c75d5..315467a095 100644
--- a/main/getopt.c
+++ b/main/getopt.c
@@ -80,7 +80,7 @@ PHPAPI int php_getopt(int argc, char* const *argv, const opt_struct opts[], char
 		}
 	}
 	if ((argv[*optind][0] == '-') && (argv[*optind][1] == '-')) {
-		char *pos;
+		const char *pos;
 		int arg_end = strlen(argv[*optind])-1;
 
 		/* '--' indicates end of args if not followed by a known long option name */
diff --git a/main/main.c b/main/main.c
index 671700887a..ebe0655d3a 100644
--- a/main/main.c
+++ b/main/main.c
@@ -671,7 +671,7 @@ PHPAPI void php_log_err(char *log_message TSRMLS_DC)
 		if (fd != -1) {
 			char *tmp;
 			int len;
-			char *error_time_str;
+			zend_string *error_time_str;
 
 			time(&error_time);
 #ifdef ZTS
@@ -683,13 +683,13 @@ PHPAPI void php_log_err(char *log_message TSRMLS_DC)
 #else
 			error_time_str = php_format_date("d-M-Y H:i:s e", 13, error_time, 1 TSRMLS_CC);
 #endif
-			len = spprintf(&tmp, 0, "[%s] %s%s", error_time_str, log_message, PHP_EOL);
+			len = spprintf(&tmp, 0, "[%s] %s%s", error_time_str->val, log_message, PHP_EOL);
 #ifdef PHP_WIN32
 			php_flock(fd, 2);
 #endif
 			php_ignore_value(write(fd, tmp, len));
 			efree(tmp);
-			efree(error_time_str);
+			STR_FREE(error_time_str);
 			close(fd);
 			PG(in_error_log) = 0;
 			return;
@@ -741,6 +741,7 @@ PHPAPI int php_printf(const char *format, ...)
  */
 PHPAPI void php_verror(const char *docref, const char *params, int type, const char *format, va_list args TSRMLS_DC)
 {
+	zend_string *replace_buffer = NULL, *replace_origin = NULL;
 	char *buffer = NULL, *docref_buf = NULL, *target = NULL;
 	char *docref_target = "", *docref_root = "";
 	char *p;
@@ -757,11 +758,10 @@ PHPAPI void php_verror(const char *docref, const char *params, int type, const c
 	buffer_len = vspprintf(&buffer, 0, format, args);
 
 	if (PG(html_errors)) {
-		size_t len;
-		char *replace = php_escape_html_entities(buffer, buffer_len, &len, 0, ENT_COMPAT, NULL TSRMLS_CC);
+		replace_buffer = php_escape_html_entities(buffer, buffer_len, 0, ENT_COMPAT, NULL TSRMLS_CC);
 		efree(buffer);
-		buffer = replace;
-		buffer_len = len;
+		buffer = replace_buffer->val;
+		buffer_len = replace_buffer->len;
 	}
 
 	/* which function caused the problem if any at all */
@@ -815,10 +815,9 @@ PHPAPI void php_verror(const char *docref, const char *params, int type, const c
 	}
 
 	if (PG(html_errors)) {
-		size_t len;
-		char *replace = php_escape_html_entities(origin, origin_len, &len, 0, ENT_COMPAT, NULL TSRMLS_CC);
+		replace_origin = php_escape_html_entities(origin, origin_len, 0, ENT_COMPAT, NULL TSRMLS_CC);
 		efree(origin);
-		origin = replace;
+		origin = replace_origin->val;
 	}
 
 	/* origin and buffer available, so lets come up with the error message */
@@ -889,24 +888,28 @@ PHPAPI void php_verror(const char *docref, const char *params, int type, const c
 	} else {
 		spprintf(&message, 0, "%s: %s", origin, buffer);
 	}
-	efree(origin);
+	if (replace_origin) {
+		STR_FREE(replace_origin);
+	} else {
+		efree(origin);
+	}
 	if (docref_buf) {
 		efree(docref_buf);
 	}
 
 	if (PG(track_errors) && module_initialized &&
-			(!EG(user_error_handler) || !(EG(user_error_handler_error_reporting) & type))) {
-		if (!EG(active_symbol_table)) {
-			zend_rebuild_symbol_table(TSRMLS_C);
-		}
-		if (EG(active_symbol_table)) {
-			zval *tmp;
-			ALLOC_INIT_ZVAL(tmp);
-			ZVAL_STRINGL(tmp, buffer, buffer_len, 1);
-			zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) &tmp, sizeof(zval *), NULL);
+			(Z_TYPE(EG(user_error_handler)) == IS_UNDEF || !(EG(user_error_handler_error_reporting) & type))) {
+		zval tmp;
+		ZVAL_STRINGL(&tmp, buffer, buffer_len);
+		if (zend_set_local_var_str("php_errormsg", sizeof("php_errormsg")-1, &tmp, 0 TSRMLS_CC) == FAILURE) {
+			zval_ptr_dtor(&tmp);
 		}
 	}
-	efree(buffer);
+	if (replace_buffer) {
+		STR_FREE(replace_buffer);
+	} else {
+		efree(buffer);
+	}
 
 	php_error(type, "%s", message);
 	efree(message);
@@ -1125,10 +1128,9 @@ static void php_error_cb(int type, const char *error_filename, const uint error_
 
 				if (PG(html_errors)) {
 					if (type == E_ERROR || type == E_PARSE) {
-						size_t len;
-						char *buf = php_escape_html_entities(buffer, buffer_len, &len, 0, ENT_COMPAT, NULL TSRMLS_CC);
-						php_printf("%s<br />\n<b>%s</b>:  %s in <b>%s</b> on line <b>%d</b><br />\n%s", STR_PRINT(prepend_string), error_type_str, buf, error_filename, error_lineno, STR_PRINT(append_string));
-						efree(buf);
+						zend_string *buf = php_escape_html_entities(buffer, buffer_len, 0, ENT_COMPAT, NULL TSRMLS_CC);
+						php_printf("%s<br />\n<b>%s</b>:  %s in <b>%s</b> on line <b>%d</b><br />\n%s", STR_PRINT(prepend_string), error_type_str, buf->val, error_filename, error_lineno, STR_PRINT(append_string));
+						STR_FREE(buf);
 					} else {
 						php_printf("%s<br />\n<b>%s</b>:  %s in <b>%s</b> on line <b>%d</b><br />\n%s", STR_PRINT(prepend_string), error_type_str, buffer, error_filename, error_lineno, STR_PRINT(append_string));
 					}
@@ -1230,10 +1232,11 @@ static void php_error_cb(int type, const char *error_filename, const uint error_
 			zend_rebuild_symbol_table(TSRMLS_C);
 		}
 		if (EG(active_symbol_table)) {
-			zval *tmp;
-			ALLOC_INIT_ZVAL(tmp);
-			ZVAL_STRINGL(tmp, buffer, buffer_len, 1);
-			zend_hash_update(EG(active_symbol_table), "php_errormsg", sizeof("php_errormsg"), (void **) & tmp, sizeof(zval *), NULL);
+			zval tmp;
+			ZVAL_STRINGL(&tmp, buffer, buffer_len);
+			if (zend_set_local_var_str("php_errormsg", sizeof("php_errormsg")-1, &tmp, 0 TSRMLS_CC) == FAILURE) {
+				zval_ptr_dtor(&tmp);
+			}
 		}
 	}
 
@@ -1311,6 +1314,7 @@ PHP_FUNCTION(set_time_limit)
 	long new_timeout;
 	char *new_timeout_str;
 	int new_timeout_strlen;
+	zend_string *key;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &new_timeout) == FAILURE) {
 		return;
@@ -1318,11 +1322,13 @@ PHP_FUNCTION(set_time_limit)
 
 	new_timeout_strlen = zend_spprintf(&new_timeout_str, 0, "%ld", new_timeout);
 
-	if (zend_alter_ini_entry_ex("max_execution_time", sizeof("max_execution_time"), new_timeout_str, new_timeout_strlen, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == SUCCESS) {
+	key = STR_INIT("max_execution_time", sizeof("max_execution_time")-1, 0);
+	if (zend_alter_ini_entry_ex(key, new_timeout_str, new_timeout_strlen, PHP_INI_USER, PHP_INI_STAGE_RUNTIME, 0 TSRMLS_CC) == SUCCESS) {
 		RETVAL_TRUE;
 	} else {
 		RETVAL_FALSE;
 	}
+	STR_RELEASE(key);
 	efree(new_timeout_str);
 }
 /* }}} */
@@ -1618,11 +1624,10 @@ int php_request_startup(TSRMLS_D)
 		}
 
 		if (PG(output_handler) && PG(output_handler)[0]) {
-			zval *oh;
+			zval oh;
 
-			MAKE_STD_ZVAL(oh);
-			ZVAL_STRING(oh, PG(output_handler), 1);
-			php_output_start_user(oh, 0, PHP_OUTPUT_HANDLER_STDFLAGS TSRMLS_CC);
+			ZVAL_STRING(&oh, PG(output_handler));
+			php_output_start_user(&oh, 0, PHP_OUTPUT_HANDLER_STDFLAGS TSRMLS_CC);
 			zval_ptr_dtor(&oh);
 		} else if (PG(output_buffering)) {
 			php_output_start_user(NULL, PG(output_buffering) > 1 ? PG(output_buffering) : 0, PHP_OUTPUT_HANDLER_STDFLAGS TSRMLS_CC);
@@ -1733,9 +1738,7 @@ void php_request_shutdown_for_hook(void *dummy)
 		int i;
 
 		for (i = 0; i < NUM_TRACK_VARS; i++) {
-			if (PG(http_globals)[i]) {
-				zval_ptr_dtor(&PG(http_globals)[i]);
-			}
+			zval_ptr_dtor(&PG(http_globals)[i]);
 		}
 	} zend_end_try();
 
@@ -1829,9 +1832,7 @@ void php_request_shutdown(void *dummy)
 		int i;
 
 		for (i=0; i<NUM_TRACK_VARS; i++) {
-			if (PG(http_globals)[i]) {
-				zval_ptr_dtor(&PG(http_globals)[i]);
-			}
+			zval_ptr_dtor(&PG(http_globals)[i]);
 		}
 	} zend_end_try();
 
@@ -1867,10 +1868,10 @@ void php_request_shutdown(void *dummy)
 	} zend_end_try();
 
 	/* 14. Free Willy (here be crashes) */
+	zend_interned_strings_restore(TSRMLS_C);
 	zend_try {
 		shutdown_memory_manager(CG(unclean_shutdown) || !report_memleaks, 0 TSRMLS_CC);
 	} zend_end_try();
-	zend_interned_strings_restore(TSRMLS_C);
 
 	/* 15. Reset max_execution_time */
 	zend_try {
@@ -2279,7 +2280,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
 
 	/* register additional functions */
 	if (sapi_module.additional_functions) {
-		if (zend_hash_find(&module_registry, "standard", sizeof("standard"), (void**)&module)==SUCCESS) {
+		if ((module = zend_hash_str_find_ptr(&module_registry, "standard", sizeof("standard")-1)) != NULL) {
 			EG(current_module) = module;
 			zend_register_functions(NULL, sapi_module.additional_functions, NULL, MODULE_PERSISTENT TSRMLS_CC);
 			EG(current_module) = NULL;
@@ -2291,7 +2292,7 @@ int php_module_startup(sapi_module_struct *sf, zend_module_entry *additional_mod
 	php_disable_classes(TSRMLS_C);
 
 	/* make core report what it should */
-	if (zend_hash_find(&module_registry, "core", sizeof("core"), (void**)&module)==SUCCESS) {
+	if ((module = zend_hash_str_find_ptr(&module_registry, "core", sizeof("core")-1)) != NULL) {
 		module->version = PHP_VERSION;
 		module->info_func = PHP_MINFO(php_core);
 	}
@@ -2512,11 +2513,10 @@ PHPAPI int php_execute_script(zend_file_handle *primary_file TSRMLS_DC)
  			primary_file->type != ZEND_HANDLE_FILENAME
 		) {
 			int realfile_len;
-			int dummy = 1;
 
 			if (expand_filepath(primary_file->filename, realfile TSRMLS_CC)) {
 				realfile_len =  strlen(realfile);
-				zend_hash_add(&EG(included_files), realfile, realfile_len+1, (void *)&dummy, sizeof(int), NULL);
+				zend_hash_str_add_empty_element(&EG(included_files), realfile, realfile_len);
 				primary_file->opened_path = estrndup(realfile, realfile_len);
 			}
 		}
@@ -2567,7 +2567,7 @@ PHPAPI int php_execute_script(zend_file_handle *primary_file TSRMLS_DC)
 
 /* {{{ php_execute_simple_script
  */
-PHPAPI int php_execute_simple_script(zend_file_handle *primary_file, zval **ret TSRMLS_DC)
+PHPAPI int php_execute_simple_script(zend_file_handle *primary_file, zval *ret TSRMLS_DC)
 {
 	char *old_cwd;
 	ALLOCA_FLAG(use_heap)
@@ -2625,19 +2625,18 @@ PHPAPI int php_handle_auth_data(const char *auth TSRMLS_DC)
 
 	if (auth && auth[0] != '\0' && strncmp(auth, "Basic ", 6) == 0) {
 		char *pass;
-		char *user;
+		zend_string *user;
 
-		user = php_base64_decode(auth + 6, strlen(auth) - 6, NULL);
+		user = php_base64_decode(auth + 6, strlen(auth) - 6);
 		if (user) {
-			pass = strchr(user, ':');
+			pass = strchr(user->val, ':');
 			if (pass) {
 				*pass++ = '\0';
-				SG(request_info).auth_user = user;
+				SG(request_info).auth_user = estrndup(user->val, user->len);
 				SG(request_info).auth_password = estrdup(pass);
 				ret = 0;
-			} else {
-				efree(user);
-			}
+			} 
+			STR_FREE(user);
 		}
 	}
 
diff --git a/main/network.c b/main/network.c
index fc2a94badd..13ed727923 100644
--- a/main/network.c
+++ b/main/network.c
@@ -555,7 +555,8 @@ PHPAPI int php_network_parse_network_address_with_port(const char *addr, long ad
 	if (n == 0) {
 		if (errstr) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Failed to resolve `%s': %s", tmp, errstr);
-			STR_FREE(errstr);
+//???			STR_FREE(errstr);
+			efree(errstr);
 		}
 		goto out;
 	}
@@ -581,7 +582,8 @@ PHPAPI int php_network_parse_network_address_with_port(const char *addr, long ad
 	php_network_freeaddresses(psal);
 
 out:
-	STR_FREE(tmp);
+//???	STR_FREE(tmp);
+	efree(tmp);
 	return ret;
 }
 
diff --git a/main/output.c b/main/output.c
index 1dac7179b8..83225107e0 100644
--- a/main/output.c
+++ b/main/output.c
@@ -109,7 +109,7 @@ static void php_output_header(TSRMLS_D)
 	if (!SG(headers_sent)) {
 		if (!OG(output_start_filename)) {
 			if (zend_is_compiling(TSRMLS_C)) {
-				OG(output_start_filename) = zend_get_compiled_filename(TSRMLS_C);
+				OG(output_start_filename) = zend_get_compiled_filename(TSRMLS_C)->val;
 				OG(output_start_lineno) = zend_get_compiled_lineno(TSRMLS_C);
 			} else if (zend_is_executing(TSRMLS_C)) {
 				OG(output_start_filename) = zend_get_executed_filename(TSRMLS_C);
@@ -126,14 +126,20 @@ static void php_output_header(TSRMLS_D)
 }
 /* }}} */
 
+static void reverse_conflict_dtor(zval *zv)
+{
+	HashTable *ht = Z_PTR_P(zv);
+	zend_hash_destroy(ht);
+}
+
 /* {{{ void php_output_startup(void)
  * Set up module globals and initalize the conflict and reverse conflict hash tables */
 PHPAPI void php_output_startup(void)
 {
 	ZEND_INIT_MODULE_GLOBALS(output, php_output_init_globals, NULL);
-	zend_hash_init(&php_output_handler_aliases, 0, NULL, NULL, 1);
-	zend_hash_init(&php_output_handler_conflicts, 0, NULL, NULL, 1);
-	zend_hash_init(&php_output_handler_reverse_conflicts, 0, NULL, (void (*)(void *)) zend_hash_destroy, 1);
+	zend_hash_init(&php_output_handler_aliases, 8, NULL, NULL, 1);
+	zend_hash_init(&php_output_handler_conflicts, 8, NULL, NULL, 1);
+	zend_hash_init(&php_output_handler_reverse_conflicts, 8, NULL, reverse_conflict_dtor, 1);
 	php_output_direct = php_output_stdout;
 }
 /* }}} */
@@ -385,7 +391,7 @@ PHPAPI int php_output_get_level(TSRMLS_D)
 PHPAPI int php_output_get_contents(zval *p TSRMLS_DC)
 {
 	if (OG(active)) {
-		ZVAL_STRINGL(p, OG(active)->buffer.data, OG(active)->buffer.used, 1);
+		ZVAL_STRINGL(p, OG(active)->buffer.data, OG(active)->buffer.used);
 		return SUCCESS;
 	} else {
 		ZVAL_NULL(p);
@@ -484,9 +490,10 @@ PHPAPI int php_output_start_internal(const char *name, size_t name_len, php_outp
  * Create a user level output handler */
 PHPAPI php_output_handler *php_output_handler_create_user(zval *output_handler, size_t chunk_size, int flags TSRMLS_DC)
 {
-	char *handler_name = NULL, *error = NULL;
+	zend_string *handler_name = NULL;
+	char *error = NULL;
 	php_output_handler *handler = NULL;
-	php_output_handler_alias_ctor_t *alias = NULL;
+	php_output_handler_alias_ctor_t alias = NULL;
 	php_output_handler_user_func_t *user = NULL;
 
 	switch (Z_TYPE_P(output_handler)) {
@@ -495,15 +502,14 @@ PHPAPI php_output_handler *php_output_handler_create_user(zval *output_handler,
 			break;
 		case IS_STRING:
 			if (Z_STRLEN_P(output_handler) && (alias = php_output_handler_alias(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler) TSRMLS_CC))) {
-				handler = (*alias)(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler), chunk_size, flags TSRMLS_CC);
+				handler = alias(Z_STRVAL_P(output_handler), Z_STRLEN_P(output_handler), chunk_size, flags TSRMLS_CC);
 				break;
 			}
 		default:
 			user = ecalloc(1, sizeof(php_output_handler_user_func_t));
 			if (SUCCESS == zend_fcall_info_init(output_handler, 0, &user->fci, &user->fcc, &handler_name, &error TSRMLS_CC)) {
-				handler = php_output_handler_init(handler_name, strlen(handler_name), chunk_size, (flags & ~0xf) | PHP_OUTPUT_HANDLER_USER TSRMLS_CC);
-				Z_ADDREF_P(output_handler);
-				user->zoh = output_handler;
+				handler = php_output_handler_init(handler_name->val, handler_name->len, chunk_size, (flags & ~0xf) | PHP_OUTPUT_HANDLER_USER TSRMLS_CC);
+				ZVAL_COPY(&user->zoh, output_handler);
 				handler->func.user = user;
 			} else {
 				efree(user);
@@ -513,7 +519,7 @@ PHPAPI php_output_handler *php_output_handler_create_user(zval *output_handler,
 				efree(error);
 			}
 			if (handler_name) {
-				efree(handler_name);
+				STR_RELEASE(handler_name);
 			}
 	}
 
@@ -552,22 +558,22 @@ PHPAPI int php_output_handler_start(php_output_handler *handler TSRMLS_DC)
 {
 	HashPosition pos;
 	HashTable *rconflicts;
-	php_output_handler_conflict_check_t *conflict;
+	php_output_handler_conflict_check_t conflict;
 
 	if (php_output_lock_error(PHP_OUTPUT_HANDLER_START TSRMLS_CC) || !handler) {
 		return FAILURE;
 	}
-	if (SUCCESS == zend_hash_find(&php_output_handler_conflicts, handler->name, handler->name_len+1, (void *) &conflict)) {
-		if (SUCCESS != (*conflict)(handler->name, handler->name_len TSRMLS_CC)) {
+	if (NULL != (conflict = zend_hash_str_find_ptr(&php_output_handler_conflicts, handler->name, handler->name_len))) {
+		if (SUCCESS != conflict(handler->name, handler->name_len TSRMLS_CC)) {
 			return FAILURE;
 		}
 	}
-	if (SUCCESS == zend_hash_find(&php_output_handler_reverse_conflicts, handler->name, handler->name_len+1, (void *) &rconflicts)) {
+	if (NULL != (rconflicts = zend_hash_str_find_ptr(&php_output_handler_reverse_conflicts, handler->name, handler->name_len))) {
 		for (zend_hash_internal_pointer_reset_ex(rconflicts, &pos);
-			zend_hash_get_current_data_ex(rconflicts, (void *) &conflict, &pos) == SUCCESS;
+			(conflict = zend_hash_get_current_data_ptr_ex(rconflicts, &pos)) != NULL;
 			zend_hash_move_forward_ex(rconflicts, &pos)
 		) {
-			if (SUCCESS != (*conflict)(handler->name, handler->name_len TSRMLS_CC)) {
+			if (SUCCESS != conflict(handler->name, handler->name_len TSRMLS_CC)) {
 				return FAILURE;
 			}
 		}
@@ -626,7 +632,7 @@ PHPAPI int php_output_handler_conflict_register(const char *name, size_t name_le
 		zend_error(E_ERROR, "Cannot register an output handler conflict outside of MINIT");
 		return FAILURE;
 	}
-	return zend_hash_update(&php_output_handler_conflicts, name, name_len+1, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL);
+	return zend_hash_str_update_ptr(&php_output_handler_conflicts, name, name_len, check_func) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
@@ -641,15 +647,15 @@ PHPAPI int php_output_handler_reverse_conflict_register(const char *name, size_t
 		return FAILURE;
 	}
 
-	if (SUCCESS == zend_hash_find(&php_output_handler_reverse_conflicts, name, name_len+1, (void *) &rev_ptr)) {
-		return zend_hash_next_index_insert(rev_ptr, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL);
+	if (SUCCESS == (rev_ptr = zend_hash_str_find_ptr(&php_output_handler_reverse_conflicts, name, name_len))) {
+		return zend_hash_next_index_insert_ptr(rev_ptr, check_func) ? SUCCESS : FAILURE;
 	} else {
-		zend_hash_init(&rev, 1, NULL, NULL, 1);
-		if (SUCCESS != zend_hash_next_index_insert(&rev, &check_func, sizeof(php_output_handler_conflict_check_t *), NULL)) {
+		zend_hash_init(&rev, 8, NULL, NULL, 1);
+		if (SUCCESS != zend_hash_next_index_insert_ptr(&rev, check_func)) {
 			zend_hash_destroy(&rev);
 			return FAILURE;
 		}
-		if (SUCCESS != zend_hash_update(&php_output_handler_reverse_conflicts, name, name_len+1, &rev, sizeof(HashTable), NULL)) {
+		if (SUCCESS != zend_hash_str_update_mem(&php_output_handler_reverse_conflicts, name, name_len+1, &rev, sizeof(HashTable))) {
 			zend_hash_destroy(&rev);
 			return FAILURE;
 		}
@@ -660,12 +666,9 @@ PHPAPI int php_output_handler_reverse_conflict_register(const char *name, size_t
 
 /* {{{ php_output_handler_alias_ctor_t php_output_handler_alias(zval *name TSRMLS_DC)
  * Get an internal output handler for a user handler if it exists */
-PHPAPI php_output_handler_alias_ctor_t *php_output_handler_alias(const char *name, size_t name_len TSRMLS_DC)
+PHPAPI php_output_handler_alias_ctor_t php_output_handler_alias(const char *name, size_t name_len TSRMLS_DC)
 {
-	php_output_handler_alias_ctor_t *func = NULL;
-
-	zend_hash_find(&php_output_handler_aliases, name, name_len+1, (void *) &func);
-	return func;
+	return zend_hash_str_find_ptr(&php_output_handler_aliases, name, name_len);
 }
 /* }}} */
 
@@ -677,7 +680,7 @@ PHPAPI int php_output_handler_alias_register(const char *name, size_t name_len,
 		zend_error(E_ERROR, "Cannot register an output handler alias outside of MINIT");
 		return FAILURE;
 	}
-	return zend_hash_update(&php_output_handler_aliases, name, name_len+1, &func, sizeof(php_output_handler_alias_ctor_t *), NULL);
+	return zend_hash_str_update_ptr(&php_output_handler_aliases, name, name_len, func) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
@@ -714,8 +717,10 @@ PHPAPI int php_output_handler_hook(php_output_handler_hook_t type, void *arg TSR
  * Destroy an output handler */
 PHPAPI void php_output_handler_dtor(php_output_handler *handler TSRMLS_DC)
 {
-	STR_FREE(handler->name);
-	STR_FREE(handler->buffer.data);
+//???	STR_FREE(handler->name);
+	if (handler->name) efree(handler->name);
+//???	STR_FREE(handler->buffer.data);
+	if (handler->buffer.data) efree(handler->buffer.data);
 	if (handler->flags & PHP_OUTPUT_HANDLER_USER) {
 		zval_ptr_dtor(&handler->func.user->zoh);
 		efree(handler->func.user);
@@ -964,23 +969,21 @@ static inline php_output_handler_status_t php_output_handler_op(php_output_handl
 
 		OG(running) = handler;
 		if (handler->flags & PHP_OUTPUT_HANDLER_USER) {
-			zval *retval = NULL, *ob_data, *ob_mode;
+			zval retval, ob_data, ob_mode;
 
-			MAKE_STD_ZVAL(ob_data);
-			ZVAL_STRINGL(ob_data, handler->buffer.data, handler->buffer.used, 1);
-			MAKE_STD_ZVAL(ob_mode);
-			ZVAL_LONG(ob_mode, (long) context->op);
+			ZVAL_STRINGL(&ob_data, handler->buffer.data, handler->buffer.used);
+			ZVAL_LONG(&ob_mode, (long) context->op);
 			zend_fcall_info_argn(&handler->func.user->fci TSRMLS_CC, 2, &ob_data, &ob_mode);
 
-#define PHP_OUTPUT_USER_SUCCESS(retval) (retval && !(Z_TYPE_P(retval) == IS_BOOL && Z_BVAL_P(retval)==0))
+#define PHP_OUTPUT_USER_SUCCESS(retval) ((Z_TYPE(retval) != IS_UNDEF) && !(Z_TYPE(retval) == IS_BOOL && Z_BVAL(retval)==0))
 			if (SUCCESS == zend_fcall_info_call(&handler->func.user->fci, &handler->func.user->fcc, &retval, NULL TSRMLS_CC) && PHP_OUTPUT_USER_SUCCESS(retval)) {
 				/* user handler may have returned TRUE */
 				status = PHP_OUTPUT_HANDLER_NO_DATA;
-				if (Z_TYPE_P(retval) != IS_BOOL) {
+				if (Z_TYPE(retval) != IS_BOOL) {
 					convert_to_string_ex(&retval);
-					if (Z_STRLEN_P(retval)) {
-						context->out.data = estrndup(Z_STRVAL_P(retval), Z_STRLEN_P(retval));
-						context->out.used = Z_STRLEN_P(retval);
+					if (Z_STRLEN(retval)) {
+						context->out.data = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
+						context->out.used = Z_STRLEN(retval);
 						context->out.free = 1;
 						status = PHP_OUTPUT_HANDLER_SUCCESS;
 					}
@@ -991,11 +994,9 @@ static inline php_output_handler_status_t php_output_handler_op(php_output_handl
 			}
 
 			zend_fcall_info_argn(&handler->func.user->fci TSRMLS_CC, 0);
-			zval_ptr_dtor(&ob_data);
-			zval_ptr_dtor(&ob_mode);
-			if (retval) {
-				zval_ptr_dtor(&retval);
-			}
+//???			zval_ptr_dtor(&ob_data);
+//???			zval_ptr_dtor(&ob_mode);
+			zval_ptr_dtor(&retval);
 
 		} else {
 
@@ -1172,7 +1173,7 @@ static int php_output_stack_apply_list(void *h, void *z)
 	php_output_handler *handler = *(php_output_handler **) h;
 	zval *array = (zval *) z;
 
-	add_next_index_stringl(array, handler->name, handler->name_len, 1);
+	add_next_index_stringl(array, handler->name, handler->name_len);
 	return 0;
 }
 /* }}} */
@@ -1182,9 +1183,9 @@ static int php_output_stack_apply_list(void *h, void *z)
 static int php_output_stack_apply_status(void *h, void *z)
 {
 	php_output_handler *handler = *(php_output_handler **) h;
-	zval *array = (zval *) z;
+	zval arr, *array = (zval *) z;
 
-	add_next_index_zval(array, php_output_handler_status(handler, NULL));
+	add_next_index_zval(array, php_output_handler_status(handler, &arr));
 
 	return 0;
 }
@@ -1193,12 +1194,10 @@ static int php_output_stack_apply_status(void *h, void *z)
  * Returns an array with the status of the output handler */
 static inline zval *php_output_handler_status(php_output_handler *handler, zval *entry)
 {
-	if (!entry) {
-		MAKE_STD_ZVAL(entry);
-		array_init(entry);
-	}
+	ZEND_ASSERT(entry != NULL);
 
-	add_assoc_stringl(entry, "name", handler->name, handler->name_len, 1);
+	array_init(entry);
+	add_assoc_stringl(entry, "name", handler->name, handler->name_len);
 	add_assoc_long(entry, "type", (long) (handler->flags & 0xf));
 	add_assoc_long(entry, "flags", (long) handler->flags);
 	add_assoc_long(entry, "level", (long) handler->level);
@@ -1523,13 +1522,13 @@ PHP_FUNCTION(ob_get_status)
 		return;
 	}
 	
-	array_init(return_value);
-
 	if (!OG(active)) {
+		array_init(return_value);
 		return;
 	}
 
 	if (full_status) {
+		array_init(return_value);
 		zend_stack_apply_with_argument(&OG(handlers), ZEND_STACK_APPLY_BOTTOMUP, php_output_stack_apply_status, return_value);
 	} else {
 		php_output_handler_status(OG(active), return_value);
diff --git a/main/php_globals.h b/main/php_globals.h
index d8ba6142d4..9baabf757c 100644
--- a/main/php_globals.h
+++ b/main/php_globals.h
@@ -113,7 +113,7 @@ struct _php_core_globals {
 
 	zend_llist tick_functions;
 
-	zval *http_globals[6];
+	zval http_globals[6];
 
 	zend_bool expose_php;
 
diff --git a/main/php_ini.c b/main/php_ini.c
index f7f4686e84..2b62e80554 100644
--- a/main/php_ini.c
+++ b/main/php_ini.c
@@ -121,22 +121,25 @@ static void php_ini_displayer_cb(zend_ini_entry *ini_entry, int type TSRMLS_DC)
 
 /* {{{ php_ini_displayer
  */
-static int php_ini_displayer(zend_ini_entry *ini_entry, int module_number TSRMLS_DC)
+static int php_ini_displayer(zval *el, void *arg TSRMLS_DC)
 {
+	zend_ini_entry *ini_entry = (zend_ini_entry*)Z_PTR_P(el);
+	int module_number = *(int *)arg;
+
 	if (ini_entry->module_number != module_number) {
 		return 0;
 	}
 	if (!sapi_module.phpinfo_as_text) {
 		PUTS("<tr>");
 		PUTS("<td class=\"e\">");
-		PHPWRITE(ini_entry->name, ini_entry->name_length - 1);
+		PHPWRITE(ini_entry->name, ini_entry->name_length);
 		PUTS("</td><td class=\"v\">");
 		php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE TSRMLS_CC);
 		PUTS("</td><td class=\"v\">");
 		php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ORIG TSRMLS_CC);
 		PUTS("</td></tr>\n");
 	} else {
-		PHPWRITE(ini_entry->name, ini_entry->name_length - 1);
+		PHPWRITE(ini_entry->name, ini_entry->name_length);
 		PUTS(" => ");
 		php_ini_displayer_cb(ini_entry, ZEND_INI_DISPLAY_ACTIVE TSRMLS_CC);
 		PUTS(" => ");
@@ -149,10 +152,12 @@ static int php_ini_displayer(zend_ini_entry *ini_entry, int module_number TSRMLS
 
 /* {{{ php_ini_available
  */
-static int php_ini_available(zend_ini_entry *ini_entry, int *module_number_available TSRMLS_DC)
+static int php_ini_available(zval *el, void *arg TSRMLS_DC)
 {
-	if (ini_entry->module_number == *module_number_available) {
-		*module_number_available = -1;
+	zend_ini_entry *ini_entry = (zend_ini_entry *)Z_PTR_P(el);
+	int *module_number_available = (int *)arg;
+	if (ini_entry->module_number == *(int *)module_number_available) {
+		*(int *)module_number_available = -1;
 		return ZEND_HASH_APPLY_STOP;
 	} else {
 		return ZEND_HASH_APPLY_KEEP;
@@ -173,11 +178,11 @@ PHPAPI void display_ini_entries(zend_module_entry *module)
 		module_number = 0;
 	}
 	module_number_available = module_number;
-	zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) php_ini_available, &module_number_available TSRMLS_CC);
+	zend_hash_apply_with_argument(EG(ini_directives), php_ini_available, &module_number_available TSRMLS_CC);
 	if (module_number_available == -1) {
 		php_info_print_table_start();
 		php_info_print_table_header(3, "Directive", "Local Value", "Master Value");
-		zend_hash_apply_with_argument(EG(ini_directives), (apply_func_arg_t) php_ini_displayer, (void *) (zend_intptr_t) module_number TSRMLS_CC);
+		zend_hash_apply_with_argument(EG(ini_directives), php_ini_displayer, (void *)&module_number TSRMLS_CC);
 		php_info_print_table_end();
 	}
 }
@@ -193,9 +198,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 */
@@ -237,14 +242,14 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t
 				/* All other entries are added into either configuration_hash or active ini section array */
 				} else {
 					/* Store in active hash */
-					zend_hash_update(active_hash, Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, arg2, sizeof(zval), (void **) &entry);
-					Z_STRVAL_P(entry) = zend_strndup(Z_STRVAL_P(entry), Z_STRLEN_P(entry));
+					entry = zend_hash_update(active_hash, Z_STR_P(arg1), arg2);
+					Z_STR_P(entry) = STR_DUP(Z_STR_P(entry), 1);
 				}
 			}
 			break;
 
 		case ZEND_INI_PARSER_POP_ENTRY: {
-				zval *option_arr;
+				zval option_arr;
 				zval *find_arr;
 
 				if (!arg2) {
@@ -255,23 +260,19 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t
 /* fprintf(stdout, "ZEND_INI_PARSER_POP_ENTRY: %s[%s] = %s\n",Z_STRVAL_P(arg1), Z_STRVAL_P(arg3), Z_STRVAL_P(arg2)); */
 
 				/* If option not found in hash or is not an array -> create array, otherwise add to existing array */
-				if (zend_hash_find(active_hash, Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, (void **) &find_arr) == FAILURE || Z_TYPE_P(find_arr) != IS_ARRAY) {
-					option_arr = (zval *) pemalloc(sizeof(zval), 1);
-					INIT_PZVAL(option_arr);
-					Z_TYPE_P(option_arr) = IS_ARRAY;
-					Z_ARRVAL_P(option_arr) = (HashTable *) pemalloc(sizeof(HashTable), 1);
-					zend_hash_init(Z_ARRVAL_P(option_arr), 0, NULL, (dtor_func_t) config_zval_dtor, 1);
-					zend_hash_update(active_hash, Z_STRVAL_P(arg1), Z_STRLEN_P(arg1) + 1, option_arr, sizeof(zval), (void **) &find_arr);
-					free(option_arr);
+				if ((find_arr = zend_hash_find(active_hash, Z_STR_P(arg1))) == NULL || Z_TYPE_P(find_arr) != IS_ARRAY) {
+					ZVAL_NEW_PERSISTENT_ARR(&option_arr);
+					zend_hash_init(Z_ARRVAL(option_arr), 8, NULL, (dtor_func_t) config_zval_dtor, 1);
+					find_arr = zend_hash_update(active_hash, Z_STR_P(arg1), &option_arr);
 				}
 
 				/* arg3 is possible option offset name */
 				if (arg3 && Z_STRLEN_P(arg3) > 0) {
-					zend_symtable_update(Z_ARRVAL_P(find_arr), Z_STRVAL_P(arg3), Z_STRLEN_P(arg3) + 1, arg2, sizeof(zval), (void **) &entry);
+					entry = zend_symtable_update(Z_ARRVAL_P(find_arr), Z_STR_P(arg3), arg2);
 				} else {
-					zend_hash_next_index_insert(Z_ARRVAL_P(find_arr), arg2, sizeof(zval), (void **) &entry);
+					entry = zend_hash_next_index_insert(Z_ARRVAL_P(find_arr), arg2);
 				}
-				Z_STRVAL_P(entry) = zend_strndup(Z_STRVAL_P(entry), Z_STRLEN_P(entry));
+				Z_STR_P(entry) = STR_DUP(Z_STR_P(entry), 1);
 			}
 			break;
 
@@ -324,16 +325,12 @@ static void php_ini_parser_cb(zval *arg1, zval *arg2, zval *arg3, int callback_t
 					}
 
 					/* Search for existing entry and if it does not exist create one */
-					if (zend_hash_find(target_hash, key, key_len + 1, (void **) &entry) == FAILURE) {
-						zval *section_arr;
-
-						section_arr = (zval *) pemalloc(sizeof(zval), 1);
-						INIT_PZVAL(section_arr);
-						Z_TYPE_P(section_arr) = IS_ARRAY;
-						Z_ARRVAL_P(section_arr) = (HashTable *) pemalloc(sizeof(HashTable), 1);
-						zend_hash_init(Z_ARRVAL_P(section_arr), 0, NULL, (dtor_func_t) config_zval_dtor, 1);
-						zend_hash_update(target_hash, key, key_len + 1, section_arr, sizeof(zval), (void **) &entry);
-						free(section_arr);
+					if ((entry = zend_hash_str_find(target_hash, key, key_len)) == NULL) {
+						zval section_arr;
+
+						ZVAL_NEW_PERSISTENT_ARR(&section_arr);
+						zend_hash_init(Z_ARRVAL(section_arr), 8, NULL, (dtor_func_t) config_zval_dtor, 1);
+						entry = zend_hash_str_update(target_hash, key, key_len, &section_arr);
 					}
 					active_ini_hash = Z_ARRVAL_P(entry);
 				}
@@ -358,7 +355,6 @@ static void php_load_php_extension_cb(void *arg TSRMLS_DC)
 static void php_load_zend_extension_cb(void *arg TSRMLS_DC)
 {
 	char *filename = *((char **) arg);
-	int length = strlen(filename);
 
 	if (IS_ABSOLUTE_PATH(filename, length)) {
 		zend_load_extension(filename TSRMLS_CC);
@@ -389,9 +385,7 @@ int php_init_config(TSRMLS_D)
 	int free_ini_search_path = 0;
 	zend_file_handle fh;
 
-	if (zend_hash_init(&configuration_hash, 0, NULL, (dtor_func_t) config_zval_dtor, 1) == FAILURE) {
-		return FAILURE;
-	}
+	zend_hash_init(&configuration_hash, 8, NULL, (dtor_func_t) config_zval_dtor, 1);
 
 	if (sapi_module.ini_defaults) {
 		sapi_module.ini_defaults(&configuration_hash);
@@ -598,12 +592,8 @@ int php_init_config(TSRMLS_D)
 		{
 			zval tmp;
 
-			Z_STRLEN(tmp) = strlen(fh.filename);
-			Z_STRVAL(tmp) = zend_strndup(fh.filename, Z_STRLEN(tmp));
-			Z_TYPE(tmp) = IS_STRING;
-			Z_SET_REFCOUNT(tmp, 0);
-
-			zend_hash_update(&configuration_hash, "cfg_file_path", sizeof("cfg_file_path"), (void *) &tmp, sizeof(zval), NULL);
+			ZVAL_NEW_STR(&tmp, STR_INIT(fh.filename, strlen(fh.filename), 1));
+			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);
 			}
@@ -785,18 +775,17 @@ PHPAPI int php_parse_user_ini_file(const char *dirname, char *ini_filename, Hash
  */
 PHPAPI void php_ini_activate_config(HashTable *source_hash, int modify_type, int stage TSRMLS_DC)
 {
-	char *str;
+	zend_string *str;
 	zval *data;
-	uint str_len;
 	ulong num_index;
 
 	/* Walk through config hash and alter matching ini entries using the values found in the hash */
 	for (zend_hash_internal_pointer_reset(source_hash);
-		zend_hash_get_current_key_ex(source_hash, &str, &str_len, &num_index, 0, NULL) == HASH_KEY_IS_STRING;
+		zend_hash_get_current_key(source_hash, &str, &num_index, 0) == HASH_KEY_IS_STRING;
 		zend_hash_move_forward(source_hash)
 	) {
-		zend_hash_get_current_data(source_hash, (void **) &data);
-		zend_alter_ini_entry_ex(str, str_len, Z_STRVAL_P(data), Z_STRLEN_P(data), modify_type, stage, 0 TSRMLS_CC);
+		data = zend_hash_get_current_data(source_hash);
+		zend_alter_ini_entry_ex(str, Z_STRVAL_P(data), Z_STRLEN_P(data), modify_type, stage, 0 TSRMLS_CC);
 	}
 }
 /* }}} */
@@ -842,7 +831,7 @@ PHPAPI void php_ini_activate_per_dir_config(char *path, uint path_len TSRMLS_DC)
 		while ((ptr = strchr(ptr, '/')) != NULL) {
 			*ptr = 0;
 			/* Search for source array matching the path from configuration_hash */
-			if (zend_hash_find(&configuration_hash, path, strlen(path) + 1, (void **) &tmp2) == SUCCESS) {
+			if ((tmp2 = zend_hash_str_find(&configuration_hash, path, strlen(path))) != NULL) {
 				php_ini_activate_config(Z_ARRVAL_P(tmp2), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE TSRMLS_CC);
 			}
 			*ptr = '/';
@@ -868,7 +857,7 @@ PHPAPI void php_ini_activate_per_host_config(const char *host, uint host_len TSR
 
 	if (has_per_host_config && host && host_len) {
 		/* Search for source array matching the host from configuration_hash */
-		if (zend_hash_find(&configuration_hash, host, host_len, (void **) &tmp) == SUCCESS) {
+		if ((tmp = zend_hash_str_find(&configuration_hash, host, host_len)) != NULL) {
 			php_ini_activate_config(Z_ARRVAL_P(tmp), PHP_INI_SYSTEM, PHP_INI_STAGE_ACTIVATE TSRMLS_CC);
 		}
 	}
@@ -879,13 +868,7 @@ PHPAPI void php_ini_activate_per_host_config(const char *host, uint host_len TSR
  */
 PHPAPI zval *cfg_get_entry(const char *name, uint name_length)
 {
-	zval *tmp;
-
-	if (zend_hash_find(&configuration_hash, name, name_length, (void **) &tmp) == SUCCESS) {
-		return tmp;
-	} else {
-		return NULL;
-	}
+	return zend_hash_str_find(&configuration_hash, name, name_length);
 }
 /* }}} */
 
@@ -895,12 +878,11 @@ PHPAPI int cfg_get_long(const char *varname, long *result)
 {
 	zval *tmp, var;
 
-	if (zend_hash_find(&configuration_hash, varname, strlen(varname) + 1, (void **) &tmp) == FAILURE) {
+	if ((tmp = zend_hash_str_find(&configuration_hash, varname, strlen(varname))) == NULL) {
 		*result = 0;
 		return FAILURE;
 	}
-	var = *tmp;
-	zval_copy_ctor(&var);
+	ZVAL_DUP(&var, tmp);
 	convert_to_long(&var);
 	*result = Z_LVAL(var);
 	return SUCCESS;
@@ -913,12 +895,11 @@ PHPAPI int cfg_get_double(const char *varname, double *result)
 {
 	zval *tmp, var;
 
-	if (zend_hash_find(&configuration_hash, varname, strlen(varname) + 1, (void **) &tmp) == FAILURE) {
+	if ((tmp = zend_hash_str_find(&configuration_hash, varname, strlen(varname))) == NULL) {
 		*result = (double) 0;
 		return FAILURE;
 	}
-	var = *tmp;
-	zval_copy_ctor(&var);
+	ZVAL_DUP(&var, tmp);
 	convert_to_double(&var);
 	*result = Z_DVAL(var);
 	return SUCCESS;
@@ -931,7 +912,7 @@ PHPAPI int cfg_get_string(const char *varname, char **result)
 {
 	zval *tmp;
 
-	if (zend_hash_find(&configuration_hash, varname, strlen(varname)+1, (void **) &tmp) == FAILURE) {
+	if ((tmp = zend_hash_str_find(&configuration_hash, varname, strlen(varname))) == NULL) {
 		*result = NULL;
 		return FAILURE;
 	}
diff --git a/main/php_main.h b/main/php_main.h
index 1325486bd9..92dafde4d8 100644
--- a/main/php_main.h
+++ b/main/php_main.h
@@ -40,7 +40,7 @@ PHPAPI void php_request_shutdown_for_hook(void *dummy);
 PHPAPI int php_register_extensions(zend_module_entry **ptr, int count TSRMLS_DC);
 
 PHPAPI int php_execute_script(zend_file_handle *primary_file TSRMLS_DC);
-PHPAPI int php_execute_simple_script(zend_file_handle *primary_file, zval **ret TSRMLS_DC);
+PHPAPI int php_execute_simple_script(zend_file_handle *primary_file, zval *ret TSRMLS_DC);
 PHPAPI int php_handle_special_queries(TSRMLS_D);
 PHPAPI int php_lint_script(zend_file_handle *file TSRMLS_DC);
 
diff --git a/main/php_output.h b/main/php_output.h
index 0312e256f8..45af14f6a5 100644
--- a/main/php_output.h
+++ b/main/php_output.h
@@ -123,7 +123,7 @@ typedef struct _php_output_handler *(*php_output_handler_alias_ctor_t)(const cha
 typedef struct _php_output_handler_user_func_t {
 	zend_fcall_info fci;
 	zend_fcall_info_cache fcc;
-	zval *zoh;
+	zval zoh;
 } php_output_handler_user_func_t;
 
 typedef struct _php_output_handler {
@@ -244,7 +244,7 @@ PHPAPI int php_output_handler_conflict(const char *handler_new, size_t handler_n
 PHPAPI int php_output_handler_conflict_register(const char *handler_name, size_t handler_name_len, php_output_handler_conflict_check_t check_func TSRMLS_DC);
 PHPAPI int php_output_handler_reverse_conflict_register(const char *handler_name, size_t handler_name_len, php_output_handler_conflict_check_t check_func TSRMLS_DC);
 
-PHPAPI php_output_handler_alias_ctor_t *php_output_handler_alias(const char *handler_name, size_t handler_name_len TSRMLS_DC);
+PHPAPI php_output_handler_alias_ctor_t php_output_handler_alias(const char *handler_name, size_t handler_name_len TSRMLS_DC);
 PHPAPI int php_output_handler_alias_register(const char *handler_name, size_t handler_name_len, php_output_handler_alias_ctor_t func TSRMLS_DC);
 
 END_EXTERN_C()
diff --git a/main/php_streams.h b/main/php_streams.h
index d1efa71988..2a142b99c2 100644
--- a/main/php_streams.h
+++ b/main/php_streams.h
@@ -61,7 +61,7 @@ END_EXTERN_C()
  * the ultimate ancestor, which is useful, because there can be several layers of calls */
 #define php_stream_alloc_rel(ops, thisptr, persistent, mode) _php_stream_alloc((ops), (thisptr), (persistent), (mode) STREAMS_REL_CC TSRMLS_CC)
 
-#define php_stream_copy_to_mem_rel(src, buf, maxlen, persistent) _php_stream_copy_to_mem((src), (buf), (maxlen), (persistent) STREAMS_REL_CC TSRMLS_CC)
+#define php_stream_copy_to_mem_rel(src, maxlen, persistent) _php_stream_copy_to_mem((src), (buf), (maxlen), (persistent) STREAMS_REL_CC TSRMLS_CC)
 
 #define php_stream_fopen_rel(filename, mode, opened, options) _php_stream_fopen((filename), (mode), (opened), (options) STREAMS_REL_CC TSRMLS_CC)
 
@@ -191,12 +191,12 @@ struct _php_stream  {
 
 	php_stream_wrapper *wrapper; /* which wrapper was used to open the stream */
 	void *wrapperthis;		/* convenience pointer for a instance of a wrapper */
-	zval *wrapperdata;		/* fgetwrapperdata retrieves this */
+	zval wrapperdata;		/* fgetwrapperdata retrieves this */
 
 	int fgetss_state;		/* for fgetss to handle multiline tags */
 	int is_persistent;
 	char mode[16];			/* "rwb" etc. ala stdio */
-	int rsrc_id;			/* used for auto-cleanup */
+	zend_resource *res;		/* used for auto-cleanup */
 	int in_free;			/* to prevent recursion during free */
 	/* so we know how to clean it up correctly.  This should be set to
 	 * PHP_STREAM_FCLOSE_XXX as appropriate */
@@ -242,21 +242,21 @@ PHPAPI php_stream *_php_stream_alloc(php_stream_ops *ops, void *abstract,
 END_EXTERN_C()
 #define php_stream_alloc(ops, thisptr, persistent_id, mode)	_php_stream_alloc((ops), (thisptr), (persistent_id), (mode) STREAMS_CC TSRMLS_CC)
 
-#define php_stream_get_resource_id(stream)		((php_stream *)(stream))->rsrc_id
+#define php_stream_get_resource_id(stream)		((php_stream *)(stream))->res->handle
 #if ZEND_DEBUG
 /* use this to tell the stream that it is OK if we don't explicitly close it */
 # define php_stream_auto_cleanup(stream)	{ (stream)->__exposed++; }
 /* use this to assign the stream to a zval and tell the stream that is
  * has been exported to the engine; it will expect to be closed automatically
  * when the resources are auto-destructed */
-# define php_stream_to_zval(stream, zval)	{ ZVAL_RESOURCE(zval, (stream)->rsrc_id); (stream)->__exposed++; }
+# define php_stream_to_zval(stream, zval)	{ ZVAL_RES(zval, (stream)->res); (stream)->__exposed++; }
 #else
 # define php_stream_auto_cleanup(stream)	/* nothing */
-# define php_stream_to_zval(stream, zval)	{ ZVAL_RESOURCE(zval, (stream)->rsrc_id); }
+# define php_stream_to_zval(stream, zval)	{ ZVAL_RES(zval, (stream)->res); }
 #endif
 
-#define php_stream_from_zval(xstr, ppzval)	ZEND_FETCH_RESOURCE2((xstr), php_stream *, (ppzval), -1, "stream", php_file_le_stream(), php_file_le_pstream())
-#define php_stream_from_zval_no_verify(xstr, ppzval)	(xstr) = (php_stream*)zend_fetch_resource((ppzval) TSRMLS_CC, -1, "stream", NULL, 2, php_file_le_stream(), php_file_le_pstream())
+#define php_stream_from_zval(xstr, pzval)	ZEND_FETCH_RESOURCE2((xstr), php_stream *, (pzval), -1, "stream", php_file_le_stream(), php_file_le_pstream())
+#define php_stream_from_zval_no_verify(xstr, pzval)	(xstr) = (php_stream*)zend_fetch_resource((pzval) TSRMLS_CC, -1, "stream", NULL, 2, php_file_le_stream(), php_file_le_pstream())
 
 BEGIN_EXTERN_C()
 PHPAPI php_stream *php_stream_encloses(php_stream *enclosing, php_stream *enclosed);
@@ -322,7 +322,7 @@ PHPAPI char *_php_stream_get_line(php_stream *stream, char *buf, size_t maxlen,
 #define php_stream_gets(stream, buf, maxlen)	_php_stream_get_line((stream), (buf), (maxlen), NULL TSRMLS_CC)
 
 #define php_stream_get_line(stream, buf, maxlen, retlen) _php_stream_get_line((stream), (buf), (maxlen), (retlen) TSRMLS_CC)
-PHPAPI char *php_stream_get_record(php_stream *stream, size_t maxlen, size_t *returned_len, const char *delim, size_t delim_len TSRMLS_DC);
+PHPAPI zend_string *php_stream_get_record(php_stream *stream, size_t maxlen, const char *delim, size_t delim_len TSRMLS_DC);
 
 /* CAREFUL! this is equivalent to puts NOT fputs! */
 PHPAPI int _php_stream_puts(php_stream *stream, const char *buf TSRMLS_DC);
@@ -348,11 +348,11 @@ PHPAPI php_stream_dirent *_php_stream_readdir(php_stream *dirstream, php_stream_
 #define php_stream_closedir(dirstream)	php_stream_close((dirstream))
 #define php_stream_rewinddir(dirstream)	php_stream_rewind((dirstream))
 
-PHPAPI int php_stream_dirent_alphasort(const char **a, const char **b);
-PHPAPI int php_stream_dirent_alphasortr(const char **a, const char **b);
+PHPAPI int php_stream_dirent_alphasort(const zend_string **a, const zend_string **b);
+PHPAPI int php_stream_dirent_alphasortr(const zend_string **a, const zend_string **b);
 
-PHPAPI int _php_stream_scandir(const char *dirname, char **namelist[], int flags, php_stream_context *context,
-			int (*compare) (const char **a, const char **b) TSRMLS_DC);
+PHPAPI int _php_stream_scandir(const char *dirname, zend_string **namelist[], int flags, php_stream_context *context,
+			int (*compare) (const zend_string **a, const zend_string **b) TSRMLS_DC);
 #define php_stream_scandir(dirname, namelist, context, compare) _php_stream_scandir((dirname), (namelist), 0, (context), (compare) TSRMLS_CC)
 
 PHPAPI int _php_stream_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC);
@@ -441,9 +441,8 @@ PHPAPI int _php_stream_copy_to_stream_ex(php_stream *src, php_stream *dest, size
 
 /* read all data from stream and put into a buffer. Caller must free buffer
  * when done. */
-PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen,
-		int persistent STREAMS_DC TSRMLS_DC);
-#define php_stream_copy_to_mem(src, buf, maxlen, persistent) _php_stream_copy_to_mem((src), (buf), (maxlen), (persistent) STREAMS_CC TSRMLS_CC)
+PHPAPI zend_string *_php_stream_copy_to_mem(php_stream *src, size_t maxlen, int persistent STREAMS_DC TSRMLS_DC);
+#define php_stream_copy_to_mem(src, maxlen, persistent) _php_stream_copy_to_mem((src), (maxlen), (persistent) STREAMS_CC TSRMLS_CC)
 
 /* output all data from a stream */
 PHPAPI size_t _php_stream_passthru(php_stream * src STREAMS_DC TSRMLS_DC);
@@ -547,7 +546,7 @@ PHPAPI int php_register_url_stream_wrapper_volatile(const char *protocol, php_st
 PHPAPI int php_unregister_url_stream_wrapper_volatile(const char *protocol TSRMLS_DC);
 PHPAPI php_stream *_php_stream_open_wrapper_ex(const char *path, const char *mode, int options, char **opened_path, php_stream_context *context STREAMS_DC TSRMLS_DC);
 PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const char **path_for_open, int options TSRMLS_DC);
-PHPAPI const char *php_stream_locate_eol(php_stream *stream, const char *buf, size_t buf_len TSRMLS_DC);
+PHPAPI const char *php_stream_locate_eol(php_stream *stream, zend_string *buf TSRMLS_DC);
 
 #define php_stream_open_wrapper(path, mode, options, opened)	_php_stream_open_wrapper_ex((path), (mode), (options), (opened), NULL STREAMS_CC TSRMLS_CC)
 #define php_stream_open_wrapper_ex(path, mode, options, opened, context)	_php_stream_open_wrapper_ex((path), (mode), (options), (opened), (context) STREAMS_CC TSRMLS_CC)
diff --git a/main/php_variables.c b/main/php_variables.c
index fef905ff7d..547dbd5582 100644
--- a/main/php_variables.c
+++ b/main/php_variables.c
@@ -49,10 +49,7 @@ PHPAPI void php_register_variable_safe(char *var, char *strval, int str_len, zva
 	assert(strval != NULL);
 	
 	/* Prepare value */
-	Z_STRLEN(new_entry) = str_len;
-	Z_STRVAL(new_entry) = estrndup(strval, Z_STRLEN(new_entry));
-	Z_TYPE(new_entry) = IS_STRING;
-
+	ZVAL_NEW_STR(&new_entry, STR_INIT(strval, str_len, 0));
 	php_register_variable_ex(var, &new_entry, track_vars_array TSRMLS_CC);
 }
 
@@ -63,14 +60,14 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars
 	char *index;
 	char *var, *var_orig;
 	int var_len, index_len;
-	zval *gpc_element, **gpc_element_p;
+	zval gpc_element, *gpc_element_p;
 	zend_bool is_array = 0;
 	HashTable *symtable1 = NULL;
 	ALLOCA_FLAG(use_heap)
 
 	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);
 	}
 
@@ -113,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);
@@ -136,7 +134,7 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars
 
 				if (track_vars_array) {
 					ht = Z_ARRVAL_P(track_vars_array);
-					zend_symtable_del(ht, var, var_len + 1);
+					zend_symtable_str_del(ht, var, var_len);
 				}
 
 				zval_dtor(val);
@@ -175,23 +173,30 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars
 			}
 
 			if (!index) {
-				MAKE_STD_ZVAL(gpc_element);
-				array_init(gpc_element);
-				if (zend_hash_next_index_insert(symtable1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p) == FAILURE) {
+				array_init(&gpc_element);
+				if ((gpc_element_p = zend_hash_next_index_insert(symtable1, &gpc_element)) == NULL) {
 					zval_ptr_dtor(&gpc_element);
 					zval_dtor(val);
 					free_alloca(var_orig, use_heap);
 					return;
 				}
 			} else {
-				if (zend_symtable_find(symtable1, index, index_len + 1, (void **) &gpc_element_p) == FAILURE
-					|| Z_TYPE_PP(gpc_element_p) != IS_ARRAY) {
-					MAKE_STD_ZVAL(gpc_element);
-					array_init(gpc_element);
-					zend_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p);
+				gpc_element_p = zend_symtable_str_find(symtable1, index, index_len);
+				if (!gpc_element_p) {
+					zval tmp;
+					array_init(&tmp);
+					gpc_element_p = zend_symtable_str_update_ind(symtable1, index, index_len, &tmp);
+				} else {
+					if (Z_TYPE_P(gpc_element_p) == IS_INDIRECT) {
+						gpc_element_p = Z_INDIRECT_P(gpc_element_p);
+					}
+					if (Z_TYPE_P(gpc_element_p) != IS_ARRAY) {
+						zval_ptr_dtor(gpc_element_p);
+						array_init(gpc_element_p);
+					}
 				}
 			}
-			symtable1 = Z_ARRVAL_PP(gpc_element_p);
+			symtable1 = Z_ARRVAL_P(gpc_element_p);
 			/* ip pointed to the '[' character, now obtain the key */
 			index = index_s;
 			index_len = new_idx_len;
@@ -206,11 +211,9 @@ PHPAPI void php_register_variable_ex(char *var_name, zval *val, zval *track_vars
 		}
 	} else {
 plain_var:
-		MAKE_STD_ZVAL(gpc_element);
-		gpc_element->value = val->value;
-		Z_TYPE_P(gpc_element) = Z_TYPE_P(val);
+		ZVAL_COPY_VALUE(&gpc_element, val);
 		if (!index) {
-			if (zend_hash_next_index_insert(symtable1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p) == FAILURE) {
+			if ((gpc_element_p = zend_hash_next_index_insert(symtable1, &gpc_element)) == NULL) {
 				zval_ptr_dtor(&gpc_element);
 			}
 		} else {
@@ -220,12 +223,12 @@ plain_var:
 			 * to have the same (plain text) cookie name for the same path and we should not overwrite
 			 * more specific cookies with the less specific ones.
 			 */
-			if (PG(http_globals)[TRACK_VARS_COOKIE] &&
-				symtable1 == Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_COOKIE]) &&
-				zend_symtable_exists(symtable1, index, index_len + 1)) {
+			if (Z_TYPE(PG(http_globals)[TRACK_VARS_COOKIE]) != IS_UNDEF &&
+				symtable1 == Z_ARRVAL(PG(http_globals)[TRACK_VARS_COOKIE]) &&
+				zend_symtable_str_exists(symtable1, index, index_len)) {
 				zval_ptr_dtor(&gpc_element);
 			} else {
-				zend_symtable_update(symtable1, index, index_len + 1, &gpc_element, sizeof(zval *), (void **) &gpc_element_p);
+				gpc_element_p = zend_symtable_str_update_ind(symtable1, index, index_len, &gpc_element);
 			}
 		}
 	}
@@ -290,8 +293,8 @@ static inline int add_post_vars(zval *arr, post_var_data_t *vars, zend_bool eof
 {
 	uint64_t max_vars = PG(max_input_vars);
 
-	vars->ptr = vars->str.c;
-	vars->end = vars->str.c + vars->str.len;
+	vars->ptr = vars->str.s->val;
+	vars->end = vars->str.s->val + vars->str.s->len;
 	while (add_post_var(arr, vars, eof TSRMLS_CC)) {
 		if (++vars->cnt > max_vars) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING,
@@ -303,7 +306,7 @@ static inline int add_post_vars(zval *arr, post_var_data_t *vars, zend_bool eof
 	}
 
 	if (!eof) {
-		memmove(vars->str.c, vars->ptr, vars->str.len = vars->end - vars->ptr);
+		memmove(vars->str.s->val, vars->ptr, vars->str.s->len = vars->end - vars->ptr);
 	}
 	return SUCCESS;
 }
@@ -325,8 +328,8 @@ SAPI_API SAPI_POST_HANDLER_FUNC(php_std_post_handler)
 				smart_str_appendl(&post_data.str, buf, len);
 
 				if (SUCCESS != add_post_vars(arr, &post_data, 0 TSRMLS_CC)) {
-					if (post_data.str.c) {
-						efree(post_data.str.c);
+					if (post_data.str.s) {
+						smart_str_free(&post_data.str);
 					}
 					return;
 				}
@@ -338,8 +341,8 @@ SAPI_API SAPI_POST_HANDLER_FUNC(php_std_post_handler)
 		}
 
 		add_post_vars(arr, &post_data, 1 TSRMLS_CC);
-		if (post_data.str.c) {
-			efree(post_data.str.c);
+		if (post_data.str.s) {
+			smart_str_free(&post_data.str);
 		}
 	}
 }
@@ -355,46 +358,39 @@ SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data)
 {
 	char *res = NULL, *var, *val, *separator = NULL;
 	const char *c_var;
-	zval *array_ptr;
+	zval array;
 	int free_buffer = 0;
 	char *strtok_buf = NULL;
 	long count = 0;
 	
+	ZVAL_UNDEF(&array);
 	switch (arg) {
 		case PARSE_POST:
 		case PARSE_GET:
 		case PARSE_COOKIE:
-			ALLOC_ZVAL(array_ptr);
-			array_init(array_ptr);
-			INIT_PZVAL(array_ptr);
+			array_init(&array);
 			switch (arg) {
 				case PARSE_POST:
-					if (PG(http_globals)[TRACK_VARS_POST]) {
-						zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_POST]);
-					}
-					PG(http_globals)[TRACK_VARS_POST] = array_ptr;
+					zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_POST]);
+					ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_POST], &array);
 					break;
 				case PARSE_GET:
-					if (PG(http_globals)[TRACK_VARS_GET]) {
-						zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_GET]);
-					}
-					PG(http_globals)[TRACK_VARS_GET] = array_ptr;
+					zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_GET]);
+					ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_GET], &array);
 					break;
 				case PARSE_COOKIE:
-					if (PG(http_globals)[TRACK_VARS_COOKIE]) {
-						zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_COOKIE]);
-					}
-					PG(http_globals)[TRACK_VARS_COOKIE] = array_ptr;
+					zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_COOKIE]);
+					ZVAL_COPY_VALUE(&PG(http_globals)[TRACK_VARS_COOKIE], &array);
 					break;
 			}
 			break;
 		default:
-			array_ptr = destArray;
+			ZVAL_COPY_VALUE(&array, destArray);
 			break;
 	}
 
 	if (arg == PARSE_POST) {
-		sapi_handle_post(array_ptr TSRMLS_CC);
+		sapi_handle_post(&array TSRMLS_CC);
 		return;
 	}
 
@@ -462,7 +458,7 @@ SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data)
 			val_len = php_url_decode(val, strlen(val));
 			val = estrndup(val, val_len);
 			if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len TSRMLS_CC)) {
-				php_register_variable_safe(var, val, new_val_len, array_ptr TSRMLS_CC);
+				php_register_variable_safe(var, val, new_val_len, &array TSRMLS_CC);
 			}
 			efree(val);
 		} else {
@@ -473,7 +469,7 @@ SAPI_API SAPI_TREAT_DATA_FUNC(php_default_treat_data)
 			val_len = 0;
 			val = estrndup("", val_len);
 			if (sapi_module.input_filter(arg, var, &val, val_len, &new_val_len TSRMLS_CC)) {
-				php_register_variable_safe(var, val, new_val_len, array_ptr TSRMLS_CC);
+				php_register_variable_safe(var, val, new_val_len, &array TSRMLS_CC);
 			}
 			efree(val);
 		}
@@ -526,7 +522,7 @@ zend_bool php_std_auto_global_callback(char *name, uint name_len TSRMLS_DC)
  */
 static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
 {
-	zval *arr, *argc, *tmp;
+	zval arr, argc, tmp;
 	int count = 0;
 	char *ss, *space;
 	
@@ -534,22 +530,15 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
 		return;
 	}
 	
-	ALLOC_INIT_ZVAL(arr);
-	array_init(arr);
+	array_init(&arr);
 
 	/* Prepare argv */
 	if (SG(request_info).argc) { /* are we in cli sapi? */
 		int i;
 		for (i = 0; i < SG(request_info).argc; i++) {
-			ALLOC_ZVAL(tmp);
-			Z_TYPE_P(tmp) = IS_STRING;
-			Z_STRLEN_P(tmp) = strlen(SG(request_info).argv[i]);
-			Z_STRVAL_P(tmp) = estrndup(SG(request_info).argv[i], Z_STRLEN_P(tmp));
-			INIT_PZVAL(tmp);
-			if (zend_hash_next_index_insert(Z_ARRVAL_P(arr), &tmp, sizeof(zval *), NULL) == FAILURE) {
-				if (Z_TYPE_P(tmp) == IS_STRING) {
-					efree(Z_STRVAL_P(tmp));
-				}
+			ZVAL_STRING(&tmp, SG(request_info).argv[i]);
+			if (zend_hash_next_index_insert(Z_ARRVAL(arr), &tmp) == NULL) {				
+				STR_FREE(Z_STR(tmp));
 			}
 		}
 	} else 	if (s && *s) {
@@ -560,16 +549,10 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
 				*space = '\0';
 			}
 			/* auto-type */
-			ALLOC_ZVAL(tmp);
-			Z_TYPE_P(tmp) = IS_STRING;
-			Z_STRLEN_P(tmp) = strlen(ss);
-			Z_STRVAL_P(tmp) = estrndup(ss, Z_STRLEN_P(tmp));
-			INIT_PZVAL(tmp);
+			ZVAL_STRING(&tmp, ss);
 			count++;
-			if (zend_hash_next_index_insert(Z_ARRVAL_P(arr), &tmp, sizeof(zval *), NULL) == FAILURE) {
-				if (Z_TYPE_P(tmp) == IS_STRING) {
-					efree(Z_STRVAL_P(tmp));
-				}
+			if (zend_hash_next_index_insert(Z_ARRVAL(arr), &tmp) == NULL) {
+				STR_FREE(Z_STR(tmp));
 			}
 			if (space) {
 				*space = '+';
@@ -581,28 +564,23 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
 	}
 
 	/* prepare argc */
-	ALLOC_INIT_ZVAL(argc);
 	if (SG(request_info).argc) {
-		Z_LVAL_P(argc) = SG(request_info).argc;
+		ZVAL_LONG(&argc, SG(request_info).argc);
 	} else {
-		Z_LVAL_P(argc) = count;
+		ZVAL_LONG(&argc, count);
 	}
-	Z_TYPE_P(argc) = IS_LONG;
 
 	if (SG(request_info).argc) {
-		Z_ADDREF_P(arr);
-		Z_ADDREF_P(argc);
-		zend_hash_update(&EG(symbol_table), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL);
-		zend_hash_update(&EG(symbol_table), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL);
+		Z_ADDREF(arr);
+		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) {
-		Z_ADDREF_P(arr);
-		Z_ADDREF_P(argc);
-		zend_hash_update(Z_ARRVAL_P(track_vars_array), "argv", sizeof("argv"), &arr, sizeof(zval *), NULL);
-		zend_hash_update(Z_ARRVAL_P(track_vars_array), "argc", sizeof("argc"), &argc, sizeof(zval *), NULL);
+	if (track_vars_array && Z_TYPE_P(track_vars_array) == IS_ARRAY) {
+		Z_ADDREF(arr);
+		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);
 }
 /* }}} */
 
@@ -610,40 +588,31 @@ static void php_build_argv(char *s, zval *track_vars_array TSRMLS_DC)
  */
 static inline void php_register_server_variables(TSRMLS_D)
 {
-	zval *array_ptr = NULL;
-
-	ALLOC_ZVAL(array_ptr);
-	array_init(array_ptr);
-	INIT_PZVAL(array_ptr);
-	if (PG(http_globals)[TRACK_VARS_SERVER]) {
-		zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
-	}
-	PG(http_globals)[TRACK_VARS_SERVER] = array_ptr;
+	zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
+	array_init(&PG(http_globals)[TRACK_VARS_SERVER]);
 
 	/* Server variables */
 	if (sapi_module.register_server_variables) {
-		sapi_module.register_server_variables(array_ptr TSRMLS_CC);
+		sapi_module.register_server_variables(&PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 	}
 
 	/* PHP Authentication support */
 	if (SG(request_info).auth_user) {
-		php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, array_ptr TSRMLS_CC);
+		php_register_variable("PHP_AUTH_USER", SG(request_info).auth_user, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 	}
 	if (SG(request_info).auth_password) {
-		php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, array_ptr TSRMLS_CC);
+		php_register_variable("PHP_AUTH_PW", SG(request_info).auth_password, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 	}
 	if (SG(request_info).auth_digest) {
-		php_register_variable("PHP_AUTH_DIGEST", SG(request_info).auth_digest, array_ptr TSRMLS_CC);
+		php_register_variable("PHP_AUTH_DIGEST", SG(request_info).auth_digest, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 	}
 	/* store request init time */
 	{
 		zval request_time_float, request_time_long;
-		Z_TYPE(request_time_float) = IS_DOUBLE;
-		Z_DVAL(request_time_float) = sapi_get_request_time(TSRMLS_C);
-		php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, array_ptr TSRMLS_CC);
-		Z_TYPE(request_time_long) = IS_LONG;
-		Z_LVAL(request_time_long) = zend_dval_to_lval(Z_DVAL(request_time_float));
-		php_register_variable_ex("REQUEST_TIME", &request_time_long, array_ptr TSRMLS_CC);
+		ZVAL_DOUBLE(&request_time_float, sapi_get_request_time(TSRMLS_C));
+		php_register_variable_ex("REQUEST_TIME_FLOAT", &request_time_float, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
+		ZVAL_LONG(&request_time_long, zend_dval_to_lval(Z_DVAL(request_time_float)));
+		php_register_variable_ex("REQUEST_TIME", &request_time_long, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 	}
 
 }
@@ -653,45 +622,40 @@ static inline void php_register_server_variables(TSRMLS_D)
  */
 static void php_autoglobal_merge(HashTable *dest, HashTable *src TSRMLS_DC)
 {
-	zval **src_entry, **dest_entry;
-	char *string_key;
-	uint string_key_len;
+	zval *src_entry, *dest_entry;
+	zend_string *string_key;
 	ulong num_key;
 	HashPosition pos;
 	int key_type;
-	int globals_check = (dest == (&EG(symbol_table)));
+	int globals_check = (dest == (&EG(symbol_table).ht));
 
 	zend_hash_internal_pointer_reset_ex(src, &pos);
-	while (zend_hash_get_current_data_ex(src, (void **)&src_entry, &pos) == SUCCESS) {
-		key_type = zend_hash_get_current_key_ex(src, &string_key, &string_key_len, &num_key, 0, &pos);
-		if (Z_TYPE_PP(src_entry) != IS_ARRAY
-			|| (key_type == HASH_KEY_IS_STRING && zend_hash_find(dest, string_key, string_key_len, (void **) &dest_entry) != SUCCESS)
-			|| (key_type == HASH_KEY_IS_LONG && zend_hash_index_find(dest, num_key, (void **)&dest_entry) != SUCCESS)
-			|| Z_TYPE_PP(dest_entry) != IS_ARRAY
+	while ((src_entry = zend_hash_get_current_data_ex(src, &pos)) != NULL) {
+		key_type = zend_hash_get_current_key_ex(src, &string_key, &num_key, 0, &pos);
+		if (Z_TYPE_P(src_entry) != IS_ARRAY
+			|| (key_type == HASH_KEY_IS_STRING && (dest_entry = zend_hash_find(dest, string_key)) == NULL)
+			|| (key_type == HASH_KEY_IS_LONG && (dest_entry = zend_hash_index_find(dest, num_key)) == NULL)
+			|| Z_TYPE_P(dest_entry) != IS_ARRAY
 			) {
-			Z_ADDREF_PP(src_entry);
+			Z_ADDREF_P(src_entry);
 			if (key_type == HASH_KEY_IS_STRING) {
-				if (!globals_check || string_key_len != sizeof("GLOBALS") || memcmp(string_key, "GLOBALS", sizeof("GLOBALS") - 1)) {
-					zend_hash_update(dest, string_key, string_key_len, src_entry, sizeof(zval *), NULL);
+				if (!globals_check || string_key->len != sizeof("GLOBALS") || memcmp(string_key->val, "GLOBALS", sizeof("GLOBALS") - 1)) {
+					zend_hash_update(dest, string_key, src_entry);
 				} else {
-					Z_DELREF_PP(src_entry);
+					Z_DELREF_P(src_entry);
 				}
 			} else {
-				zend_hash_index_update(dest, num_key, src_entry, sizeof(zval *), NULL);
+				zend_hash_index_update(dest, num_key, src_entry);
 			}
 		} else {
 			SEPARATE_ZVAL(dest_entry);
-			php_autoglobal_merge(Z_ARRVAL_PP(dest_entry), Z_ARRVAL_PP(src_entry) TSRMLS_CC);
+			php_autoglobal_merge(Z_ARRVAL_P(dest_entry), Z_ARRVAL_P(src_entry) TSRMLS_CC);
 		}
 		zend_hash_move_forward_ex(src, &pos);
 	}
 }
 /* }}} */
 
-static zend_bool php_auto_globals_create_server(const char *name, uint name_len TSRMLS_DC);
-static zend_bool php_auto_globals_create_env(const char *name, uint name_len TSRMLS_DC);
-static zend_bool php_auto_globals_create_request(const char *name, uint name_len TSRMLS_DC);
-
 /* {{{ php_hash_environment
  */
 PHPAPI int php_hash_environment(TSRMLS_D)
@@ -699,172 +663,126 @@ PHPAPI int php_hash_environment(TSRMLS_D)
 	memset(PG(http_globals), 0, sizeof(PG(http_globals)));
 	zend_activate_auto_globals(TSRMLS_C);
 	if (PG(register_argc_argv)) {
-		php_build_argv(SG(request_info).query_string, PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
+		php_build_argv(SG(request_info).query_string, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 	}
 	return SUCCESS;
 }
 /* }}} */
 
-static zend_bool php_auto_globals_create_get(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_get(zend_string *name TSRMLS_DC)
 {
-	zval *vars;
-
 	if (PG(variables_order) && (strchr(PG(variables_order),'G') || strchr(PG(variables_order),'g'))) {
 		sapi_module.treat_data(PARSE_GET, NULL, NULL TSRMLS_CC);
-		vars = PG(http_globals)[TRACK_VARS_GET];
 	} else {
-		ALLOC_ZVAL(vars);
-		array_init(vars);
-		INIT_PZVAL(vars);
-		if (PG(http_globals)[TRACK_VARS_GET]) {
-			zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_GET]);
-		}
-		PG(http_globals)[TRACK_VARS_GET] = vars;
+		zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_GET]);
+		array_init(&PG(http_globals)[TRACK_VARS_GET]);
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &vars, sizeof(zval *), NULL);
-	Z_ADDREF_P(vars);
+	zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_GET]);
+	Z_ADDREF(PG(http_globals)[TRACK_VARS_GET]);
 	
 	return 0; /* don't rearm */
 }
 
-static zend_bool php_auto_globals_create_post(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_post(zend_string *name TSRMLS_DC)
 {
-	zval *vars;
-
 	if (PG(variables_order) &&
 			(strchr(PG(variables_order),'P') || strchr(PG(variables_order),'p')) &&
 		!SG(headers_sent) &&
 		SG(request_info).request_method &&
 		!strcasecmp(SG(request_info).request_method, "POST")) {
 		sapi_module.treat_data(PARSE_POST, NULL, NULL TSRMLS_CC);
-		vars = PG(http_globals)[TRACK_VARS_POST];
 	} else {
-		ALLOC_ZVAL(vars);
-		array_init(vars);
-		INIT_PZVAL(vars);
-		if (PG(http_globals)[TRACK_VARS_POST]) {
-			zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_POST]);
-		}
-		PG(http_globals)[TRACK_VARS_POST] = vars;
+		zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_POST]);
+		array_init(&PG(http_globals)[TRACK_VARS_POST]);
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &vars, sizeof(zval *), NULL);
-	Z_ADDREF_P(vars);
+	zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_POST]);
+	Z_ADDREF(PG(http_globals)[TRACK_VARS_POST]);
 	
 	return 0; /* don't rearm */
 }
 
-static zend_bool php_auto_globals_create_cookie(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_cookie(zend_string *name TSRMLS_DC)
 {
-	zval *vars;
-
 	if (PG(variables_order) && (strchr(PG(variables_order),'C') || strchr(PG(variables_order),'c'))) {
 		sapi_module.treat_data(PARSE_COOKIE, NULL, NULL TSRMLS_CC);
-		vars = PG(http_globals)[TRACK_VARS_COOKIE];
 	} else {
-		ALLOC_ZVAL(vars);
-		array_init(vars);
-		INIT_PZVAL(vars);
-		if (PG(http_globals)[TRACK_VARS_COOKIE]) {
-			zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_COOKIE]);
-		}
-		PG(http_globals)[TRACK_VARS_COOKIE] = vars;
+		zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_COOKIE]);
+		array_init(&PG(http_globals)[TRACK_VARS_COOKIE]);
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &vars, sizeof(zval *), NULL);
-	Z_ADDREF_P(vars);
+	zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_COOKIE]);
+	Z_ADDREF(PG(http_globals)[TRACK_VARS_COOKIE]);
 	
 	return 0; /* don't rearm */
 }
 
-static zend_bool php_auto_globals_create_files(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_files(zend_string *name TSRMLS_DC)
 {
-	zval *vars;
-
-	if (PG(http_globals)[TRACK_VARS_FILES]) {
-		vars = PG(http_globals)[TRACK_VARS_FILES];
-	} else {
-		ALLOC_ZVAL(vars);
-		array_init(vars);
-		INIT_PZVAL(vars);
-		PG(http_globals)[TRACK_VARS_FILES] = vars;
+	if (Z_TYPE(PG(http_globals)[TRACK_VARS_FILES]) == IS_UNDEF) {
+		array_init(&PG(http_globals)[TRACK_VARS_FILES]);
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &vars, sizeof(zval *), NULL);
-	Z_ADDREF_P(vars);
+	zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_FILES]);
+	Z_ADDREF(PG(http_globals)[TRACK_VARS_FILES]);
 	
 	return 0; /* don't rearm */
 }
 
-static zend_bool php_auto_globals_create_server(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_server(zend_string *name TSRMLS_DC)
 {
 	if (PG(variables_order) && (strchr(PG(variables_order),'S') || strchr(PG(variables_order),'s'))) {
 		php_register_server_variables(TSRMLS_C);
 
 		if (PG(register_argc_argv)) {
 			if (SG(request_info).argc) {
-				zval **argc, **argv;
+				zval *argc, *argv;
 	
-				if (zend_hash_find(&EG(symbol_table), "argc", sizeof("argc"), (void**)&argc) == SUCCESS &&
-					zend_hash_find(&EG(symbol_table), "argv", sizeof("argv"), (void**)&argv) == SUCCESS) {
-					Z_ADDREF_PP(argc);
-					Z_ADDREF_PP(argv);
-					zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argv", sizeof("argv"), argv, sizeof(zval *), NULL);
-					zend_hash_update(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER]), "argc", sizeof("argc"), argc, sizeof(zval *), NULL);
+				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(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);
 				}
 			} else {
-				php_build_argv(SG(request_info).query_string, PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
+				php_build_argv(SG(request_info).query_string, &PG(http_globals)[TRACK_VARS_SERVER] TSRMLS_CC);
 			}
 		}
 	
 	} else {
-		zval *server_vars=NULL;
-		ALLOC_ZVAL(server_vars);
-		array_init(server_vars);
-		INIT_PZVAL(server_vars);
-		if (PG(http_globals)[TRACK_VARS_SERVER]) {
-			zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
-		}
-		PG(http_globals)[TRACK_VARS_SERVER] = server_vars;
+		zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_SERVER]);
+		array_init(&PG(http_globals)[TRACK_VARS_SERVER]);
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_SERVER], sizeof(zval *), NULL);
-	Z_ADDREF_P(PG(http_globals)[TRACK_VARS_SERVER]);
+	zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_SERVER]);
+	Z_ADDREF(PG(http_globals)[TRACK_VARS_SERVER]);
 	
 	return 0; /* don't rearm */
 }
 
-static zend_bool php_auto_globals_create_env(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_env(zend_string *name TSRMLS_DC)
 {
-	zval *env_vars = NULL;
-	ALLOC_ZVAL(env_vars);
-	array_init(env_vars);
-	INIT_PZVAL(env_vars);
-	if (PG(http_globals)[TRACK_VARS_ENV]) {
-		zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_ENV]);
-	}
-	PG(http_globals)[TRACK_VARS_ENV] = env_vars;
+	zval_ptr_dtor(&PG(http_globals)[TRACK_VARS_ENV]);
+	array_init(&PG(http_globals)[TRACK_VARS_ENV]);
 	
 	if (PG(variables_order) && (strchr(PG(variables_order),'E') || strchr(PG(variables_order),'e'))) {
-		php_import_environment_variables(PG(http_globals)[TRACK_VARS_ENV] TSRMLS_CC);
+		php_import_environment_variables(&PG(http_globals)[TRACK_VARS_ENV] TSRMLS_CC);
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &PG(http_globals)[TRACK_VARS_ENV], sizeof(zval *), NULL);
-	Z_ADDREF_P(PG(http_globals)[TRACK_VARS_ENV]);
+	zend_hash_update(&EG(symbol_table).ht, name, &PG(http_globals)[TRACK_VARS_ENV]);
+	Z_ADDREF(PG(http_globals)[TRACK_VARS_ENV]);
 
 	return 0; /* don't rearm */
 }
 
-static zend_bool php_auto_globals_create_request(const char *name, uint name_len TSRMLS_DC)
+static zend_bool php_auto_globals_create_request(zend_string *name TSRMLS_DC)
 {
-	zval *form_variables;
+	zval form_variables;
 	unsigned char _gpc_flags[3] = {0, 0, 0};
 	char *p;
 
-	ALLOC_ZVAL(form_variables);
-	array_init(form_variables);
-	INIT_PZVAL(form_variables);
+	array_init(&form_variables);
 
 	if (PG(request_order) != NULL) {
 		p = PG(request_order);
@@ -877,40 +795,40 @@ static zend_bool php_auto_globals_create_request(const char *name, uint name_len
 			case 'g':
 			case 'G':
 				if (!_gpc_flags[0]) {
-					php_autoglobal_merge(Z_ARRVAL_P(form_variables), Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_GET]) TSRMLS_CC);
+					php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_GET]) TSRMLS_CC);
 					_gpc_flags[0] = 1;
 				}
 				break;
 			case 'p':
 			case 'P':
 				if (!_gpc_flags[1]) {
-					php_autoglobal_merge(Z_ARRVAL_P(form_variables), Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_POST]) TSRMLS_CC);
+					php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_POST]) TSRMLS_CC);
 					_gpc_flags[1] = 1;
 				}
 				break;
 			case 'c':
 			case 'C':
 				if (!_gpc_flags[2]) {
-					php_autoglobal_merge(Z_ARRVAL_P(form_variables), Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_COOKIE]) TSRMLS_CC);
+					php_autoglobal_merge(Z_ARRVAL(form_variables), Z_ARRVAL(PG(http_globals)[TRACK_VARS_COOKIE]) TSRMLS_CC);
 					_gpc_flags[2] = 1;
 				}
 				break;
 		}
 	}
 
-	zend_hash_update(&EG(symbol_table), name, name_len + 1, &form_variables, sizeof(zval *), NULL);
+	zend_hash_update(&EG(symbol_table).ht, name, &form_variables);
 	return 0;
 }
 
 void php_startup_auto_globals(TSRMLS_D)
 {
-	zend_register_auto_global(ZEND_STRL("_GET"), 0, php_auto_globals_create_get TSRMLS_CC);
-	zend_register_auto_global(ZEND_STRL("_POST"), 0, php_auto_globals_create_post TSRMLS_CC);
-	zend_register_auto_global(ZEND_STRL("_COOKIE"), 0, php_auto_globals_create_cookie TSRMLS_CC);
-	zend_register_auto_global(ZEND_STRL("_SERVER"), PG(auto_globals_jit), php_auto_globals_create_server TSRMLS_CC);
-	zend_register_auto_global(ZEND_STRL("_ENV"), PG(auto_globals_jit), php_auto_globals_create_env TSRMLS_CC);
-	zend_register_auto_global(ZEND_STRL("_REQUEST"), PG(auto_globals_jit), php_auto_globals_create_request TSRMLS_CC);
-	zend_register_auto_global(ZEND_STRL("_FILES"), 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 b1011e21cb..98a29f1e39 100644
--- a/main/rfc1867.c
+++ b/main/rfc1867.c
@@ -148,17 +148,15 @@ static void normalize_protected_variable(char *varname TSRMLS_DC) /* {{{ */
 
 static void add_protected_variable(char *varname TSRMLS_DC) /* {{{ */
 {
-	int dummy = 1;
-
 	normalize_protected_variable(varname TSRMLS_CC);
-	zend_hash_add(&PG(rfc1867_protected_variables), varname, strlen(varname)+1, &dummy, sizeof(int), NULL);
+	zend_hash_str_add_empty_element(&PG(rfc1867_protected_variables), varname, strlen(varname));
 }
 /* }}} */
 
 static zend_bool is_protected_variable(char *varname TSRMLS_DC) /* {{{ */
 {
 	normalize_protected_variable(varname TSRMLS_CC);
-	return zend_hash_exists(&PG(rfc1867_protected_variables), varname, strlen(varname)+1);
+	return zend_hash_str_exists(&PG(rfc1867_protected_variables), varname, strlen(varname));
 }
 /* }}} */
 
@@ -190,16 +188,23 @@ static void register_http_post_files_variable_ex(char *var, zval *val, zval *htt
 }
 /* }}} */
 
-static int unlink_filename(char **filename TSRMLS_DC) /* {{{ */
+static int unlink_filename(zval *el TSRMLS_DC) /* {{{ */
 {
-	VCWD_UNLINK(*filename);
+	char *filename = (char*)Z_PTR_P(el);
+	VCWD_UNLINK(filename);
 	return 0;
 }
 /* }}} */
 
+
+static void free_filename(zval *el) {
+	char *filename = (char*)Z_PTR_P(el);
+	efree(filename);
+}
+
 void destroy_uploaded_files_hash(TSRMLS_D) /* {{{ */
 {
-	zend_hash_apply(SG(rfc1867_uploaded_files), (apply_func_t) unlink_filename TSRMLS_CC);
+	zend_hash_apply(SG(rfc1867_uploaded_files), unlink_filename TSRMLS_CC);
 	zend_hash_destroy(SG(rfc1867_uploaded_files));
 	FREE_HASHTABLE(SG(rfc1867_uploaded_files));
 }
@@ -683,7 +688,6 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 	int boundary_len = 0, cancel_upload = 0, is_arr_upload = 0, array_len = 0;
 	int64_t total_bytes = 0, max_file_size = 0;
 	int skip_upload = 0, anonindex = 0, is_anonymous;
-	zval *http_post_files = NULL;
 	HashTable *uploaded_files = NULL;
 	multipart_buffer *mbuff;
 	zval *array_ptr = (zval *) arg;
@@ -758,16 +762,13 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 	}
 
 	/* Initialize $_FILES[] */
-	zend_hash_init(&PG(rfc1867_protected_variables), 5, NULL, NULL, 0);
+	zend_hash_init(&PG(rfc1867_protected_variables), 8, 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, 8, NULL, free_filename, 0);
 	SG(rfc1867_uploaded_files) = uploaded_files;
 
-	ALLOC_ZVAL(http_post_files);
-	array_init(http_post_files);
-	INIT_PZVAL(http_post_files);
-	PG(http_globals)[TRACK_VARS_FILES] = http_post_files;
+	array_init(&PG(http_globals)[TRACK_VARS_FILES]);
 
 	zend_llist_init(&header, sizeof(mime_header_entry), (llist_dtor_func_t) php_free_hdr_entry, 0);
 
@@ -1098,7 +1099,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 				}
 				temp_filename = "";
 			} else {
-				zend_hash_add(SG(rfc1867_uploaded_files), temp_filename, strlen(temp_filename) + 1, &temp_filename, sizeof(char *), NULL);
+				zend_hash_str_add_ptr(SG(rfc1867_uploaded_files), temp_filename, strlen(temp_filename), temp_filename);
 			}
 
 			/* is_arr_upload is true when name of file upload field
@@ -1149,7 +1150,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 			} else {
 				snprintf(lbuf, llen, "%s[name]", param);
 			}
-			register_http_post_files_variable(lbuf, s, http_post_files, 0 TSRMLS_CC);
+			register_http_post_files_variable(lbuf, s, &PG(http_globals)[TRACK_VARS_FILES], 0 TSRMLS_CC);
 			efree(filename);
 			s = NULL;
 
@@ -1180,7 +1181,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 			} else {
 				snprintf(lbuf, llen, "%s[type]", param);
 			}
-			register_http_post_files_variable(lbuf, cd, http_post_files, 0 TSRMLS_CC);
+			register_http_post_files_variable(lbuf, cd, &PG(http_globals)[TRACK_VARS_FILES], 0 TSRMLS_CC);
 
 			/* Restore Content-Type Header */
 			if (s != NULL) {
@@ -1198,7 +1199,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 
 				/* if param is of form xxx[.*] this will cut it to xxx */
 				if (!is_anonymous) {
-					ZVAL_STRING(&zfilename, temp_filename, 1);
+					ZVAL_STRING(&zfilename, temp_filename);
 					safe_php_register_variable_ex(param, &zfilename, NULL, 1 TSRMLS_CC);
 				}
 
@@ -1209,8 +1210,8 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 					snprintf(lbuf, llen, "%s[tmp_name]", param);
 				}
 				add_protected_variable(lbuf TSRMLS_CC);
-				ZVAL_STRING(&zfilename, temp_filename, 1);
-				register_http_post_files_variable_ex(lbuf, &zfilename, http_post_files, 1 TSRMLS_CC);
+				ZVAL_STRING(&zfilename, temp_filename);
+				register_http_post_files_variable_ex(lbuf, &zfilename, &PG(http_globals)[TRACK_VARS_FILES], 1 TSRMLS_CC);
 			}
 
 			{
@@ -1248,7 +1249,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 				} else {
 					snprintf(lbuf, llen, "%s[error]", param);
 				}
-				register_http_post_files_variable_ex(lbuf, &error_type, http_post_files, 0 TSRMLS_CC);
+				register_http_post_files_variable_ex(lbuf, &error_type, &PG(http_globals)[TRACK_VARS_FILES], 0 TSRMLS_CC);
 
 				/* Add $foo_size */
 				if (is_arr_upload) {
@@ -1258,7 +1259,7 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 				}
 				if (!is_anonymous) {
 					if (size_overflow) {
-						ZVAL_STRING(&file_size, file_size_buf, 1);
+						ZVAL_STRING(&file_size, file_size_buf);
 					}
 					safe_php_register_variable_ex(lbuf, &file_size, NULL, size_overflow TSRMLS_CC);
 				}
@@ -1270,9 +1271,9 @@ SAPI_API SAPI_POST_HANDLER_FUNC(rfc1867_post_handler) /* {{{ */
 					snprintf(lbuf, llen, "%s[size]", param);
 				}
 				if (size_overflow) {
-					ZVAL_STRING(&file_size, file_size_buf, 1);
+					ZVAL_STRING(&file_size, file_size_buf);
 				}
-				register_http_post_files_variable_ex(lbuf, &file_size, http_post_files, size_overflow TSRMLS_CC);
+				register_http_post_files_variable_ex(lbuf, &file_size, &PG(http_globals)[TRACK_VARS_FILES], size_overflow TSRMLS_CC);
 			}
 			efree(param);
 		}
diff --git a/main/spprintf.c b/main/spprintf.c
index 5b16d51441..dfee6d9612 100644
--- a/main/spprintf.c
+++ b/main/spprintf.c
@@ -145,13 +145,13 @@
  * Macro that does padding. The padding is done by printing
  * the character ch.
  */
-#define PAD(xbuf, count, ch) do {					\
-	if ((count) > 0) {                  			\
-		size_t newlen;								\
-		smart_str_alloc(xbuf, (count), 0); 			\
-		memset(xbuf->c + xbuf->len, ch, (count));	\
-		xbuf->len += (count);				\
-	}												\
+#define PAD(xbuf, count, ch) do {							\
+	if ((count) > 0) {                  					\
+		size_t newlen;										\
+		smart_str_alloc(xbuf, (count), 0); 					\
+		memset(xbuf->s->val + xbuf->s->len, ch, (count));	\
+		xbuf->s->len += (count);							\
+	}														\
 } while (0)
 
 #define NUM(c) (c - '0')
@@ -700,7 +700,7 @@ static void xbuf_format_converter(smart_str *xbuf, const char *fmt, va_list ap)
 
 
 				case 'n':
-					*(va_arg(ap, int *)) = xbuf->len;
+					*(va_arg(ap, int *)) = xbuf->s->len;
 					goto skip_output;
 
 					/*
@@ -795,17 +795,20 @@ skip_output:
 PHPAPI int vspprintf(char **pbuf, size_t max_len, const char *format, va_list ap) /* {{{ */
 {
 	smart_str xbuf = {0};
+	int result;
 
 	xbuf_format_converter(&xbuf, format, ap);
 
-	if (max_len && xbuf.len > max_len) {
-		xbuf.len = max_len;
+	if (max_len && xbuf.s->len > max_len) {
+		xbuf.s->len = max_len;
 	}
 	smart_str_0(&xbuf);
 
-	*pbuf = xbuf.c;
+	*pbuf = estrndup(xbuf.s->val, xbuf.s->len);
+	result = xbuf.s->len;
+	smart_str_free(&xbuf);
 
-	return xbuf.len;
+	return result;
 }
 /* }}} */
 
diff --git a/main/streams/filter.c b/main/streams/filter.c
index 71599f0d12..d2411c928a 100644
--- a/main/streams/filter.c
+++ b/main/streams/filter.c
@@ -46,26 +46,25 @@ PHPAPI HashTable *_php_get_stream_filters_hash(TSRMLS_D)
 /* API for registering GLOBAL filters */
 PHPAPI int php_stream_filter_register_factory(const char *filterpattern, php_stream_filter_factory *factory TSRMLS_DC)
 {
-	return zend_hash_add(&stream_filters_hash, (char*)filterpattern, strlen(filterpattern) + 1, factory, sizeof(*factory), NULL);
+	return zend_hash_str_add_ptr(&stream_filters_hash, filterpattern, strlen(filterpattern), factory) ? SUCCESS : FAILURE;
 }
 
 PHPAPI int php_stream_filter_unregister_factory(const char *filterpattern TSRMLS_DC)
 {
-	return zend_hash_del(&stream_filters_hash, (char*)filterpattern, strlen(filterpattern) + 1);
+	return zend_hash_str_del(&stream_filters_hash, filterpattern, strlen(filterpattern));
 }
 
 /* API for registering VOLATILE wrappers */
 PHPAPI int php_stream_filter_register_factory_volatile(const char *filterpattern, php_stream_filter_factory *factory TSRMLS_DC)
 {
 	if (!FG(stream_filters)) {
-		php_stream_filter_factory tmpfactory;
-
 		ALLOC_HASHTABLE(FG(stream_filters));
 		zend_hash_init(FG(stream_filters), zend_hash_num_elements(&stream_filters_hash), NULL, NULL, 1);
-		zend_hash_copy(FG(stream_filters), &stream_filters_hash, NULL, &tmpfactory, sizeof(php_stream_filter_factory));
+//???		zend_hash_copy(FG(stream_filters), &stream_filters_hash, NULL, &tmpfactory, sizeof(php_stream_filter_factory));
+		zend_hash_copy(FG(stream_filters), &stream_filters_hash, NULL);
 	}
 
-	return zend_hash_add(FG(stream_filters), (char*)filterpattern, strlen(filterpattern) + 1, factory, sizeof(*factory), NULL);
+	return zend_hash_str_add_ptr(FG(stream_filters), (char*)filterpattern, strlen(filterpattern), factory) ? SUCCESS : FAILURE;
 }
 
 /* Buckets */
@@ -259,7 +258,7 @@ PHPAPI php_stream_filter *php_stream_filter_create(const char *filtername, zval
 
 	n = strlen(filtername);
 	
-	if (SUCCESS == zend_hash_find(filter_hash, (char*)filtername, n + 1, (void**)&factory)) {
+	if (NULL != (factory = zend_hash_str_find_ptr(filter_hash, filtername, n))) {
 		filter = factory->create_filter(filtername, filterparams, persistent TSRMLS_CC);
 	} else if ((period = strrchr(filtername, '.'))) {
 		/* try a wildcard */
@@ -271,7 +270,7 @@ PHPAPI php_stream_filter *php_stream_filter_create(const char *filtername, zval
 		while (period && !filter) {
 			*period = '\0';
 			strncat(wildname, ".*", 2);
-			if (SUCCESS == zend_hash_find(filter_hash, wildname, strlen(wildname) + 1, (void**)&factory)) {
+			if (NULL != (factory = zend_hash_str_find_ptr(filter_hash, wildname, strlen(wildname)))) {
 				filter = factory->create_filter(filtername, filterparams, persistent TSRMLS_CC);
 			}
 
@@ -300,7 +299,7 @@ PHPAPI php_stream_filter *_php_stream_filter_alloc(php_stream_filter_ops *fops,
 	memset(filter, 0, sizeof(php_stream_filter));
 
 	filter->fops = fops;
-	filter->abstract = abstract;
+	Z_PTR(filter->abstract) = abstract;
 	filter->is_persistent = persistent;
 	
 	return filter;
@@ -523,8 +522,8 @@ PHPAPI php_stream_filter *php_stream_filter_remove(php_stream_filter *filter, in
 		filter->chain->tail = filter->prev;
 	}
 
-	if (filter->rsrc_id > 0) {
-		zend_list_delete(filter->rsrc_id);
+	if (filter->res) {
+		zend_list_delete(filter->res);
 	}
 
 	if (call_dtor) {
diff --git a/main/streams/memory.c b/main/streams/memory.c
index 854b9e2720..89bd59e215 100644
--- a/main/streams/memory.c
+++ b/main/streams/memory.c
@@ -20,9 +20,9 @@
 
 #define _GNU_SOURCE
 #include "php.h"
+#include "ext/standard/base64.h"
 
 PHPAPI int php_url_decode(char *str, int len);
-PHPAPI unsigned char *php_base64_decode(const unsigned char *str, int length, int *ret_length);
 
 /* Memory streams use a dynamic memory buffer to emulate a stream.
  * You can use php_stream_memory_open to create a readonly stream
@@ -351,7 +351,7 @@ typedef struct {
 	php_stream  *innerstream;
 	size_t      smax;
 	int			mode;
-	zval*       meta;
+	zval        meta;
 } php_stream_temp_data;
 
 
@@ -416,9 +416,7 @@ static int php_stream_temp_close(php_stream *stream, int close_handle TSRMLS_DC)
 		ret = 0;
 	}
 	
-	if (ts->meta) {
-		zval_ptr_dtor(&ts->meta);
-	}
+	zval_ptr_dtor(&ts->meta);
 
 	efree(ts);
 
@@ -522,8 +520,8 @@ static int php_stream_temp_set_option(php_stream *stream, int option, int value,
 	
 	switch(option) {
 		case PHP_STREAM_OPTION_META_DATA_API:
-			if (ts->meta) {
-				zend_hash_copy(Z_ARRVAL_P((zval*)ptrparam), Z_ARRVAL_P(ts->meta), (copy_ctor_func_t) zval_add_ref, NULL, sizeof(zval*));
+			if (Z_TYPE(ts->meta) != IS_UNDEF) {
+				zend_hash_copy(Z_ARRVAL_P((zval*)ptrparam), Z_ARRVAL(ts->meta), zval_add_ref);
 			}
 			return PHP_STREAM_OPTION_RETURN_OK;
 		default:
@@ -556,7 +554,7 @@ PHPAPI php_stream *_php_stream_temp_create(int mode, size_t max_memory_usage STR
 	self = ecalloc(1, sizeof(*self));
 	self->smax = max_memory_usage;
 	self->mode = mode;
-	self->meta = NULL;
+	ZVAL_UNDEF(&self->meta);
 	stream = php_stream_alloc_rel(&php_stream_temp_ops, self, 0, mode & TEMP_STREAM_READONLY ? "rb" : "w+b");
 	stream->flags |= PHP_STREAM_FLAG_NO_BUFFER;
 	self->innerstream = php_stream_memory_create_rel(mode);
@@ -607,9 +605,11 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, con
 	char *comma, *semi, *sep, *key;
 	size_t mlen, dlen, plen, vlen;
 	off_t newoffs;
-	zval *meta = NULL;
+	zval meta;
 	int base64 = 0, ilen;
+	zend_string *base64_comma = NULL;
 
+	ZVAL_NULL(&meta);
 	if (memcmp(path, "data:", 5)) {
 		return NULL;
 	}
@@ -639,14 +639,13 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, con
 			return NULL;
 		}
 
-		MAKE_STD_ZVAL(meta);
-		array_init(meta);
+		array_init(&meta);
 		if (!semi) { /* there is only a mime type */
-			add_assoc_stringl(meta, "mediatype", (char *) path, mlen, 1);
+			add_assoc_stringl(&meta, "mediatype", (char *) path, mlen);
 			mlen = 0;
 		} else if (sep && sep < semi) { /* there is a mime type */
 			plen = semi - path;
-			add_assoc_stringl(meta, "mediatype", (char *) path, plen, 1);
+			add_assoc_stringl(&meta, "mediatype", (char *) path, plen);
 			mlen -= plen;
 			path += plen;
 		} else if (semi != path || mlen != sizeof(";base64")-1 || memcmp(path, ";base64", sizeof(";base64")-1)) { /* must be error since parameters are only allowed after mediatype */
@@ -676,7 +675,7 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, con
 			plen = sep - path;
 			vlen = (semi ? semi - sep : mlen - plen) - 1 /* '=' */;
 			key = estrndup(path, plen);
-			add_assoc_stringl_ex(meta, key, plen + 1, sep + 1, vlen, 1);
+			add_assoc_stringl_ex(&meta, key, plen, sep + 1, vlen);
 			efree(key);
 			plen += vlen + 1;
 			mlen -= plen;
@@ -688,22 +687,23 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, con
 			return NULL;
 		}
 	} else {
-		MAKE_STD_ZVAL(meta);
-		array_init(meta);
+		array_init(&meta);
 	}
-	add_assoc_bool(meta, "base64", base64);
+	add_assoc_bool(&meta, "base64", base64);
 
 	/* skip ',' */
 	comma++;
 	dlen--;
 
 	if (base64) {
-		comma = (char*)php_base64_decode((const unsigned char *)comma, dlen, &ilen);
-		if (!comma) {
+		base64_comma = php_base64_decode((const unsigned char *)comma, dlen);
+		if (!base64_comma) {
 			zval_ptr_dtor(&meta);
 			php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "rfc2397: unable to decode");
 			return NULL;
 		}
+		comma = base64_comma->val;
+		ilen = base64_comma->len;
 	} else {
 		comma = estrndup(comma, dlen);
 		ilen = dlen = php_url_decode(comma, dlen);
@@ -724,9 +724,13 @@ static php_stream * php_stream_url_wrap_rfc2397(php_stream_wrapper *wrapper, con
 		ts = (php_stream_temp_data*)stream->abstract;
 		assert(ts != NULL);
 		ts->mode = mode && mode[0] == 'r' && mode[1] != '+' ? TEMP_STREAM_READONLY : 0;
-		ts->meta = meta;
+		ZVAL_COPY_VALUE(&ts->meta, &meta);
+	}
+	if (base64_comma) {
+		STR_FREE(base64_comma);
+	} else {
+		efree(comma);
 	}
-	efree(comma);
 
 	return stream;
 }
diff --git a/main/streams/php_stream_context.h b/main/streams/php_stream_context.h
index 5c6925a856..c0b70934c6 100644
--- a/main/streams/php_stream_context.h
+++ b/main/streams/php_stream_context.h
@@ -33,34 +33,34 @@ typedef void (*php_stream_notification_func)(php_stream_context *context,
    If no context was passed, use the default context
    The default context has not yet been created, do it now. */
 #define php_stream_context_from_zval(zcontext, nocontext) ( \
-		(zcontext) ? zend_fetch_resource(&(zcontext) TSRMLS_CC, -1, "Stream-Context", NULL, 1, php_le_stream_context(TSRMLS_C)) : \
+		(zcontext) ? zend_fetch_resource(zcontext TSRMLS_CC, -1, "Stream-Context", NULL, 1, php_le_stream_context(TSRMLS_C)) : \
 		(nocontext) ? NULL : \
 		FG(default_context) ? FG(default_context) : \
 		(FG(default_context) = php_stream_context_alloc(TSRMLS_C)) )
 
-#define php_stream_context_to_zval(context, zval) { ZVAL_RESOURCE(zval, (context)->rsrc_id); zend_list_addref((context)->rsrc_id); }
+#define php_stream_context_to_zval(context, zval) { ZVAL_RES(zval, (context)->res); GC_REFCOUNT((context)->res)++; }
 
 typedef struct _php_stream_notifier php_stream_notifier;
 
 struct _php_stream_notifier {
 	php_stream_notification_func func;
 	void (*dtor)(php_stream_notifier *notifier);
-	void *ptr;
+	zval ptr;
 	int mask;
 	size_t progress, progress_max; /* position for progress notification */
 };
 
 struct _php_stream_context {
 	php_stream_notifier *notifier;
-	zval *options;	/* hash keyed by wrapper family or specific wrapper */
-	int rsrc_id;	/* used for auto-cleanup */
+	zval options;	/* hash keyed by wrapper family or specific wrapper */
+	zend_resource *res;	/* used for auto-cleanup */
 };
 
 BEGIN_EXTERN_C()
 PHPAPI void php_stream_context_free(php_stream_context *context);
 PHPAPI php_stream_context *php_stream_context_alloc(TSRMLS_D);
-PHPAPI int php_stream_context_get_option(php_stream_context *context,
-		const char *wrappername, const char *optionname, zval ***optionvalue);
+PHPAPI zval *php_stream_context_get_option(php_stream_context *context,
+		const char *wrappername, const char *optionname);
 PHPAPI int php_stream_context_set_option(php_stream_context *context,
 		const char *wrappername, const char *optionname, zval *optionvalue);
 
diff --git a/main/streams/php_stream_filter_api.h b/main/streams/php_stream_filter_api.h
index 9d9894c1c5..31e73ff6e4 100644
--- a/main/streams/php_stream_filter_api.h
+++ b/main/streams/php_stream_filter_api.h
@@ -107,7 +107,7 @@ typedef struct _php_stream_filter_chain {
 
 struct _php_stream_filter {
 	php_stream_filter_ops *fops;
-	void *abstract; /* for use by filter implementation */
+	zval abstract; /* for use by filter implementation */
 	php_stream_filter *next;
 	php_stream_filter *prev;
 	int is_persistent;
@@ -119,7 +119,7 @@ struct _php_stream_filter {
 	php_stream_bucket_brigade buffer;
 
 	/* filters are auto_registered when they're applied */
-	int rsrc_id;
+	zend_resource *res;
 };
 
 /* stack filter onto a stream */
diff --git a/main/streams/streams.c b/main/streams/streams.c
index 6716dce524..0889bd57a7 100644
--- a/main/streams/streams.c
+++ b/main/streams/streams.c
@@ -65,19 +65,20 @@ PHPAPI HashTable *php_stream_get_url_stream_wrappers_hash_global(void)
 	return &url_stream_wrappers_hash;
 }
 
-static int _php_stream_release_context(zend_rsrc_list_entry *le, void *pContext TSRMLS_DC)
+static int _php_stream_release_context(zval *zv, void *pContext TSRMLS_DC)
 {
+	zend_resource *le = Z_RES_P(zv);
 	if (le->ptr == pContext) {
-		return --le->refcount == 0;
+		return --GC_REFCOUNT(le) == 0;
 	}
 	return 0;
 }
 
-static int forget_persistent_resource_id_numbers(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static int forget_persistent_resource_id_numbers(zend_resource *rsrc TSRMLS_DC)
 {
 	php_stream *stream;
 
-	if (Z_TYPE_P(rsrc) != le_pstream) {
+	if (rsrc->type != le_pstream) {
 		return 0;
 	}
 
@@ -87,11 +88,11 @@ static int forget_persistent_resource_id_numbers(zend_rsrc_list_entry *rsrc TSRM
 fprintf(stderr, "forget_persistent: %s:%p\n", stream->ops->label, stream);
 #endif
 
-	stream->rsrc_id = FAILURE;
+	stream->res = NULL;
 
 	if (stream->context) {
 		zend_hash_apply_with_argument(&EG(regular_list),
-				(apply_func_arg_t) _php_stream_release_context,
+				_php_stream_release_context,
 				stream->context TSRMLS_CC);
 		stream->context = NULL;
 	}
@@ -116,36 +117,32 @@ PHPAPI php_stream *php_stream_encloses(php_stream *enclosing, php_stream *enclos
 
 PHPAPI int php_stream_from_persistent_id(const char *persistent_id, php_stream **stream TSRMLS_DC)
 {
-	zend_rsrc_list_entry *le;
+	zend_resource *le;
 
-	if (zend_hash_find(&EG(persistent_list), (char*)persistent_id, strlen(persistent_id)+1, (void*) &le) == SUCCESS) {
-		if (Z_TYPE_P(le) == le_pstream) {
+	if ((le = zend_hash_str_find_ptr(&EG(persistent_list), persistent_id, strlen(persistent_id))) != NULL) {
+		if (le->type == le_pstream) {
 			if (stream) {
 				HashPosition pos;
-				zend_rsrc_list_entry *regentry;
-				ulong index = -1; /* intentional */
+				zend_resource *regentry;
 
 				/* see if this persistent resource already has been loaded to the
 				 * regular list; allowing the same resource in several entries in the
 				 * regular list causes trouble (see bug #54623) */
 				zend_hash_internal_pointer_reset_ex(&EG(regular_list), &pos);
-				while (zend_hash_get_current_data_ex(&EG(regular_list),
-						(void **)&regentry, &pos) == SUCCESS) {
+				while ((regentry = zend_hash_get_current_data_ptr_ex(&EG(regular_list), &pos)) != NULL) {
 					if (regentry->ptr == le->ptr) {
-						zend_hash_get_current_key_ex(&EG(regular_list), NULL, NULL,
-							&index, 0, &pos);
 						break;
 					}
 					zend_hash_move_forward_ex(&EG(regular_list), &pos);
 				}
 				
 				*stream = (php_stream*)le->ptr;
-				if (index == -1) { /* not found in regular list */
-					le->refcount++;
-					(*stream)->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, *stream, le_pstream);
+				if (!regentry) { /* not found in regular list */
+					GC_REFCOUNT(le)++;
+					(*stream)->res = ZEND_REGISTER_RESOURCE(NULL, *stream, le_pstream);
 				} else {
-					regentry->refcount++;
-					(*stream)->rsrc_id = index;
+					GC_REFCOUNT(regentry)++;
+					(*stream)->res = regentry;
 				}
 			}
 			return PHP_STREAM_PERSISTENT_SUCCESS;
@@ -159,13 +156,10 @@ PHPAPI int php_stream_from_persistent_id(const char *persistent_id, php_stream *
 
 static zend_llist *php_get_wrapper_errors_list(php_stream_wrapper *wrapper TSRMLS_DC)
 {
-    zend_llist *list = NULL;
     if (!FG(wrapper_errors)) {
         return NULL;
     } else {
-        zend_hash_find(FG(wrapper_errors), (const char*)&wrapper,
-            sizeof wrapper, (void**)&list);
-        return list;
+        return (zend_llist*) zend_hash_str_find_ptr(FG(wrapper_errors), (const char*)&wrapper, sizeof(wrapper));
     }
 }
 
@@ -237,7 +231,7 @@ void php_stream_display_wrapper_errors(php_stream_wrapper *wrapper, const char *
 void php_stream_tidy_wrapper_error_log(php_stream_wrapper *wrapper TSRMLS_DC)
 {
 	if (wrapper && FG(wrapper_errors)) {
-		zend_hash_del(FG(wrapper_errors), (const char*)&wrapper, sizeof wrapper);
+		zend_hash_str_del(FG(wrapper_errors), (const char*)&wrapper, sizeof(wrapper));
 	}
 }
 
@@ -246,6 +240,12 @@ static void wrapper_error_dtor(void *error)
 	efree(*(char**)error);
 }
 
+static void wrapper_list_dtor(zval *item) {
+	zend_llist *list = (zend_llist*)Z_PTR_P(item);
+	zend_llist_destroy(list);
+	efree(list);
+}
+
 PHPAPI void php_stream_wrapper_log_error(php_stream_wrapper *wrapper, int options TSRMLS_DC, const char *fmt, ...)
 {
 	va_list args;
@@ -262,18 +262,16 @@ PHPAPI void php_stream_wrapper_log_error(php_stream_wrapper *wrapper, int option
 		zend_llist *list = NULL;
 		if (!FG(wrapper_errors)) {
 			ALLOC_HASHTABLE(FG(wrapper_errors));
-			zend_hash_init(FG(wrapper_errors), 8, NULL,
-					(dtor_func_t)zend_llist_destroy, 0);
+			zend_hash_init(FG(wrapper_errors), 8, NULL, wrapper_list_dtor, 0);
 		} else {
-			zend_hash_find(FG(wrapper_errors), (const char*)&wrapper,
-				sizeof wrapper, (void**)&list);
+			list = zend_hash_str_find_ptr(FG(wrapper_errors), (const char*)&wrapper, sizeof(wrapper));
 		}
 
 		if (!list) {
 			zend_llist new_list;
-			zend_llist_init(&new_list, sizeof buffer, wrapper_error_dtor, 0);
-			zend_hash_update(FG(wrapper_errors), (const char*)&wrapper,
-				sizeof wrapper, &new_list, sizeof new_list, (void**)&list);
+			zend_llist_init(&new_list, sizeof(buffer), wrapper_error_dtor, 0);
+			list = zend_hash_str_update_mem(FG(wrapper_errors), (const char*)&wrapper, 
+					sizeof(wrapper), &new_list, sizeof(new_list));
 		}
 
 		/* append to linked list */
@@ -315,27 +313,23 @@ fprintf(stderr, "stream_alloc: %s:%p persistent=%s\n", ops->label, ret, persiste
 	}
 
 	if (persistent_id) {
-		zend_rsrc_list_entry le;
+		zval tmp;
 
-		Z_TYPE(le) = le_pstream;
-		le.ptr = ret;
-		le.refcount = 0;
-
-		if (FAILURE == zend_hash_update(&EG(persistent_list), (char *)persistent_id,
-					strlen(persistent_id) + 1,
-					(void *)&le, sizeof(le), NULL)) {
+		ZVAL_NEW_PERSISTENT_RES(&tmp, -1, ret, le_pstream);
 
+		if (NULL == zend_hash_str_update(&EG(persistent_list), persistent_id,
+					strlen(persistent_id), &tmp)) {
 			pefree(ret, 1);
 			return NULL;
 		}
 	}
 
-	ret->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, ret, persistent_id ? le_pstream : le_stream);
+	ret->res = ZEND_REGISTER_RESOURCE(NULL, ret, persistent_id ? le_pstream : le_stream);
 	strlcpy(ret->mode, mode, sizeof(ret->mode));
 
 	ret->wrapper          = NULL;
 	ret->wrapperthis      = NULL;
-	ret->wrapperdata      = NULL;
+	ZVAL_UNDEF(&ret->wrapperdata);
 	ret->stdiocast        = NULL;
 	ret->orig_path        = NULL;
 	ret->context          = NULL;
@@ -374,8 +368,9 @@ static const char *_php_stream_pretty_free_options(int close_options, char *out)
 }
 #endif
 
-static int _php_stream_free_persistent(zend_rsrc_list_entry *le, void *pStream TSRMLS_DC)
+static int _php_stream_free_persistent(zval *zv, void *pStream TSRMLS_DC)
 {
+	zend_resource *le = Z_RES_P(zv);
 	return le->ptr == pStream;
 }
 
@@ -467,7 +462,9 @@ fprintf(stderr, "stream_free: %s:%p[%s] preserve_handle=%d release_cast=%d remov
 		 * the resource list, otherwise the resource will point to invalid memory.
 		 * In any case, let's always completely delete it from the resource list,
 		 * not only when PHP_STREAM_FREE_RELEASE_STREAM is set */
-		while (zend_list_delete(stream->rsrc_id) == SUCCESS) {}
+//???		while (zend_list_delete(stream->res) == SUCCESS) {}
+//???		stream->res->gc.refcount = 0;
+		zend_list_close(stream->res);
 	}
 
 	if (close_options & PHP_STREAM_FREE_CALL_DTOR) {
@@ -507,9 +504,9 @@ fprintf(stderr, "stream_free: %s:%p[%s] preserve_handle=%d release_cast=%d remov
 			stream->wrapper = NULL;
 		}
 
-		if (stream->wrapperdata) {
+		if (Z_TYPE(stream->wrapperdata) != IS_UNDEF) {
 			zval_ptr_dtor(&stream->wrapperdata);
-			stream->wrapperdata = NULL;
+			ZVAL_UNDEF(&stream->wrapperdata);
 		}
 
 		if (stream->readbuf) {
@@ -559,7 +556,7 @@ fprintf(stderr, "stream_free: %s:%p[%s] preserve_handle=%d release_cast=%d remov
 	}
 
 	if (context) {
-		zend_list_delete(context->rsrc_id);
+		zend_list_delete(context->res);
 	}
 
 	return ret;
@@ -689,7 +686,7 @@ static void php_stream_fill_read_buffer(php_stream *stream, size_t size TSRMLS_D
 						stream->is_persistent);
 			}
 
-			justread = stream->ops->read(stream, stream->readbuf + stream->writepos,
+			justread = stream->ops->read(stream, (char*)stream->readbuf + stream->writepos,
 					stream->readbuflen - stream->writepos
 					TSRMLS_CC);
 
@@ -791,7 +788,7 @@ PHPAPI int _php_stream_putc(php_stream *stream, int c TSRMLS_DC)
 {
 	unsigned char buf = c;
 
-	if (php_stream_write(stream, &buf, 1) > 0) {
+	if (php_stream_write(stream, (char*)&buf, 1) > 0) {
 		return 1;
 	}
 	return EOF;
@@ -839,18 +836,18 @@ PHPAPI int _php_stream_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_D
 	return (stream->ops->stat)(stream, ssb TSRMLS_CC);
 }
 
-PHPAPI const char *php_stream_locate_eol(php_stream *stream, const char *buf, size_t buf_len TSRMLS_DC)
+PHPAPI const char *php_stream_locate_eol(php_stream *stream, zend_string *buf TSRMLS_DC)
 {
 	size_t avail;
 	const char *cr, *lf, *eol = NULL;
 	const char *readptr;
 
 	if (!buf) {
-		readptr = stream->readbuf + stream->readpos;
+		readptr = (char*)stream->readbuf + stream->readpos;
 		avail = stream->writepos - stream->readpos;
 	} else {
-		readptr = buf;
-		avail = buf_len;
+		readptr = buf->val;
+		avail = buf->len;
 	}
 
 	/* Look for EOL */
@@ -918,8 +915,8 @@ PHPAPI char *_php_stream_get_line(php_stream *stream, char *buf, size_t maxlen,
 			const char *eol;
 			int done = 0;
 
-			readptr = stream->readbuf + stream->readpos;
-			eol = php_stream_locate_eol(stream, NULL, 0 TSRMLS_CC);
+			readptr = (char*)stream->readbuf + stream->readpos;
+			eol = php_stream_locate_eol(stream, NULL TSRMLS_CC);
 
 			if (eol) {
 				cpysz = eol - readptr + 1;
@@ -1022,13 +1019,13 @@ static const char *_php_stream_search_delim(php_stream *stream,
 	}
 }
 
-PHPAPI char *php_stream_get_record(php_stream *stream, size_t maxlen, size_t *returned_len, const char *delim, size_t delim_len TSRMLS_DC)
+PHPAPI zend_string *php_stream_get_record(php_stream *stream, size_t maxlen, const char *delim, size_t delim_len TSRMLS_DC)
 {
-	char	*ret_buf;				/* returned buffer */
+	zend_string	*ret_buf;				/* returned buffer */
 	const char *found_delim = NULL;
 	size_t	buffered_len,
 			tent_ret_len;			/* tentative returned length */
-	int		has_delim	 = delim_len > 0;
+	int	has_delim = delim_len > 0;
 
 	if (maxlen == 0) {
 		return NULL;
@@ -1097,16 +1094,16 @@ PHPAPI char *php_stream_get_record(php_stream *stream, size_t maxlen, size_t *re
 		}
 	}
 
-	ret_buf = emalloc(tent_ret_len + 1);
+	ret_buf = STR_ALLOC(tent_ret_len, 0);
 	/* php_stream_read will not call ops->read here because the necessary
 	 * data is guaranteedly buffered */
-	*returned_len = php_stream_read(stream, ret_buf, tent_ret_len);
+	ret_buf->len = php_stream_read(stream, ret_buf->val, tent_ret_len);
 
 	if (found_delim) {
 		stream->readpos += delim_len;
 		stream->position += delim_len;
 	}
-	ret_buf[*returned_len] = '\0';
+	ret_buf->val[ret_buf->len] = '\0';
 	return ret_buf;
 }
 
@@ -1422,7 +1419,7 @@ PHPAPI size_t _php_stream_passthru(php_stream * stream STREAMS_DC TSRMLS_DC)
 }
 
 
-PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen, int persistent STREAMS_DC TSRMLS_DC)
+PHPAPI zend_string *_php_stream_copy_to_mem(php_stream *src, size_t maxlen, int persistent STREAMS_DC TSRMLS_DC)
 {
 	size_t ret = 0;
 	char *ptr;
@@ -1430,9 +1427,10 @@ PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen
 	int step = CHUNK_SIZE;
 	int min_room = CHUNK_SIZE / 4;
 	php_stream_statbuf ssbuf;
+	zend_string *result;
 
 	if (maxlen == 0) {
-		return 0;
+		return STR_EMPTY_ALLOC();
 	}
 
 	if (maxlen == PHP_STREAM_COPY_ALL) {
@@ -1440,7 +1438,8 @@ PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen
 	}
 
 	if (maxlen > 0) {
-		ptr = *buf = pemalloc_rel_orig(maxlen + 1, persistent);
+		result = STR_ALLOC(maxlen, persistent);
+		ptr = result->val;
 		while ((len < maxlen) && !php_stream_eof(src)) {
 			ret = php_stream_read(src, ptr, maxlen - len);
 			if (!ret) {
@@ -1451,11 +1450,12 @@ PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen
 		}
 		if (len) {
 			*ptr = '\0';
+			result->len = len;
 		} else {
-			pefree(*buf, persistent);
-			*buf = NULL;
+			STR_FREE(result);
+			result = NULL;
 		}
-		return len;
+		return result;
 	}
 
 	/* avoid many reallocs by allocating a good sized chunk to begin with, if
@@ -1470,26 +1470,28 @@ PHPAPI size_t _php_stream_copy_to_mem(php_stream *src, char **buf, size_t maxlen
 		max_len = step;
 	}
 
-	ptr = *buf = pemalloc_rel_orig(max_len, persistent);
+	result = STR_ALLOC(max_len, persistent);
+	ptr = result->val;
 
-	while((ret = php_stream_read(src, ptr, max_len - len)))	{
+	while ((ret = php_stream_read(src, ptr, max_len - len)))	{
 		len += ret;
 		if (len + min_room >= max_len) {
-			*buf = perealloc_rel_orig(*buf, max_len + step, persistent);
+			result = STR_REALLOC(result, max_len + step, persistent);
 			max_len += step;
-			ptr = *buf + len;
+			ptr = result->val + len;
 		} else {
 			ptr += ret;
 		}
 	}
 	if (len) {
-		*buf = perealloc_rel_orig(*buf, len + 1, persistent);
-		(*buf)[len] = '\0';
+		result = STR_REALLOC(result, len, persistent);
+		result->val[len] = '\0';
 	} else {
-		pefree(*buf, persistent);
-		*buf = NULL;
+		STR_FREE(result);
+		result = NULL;
 	}
-	return len;
+
+	return result;
 }
 
 /* Returns SUCCESS/FAILURE and sets *len to the number of bytes moved */
@@ -1613,14 +1615,14 @@ PHPAPI size_t _php_stream_copy_to_stream(php_stream *src, php_stream *dest, size
 
 /* {{{ wrapper init and registration */
 
-static void stream_resource_regular_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void stream_resource_regular_dtor(zend_resource *rsrc TSRMLS_DC)
 {
 	php_stream *stream = (php_stream*)rsrc->ptr;
 	/* set the return value for pclose */
 	FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
 }
 
-static void stream_resource_persistent_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void stream_resource_persistent_dtor(zend_resource *rsrc TSRMLS_DC)
 {
 	php_stream *stream = (php_stream*)rsrc->ptr;
 	FG(pclose_ret) = php_stream_free(stream, PHP_STREAM_FREE_CLOSE | PHP_STREAM_FREE_RSRC_DTOR);
@@ -1655,14 +1657,11 @@ int php_init_stream_wrappers(int module_number TSRMLS_DC)
 	/* Filters are cleaned up by the streams they're attached to */
 	le_stream_filter = zend_register_list_destructors_ex(NULL, NULL, "stream filter", module_number);
 
-	return (
-			zend_hash_init(&url_stream_wrappers_hash, 0, NULL, NULL, 1) == SUCCESS
-			&&
-			zend_hash_init(php_get_stream_filters_hash_global(), 0, NULL, NULL, 1) == SUCCESS
-			&&
-			zend_hash_init(php_stream_xport_get_hash(), 0, NULL, NULL, 1) == SUCCESS
-			&&
-			php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
+	zend_hash_init(&url_stream_wrappers_hash, 8, NULL, NULL, 1);
+	zend_hash_init(php_get_stream_filters_hash_global(), 8, NULL, NULL, 1);
+	zend_hash_init(php_stream_xport_get_hash(), 8, NULL, NULL, 1);
+
+	return (php_stream_xport_register("tcp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
 			&&
 			php_stream_xport_register("udp", php_stream_generic_socket_factory TSRMLS_CC) == SUCCESS
 #if defined(AF_UNIX) && !(defined(PHP_WIN32) || defined(__riscos__) || defined(NETWARE))
@@ -1710,21 +1709,19 @@ PHPAPI int php_register_url_stream_wrapper(const char *protocol, php_stream_wrap
 		return FAILURE;
 	}
 
-	return zend_hash_add(&url_stream_wrappers_hash, protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
+	return zend_hash_str_add_ptr(&url_stream_wrappers_hash, protocol, protocol_len, wrapper) ? SUCCESS : FAILURE;
 }
 
 PHPAPI int php_unregister_url_stream_wrapper(const char *protocol TSRMLS_DC)
 {
-	return zend_hash_del(&url_stream_wrappers_hash, protocol, strlen(protocol) + 1);
+	return zend_hash_str_del(&url_stream_wrappers_hash, protocol, strlen(protocol));
 }
 
 static void clone_wrapper_hash(TSRMLS_D)
 {
-	php_stream_wrapper *tmp;
-
 	ALLOC_HASHTABLE(FG(stream_wrappers));
 	zend_hash_init(FG(stream_wrappers), zend_hash_num_elements(&url_stream_wrappers_hash), NULL, NULL, 1);
-	zend_hash_copy(FG(stream_wrappers), &url_stream_wrappers_hash, NULL, &tmp, sizeof(tmp));
+	zend_hash_copy(FG(stream_wrappers), &url_stream_wrappers_hash, NULL);
 }
 
 /* API for registering VOLATILE wrappers */
@@ -1740,7 +1737,7 @@ PHPAPI int php_register_url_stream_wrapper_volatile(const char *protocol, php_st
 		clone_wrapper_hash(TSRMLS_C);
 	}
 
-	return zend_hash_add(FG(stream_wrappers), protocol, protocol_len + 1, &wrapper, sizeof(wrapper), NULL);
+	return zend_hash_str_add_ptr(FG(stream_wrappers), protocol, protocol_len, wrapper) ? SUCCESS : FAILURE;
 }
 
 PHPAPI int php_unregister_url_stream_wrapper_volatile(const char *protocol TSRMLS_DC)
@@ -1749,7 +1746,7 @@ PHPAPI int php_unregister_url_stream_wrapper_volatile(const char *protocol TSRML
 		clone_wrapper_hash(TSRMLS_C);
 	}
 
-	return zend_hash_del(FG(stream_wrappers), protocol, strlen(protocol) + 1);
+	return zend_hash_str_del(FG(stream_wrappers), protocol, strlen(protocol));
 }
 /* }}} */
 
@@ -1757,7 +1754,7 @@ PHPAPI int php_unregister_url_stream_wrapper_volatile(const char *protocol TSRML
 PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const char **path_for_open, int options TSRMLS_DC)
 {
 	HashTable *wrapper_hash = (FG(stream_wrappers) ? FG(stream_wrappers) : &url_stream_wrappers_hash);
-	php_stream_wrapper **wrapperpp = NULL;
+	php_stream_wrapper *wrapper = NULL;
 	const char *p, *protocol = NULL;
 	int n = 0;
 
@@ -1784,9 +1781,9 @@ PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const
 
 	if (protocol) {
 		char *tmp = estrndup(protocol, n);
-		if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
+		if (NULL == (wrapper = zend_hash_str_find_ptr(wrapper_hash, (char*)tmp, n))) {
 			php_strtolower(tmp, n);
-			if (FAILURE == zend_hash_find(wrapper_hash, (char*)tmp, n + 1, (void**)&wrapperpp)) {
+			if (NULL == (wrapper = zend_hash_str_find_ptr(wrapper_hash, (char*)tmp, n))) {
 				char wrapper_name[32];
 
 				if (n >= sizeof(wrapper_name)) {
@@ -1796,7 +1793,7 @@ PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const
 
 				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to find the wrapper \"%s\" - did you forget to enable it when you configured PHP?", wrapper_name);
 
-				wrapperpp = NULL;
+				wrapper = NULL;
 				protocol = NULL;
 			}
 		}
@@ -1846,14 +1843,14 @@ PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const
 		if (FG(stream_wrappers)) {
 		/* The file:// wrapper may have been disabled/overridden */
 
-			if (wrapperpp) {
+			if (wrapper) {
 				/* It was found so go ahead and provide it */
-				return *wrapperpp;
+				return wrapper;
 			}
 
 			/* Check again, the original check might have not known the protocol name */
-			if (zend_hash_find(wrapper_hash, "file", sizeof("file"), (void**)&wrapperpp) == SUCCESS) {
-				return *wrapperpp;
+			if ((wrapper = zend_hash_str_find_ptr(wrapper_hash, "file", sizeof("file")-1)) != NULL) {
+				return wrapper;
 			}
 
 			if (options & REPORT_ERRORS) {
@@ -1865,7 +1862,7 @@ PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const
 		return plain_files_wrapper;
 	}
 
-	if (wrapperpp && (*wrapperpp)->is_url &&
+	if (wrapper && wrapper->is_url &&
         (options & STREAM_DISABLE_URL_PROTECTION) == 0 &&
 	    (!PG(allow_url_fopen) ||
 	     (((options & STREAM_OPEN_FOR_INCLUDE) ||
@@ -1883,7 +1880,7 @@ PHPAPI php_stream_wrapper *php_stream_locate_url_wrapper(const char *path, const
 		return NULL;
 	}
 
-	return *wrapperpp;
+	return wrapper;
 }
 /* }}} */
 
@@ -2168,10 +2165,10 @@ PHPAPI php_stream_context *php_stream_context_set(php_stream *stream, php_stream
 	stream->context = context;
 
 	if (context) {
-		zend_list_addref(context->rsrc_id);
+		GC_REFCOUNT(context->res)++;
 	}
 	if (oldcontext) {
-		zend_list_delete(oldcontext->rsrc_id);
+		zend_list_delete(oldcontext->res);
 	}
 
 	return oldcontext;
@@ -2186,9 +2183,9 @@ PHPAPI void php_stream_notification_notify(php_stream_context *context, int noti
 
 PHPAPI void php_stream_context_free(php_stream_context *context)
 {
-	if (context->options) {
+	if (Z_TYPE(context->options) != IS_UNDEF) {
 		zval_ptr_dtor(&context->options);
-		context->options = NULL;
+		ZVAL_UNDEF(&context->options);
 	}
 	if (context->notifier) {
 		php_stream_notification_free(context->notifier);
@@ -2203,10 +2200,9 @@ PHPAPI php_stream_context *php_stream_context_alloc(TSRMLS_D)
 
 	context = ecalloc(1, sizeof(php_stream_context));
 	context->notifier = NULL;
-	MAKE_STD_ZVAL(context->options);
-	array_init(context->options);
+	array_init(&context->options);
 
-	context->rsrc_id = ZEND_REGISTER_RESOURCE(NULL, context, php_le_stream_context(TSRMLS_C));
+	context->res = ZEND_REGISTER_RESOURCE(NULL, context, php_le_stream_context(TSRMLS_C));
 	return context;
 }
 
@@ -2223,65 +2219,61 @@ PHPAPI void php_stream_notification_free(php_stream_notifier *notifier)
 	efree(notifier);
 }
 
-PHPAPI int php_stream_context_get_option(php_stream_context *context,
-		const char *wrappername, const char *optionname, zval ***optionvalue)
+PHPAPI zval *php_stream_context_get_option(php_stream_context *context,
+		const char *wrappername, const char *optionname)
 {
-	zval **wrapperhash;
+	zval *wrapperhash;
 
-	if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
-		return FAILURE;
+	if (NULL == (wrapperhash = zend_hash_str_find(Z_ARRVAL(context->options), wrappername, strlen(wrappername)))) {
+		return NULL;
 	}
-	return zend_hash_find(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)optionvalue);
+	return zend_hash_str_find(Z_ARRVAL_P(wrapperhash), optionname, strlen(optionname));
 }
 
 PHPAPI int php_stream_context_set_option(php_stream_context *context,
 		const char *wrappername, const char *optionname, zval *optionvalue)
 {
-	zval **wrapperhash;
-	zval *category, *copied_val;
+	zval *wrapperhash;
+	zval category, copied_val;
 
-	ALLOC_INIT_ZVAL(copied_val);
-	*copied_val = *optionvalue;
-	zval_copy_ctor(copied_val);
-	INIT_PZVAL(copied_val);
+	ZVAL_DUP(&copied_val, optionvalue);
 
-	if (FAILURE == zend_hash_find(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&wrapperhash)) {
-		MAKE_STD_ZVAL(category);
-		array_init(category);
-		if (FAILURE == zend_hash_update(Z_ARRVAL_P(context->options), (char*)wrappername, strlen(wrappername)+1, (void**)&category, sizeof(zval *), NULL)) {
+	if (NULL == (wrapperhash = zend_hash_str_find(Z_ARRVAL(context->options), wrappername, strlen(wrappername)))) {
+		array_init(&category);
+		if (NULL == zend_hash_str_update(Z_ARRVAL(context->options), (char*)wrappername, strlen(wrappername), &category)) {
 			return FAILURE;
 		}
 
 		wrapperhash = &category;
 	}
-	return zend_hash_update(Z_ARRVAL_PP(wrapperhash), (char*)optionname, strlen(optionname)+1, (void**)&copied_val, sizeof(zval *), NULL);
+	return zend_hash_str_update(Z_ARRVAL_P(wrapperhash), optionname, strlen(optionname), &copied_val) ? SUCCESS : FAILURE;
 }
 /* }}} */
 
 /* {{{ php_stream_dirent_alphasort
  */
-PHPAPI int php_stream_dirent_alphasort(const char **a, const char **b)
+PHPAPI int php_stream_dirent_alphasort(const zend_string **a, const zend_string **b)
 {
-	return strcoll(*a, *b);
+	return strcoll((*a)->val, (*b)->val);
 }
 /* }}} */
 
 /* {{{ php_stream_dirent_alphasortr
  */
-PHPAPI int php_stream_dirent_alphasortr(const char **a, const char **b)
+PHPAPI int php_stream_dirent_alphasortr(const zend_string **a, const zend_string **b)
 {
-	return strcoll(*b, *a);
+	return strcoll((*b)->val, (*a)->val);
 }
 /* }}} */
 
 /* {{{ php_stream_scandir
  */
-PHPAPI int _php_stream_scandir(const char *dirname, char **namelist[], int flags, php_stream_context *context,
-			  int (*compare) (const char **a, const char **b) TSRMLS_DC)
+PHPAPI int _php_stream_scandir(const char *dirname, zend_string **namelist[], int flags, php_stream_context *context,
+			  int (*compare) (const zend_string **a, const zend_string **b) TSRMLS_DC)
 {
 	php_stream *stream;
 	php_stream_dirent sdp;
-	char **vector = NULL;
+	zend_string **vector = NULL;
 	unsigned int vector_size = 0;
 	unsigned int nfiles = 0;
 
@@ -2307,10 +2299,10 @@ PHPAPI int _php_stream_scandir(const char *dirname, char **namelist[], int flags
 				}
 				vector_size *= 2;
 			}
-			vector = (char **) safe_erealloc(vector, vector_size, sizeof(char *), 0);
+			vector = (zend_string **) safe_erealloc(vector, vector_size, sizeof(char *), 0);
 		}
 
-		vector[nfiles] = estrdup(sdp.d_name);
+		vector[nfiles] = STR_INIT(sdp.d_name, strlen(sdp.d_name), 0);
 
 		nfiles++;
 		if(vector_size < 10 || nfiles == 0) {
@@ -2325,7 +2317,7 @@ PHPAPI int _php_stream_scandir(const char *dirname, char **namelist[], int flags
 	*namelist = vector;
 
 	if (nfiles > 0 && compare) {
-		qsort(*namelist, nfiles, sizeof(char *), (int(*)(const void *, const void *))compare);
+		qsort(*namelist, nfiles, sizeof(zend_string *), (int(*)(const void *, const void *))compare);
 	}
 	return nfiles;
 }
diff --git a/main/streams/transports.c b/main/streams/transports.c
index f54e8e6cdf..7ede9407e6 100644
--- a/main/streams/transports.c
+++ b/main/streams/transports.c
@@ -31,12 +31,12 @@ PHPAPI HashTable *php_stream_xport_get_hash(void)
 
 PHPAPI int php_stream_xport_register(const char *protocol, php_stream_transport_factory factory TSRMLS_DC)
 {
-	return zend_hash_update(&xport_hash, protocol, strlen(protocol) + 1, &factory, sizeof(factory), NULL);
+	return zend_hash_str_update_ptr(&xport_hash, protocol, strlen(protocol), factory) ? SUCCESS : FAILURE;
 }
 
 PHPAPI int php_stream_xport_unregister(const char *protocol TSRMLS_DC)
 {
-	return zend_hash_del(&xport_hash, protocol, strlen(protocol) + 1);
+	return zend_hash_str_del(&xport_hash, protocol, strlen(protocol));
 }
 
 #define ERR_REPORT(out_err, fmt, arg) \
@@ -58,7 +58,7 @@ PHPAPI php_stream *_php_stream_xport_create(const char *name, size_t namelen, in
 		STREAMS_DC TSRMLS_DC)
 {
 	php_stream *stream = NULL;
-	php_stream_transport_factory *factory = NULL;
+	php_stream_transport_factory factory;
 	const char *p, *protocol = NULL;
 	int n = 0, failed = 0;
 	char *error_text = NULL;
@@ -107,7 +107,7 @@ PHPAPI php_stream *_php_stream_xport_create(const char *name, size_t namelen, in
 
 	if (protocol) {
 		char *tmp = estrndup(protocol, n);
-		if (FAILURE == zend_hash_find(&xport_hash, (char*)tmp, n + 1, (void**)&factory)) {
+		if (NULL == (factory = zend_hash_str_find_ptr(&xport_hash, tmp, n))) {
 			char wrapper_name[32];
 
 			if (n >= sizeof(wrapper_name))
@@ -129,7 +129,7 @@ PHPAPI php_stream *_php_stream_xport_create(const char *name, size_t namelen, in
 		return NULL;
 	}
 
-	stream = (*factory)(protocol, n,
+	stream = (factory)(protocol, n,
 			(char*)name, namelen, persistent_id, options, flags, timeout,
 			context STREAMS_REL_CC TSRMLS_CC);
 
@@ -157,16 +157,16 @@ PHPAPI php_stream *_php_stream_xport_create(const char *name, size_t namelen, in
 					ERR_RETURN(error_string, error_text, "bind() failed: %s");
 					failed = 1;
 				} else if (flags & STREAM_XPORT_LISTEN) {
-					zval **zbacklog = NULL;
+					zval *zbacklog = NULL;
 					int backlog = 32;
 					
-					if (stream->context && php_stream_context_get_option(stream->context, "socket", "backlog", &zbacklog) == SUCCESS) {
-						zval *ztmp = *zbacklog;
+					if (stream->context && (zbacklog = php_stream_context_get_option(stream->context, "socket", "backlog")) != NULL) {
+						zval *ztmp = zbacklog;
 						
-						convert_to_long_ex(&ztmp);
+						convert_to_long_ex(ztmp);
 						backlog = Z_LVAL_P(ztmp);
-						if (ztmp != *zbacklog) {
-							zval_ptr_dtor(&ztmp);
+						if (ztmp != zbacklog) {
+							zval_ptr_dtor(ztmp);
 						}
 					}
 					
diff --git a/main/streams/userspace.c b/main/streams/userspace.c
index 7d958729e5..7c6aa92316 100644
--- a/main/streams/userspace.c
+++ b/main/streams/userspace.c
@@ -70,7 +70,7 @@ static php_stream_wrapper_ops user_stream_wops = {
 };
 
 
-static void stream_wrapper_dtor(zend_rsrc_list_entry *rsrc TSRMLS_DC)
+static void stream_wrapper_dtor(zend_resource *rsrc TSRMLS_DC)
 {
 	struct php_user_stream_wrapper * uwrap = (struct php_user_stream_wrapper*)rsrc->ptr;
 
@@ -120,7 +120,7 @@ PHP_MINIT_FUNCTION(user_streams)
 
 struct _php_userstream_data {
 	struct php_user_stream_wrapper * wrapper;
-	zval * object;
+	zval object;
 };
 typedef struct _php_userstream_data php_userstream_data_t;
 
@@ -281,18 +281,15 @@ typedef struct _php_userstream_data php_userstream_data_t;
 
 	}}} **/
 
-static zval *user_stream_create_object(struct php_user_stream_wrapper *uwrap, php_stream_context *context TSRMLS_DC)
+static void user_stream_create_object(struct php_user_stream_wrapper *uwrap, php_stream_context *context, zval *object TSRMLS_DC)
 {
-	zval *object;
 	/* create an instance of our class */
-	ALLOC_ZVAL(object);
 	object_init_ex(object, uwrap->ce);
-	Z_SET_REFCOUNT_P(object, 1);
-	Z_SET_ISREF_P(object);
+//???	Z_SET_ISREF_P(object);
 
 	if (context) {
-		add_property_resource(object, "context", context->rsrc_id);
-		zend_list_addref(context->rsrc_id);
+		add_property_resource(object, "context", context->res);
+		GC_REFCOUNT(context->res)++;
 	} else {
 		add_property_null(object, "context");
 	}
@@ -300,14 +297,14 @@ static zval *user_stream_create_object(struct php_user_stream_wrapper *uwrap, ph
 	if (uwrap->ce->constructor) {
 		zend_fcall_info fci;
 		zend_fcall_info_cache fcc;
-		zval *retval_ptr;
+		zval retval;
 
 		fci.size = sizeof(fci);
 		fci.function_table = &uwrap->ce->function_table;
-		fci.function_name = NULL;
+		ZVAL_UNDEF(&fci.function_name);
 		fci.symbol_table = NULL;
-		fci.object_ptr = object;
-		fci.retval_ptr_ptr = &retval_ptr;
+		fci.object = Z_OBJ_P(object);
+		fci.retval = &retval;
 		fci.param_count = 0;
 		fci.params = NULL;
 		fci.no_separation = 1;
@@ -316,20 +313,16 @@ static zval *user_stream_create_object(struct php_user_stream_wrapper *uwrap, ph
 		fcc.function_handler = uwrap->ce->constructor;
 		fcc.calling_scope = EG(scope);
 		fcc.called_scope = Z_OBJCE_P(object);
-		fcc.object_ptr = object;
+		fcc.object = Z_OBJ_P(object);
 
 		if (zend_call_function(&fci, &fcc TSRMLS_CC) == FAILURE) {
-			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute %s::%s()", uwrap->ce->name, uwrap->ce->constructor->common.function_name);
+			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Could not execute %s::%s()", uwrap->ce->name->val, uwrap->ce->constructor->common.function_name->val);
 			zval_dtor(object);
-			FREE_ZVAL(object);
-			return NULL;
+			ZVAL_UNDEF(object);
 		} else {
-			if (retval_ptr) {
-				zval_ptr_dtor(&retval_ptr);
-			}
+			zval_ptr_dtor(&retval);
 		}
 	}
-	return object;
 }
 
 static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char *filename, const char *mode,
@@ -337,8 +330,8 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char *
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
 	php_userstream_data_t *us;
-	zval *zfilename, *zmode, *zopened, *zoptions, *zretval = NULL, *zfuncname;
-	zval **args[4];
+	zval zretval, zfuncname;
+	zval args[4];
 	int call_result;
 	php_stream *stream = NULL;
 	zend_bool old_in_user_include;
@@ -364,8 +357,8 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char *
 	us = emalloc(sizeof(*us));
 	us->wrapper = uwrap;
 
-	us->object = user_stream_create_object(uwrap, context TSRMLS_CC);
-	if(us->object == NULL) {
+	user_stream_create_object(uwrap, context, &us->object TSRMLS_CC);
+	if (Z_TYPE(us->object) == IS_UNDEF) {
 		FG(user_stream_current_filename) = NULL;
 		PG(in_user_include) = old_in_user_include;
 		efree(us);
@@ -373,46 +366,31 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char *
 	}
 
 	/* call it's stream_open method - set up params first */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, filename, 1);
-	args[0] = &zfilename;
-
-	MAKE_STD_ZVAL(zmode);
-	ZVAL_STRING(zmode, mode, 1);
-	args[1] = &zmode;
-
-	MAKE_STD_ZVAL(zoptions);
-	ZVAL_LONG(zoptions, options);
-	args[2] = &zoptions;
+	ZVAL_STRING(&args[0], filename);
+	ZVAL_STRING(&args[1], mode);
+	ZVAL_LONG(&args[2], options);
+	ZVAL_NEW_REF(&args[3], &EG(uninitialized_zval));
 
-	MAKE_STD_ZVAL(zopened);
-	Z_SET_REFCOUNT_P(zopened, 1);
-	Z_SET_ISREF_P(zopened);
-	ZVAL_NULL(zopened);
-	args[3] = &zopened;
-
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_OPEN, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_OPEN);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
-			zfuncname,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+			&zfuncname,
 			&zretval,
 			4, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
+	if (call_result == SUCCESS && Z_TYPE(zretval) != IS_UNDEF && zval_is_true(&zretval)) {
 		/* the stream is now open! */
 		stream = php_stream_alloc_rel(&php_stream_userspace_ops, us, 0, mode);
 
 		/* if the opened path is set, copy it out */
-		if (Z_TYPE_P(zopened) == IS_STRING && opened_path) {
-			*opened_path = estrndup(Z_STRVAL_P(zopened), Z_STRLEN_P(zopened));
+		if (Z_ISREF(args[4]) && Z_TYPE_P(Z_REFVAL(args[4])) == IS_STRING && opened_path) {
+			*opened_path = estrndup(Z_STRVAL_P(Z_REFVAL(args[4])), Z_STRLEN_P(Z_REFVAL(args[4])));
 		}
 
 		/* set wrapper data to be a reference to our object */
-		stream->wrapperdata = us->object;
-		zval_add_ref(&stream->wrapperdata);
+		ZVAL_COPY(&stream->wrapperdata, &us->object);
 	} else {
 		php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_OPEN "\" call failed",
 			us->wrapper->classname);
@@ -421,16 +399,15 @@ static php_stream *user_wrapper_opener(php_stream_wrapper *wrapper, const char *
 	/* destroy everything else */
 	if (stream == NULL) {
 		zval_ptr_dtor(&us->object);
+		ZVAL_UNDEF(&us->object);
 		efree(us);
 	}
-	if (zretval)
-		zval_ptr_dtor(&zretval);
-
+	zval_ptr_dtor(&zretval);
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zopened);
-	zval_ptr_dtor(&zoptions);
-	zval_ptr_dtor(&zmode);
-	zval_ptr_dtor(&zfilename);
+	zval_ptr_dtor(&args[3]);
+	zval_ptr_dtor(&args[2]);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	FG(user_stream_current_filename) = NULL;
 
@@ -443,8 +420,8 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, const char
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
 	php_userstream_data_t *us;
-	zval *zfilename, *zoptions, *zretval = NULL, *zfuncname;
-	zval **args[2];
+	zval zretval, zfuncname;
+	zval args[2];
 	int call_result;
 	php_stream *stream = NULL;
 
@@ -458,39 +435,32 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, const char
 	us = emalloc(sizeof(*us));
 	us->wrapper = uwrap;
 
-	us->object = user_stream_create_object(uwrap, context TSRMLS_CC);
-	if(us->object == NULL) {
+	user_stream_create_object(uwrap, context, &us->object TSRMLS_CC);
+	if (Z_TYPE(us->object) == IS_UNDEF) {
 		FG(user_stream_current_filename) = NULL;
 		efree(us);
 		return NULL;
 	}
 
 	/* call it's dir_open method - set up params first */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, filename, 1);
-	args[0] = &zfilename;
+	ZVAL_STRING(&args[0], filename);
+	ZVAL_LONG(&args[1], options);
 
-	MAKE_STD_ZVAL(zoptions);
-	ZVAL_LONG(zoptions, options);
-	args[1] = &zoptions;
-
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_DIR_OPEN, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_DIR_OPEN);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
-			zfuncname,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+			&zfuncname,
 			&zretval,
 			2, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval != NULL && zval_is_true(zretval)) {
+	if (call_result == SUCCESS && Z_TYPE(zretval) != IS_UNDEF && zval_is_true(&zretval)) {
 		/* the stream is now open! */
 		stream = php_stream_alloc_rel(&php_stream_userspace_dir_ops, us, 0, mode);
 
 		/* set wrapper data to be a reference to our object */
-		stream->wrapperdata = us->object;
-		zval_add_ref(&stream->wrapperdata);
+		ZVAL_COPY(&stream->wrapperdata, &us->object);
 	} else {
 		php_stream_wrapper_log_error(wrapper, options TSRMLS_CC, "\"%s::" USERSTREAM_DIR_OPEN "\" call failed",
 			us->wrapper->classname);
@@ -499,14 +469,14 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, const char
 	/* destroy everything else */
 	if (stream == NULL) {
 		zval_ptr_dtor(&us->object);
+		ZVAL_UNDEF(&us->object);
 		efree(us);
 	}
-	if (zretval)
-		zval_ptr_dtor(&zretval);
+	zval_ptr_dtor(&zretval);
 
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zoptions);
-	zval_ptr_dtor(&zfilename);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	FG(user_stream_current_filename) = NULL;
 
@@ -518,43 +488,41 @@ static php_stream *user_wrapper_opendir(php_stream_wrapper *wrapper, const char
    Registers a custom URL protocol handler class */
 PHP_FUNCTION(stream_wrapper_register)
 {
-	char *protocol, *classname;
-	int protocol_len, classname_len;
+	zend_string *protocol, *classname;
 	struct php_user_stream_wrapper * uwrap;
-	int rsrc_id;
+	zend_resource *rsrc;
 	long flags = 0;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ss|l", &protocol, &protocol_len, &classname, &classname_len, &flags) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "SS|l", &protocol, &classname, &flags) == FAILURE) {
 		RETURN_FALSE;
 	}
 
 	uwrap = (struct php_user_stream_wrapper *)ecalloc(1, sizeof(*uwrap));
-	uwrap->protoname = estrndup(protocol, protocol_len);
-	uwrap->classname = estrndup(classname, classname_len);
+	uwrap->protoname = estrndup(protocol->val, protocol->len);
+	uwrap->classname = estrndup(classname->val, classname->len);
 	uwrap->wrapper.wops = &user_stream_wops;
 	uwrap->wrapper.abstract = uwrap;
 	uwrap->wrapper.is_url = ((flags & PHP_STREAM_IS_URL) != 0);
 
-	rsrc_id = ZEND_REGISTER_RESOURCE(NULL, uwrap, le_protocols);
+	rsrc = ZEND_REGISTER_RESOURCE(NULL, uwrap, le_protocols);
 
-	if (zend_lookup_class(uwrap->classname, classname_len, (zend_class_entry***)&uwrap->ce TSRMLS_CC) == SUCCESS) {
-		uwrap->ce = *(zend_class_entry**)uwrap->ce;
-		if (php_register_url_stream_wrapper_volatile(protocol, &uwrap->wrapper TSRMLS_CC) == SUCCESS) {
+	if ((uwrap->ce = zend_lookup_class(classname TSRMLS_CC)) != NULL) {
+		if (php_register_url_stream_wrapper_volatile(protocol->val, &uwrap->wrapper TSRMLS_CC) == SUCCESS) {
 			RETURN_TRUE;
 		} else {
 			/* We failed.  But why? */
-			if (zend_hash_exists(php_stream_get_url_stream_wrappers_hash(), protocol, protocol_len + 1)) {
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Protocol %s:// is already defined.", protocol);
+			if (zend_hash_exists(php_stream_get_url_stream_wrappers_hash(), protocol)) {
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Protocol %s:// is already defined.", protocol->val);
 			} else {
 				/* Hash doesn't exist so it must have been an invalid protocol scheme */
-				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid protocol scheme specified. Unable to register wrapper class %s to %s://", classname, protocol);
+				php_error_docref(NULL TSRMLS_CC, E_WARNING, "Invalid protocol scheme specified. Unable to register wrapper class %s to %s://", classname->val, protocol->val);
 			}
 		}
 	} else {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "class '%s' is undefined", classname);
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "class '%s' is undefined", classname->val);
 	}
 
-	zend_list_delete(rsrc_id);
+	zend_list_delete(rsrc);
 	RETURN_FALSE;
 }
 /* }}} */
@@ -584,34 +552,30 @@ PHP_FUNCTION(stream_wrapper_unregister)
 	Restore the original protocol handler, overriding if necessary */
 PHP_FUNCTION(stream_wrapper_restore)
 {
-	char *protocol;
-	int protocol_len;
-	php_stream_wrapper **wrapperpp = NULL, *wrapper;
+	zend_string *protocol;
+	php_stream_wrapper *wrapper;
 	HashTable *global_wrapper_hash;
 
-	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &protocol, &protocol_len) == FAILURE) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "S", &protocol) == FAILURE) {
 		RETURN_FALSE;
 	}
 
 	global_wrapper_hash = php_stream_get_url_stream_wrappers_hash_global();
 	if (php_stream_get_url_stream_wrappers_hash() == global_wrapper_hash) {
-		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s:// was never changed, nothing to restore", protocol);
+		php_error_docref(NULL TSRMLS_CC, E_NOTICE, "%s:// was never changed, nothing to restore", protocol->val);
 		RETURN_TRUE;
 	}
 
-	if ((zend_hash_find(global_wrapper_hash, protocol, protocol_len + 1, (void**)&wrapperpp) == FAILURE) || !wrapperpp) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// never existed, nothing to restore", protocol);
+	if ((wrapper = zend_hash_find_ptr(global_wrapper_hash, protocol)) == NULL) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s:// never existed, nothing to restore", protocol->val);
 		RETURN_FALSE;
 	}
 
-	/* next line might delete the pointer that wrapperpp points at, so deref it now */
-	wrapper = *wrapperpp;
-
 	/* A failure here could be okay given that the protocol might have been merely unregistered */
-	php_unregister_url_stream_wrapper_volatile(protocol TSRMLS_CC);
+	php_unregister_url_stream_wrapper_volatile(protocol->val TSRMLS_CC);
 
-	if (php_register_url_stream_wrapper_volatile(protocol, wrapper TSRMLS_CC) == FAILURE) {
-		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to restore original %s:// wrapper", protocol);
+	if (php_register_url_stream_wrapper_volatile(protocol->val, wrapper TSRMLS_CC) == FAILURE) {
+		php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unable to restore original %s:// wrapper", protocol->val);
 		RETURN_FALSE;
 	}
 
@@ -622,33 +586,31 @@ PHP_FUNCTION(stream_wrapper_restore)
 static size_t php_userstreamop_write(php_stream *stream, const char *buf, size_t count TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int call_result;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
-	zval **args[1];
-	zval *zbufptr;
+	zval args[1];
 	size_t didwrite = 0;
 
 	assert(us != NULL);
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_WRITE, sizeof(USERSTREAM_WRITE)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_WRITE, sizeof(USERSTREAM_WRITE)-1);
 
-	MAKE_STD_ZVAL(zbufptr);
-	ZVAL_STRINGL(zbufptr, (char*)buf, count, 1);;
-	args[0] = &zbufptr;
+	ZVAL_STRINGL(&args[0], (char*)buf, count);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			1, args,
 			0, NULL TSRMLS_CC);
-	zval_ptr_dtor(&zbufptr);
+	zval_ptr_dtor(&args[0]);
+	zval_ptr_dtor(&func_name);
 
 	didwrite = 0;
-	if (call_result == SUCCESS && retval != NULL) {
-		convert_to_long(retval);
-		didwrite = Z_LVAL_P(retval);
+	if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		convert_to_long(&retval);
+		didwrite = Z_LVAL(retval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_WRITE " is not implemented!",
 				us->wrapper->classname);
@@ -662,8 +624,7 @@ static size_t php_userstreamop_write(php_stream *stream, const char *buf, size_t
 		didwrite = count;
 	}
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
 
 	return didwrite;
 }
@@ -671,60 +632,56 @@ static size_t php_userstreamop_write(php_stream *stream, const char *buf, size_t
 static size_t php_userstreamop_read(php_stream *stream, char *buf, size_t count TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
-	zval **args[1];
+	zval retval;
+	zval args[1];
 	int call_result;
 	size_t didread = 0;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
-	zval *zcount;
 
 	assert(us != NULL);
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_READ, sizeof(USERSTREAM_READ)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_READ, sizeof(USERSTREAM_READ)-1);
 
-	MAKE_STD_ZVAL(zcount);
-	ZVAL_LONG(zcount, count);
-	args[0] = &zcount;
+	ZVAL_LONG(&args[0], count);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			1, args,
 			0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL) {
-		convert_to_string(retval);
-		didread = Z_STRLEN_P(retval);
+	if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+		convert_to_string(&retval);
+		didread = Z_STRLEN(retval);
 		if (didread > count) {
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " - read %ld bytes more data than requested (%ld read, %ld max) - excess data will be lost",
 					us->wrapper->classname, (long)(didread - count), (long)didread, (long)count);
 			didread = count;
 		}
 		if (didread > 0)
-			memcpy(buf, Z_STRVAL_P(retval), didread);
+			memcpy(buf, Z_STRVAL(retval), didread);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_READ " is not implemented!",
 				us->wrapper->classname);
 	}
-	zval_ptr_dtor(&zcount);
+	zval_ptr_dtor(&args[0]);
 
-	if (retval) {
-		zval_ptr_dtor(&retval);
-		retval = NULL;
-	}
+	zval_ptr_dtor(&retval);
+	ZVAL_UNDEF(&retval);
+	zval_ptr_dtor(&func_name);
 
 	/* since the user stream has no way of setting the eof flag directly, we need to ask it if we hit eof */
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL, 0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
+	if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF && zval_is_true(&retval)) {
 		stream->eof = 1;
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING,
@@ -734,10 +691,8 @@ static size_t php_userstreamop_read(php_stream *stream, char *buf, size_t count
 		stream->eof = 1;
 	}
 
-	if (retval) {
-		zval_ptr_dtor(&retval);
-		retval = NULL;
-	}
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	return didread;
 }
@@ -745,23 +700,24 @@ static size_t php_userstreamop_read(php_stream *stream, char *buf, size_t count
 static int php_userstreamop_close(php_stream *stream, int close_handle TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 
 	assert(us != NULL);
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_CLOSE, sizeof(USERSTREAM_CLOSE)-1);
 
 	call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL, 0, NULL TSRMLS_CC);
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	zval_ptr_dtor(&us->object);
+	ZVAL_UNDEF(&us->object);
 
 	efree(us);
 
@@ -771,27 +727,27 @@ static int php_userstreamop_close(php_stream *stream, int close_handle TSRMLS_DC
 static int php_userstreamop_flush(php_stream *stream TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int call_result;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 
 	assert(us != NULL);
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_FLUSH, sizeof(USERSTREAM_FLUSH)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_FLUSH, sizeof(USERSTREAM_FLUSH)-1);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL, 0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL && zval_is_true(retval))
+	if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF && zval_is_true(&retval))
 		call_result = 0;
 	else
 		call_result = -1;
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	return call_result;
 }
@@ -799,69 +755,61 @@ static int php_userstreamop_flush(php_stream *stream TSRMLS_DC)
 static int php_userstreamop_seek(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int call_result, ret;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
-	zval **args[2];
-	zval *zoffs, *zwhence;
+	zval args[2];
 
 	assert(us != NULL);
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_SEEK, sizeof(USERSTREAM_SEEK)-1, 0);
-
-	MAKE_STD_ZVAL(zoffs);
-	ZVAL_LONG(zoffs, offset);
-	args[0] = &zoffs;
+	ZVAL_STRINGL(&func_name, USERSTREAM_SEEK, sizeof(USERSTREAM_SEEK)-1);
 
-	MAKE_STD_ZVAL(zwhence);
-	ZVAL_LONG(zwhence, whence);
-	args[1] = &zwhence;
+	ZVAL_LONG(&args[0], offset);
+	ZVAL_LONG(&args[1], whence);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			2, args,
 			0, NULL TSRMLS_CC);
 
-	zval_ptr_dtor(&zoffs);
-	zval_ptr_dtor(&zwhence);
+	zval_ptr_dtor(&args[0]);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&func_name);
 
 	if (call_result == FAILURE) {
 		/* stream_seek is not implemented, so disable seeks for this stream */
 		stream->flags |= PHP_STREAM_FLAG_NO_SEEK;
 		/* there should be no retval to clean up */
 
-		if (retval)
-			zval_ptr_dtor(&retval);
+		zval_ptr_dtor(&retval);
 
 		return -1;
-	} else if (call_result == SUCCESS && retval != NULL && zval_is_true(retval)) {
+	} else if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF && zval_is_true(&retval)) {
 		ret = 0;
 	} else {
 		ret = -1;
 	}
 
-	if (retval) {
-		zval_ptr_dtor(&retval);
-		retval = NULL;
-	}
+	zval_ptr_dtor(&retval);
+	ZVAL_UNDEF(&retval);
 
 	if (ret) {
 		return ret;
 	}
 
 	/* now determine where we are */
-	ZVAL_STRINGL(&func_name, USERSTREAM_TELL, sizeof(USERSTREAM_TELL)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_TELL, sizeof(USERSTREAM_TELL)-1);
 
 	call_result = call_user_function_ex(NULL,
-		&us->object,
+		ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 		&func_name,
 		&retval,
 		0, NULL, 0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_LONG) {
-		*newoffs = Z_LVAL_P(retval);
+	if (call_result == SUCCESS && Z_TYPE(retval) == IS_LONG) {
+		*newoffs = Z_LVAL(retval);
 		ret = 0;
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_TELL " is not implemented!", us->wrapper->classname);
@@ -870,9 +818,8 @@ static int php_userstreamop_seek(php_stream *stream, off_t offset, int whence, o
 		ret = -1;
 	}
 
-	if (retval) {
-		zval_ptr_dtor(&retval);
-	}
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 	return ret;
 }
 
@@ -880,13 +827,13 @@ static int php_userstreamop_seek(php_stream *stream, off_t offset, int whence, o
  * relevant fields into the statbuf provided */
 static int statbuf_from_array(zval *array, php_stream_statbuf *ssb TSRMLS_DC)
 {
-	zval **elem;
+	zval *elem;
 
 #define STAT_PROP_ENTRY_EX(name, name2)                        \
-	if (SUCCESS == zend_hash_find(Z_ARRVAL_P(array), #name, sizeof(#name), (void**)&elem)) {     \
+	if (NULL != (elem = zend_hash_str_find(Z_ARRVAL_P(array), #name, sizeof(#name)-1))) {     \
 		SEPARATE_ZVAL(elem);																	 \
-		convert_to_long(*elem);                                                                   \
-		ssb->sb.st_##name2 = Z_LVAL_PP(elem);                                                      \
+		convert_to_long(elem);                                                                   \
+		ssb->sb.st_##name2 = Z_LVAL_P(elem);                                                      \
 	}
 
 #define STAT_PROP_ENTRY(name) STAT_PROP_ENTRY_EX(name,name)
@@ -926,21 +873,21 @@ static int statbuf_from_array(zval *array, php_stream_statbuf *ssb TSRMLS_DC)
 static int php_userstreamop_stat(php_stream *stream, php_stream_statbuf *ssb TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int call_result;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 	int ret = -1;
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_STAT, sizeof(USERSTREAM_STAT)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_STAT, sizeof(USERSTREAM_STAT)-1);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL, 0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_ARRAY) {
-		if (SUCCESS == statbuf_from_array(retval, ssb TSRMLS_CC))
+	if (call_result == SUCCESS && Z_TYPE(retval) == IS_ARRAY) {
+		if (SUCCESS == statbuf_from_array(&retval, ssb TSRMLS_CC))
 			ret = 0;
 	} else {
 		if (call_result == FAILURE) {
@@ -949,8 +896,8 @@ static int php_userstreamop_stat(php_stream *stream, php_stream_statbuf *ssb TSR
 		}
 	}
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	return ret;
 }
@@ -958,59 +905,57 @@ static int php_userstreamop_stat(php_stream *stream, php_stream_statbuf *ssb TSR
 
 static int php_userstreamop_set_option(php_stream *stream, int option, int value, void *ptrparam TSRMLS_DC) {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int call_result;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 	int ret = PHP_STREAM_OPTION_RETURN_NOTIMPL;
-	zval *zvalue = NULL;
-	zval **args[3];
+	zval args[3];
 
 	switch (option) {
 	case PHP_STREAM_OPTION_CHECK_LIVENESS:
-		ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1, 0);
-		call_result = call_user_function_ex(NULL, &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
-		if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
-			ret = zval_is_true(retval) ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
+		ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1);
+		call_result = call_user_function_ex(NULL, ZVAL_IS_UNDEF(&us->object)? NULL : &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
+		if (call_result == SUCCESS && Z_TYPE(retval) == IS_BOOL) {
+			ret = zval_is_true(&retval) ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
 		} else {
 			ret = PHP_STREAM_OPTION_RETURN_ERR;
 			php_error_docref(NULL TSRMLS_CC, E_WARNING,
 					"%s::" USERSTREAM_EOF " is not implemented! Assuming EOF",
 					us->wrapper->classname);
 		}
+		zval_ptr_dtor(&retval);
+		zval_ptr_dtor(&func_name);
 		break;
 
 	case PHP_STREAM_OPTION_LOCKING:
-		MAKE_STD_ZVAL(zvalue);
-		ZVAL_LONG(zvalue, 0);
+		ZVAL_LONG(&args[0], 0);
 
 		if (value & LOCK_NB) {
-			Z_LVAL_P(zvalue) |= PHP_LOCK_NB;
+			Z_LVAL_P(&args[0]) |= PHP_LOCK_NB;
 		}
 		switch(value & ~LOCK_NB) {
 		case LOCK_SH:
-			Z_LVAL_P(zvalue) |= PHP_LOCK_SH;
+			Z_LVAL_P(&args[0]) |= PHP_LOCK_SH;
 			break;
 		case LOCK_EX:
-			Z_LVAL_P(zvalue) |= PHP_LOCK_EX;
+			Z_LVAL_P(&args[0]) |= PHP_LOCK_EX;
 			break;
 		case LOCK_UN:
-			Z_LVAL_P(zvalue) |= PHP_LOCK_UN;
+			Z_LVAL_P(&args[0]) |= PHP_LOCK_UN;
 			break;
 		}
 
-		args[0] = &zvalue;
-
 		/* TODO wouldblock */
-		ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1, 0);
+		ZVAL_STRINGL(&func_name, USERSTREAM_LOCK, sizeof(USERSTREAM_LOCK)-1);
 
 		call_result = call_user_function_ex(NULL,
-											&us->object,
-											&func_name,
-											&retval,
-											1, args, 0, NULL TSRMLS_CC);
+						ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+						&func_name,
+						&retval,
+						1, args, 0, NULL TSRMLS_CC);
 
-		if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) == IS_BOOL) {
-			ret = !Z_LVAL_P(retval);
+		if (call_result == SUCCESS && Z_TYPE(retval) == IS_BOOL) {
+			ret = !Z_LVAL(retval);
 		} else if (call_result == FAILURE) {
 			if (value == 0) {
 			   	/* lock support test (TODO: more check) */
@@ -1022,15 +967,19 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
 			}
 		}
 
+		zval_ptr_dtor(&retval);
+		zval_ptr_dtor(&func_name);
+		zval_ptr_dtor(&args[0]);
 		break;
 
 	case PHP_STREAM_OPTION_TRUNCATE_API:
-		ZVAL_STRINGL(&func_name, USERSTREAM_TRUNCATE, sizeof(USERSTREAM_TRUNCATE)-1, 0);
+		ZVAL_STRINGL(&func_name, USERSTREAM_TRUNCATE, sizeof(USERSTREAM_TRUNCATE)-1);
 
 		switch (value) {
 		case PHP_STREAM_TRUNCATE_SUPPORTED:
-			if (zend_is_callable_ex(&func_name, us->object, IS_CALLABLE_CHECK_SILENT,
-					NULL, NULL, NULL, NULL TSRMLS_CC))
+			if (zend_is_callable_ex(&func_name,
+					ZVAL_IS_UNDEF(&us->object)? NULL : Z_OBJ(us->object),
+					IS_CALLABLE_CHECK_SILENT, NULL, NULL, NULL TSRMLS_CC))
 				ret = PHP_STREAM_OPTION_RETURN_OK;
 			else
 				ret = PHP_STREAM_OPTION_RETURN_ERR;
@@ -1039,18 +988,16 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
 		case PHP_STREAM_TRUNCATE_SET_SIZE: {
 			ptrdiff_t new_size = *(ptrdiff_t*) ptrparam;
 			if (new_size >= 0 && new_size <= (ptrdiff_t)LONG_MAX) {
-				MAKE_STD_ZVAL(zvalue);
-				ZVAL_LONG(zvalue, (long)new_size);
-				args[0] = &zvalue;
+				ZVAL_LONG(&args[0], (long)new_size);
 				call_result = call_user_function_ex(NULL,
-													&us->object,
-													&func_name,
-													&retval,
-													1, args, 0, NULL TSRMLS_CC);
-				if (call_result == SUCCESS && retval != NULL) {
-					if (Z_TYPE_P(retval) == IS_BOOL) {
-						ret = Z_LVAL_P(retval) ? PHP_STREAM_OPTION_RETURN_OK :
-												 PHP_STREAM_OPTION_RETURN_ERR;
+								ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
+								&func_name,
+								&retval,
+								1, args, 0, NULL TSRMLS_CC);
+				if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
+					if (Z_TYPE(retval) == IS_BOOL) {
+						ret = Z_LVAL(retval) ? PHP_STREAM_OPTION_RETURN_OK :
+											   PHP_STREAM_OPTION_RETURN_ERR;
 					} else {
 						php_error_docref(NULL TSRMLS_CC, E_WARNING,
 								"%s::" USERSTREAM_TRUNCATE " did not return a boolean!",
@@ -1061,58 +1008,53 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
 							"%s::" USERSTREAM_TRUNCATE " is not implemented!",
 							us->wrapper->classname);
 				}
+				zval_ptr_dtor(&retval);
+				zval_ptr_dtor(&args[0]);
 			} else { /* bad new size */
 				ret = PHP_STREAM_OPTION_RETURN_ERR;
 			}
 			break;
 		}
 		}
+		zval_ptr_dtor(&func_name);
 		break;
 
 	case PHP_STREAM_OPTION_READ_BUFFER:
 	case PHP_STREAM_OPTION_WRITE_BUFFER:
 	case PHP_STREAM_OPTION_READ_TIMEOUT:
 	case PHP_STREAM_OPTION_BLOCKING: {
-		zval *zoption = NULL;
-		zval *zptrparam = NULL;
-
-		ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1, 0);
 
-		ALLOC_INIT_ZVAL(zoption);
-		ZVAL_LONG(zoption, option);
+		ZVAL_STRINGL(&func_name, USERSTREAM_SET_OPTION, sizeof(USERSTREAM_SET_OPTION)-1);
 
-		ALLOC_INIT_ZVAL(zvalue);
-		ALLOC_INIT_ZVAL(zptrparam);
-
-		args[0] = &zoption;
-		args[1] = &zvalue;
-		args[2] = &zptrparam;
+		ZVAL_LONG(&args[0], option);
+		ZVAL_NULL(&args[1]);
+		ZVAL_NULL(&args[2]);
 
 		switch(option) {
 		case PHP_STREAM_OPTION_READ_BUFFER:
 		case PHP_STREAM_OPTION_WRITE_BUFFER:
-			ZVAL_LONG(zvalue, value);
+			ZVAL_LONG(&args[1], value);
 			if (ptrparam) {
-				ZVAL_LONG(zptrparam, *(long *)ptrparam);
+				ZVAL_LONG(&args[2], *(long *)ptrparam);
 			} else {
-				ZVAL_LONG(zptrparam, BUFSIZ);
+				ZVAL_LONG(&args[2], BUFSIZ);
 			}
 			break;
 		case PHP_STREAM_OPTION_READ_TIMEOUT: {
 			struct timeval tv = *(struct timeval*)ptrparam;
-			ZVAL_LONG(zvalue, tv.tv_sec);
-			ZVAL_LONG(zptrparam, tv.tv_usec);
+			ZVAL_LONG(&args[1], tv.tv_sec);
+			ZVAL_LONG(&args[2], tv.tv_usec);
 			break;
 			}
 		case PHP_STREAM_OPTION_BLOCKING:
-			ZVAL_LONG(zvalue, value);
+			ZVAL_LONG(&args[1], value);
 			break;
 		default:
 			break;
 		}
 
 		call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			3, args, 0, NULL TSRMLS_CC);
@@ -1121,33 +1063,22 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_SET_OPTION " is not implemented!",
 					us->wrapper->classname);
 			ret = PHP_STREAM_OPTION_RETURN_ERR;
-		} else if (retval && zend_is_true(retval TSRMLS_CC)) {
+		} else if (Z_TYPE(retval) != IS_UNDEF && zend_is_true(&retval TSRMLS_CC)) {
 			ret = PHP_STREAM_OPTION_RETURN_OK;
 		} else {
 			ret = PHP_STREAM_OPTION_RETURN_ERR;
 		}
 
-		if (zoption) {
-			zval_ptr_dtor(&zoption);
-		}
-		if (zptrparam) {
-			zval_ptr_dtor(&zptrparam);
-		}
+		zval_ptr_dtor(&retval);
+		zval_ptr_dtor(&args[2]);
+		zval_ptr_dtor(&args[1]);
+		zval_ptr_dtor(&args[0]);
+		zval_ptr_dtor(&func_name);
 
 		break;
 		}
 	}
 
-	/* clean up */
-	if (retval) {
-		zval_ptr_dtor(&retval);
-	}
-
-
-	if (zvalue) {
-		zval_ptr_dtor(&zvalue);
-	}
-
 	return ret;
 }
 
@@ -1155,46 +1086,43 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
 static int user_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int options, php_stream_context *context TSRMLS_DC)
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
-	zval *zfilename, *zfuncname, *zretval;
-	zval **args[1];
+	zval zfuncname, zretval;
+	zval args[1];
 	int call_result;
-	zval *object;
+	zval object;
 	int ret = 0;
 
 	/* create an instance of our class */
-	object = user_stream_create_object(uwrap, context TSRMLS_CC);
-	if(object == NULL) {
+	user_stream_create_object(uwrap, context, &object TSRMLS_CC);
+	if (Z_TYPE(object) == IS_UNDEF) {
 		return ret;
 	}
 
 	/* call the unlink method */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, url, 1);
-	args[0] = &zfilename;
+	ZVAL_STRING(&args[0], url);
 
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_UNLINK, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_UNLINK);
 
 	call_result = call_user_function_ex(NULL,
 			&object,
-			zfuncname,
+			&zfuncname,
 			&zretval,
 			1, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
-		ret = Z_LVAL_P(zretval);
+	if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
+		ret = Z_LVAL(zretval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_UNLINK " is not implemented!", uwrap->classname);
  	}
 
 	/* clean up */
 	zval_ptr_dtor(&object);
-	if (zretval)
-		zval_ptr_dtor(&zretval);
-
+	zval_ptr_dtor(&zretval);
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zfilename);
+
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 }
@@ -1203,51 +1131,44 @@ static int user_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from
 							   int options, php_stream_context *context TSRMLS_DC)
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
-	zval *zold_name, *znew_name, *zfuncname, *zretval;
-	zval **args[2];
+	zval zfuncname, zretval;
+	zval args[2];
 	int call_result;
-	zval *object;
+	zval object;
 	int ret = 0;
 
 	/* create an instance of our class */
-	object = user_stream_create_object(uwrap, context TSRMLS_CC);	
-	if(object == NULL) {
+	user_stream_create_object(uwrap, context, &object TSRMLS_CC);	
+	if (Z_TYPE(object) == IS_UNDEF) {
 		return ret;
 	}
 
 	/* call the rename method */
-	MAKE_STD_ZVAL(zold_name);
-	ZVAL_STRING(zold_name, url_from, 1);
-	args[0] = &zold_name;
-
-	MAKE_STD_ZVAL(znew_name);
-	ZVAL_STRING(znew_name, url_to, 1);
-	args[1] = &znew_name;
+	ZVAL_STRING(&args[0], url_from);
+	ZVAL_STRING(&args[1], url_to);
 
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_RENAME, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_RENAME);
 
 	call_result = call_user_function_ex(NULL,
 			&object,
-			zfuncname,
+			&zfuncname,
 			&zretval,
 			2, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
-		ret = Z_LVAL_P(zretval);
+	if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
+		ret = Z_LVAL(zretval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_RENAME " is not implemented!", uwrap->classname);
  	}
 
 	/* clean up */
 	zval_ptr_dtor(&object);
-	if (zretval)
-		zval_ptr_dtor(&zretval);
+	zval_ptr_dtor(&zretval);
 
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zold_name);
-	zval_ptr_dtor(&znew_name);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 }
@@ -1256,57 +1177,46 @@ static int user_wrapper_mkdir(php_stream_wrapper *wrapper, const char *url, int
 							  int options, php_stream_context *context TSRMLS_DC)
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
-	zval *zfilename, *zmode, *zoptions, *zfuncname, *zretval;
-	zval **args[3];
+	zval zfuncname, zretval;
+	zval args[3];
 	int call_result;
-	zval *object;
+	zval object;
 	int ret = 0;
 
 	/* create an instance of our class */
-	object = user_stream_create_object(uwrap, context TSRMLS_CC);	
-	if(object == NULL) {
+	user_stream_create_object(uwrap, context, &object TSRMLS_CC);	
+	if (Z_TYPE(object) == IS_UNDEF) {
 		return ret;
 	}
 
 	/* call the mkdir method */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, url, 1);
-	args[0] = &zfilename;
-
-	MAKE_STD_ZVAL(zmode);
-	ZVAL_LONG(zmode, mode);
-	args[1] = &zmode;
+	ZVAL_STRING(&args[0], url);
+	ZVAL_LONG(&args[1], mode);
+	ZVAL_LONG(&args[2], options);
 
-	MAKE_STD_ZVAL(zoptions);
-	ZVAL_LONG(zoptions, options);
-	args[2] = &zoptions;
-
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_MKDIR, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_MKDIR);
 
 	call_result = call_user_function_ex(NULL,
 			&object,
-			zfuncname,
+			&zfuncname,
 			&zretval,
 			3, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
-		ret = Z_LVAL_P(zretval);
+	if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
+		ret = Z_LVAL(zretval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_MKDIR " is not implemented!", uwrap->classname);
  	}
 
 	/* clean up */
 	zval_ptr_dtor(&object);
-	if (zretval) {
-		zval_ptr_dtor(&zretval);
-	}
+	zval_ptr_dtor(&zretval);
 
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zfilename);
-	zval_ptr_dtor(&zmode);
-	zval_ptr_dtor(&zoptions);
+	zval_ptr_dtor(&args[2]);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 }
@@ -1315,52 +1225,44 @@ static int user_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url,
 							  int options, php_stream_context *context TSRMLS_DC)
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
-	zval *zfilename, *zoptions, *zfuncname, *zretval;
-	zval **args[3];
+	zval zfuncname, zretval;
+	zval args[2];
 	int call_result;
-	zval *object;
+	zval object;
 	int ret = 0;
 
 	/* create an instance of our class */
-	object = user_stream_create_object(uwrap, context TSRMLS_CC);	
-	if(object == NULL) {
+	user_stream_create_object(uwrap, context, &object TSRMLS_CC);	
+	if (Z_TYPE(object) == IS_UNDEF) {
 		return ret;
 	}
 
 	/* call the rmdir method */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, url, 1);
-	args[0] = &zfilename;
+	ZVAL_STRING(&args[0], url);
+	ZVAL_LONG(&args[1], options);
 
-	MAKE_STD_ZVAL(zoptions);
-	ZVAL_LONG(zoptions, options);
-	args[1] = &zoptions;
-
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_RMDIR, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_RMDIR);
 
 	call_result = call_user_function_ex(NULL,
 			&object,
-			zfuncname,
+			&zfuncname,
 			&zretval,
 			2, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
-		ret = Z_LVAL_P(zretval);
+	if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
+		ret = Z_LVAL(zretval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_RMDIR " is not implemented!", uwrap->classname);
  	}
 
 	/* clean up */
 	zval_ptr_dtor(&object);
-	if (zretval) {
-		zval_ptr_dtor(&zretval);
-	}
+	zval_ptr_dtor(&zretval);
 
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zfilename);
-	zval_ptr_dtor(&zoptions);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 }
@@ -1369,81 +1271,70 @@ static int user_wrapper_metadata(php_stream_wrapper *wrapper, const char *url, i
 								 void *value, php_stream_context *context TSRMLS_DC)
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
-	zval *zfilename, *zoption, *zvalue, *zfuncname, *zretval;
-	zval **args[3];
+	zval zfuncname, zretval;
+	zval args[3];
 	int call_result;
-	zval *object;
+	zval object;
 	int ret = 0;
 
-	MAKE_STD_ZVAL(zvalue);
 	switch(option) {
 		case PHP_STREAM_META_TOUCH:
-			array_init(zvalue);
+			array_init(&args[2]);
 			if(value) {
 				struct utimbuf *newtime = (struct utimbuf *)value;
-				add_index_long(zvalue, 0, newtime->modtime);
-				add_index_long(zvalue, 1, newtime->actime);
+				add_index_long(&args[2], 0, newtime->modtime);
+				add_index_long(&args[2], 1, newtime->actime);
 			}
 			break;
 		case PHP_STREAM_META_GROUP:
 		case PHP_STREAM_META_OWNER:
 		case PHP_STREAM_META_ACCESS:
-			ZVAL_LONG(zvalue, *(long *)value);
+			ZVAL_LONG(&args[2], *(long *)value);
 			break;
 		case PHP_STREAM_META_GROUP_NAME:
 		case PHP_STREAM_META_OWNER_NAME:
-			ZVAL_STRING(zvalue, value, 1);
+			ZVAL_STRING(&args[2], value);
 			break;
 		default:
 			php_error_docref(NULL TSRMLS_CC, E_WARNING, "Unknown option %d for " USERSTREAM_METADATA, option);
-			zval_ptr_dtor(&zvalue);
+			zval_ptr_dtor(&args[2]);
 			return ret;
 	}
 
 	/* create an instance of our class */
-	object = user_stream_create_object(uwrap, context TSRMLS_CC);	
-	if(object == NULL) {
-		zval_ptr_dtor(&zvalue);
+	user_stream_create_object(uwrap, context, &object TSRMLS_CC);	
+	if (Z_TYPE(object) == IS_UNDEF) {
+		zval_ptr_dtor(&args[2]);
 		return ret;
 	}
 
 	/* call the mkdir method */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, url, 1);
-	args[0] = &zfilename;
+	ZVAL_STRING(&args[0], url);
+	ZVAL_LONG(&args[1], option);
 
-	MAKE_STD_ZVAL(zoption);
-	ZVAL_LONG(zoption, option);
-	args[1] = &zoption;
-
-	args[2] = &zvalue;
-
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_METADATA, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_METADATA);
 
 	call_result = call_user_function_ex(NULL,
 			&object,
-			zfuncname,
+			&zfuncname,
 			&zretval,
 			3, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval && Z_TYPE_P(zretval) == IS_BOOL) {
-		ret = Z_LVAL_P(zretval);
+	if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
+		ret = Z_LVAL(zretval);
 	} else if (call_result == FAILURE) {
 		php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_METADATA " is not implemented!", uwrap->classname);
  	}
 
 	/* clean up */
 	zval_ptr_dtor(&object);
-	if (zretval) {
-		zval_ptr_dtor(&zretval);
-	}
+	zval_ptr_dtor(&zretval);
 
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zfilename);
-	zval_ptr_dtor(&zoption);
-	zval_ptr_dtor(&zvalue);
+	zval_ptr_dtor(&args[0]);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[2]);
 
 	return ret;
 }
@@ -1453,40 +1344,34 @@ static int user_wrapper_stat_url(php_stream_wrapper *wrapper, const char *url, i
 								 php_stream_statbuf *ssb, php_stream_context *context TSRMLS_DC)
 {
 	struct php_user_stream_wrapper *uwrap = (struct php_user_stream_wrapper*)wrapper->abstract;
-	zval *zfilename, *zfuncname, *zretval, *zflags;
-	zval **args[2];
+	zval zfuncname, zretval;
+	zval args[2];
 	int call_result;
-	zval *object;
+	zval object;
 	int ret = -1;
 
 	/* create an instance of our class */
-	object = user_stream_create_object(uwrap, context TSRMLS_CC);	
-	if(object == NULL) {
+	user_stream_create_object(uwrap, context, &object TSRMLS_CC);
+	if (Z_TYPE(object) == IS_UNDEF) {
 		return ret;
 	}
 
 	/* call it's stat_url method - set up params first */
-	MAKE_STD_ZVAL(zfilename);
-	ZVAL_STRING(zfilename, url, 1);
-	args[0] = &zfilename;
-
-	MAKE_STD_ZVAL(zflags);
-	ZVAL_LONG(zflags, flags);
-	args[1] = &zflags;
+	ZVAL_STRING(&args[0], url);
+	ZVAL_LONG(&args[1], flags);
 
-	MAKE_STD_ZVAL(zfuncname);
-	ZVAL_STRING(zfuncname, USERSTREAM_STATURL, 1);
+	ZVAL_STRING(&zfuncname, USERSTREAM_STATURL);
 
 	call_result = call_user_function_ex(NULL,
 			&object,
-			zfuncname,
+			&zfuncname,
 			&zretval,
 			2, args,
 			0, NULL	TSRMLS_CC);
 
-	if (call_result == SUCCESS && zretval != NULL && Z_TYPE_P(zretval) == IS_ARRAY) {
+	if (call_result == SUCCESS && Z_TYPE(zretval) == IS_ARRAY) {
 		/* We got the info we needed */
-		if (SUCCESS == statbuf_from_array(zretval, ssb TSRMLS_CC))
+		if (SUCCESS == statbuf_from_array(&zretval, ssb TSRMLS_CC))
 			ret = 0;
 	} else {
 		if (call_result == FAILURE) {
@@ -1497,12 +1382,11 @@ static int user_wrapper_stat_url(php_stream_wrapper *wrapper, const char *url, i
 
 	/* clean up */
 	zval_ptr_dtor(&object);
-	if (zretval)
-		zval_ptr_dtor(&zretval);
+	zval_ptr_dtor(&zretval);
 
 	zval_ptr_dtor(&zfuncname);
-	zval_ptr_dtor(&zfilename);
-	zval_ptr_dtor(&zflags);
+	zval_ptr_dtor(&args[1]);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 
@@ -1511,7 +1395,7 @@ static int user_wrapper_stat_url(php_stream_wrapper *wrapper, const char *url, i
 static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t count TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	int call_result;
 	size_t didread = 0;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
@@ -1521,18 +1405,18 @@ static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t cou
 	if (count != sizeof(php_stream_dirent))
 		return 0;
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_READ, sizeof(USERSTREAM_DIR_READ)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_READ, sizeof(USERSTREAM_DIR_READ)-1);
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL,
 			0, NULL TSRMLS_CC);
 
-	if (call_result == SUCCESS && retval != NULL && Z_TYPE_P(retval) != IS_BOOL) {
-		convert_to_string(retval);
-		PHP_STRLCPY(ent->d_name, Z_STRVAL_P(retval), sizeof(ent->d_name), Z_STRLEN_P(retval));
+	if (call_result == SUCCESS && Z_TYPE(retval) != IS_BOOL) {
+		convert_to_string(&retval);
+		PHP_STRLCPY(ent->d_name, Z_STRVAL(retval), sizeof(ent->d_name), Z_STRLEN(retval));
 
 		didread = sizeof(php_stream_dirent);
 	} else if (call_result == FAILURE) {
@@ -1540,8 +1424,8 @@ static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t cou
 				us->wrapper->classname);
 	}
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	return didread;
 }
@@ -1549,23 +1433,23 @@ static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t cou
 static int php_userstreamop_closedir(php_stream *stream, int close_handle TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 
 	assert(us != NULL);
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_CLOSE, sizeof(USERSTREAM_DIR_CLOSE)-1);
 
 	call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL, 0, NULL TSRMLS_CC);
 
-	if (retval)
-		zval_ptr_dtor(&retval);
-
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 	zval_ptr_dtor(&us->object);
+	ZVAL_UNDEF(&us->object);
 
 	efree(us);
 
@@ -1575,19 +1459,19 @@ static int php_userstreamop_closedir(php_stream *stream, int close_handle TSRMLS
 static int php_userstreamop_rewinddir(php_stream *stream, off_t offset, int whence, off_t *newoffs TSRMLS_DC)
 {
 	zval func_name;
-	zval *retval = NULL;
+	zval retval;
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_DIR_REWIND, sizeof(USERSTREAM_DIR_REWIND)-1);
 
 	call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			0, NULL, 0, NULL TSRMLS_CC);
 
-	if (retval)
-		zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
 
 	return 0;
 
@@ -1597,28 +1481,25 @@ static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr T
 {
 	php_userstream_data_t *us = (php_userstream_data_t *)stream->abstract;
 	zval func_name;
-	zval *retval = NULL;
-	zval *zcastas = NULL;
-	zval **args[1];
+	zval retval;
+	zval args[1];
 	php_stream * intstream = NULL;
 	int call_result;
 	int ret = FAILURE;
 
-	ZVAL_STRINGL(&func_name, USERSTREAM_CAST, sizeof(USERSTREAM_CAST)-1, 0);
+	ZVAL_STRINGL(&func_name, USERSTREAM_CAST, sizeof(USERSTREAM_CAST)-1);
 
-	ALLOC_INIT_ZVAL(zcastas);
 	switch(castas) {
 	case PHP_STREAM_AS_FD_FOR_SELECT:
-		ZVAL_LONG(zcastas, PHP_STREAM_AS_FD_FOR_SELECT);
+		ZVAL_LONG(&args[0], PHP_STREAM_AS_FD_FOR_SELECT);
 		break;
 	default:
-		ZVAL_LONG(zcastas, PHP_STREAM_AS_STDIO);
+		ZVAL_LONG(&args[0], PHP_STREAM_AS_STDIO);
 		break;
 	}
-	args[0] = &zcastas;
 
 	call_result = call_user_function_ex(NULL,
-			&us->object,
+			ZVAL_IS_UNDEF(&us->object)? NULL : &us->object,
 			&func_name,
 			&retval,
 			1, args, 0, NULL TSRMLS_CC);
@@ -1629,7 +1510,7 @@ static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr T
 					us->wrapper->classname);
 			break;
 		}
-		if (retval == NULL || !zend_is_true(retval TSRMLS_CC)) {
+		if (ZVAL_IS_UNDEF(&retval) || !zend_is_true(&retval TSRMLS_CC)) {
 			break;
 		}
 		php_stream_from_zval_no_verify(intstream, &retval);
@@ -1647,12 +1528,9 @@ static int php_userstreamop_cast(php_stream *stream, int castas, void **retptr T
 		ret = php_stream_cast(intstream, castas, retptr, 1);
 	} while (0);
 
-	if (retval) {
-		zval_ptr_dtor(&retval);
-	}
-	if (zcastas) {
-		zval_ptr_dtor(&zcastas);
-	}
+	zval_ptr_dtor(&retval);
+	zval_ptr_dtor(&func_name);
+	zval_ptr_dtor(&args[0]);
 
 	return ret;
 }
diff --git a/main/streams/xp_socket.c b/main/streams/xp_socket.c
index a6dc115962..9e1521b537 100644
--- a/main/streams/xp_socket.c
+++ b/main/streams/xp_socket.c
@@ -619,7 +619,7 @@ static inline int php_tcp_sockop_connect(php_stream *stream, php_netstream_data_
 	int portno, bindport = 0;
 	int err = 0;
 	int ret;
-	zval **tmpzval = NULL;
+	zval *tmpzval = NULL;
 
 #ifdef AF_UNIX
 	if (stream->ops == &php_stream_unix_socket_ops || stream->ops == &php_stream_unixdg_socket_ops) {
@@ -654,15 +654,15 @@ static inline int php_tcp_sockop_connect(php_stream *stream, php_netstream_data_
 		return -1;
 	}
 
-	if (stream->context && php_stream_context_get_option(stream->context, "socket", "bindto", &tmpzval) == SUCCESS) {
-		if (Z_TYPE_PP(tmpzval) != IS_STRING) {
+	if (stream->context && (tmpzval = php_stream_context_get_option(stream->context, "socket", "bindto")) != NULL) {
+		if (Z_TYPE_P(tmpzval) != IS_STRING) {
 			if (xparam->want_errortext) {
 				spprintf(&xparam->outputs.error_text, 0, "local_addr context option is not a string.");
 			}
 			efree(host);
 			return -1;
 		}
-		bindto = parse_ip_address_ex(Z_STRVAL_PP(tmpzval), Z_STRLEN_PP(tmpzval), &bindport, xparam->want_errortext, &xparam->outputs.error_text TSRMLS_CC);
+		bindto = parse_ip_address_ex(Z_STRVAL_P(tmpzval), Z_STRLEN_P(tmpzval), &bindport, xparam->want_errortext, &xparam->outputs.error_text TSRMLS_CC);
 	}
 
 	/* Note: the test here for php_stream_udp_socket_ops is important, because we
@@ -734,7 +734,7 @@ static inline int php_tcp_sockop_accept(php_stream *stream, php_netstream_data_t
 			if (xparam->outputs.client) {
 				xparam->outputs.client->context = stream->context;
 				if (stream->context) {
-					zend_list_addref(stream->context->rsrc_id);
+					GC_REFCOUNT(stream->context->res)++;
 				}
 			}
 		}
diff --git a/sapi/aolserver/aolserver.c b/sapi/aolserver/aolserver.c
index a89b98e57a..13091b908a 100644
--- a/sapi/aolserver/aolserver.c
+++ b/sapi/aolserver/aolserver.c
@@ -273,7 +273,7 @@ PHP_FUNCTION(getallheaders)
 		char *key = Ns_SetKey(NSG(conn->headers), i);
 		char *value = Ns_SetValue(NSG(conn->headers), i);
 		
-		add_assoc_string(return_value, key, value, 1);
+		add_assoc_string(return_value, key, value);
 	}
 }
 
diff --git a/sapi/apache/php_apache.c b/sapi/apache/php_apache.c
index 43a4c90efe..1ad4897a35 100644
--- a/sapi/apache/php_apache.c
+++ b/sapi/apache/php_apache.c
@@ -404,7 +404,7 @@ PHP_FUNCTION(apache_request_headers)
 		if (!tenv[i].key) {
 			continue;
 		}
-		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
+		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
 			RETURN_FALSE;
 		}
     }
@@ -424,7 +424,7 @@ PHP_FUNCTION(apache_response_headers)
 	tenv = (table_entry *)env_arr->elts;
 	for (i = 0; i < env_arr->nelts; ++i) {
 		if (!tenv[i].key) continue;
-		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
+		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
 			RETURN_FALSE;
 		}
 	}
@@ -475,34 +475,34 @@ PHP_FUNCTION(apache_lookup_uri)
 	add_property_long(return_value,"status", rr->status);
 
 	if (rr->the_request) {
-		add_property_string(return_value,"the_request", rr->the_request, 1);
+		add_property_string(return_value,"the_request", rr->the_request);
 	}
 	if (rr->status_line) {
-		add_property_string(return_value,"status_line", (char *)rr->status_line, 1);		
+		add_property_string(return_value,"status_line", (char *)rr->status_line);
 	}
 	if (rr->method) {
-		add_property_string(return_value,"method", (char *)rr->method, 1);		
+		add_property_string(return_value,"method", (char *)rr->method);
 	}
 	if (rr->content_type) {
-		add_property_string(return_value,"content_type", (char *)rr->content_type, 1);
+		add_property_string(return_value,"content_type", (char *)rr->content_type);
 	}
 	if (rr->handler) {
-		add_property_string(return_value,"handler", (char *)rr->handler, 1);		
+		add_property_string(return_value,"handler", (char *)rr->handler);
 	}
 	if (rr->uri) {
-		add_property_string(return_value,"uri", rr->uri, 1);
+		add_property_string(return_value,"uri", rr->uri);
 	}
 	if (rr->filename) {
-		add_property_string(return_value,"filename", rr->filename, 1);
+		add_property_string(return_value,"filename", rr->filename);
 	}
 	if (rr->path_info) {
-		add_property_string(return_value,"path_info", rr->path_info, 1);
+		add_property_string(return_value,"path_info", rr->path_info);
 	}
 	if (rr->args) {
-		add_property_string(return_value,"args", rr->args, 1);
+		add_property_string(return_value,"args", rr->args);
 	}
 	if (rr->boundary) {
-		add_property_string(return_value,"boundary", rr->boundary, 1);
+		add_property_string(return_value,"boundary", rr->boundary);
 	}
 
 	add_property_long(return_value,"no_cache", rr->no_cache);
@@ -515,7 +515,7 @@ PHP_FUNCTION(apache_lookup_uri)
 
 #if MODULE_MAGIC_NUMBER >= 19980324
 	if (rr->unparsed_uri) {
-		add_property_string(return_value,"unparsed_uri", rr->unparsed_uri, 1);
+		add_property_string(return_value,"unparsed_uri", rr->unparsed_uri);
 	}
 	if(rr->mtime) {
 		add_property_long(return_value,"mtime", rr->mtime);
@@ -580,9 +580,9 @@ PHP_FUNCTION(apache_get_modules)
 	for (n = 0; ap_loaded_modules[n]; ++n) {
 		char *s = (char *) ap_loaded_modules[n]->name;
 		if ((p = strchr(s, '.'))) {
-			add_next_index_stringl(return_value, s, (p - s), 1);
+			add_next_index_stringl(return_value, s, (p - s));
 		} else {
-			add_next_index_string(return_value, s, 1);
+			add_next_index_string(return_value, s);
 		}	
 	}
 }
diff --git a/sapi/apache2filter/php_functions.c b/sapi/apache2filter/php_functions.c
index f1ae9c974b..3a0b3ee0b9 100644
--- a/sapi/apache2filter/php_functions.c
+++ b/sapi/apache2filter/php_functions.c
@@ -93,7 +93,7 @@ PHP_FUNCTION(virtual)
 #define ADD_TIME(name) \
 		add_property_long(return_value, #name, apr_time_sec(rr->name));
 #define ADD_STRING(name) \
-		if (rr->name) add_property_string(return_value, #name, (char *) rr->name, 1)
+		if (rr->name) add_property_string(return_value, #name, (char *) rr->name)
 
 PHP_FUNCTION(apache_lookup_uri)
 {
@@ -163,7 +163,7 @@ PHP_FUNCTION(apache_request_headers)
 
 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
 		if (!val) val = "";
-		add_assoc_string(return_value, key, val, 1);
+		add_assoc_string(return_value, key, val);
 	APR_ARRAY_FOREACH_CLOSE()
 }
 /* }}} */
@@ -183,7 +183,7 @@ PHP_FUNCTION(apache_response_headers)
 
 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
 		if (!val) val = "";
-		add_assoc_string(return_value, key, val, 1);
+		add_assoc_string(return_value, key, val);
 	APR_ARRAY_FOREACH_CLOSE()
 }
 /* }}} */
@@ -313,9 +313,9 @@ PHP_FUNCTION(apache_get_modules)
 	for (n = 0; ap_loaded_modules[n]; ++n) {
 		char *s = (char *) ap_loaded_modules[n]->name;
 		if ((p = strchr(s, '.'))) {
-			add_next_index_stringl(return_value, s, (p - s), 1);
+			add_next_index_stringl(return_value, s, (p - s));
 		} else {
-			add_next_index_string(return_value, s, 1);
+			add_next_index_string(return_value, s);
 		}
 	}
 }
diff --git a/sapi/apache2handler/php_functions.c b/sapi/apache2handler/php_functions.c
index 2c57300926..c6bed48dac 100644
--- a/sapi/apache2handler/php_functions.c
+++ b/sapi/apache2handler/php_functions.c
@@ -113,7 +113,7 @@ PHP_FUNCTION(virtual)
 #define ADD_TIME(name) \
 		add_property_long(return_value, #name, apr_time_sec(rr->name));
 #define ADD_STRING(name) \
-		if (rr->name) add_property_string(return_value, #name, (char *) rr->name, 1)
+		if (rr->name) add_property_string(return_value, #name, (char *) rr->name)
 
 PHP_FUNCTION(apache_lookup_uri)
 {
@@ -187,7 +187,7 @@ PHP_FUNCTION(apache_request_headers)
 
 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
 		if (!val) val = "";
-		add_assoc_string(return_value, key, val, 1);
+		add_assoc_string(return_value, key, val);
 	APR_ARRAY_FOREACH_CLOSE()
 }
 /* }}} */
@@ -211,7 +211,7 @@ PHP_FUNCTION(apache_response_headers)
 
 	APR_ARRAY_FOREACH_OPEN(arr, key, val)
 		if (!val) val = "";
-		add_assoc_string(return_value, key, val, 1);
+		add_assoc_string(return_value, key, val);
 	APR_ARRAY_FOREACH_CLOSE()
 }
 /* }}} */
@@ -355,9 +355,9 @@ PHP_FUNCTION(apache_get_modules)
 	for (n = 0; ap_loaded_modules[n]; ++n) {
 		char *s = (char *) ap_loaded_modules[n]->name;
 		if ((p = strchr(s, '.'))) {
-			add_next_index_stringl(return_value, s, (p - s), 1);
+			add_next_index_stringl(return_value, s, (p - s));
 		} else {
-			add_next_index_string(return_value, s, 1);
+			add_next_index_string(return_value, s);
 		}
 	}
 }
diff --git a/sapi/apache_hooks/php_apache.c b/sapi/apache_hooks/php_apache.c
index 76a4219b0a..8045bbce32 100644
--- a/sapi/apache_hooks/php_apache.c
+++ b/sapi/apache_hooks/php_apache.c
@@ -1401,7 +1401,7 @@ static PHP_MINIT_FUNCTION(apache)
 
 	le_apachereq = zend_register_list_destructors_ex(php_apache_request_free, NULL, "ApacheRequest", module_number);
 	INIT_OVERLOADED_CLASS_ENTRY(ce, "ApacheRequest", php_apache_request_class_functions, NULL, NULL, NULL);
-	apacherequest_class_entry = zend_register_internal_class_ex(&ce, NULL, NULL TSRMLS_CC);
+	apacherequest_class_entry = zend_register_internal_class_ex(&ce, NULL TSRMLS_CC);
 
 	REGISTER_LONG_CONSTANT("OK",				OK,					CONST_CS | CONST_PERSISTENT);
 	REGISTER_LONG_CONSTANT("DECLINED",			DECLINED,			CONST_CS | CONST_PERSISTENT);
@@ -1764,7 +1764,7 @@ static void apache_table_to_zval(table *t, zval *return_value)
 		if (!tenv[i].key) {
 			continue;
 		}
-		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val, 1)==FAILURE) {
+		if (add_assoc_string(return_value, tenv[i].key, (tenv[i].val==NULL) ? "" : tenv[i].val)==FAILURE) {
 			RETURN_FALSE;
 		}
     }
@@ -1848,34 +1848,34 @@ PHP_FUNCTION(apache_lookup_uri)
 	add_property_long(return_value,"status", rr->status);
 
 	if (rr->the_request) {
-		add_property_string(return_value,"the_request", rr->the_request, 1);
+		add_property_string(return_value,"the_request", rr->the_request);
 	}
 	if (rr->status_line) {
-		add_property_string(return_value,"status_line", (char *)rr->status_line, 1);		
+		add_property_string(return_value,"status_line", (char *)rr->status_line);
 	}
 	if (rr->method) {
-		add_property_string(return_value,"method", (char *)rr->method, 1);		
+		add_property_string(return_value,"method", (char *)rr->method);
 	}
 	if (rr->content_type) {
-		add_property_string(return_value,"content_type", (char *)rr->content_type, 1);
+		add_property_string(return_value,"content_type", (char *)rr->content_type);
 	}
 	if (rr->handler) {
-		add_property_string(return_value,"handler", (char *)rr->handler, 1);		
+		add_property_string(return_value,"handler", (char *)rr->handler);
 	}
 	if (rr->uri) {
-		add_property_string(return_value,"uri", rr->uri, 1);
+		add_property_string(return_value,"uri", rr->uri);
 	}
 	if (rr->filename) {
-		add_property_string(return_value,"filename", rr->filename, 1);
+		add_property_string(return_value,"filename", rr->filename);
 	}
 	if (rr->path_info) {
-		add_property_string(return_value,"path_info", rr->path_info, 1);
+		add_property_string(return_value,"path_info", rr->path_info);
 	}
 	if (rr->args) {
-		add_property_string(return_value,"args", rr->args, 1);
+		add_property_string(return_value,"args", rr->args);
 	}
 	if (rr->boundary) {
-		add_property_string(return_value,"boundary", rr->boundary, 1);
+		add_property_string(return_value,"boundary", rr->boundary);
 	}
 	add_property_long(return_value,"no_cache", rr->no_cache);
 	add_property_long(return_value,"no_local_copy", rr->no_local_copy);
@@ -1887,7 +1887,7 @@ PHP_FUNCTION(apache_lookup_uri)
 
 #if MODULE_MAGIC_NUMBER >= 19980324
 	if (rr->unparsed_uri) {
-		add_property_string(return_value,"unparsed_uri", rr->unparsed_uri, 1);
+		add_property_string(return_value,"unparsed_uri", rr->unparsed_uri);
 	}
 	if(rr->mtime) {
 		add_property_long(return_value,"mtime", rr->mtime);
@@ -1952,9 +1952,9 @@ PHP_FUNCTION(apache_get_modules)
 	for (n = 0; ap_loaded_modules[n]; ++n) {
 		char *s = (char *) ap_loaded_modules[n]->name;
 		if ((p = strchr(s, '.'))) {
-			add_next_index_stringl(return_value, s, (p - s), 1);
+			add_next_index_stringl(return_value, s, (p - s));
 		} else {
-			add_next_index_string(return_value, s, 1);
+			add_next_index_string(return_value, s);
 		}	
 	}
 }
diff --git a/sapi/cgi/cgi_main.c b/sapi/cgi/cgi_main.c
index 7006ecd73f..3b4abcf16f 100644
--- a/sapi/cgi/cgi_main.c
+++ b/sapi/cgi/cgi_main.c
@@ -223,20 +223,20 @@ static int print_module_info(zend_module_entry *module, void *arg TSRMLS_DC)
 
 static int module_name_cmp(const void *a, const void *b TSRMLS_DC)
 {
-	Bucket *f = *((Bucket **) a);
-	Bucket *s = *((Bucket **) b);
+	Bucket *f = (Bucket *) a;
+	Bucket *s = (Bucket *) b;
 
-	return strcasecmp(	((zend_module_entry *)f->pData)->name,
-						((zend_module_entry *)s->pData)->name);
+	return strcasecmp(	((zend_module_entry *)Z_PTR(f->val))->name,
+						((zend_module_entry *)Z_PTR(s->val))->name);
 }
 
 static void print_modules(TSRMLS_D)
 {
 	HashTable sorted_registry;
-	zend_module_entry tmp;
 
-	zend_hash_init(&sorted_registry, 50, NULL, NULL, 1);
-	zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
+	zend_hash_init(&sorted_registry, 64, NULL, NULL, 1);
+//???	zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
+	zend_hash_copy(&sorted_registry, &module_registry, NULL);
 	zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);
 	zend_hash_apply_with_argument(&sorted_registry, (apply_func_arg_t) print_module_info, NULL TSRMLS_CC);
 	zend_hash_destroy(&sorted_registry);
@@ -619,7 +619,7 @@ static char *sapi_fcgi_read_cookies(TSRMLS_D)
 static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, unsigned int val_len, void *arg TSRMLS_DC)
 {
 	zval *array_ptr = (zval*)arg;	
-	int filter_arg = (array_ptr == PG(http_globals)[TRACK_VARS_ENV])?PARSE_ENV:PARSE_SERVER;
+	int filter_arg = (Z_ARR_P(array_ptr) == Z_ARR(PG(http_globals)[TRACK_VARS_ENV]))?PARSE_ENV:PARSE_SERVER;
 	unsigned int new_val_len;
 
 	if (sapi_module.input_filter(filter_arg, var, &val, strlen(val), &new_val_len TSRMLS_CC)) {
@@ -629,25 +629,19 @@ static void cgi_php_load_env_var(char *var, unsigned int var_len, char *val, uns
 
 static void cgi_php_import_environment_variables(zval *array_ptr TSRMLS_DC)
 {
-	if (PG(http_globals)[TRACK_VARS_ENV] &&
-		array_ptr != PG(http_globals)[TRACK_VARS_ENV] &&
-		Z_TYPE_P(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&
-		zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_ENV])) > 0
+	if (Z_TYPE(PG(http_globals)[TRACK_VARS_ENV]) == IS_ARRAY &&
+		Z_ARR_P(array_ptr) != Z_ARR(PG(http_globals)[TRACK_VARS_ENV]) &&
+		zend_hash_num_elements(Z_ARRVAL(PG(http_globals)[TRACK_VARS_ENV])) > 0
 	) {
 		zval_dtor(array_ptr);
-		*array_ptr = *PG(http_globals)[TRACK_VARS_ENV];
-		INIT_PZVAL(array_ptr);
-		zval_copy_ctor(array_ptr);
+		ZVAL_DUP(array_ptr, &PG(http_globals)[TRACK_VARS_ENV]);
 		return;
-	} else if (PG(http_globals)[TRACK_VARS_SERVER] &&
-		array_ptr != PG(http_globals)[TRACK_VARS_SERVER] &&
-		Z_TYPE_P(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY &&
-		zend_hash_num_elements(Z_ARRVAL_P(PG(http_globals)[TRACK_VARS_SERVER])) > 0
+	} else if (Z_TYPE(PG(http_globals)[TRACK_VARS_SERVER]) == IS_ARRAY &&
+		Z_ARR_P(array_ptr) != Z_ARR(PG(http_globals)[TRACK_VARS_SERVER]) &&
+		zend_hash_num_elements(Z_ARRVAL(PG(http_globals)[TRACK_VARS_SERVER])) > 0
 	) {
 		zval_dtor(array_ptr);
-		*array_ptr = *PG(http_globals)[TRACK_VARS_SERVER];
-		INIT_PZVAL(array_ptr);
-		zval_copy_ctor(array_ptr);
+		ZVAL_DUP(array_ptr, &PG(http_globals)[TRACK_VARS_SERVER]);
 		return;
 	}
 
@@ -758,13 +752,12 @@ static void php_cgi_ini_activate_user_config(char *path, int path_len, const cha
 	time_t request_time = sapi_get_request_time(TSRMLS_C);
 
 	/* Find cached config entry: If not found, create one */
-	if (zend_hash_find(&CGIG(user_config_cache), path, path_len + 1, (void **) &entry) == FAILURE) {
+	if ((entry = zend_hash_str_find_ptr(&CGIG(user_config_cache), path, path_len)) == NULL) {
 		new_entry = pemalloc(sizeof(user_config_cache_entry), 1);
 		new_entry->expires = 0;
 		new_entry->user_config = (HashTable *) pemalloc(sizeof(HashTable), 1);
-		zend_hash_init(new_entry->user_config, 0, NULL, (dtor_func_t) config_zval_dtor, 1);
-		zend_hash_update(&CGIG(user_config_cache), path, path_len + 1, new_entry, sizeof(user_config_cache_entry), (void **) &entry);
-		free(new_entry);
+		zend_hash_init(new_entry->user_config, 8, NULL, (dtor_func_t) config_zval_dtor, 1);
+		entry = zend_hash_str_update_ptr(&CGIG(user_config_cache), path, path_len, new_entry);
 	}
 
 	/* Check whether cache entry has expired and rescan if it is */
@@ -852,7 +845,7 @@ static int sapi_cgi_activate(TSRMLS_D)
 			server_name_len = strlen(server_name);
 			server_name = estrndup(server_name, server_name_len);
 			zend_str_tolower(server_name, server_name_len);
-			php_ini_activate_per_host_config(server_name, server_name_len + 1 TSRMLS_CC);
+			php_ini_activate_per_host_config(server_name, server_name_len TSRMLS_CC);
 			efree(server_name);
 		}
 	}
@@ -1482,7 +1475,7 @@ static void php_cgi_globals_ctor(php_cgi_globals_struct *php_cgi_globals TSRMLS_
 #ifdef PHP_WIN32
 	php_cgi_globals->impersonate = 0;
 #endif
-	zend_hash_init(&php_cgi_globals->user_config_cache, 0, NULL, (dtor_func_t) user_config_cache_entry_dtor, 1);
+	zend_hash_init(&php_cgi_globals->user_config_cache, 8, NULL, (dtor_func_t) user_config_cache_entry_dtor, 1);
 }
 /* }}} */
 
@@ -1571,7 +1564,7 @@ static void add_request_header(char *var, unsigned int var_len, char *val, unsig
 	} else {
 		return;
 	}
-	add_assoc_stringl_ex(return_value, var, var_len+1, val, val_len, 1);
+	add_assoc_stringl_ex(return_value, var, var_len+1, val, val_len);
 	if (str) {
 		free_alloca(var, use_heap);
 	}
@@ -1652,7 +1645,7 @@ PHP_FUNCTION(apache_request_headers) /* {{{ */
 				continue;
 			}
 			val++;
-			add_assoc_string_ex(return_value, var, var_len+1, val, 1);
+			add_assoc_string_ex(return_value, var, var_len, val);
 		}
 		if (t != buf && t != NULL) {
 			efree(t);
@@ -1681,7 +1674,7 @@ static void add_response_header(sapi_header_struct *h, zval *return_value TSRMLS
 				do {
 					p++;
 				} while (*p == ' ' || *p == '\t');
-				add_assoc_stringl_ex(return_value, s, len+1, p, h->header_len - (p - h->header), 1);
+				add_assoc_stringl_ex(return_value, s, len, p, h->header_len - (p - h->header));
 				free_alloca(s, use_heap);
 			}
 		}
@@ -2250,7 +2243,7 @@ consult the installation file that came with this distribution, or visit \n\
 
 				if (script_file) {
 					/* override path_translated if -f on command line */
-					STR_FREE(SG(request_info).path_translated);
+					if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 					SG(request_info).path_translated = script_file;
 					/* before registering argv to module exchange the *new* argv[0] */
 					/* we can achieve this without allocating more memory */
@@ -2259,7 +2252,7 @@ consult the installation file that came with this distribution, or visit \n\
 					SG(request_info).argv[0] = script_file;
 				} else if (argc > php_optind) {
 					/* file is on command line, but not in -f opt */
-					STR_FREE(SG(request_info).path_translated);
+					if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 					SG(request_info).path_translated = estrdup(argv[php_optind]);
 					/* arguments after the file are considered script args */
 					SG(request_info).argc = argc - php_optind;
@@ -2362,7 +2355,7 @@ consult the installation file that came with this distribution, or visit \n\
 						goto fastcgi_request_done;
 					}
 
-					STR_FREE(SG(request_info).path_translated);
+					if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 
 					if (free_query_string && SG(request_info).query_string) {
 						free(SG(request_info).query_string);
@@ -2503,7 +2496,7 @@ consult the installation file that came with this distribution, or visit \n\
 
 fastcgi_request_done:
 			{
-				STR_FREE(SG(request_info).path_translated);
+				if (SG(request_info).path_translated) efree(SG(request_info).path_translated);
 
 				php_request_shutdown((void *) 0);
 
diff --git a/sapi/cgi/fastcgi.c b/sapi/cgi/fastcgi.c
index 8ddc2e4577..585b6b8e87 100644
--- a/sapi/cgi/fastcgi.c
+++ b/sapi/cgi/fastcgi.c
@@ -411,7 +411,7 @@ int fcgi_init(void)
 		sa_t sa;
 		socklen_t len = sizeof(sa);
 #endif
-		zend_hash_init(&fcgi_mgmt_vars, 0, NULL, fcgi_free_mgmt_var_cb, 1);
+		zend_hash_init(&fcgi_mgmt_vars, 8, NULL, fcgi_free_mgmt_var_cb, 1);
 		fcgi_set_mgmt_var("FCGI_MPXS_CONNS", sizeof("FCGI_MPXS_CONNS")-1, "0", sizeof("0")-1);
 
 		is_initialized = 1;
@@ -973,7 +973,7 @@ static int fcgi_read_request(fcgi_request *req)
 		}
 	} else if (hdr.type == FCGI_GET_VALUES) {
 		unsigned char *p = buf + sizeof(fcgi_header);
-		zval ** value;
+		zval *value;
 		unsigned int zlen;
 		fcgi_hash_bucket *q;
 
@@ -989,10 +989,10 @@ static int fcgi_read_request(fcgi_request *req)
 
 		q = req->env.list;
 		while (q != NULL) {
-			if (zend_hash_find(&fcgi_mgmt_vars, q->var, q->var_len, (void**) &value) != SUCCESS) {
+			if ((value = zend_hash_str_find(&fcgi_mgmt_vars, q->var, q->var_len)) == NULL) {
 				continue;
 			}
-			zlen = Z_STRLEN_PP(value);
+			zlen = Z_STRLEN_P(value);
 			if ((p + 4 + 4 + q->var_len + zlen) >= (buf + sizeof(buf))) {
 				break;
 			}
@@ -1014,7 +1014,7 @@ static int fcgi_read_request(fcgi_request *req)
 			}
 			memcpy(p, q->var, q->var_len);
 			p += q->var_len;
-			memcpy(p, Z_STRVAL_PP(value), zlen);
+			memcpy(p, Z_STRVAL_P(value), zlen);
 			p += zlen;
 		}
 		len = p - buf - sizeof(fcgi_header);
@@ -1510,19 +1510,14 @@ void fcgi_impersonate(void)
 
 void fcgi_set_mgmt_var(const char * name, size_t name_len, const char * value, size_t value_len)
 {
-	zval * zvalue;
-	zvalue = pemalloc(sizeof(*zvalue), 1);
-	Z_TYPE_P(zvalue) = IS_STRING;
-	Z_STRVAL_P(zvalue) = pestrndup(value, value_len, 1);
-	Z_STRLEN_P(zvalue) = value_len;
-	zend_hash_add(&fcgi_mgmt_vars, name, name_len, &zvalue, sizeof(zvalue), NULL);
+	zval zvalue;
+	ZVAL_NEW_STR(&zvalue, STR_INIT(value, value_len, 1));
+	zend_hash_str_add(&fcgi_mgmt_vars, name, name_len, &zvalue);
 }
 
-void fcgi_free_mgmt_var_cb(void * ptr)
+void fcgi_free_mgmt_var_cb(zval *zv)
 {
-	zval ** var = (zval **)ptr;
-	pefree(Z_STRVAL_PP(var), 1);
-	pefree(*var, 1);
+	pefree(Z_STR_P(zv), 1);
 }
 
 /*
diff --git a/sapi/cgi/fastcgi.h b/sapi/cgi/fastcgi.h
index 702f51df6b..d5f141cd1b 100644
--- a/sapi/cgi/fastcgi.h
+++ b/sapi/cgi/fastcgi.h
@@ -139,7 +139,7 @@ void fcgi_impersonate(void);
 #endif
 
 void fcgi_set_mgmt_var(const char * name, size_t name_len, const char * value, size_t value_len);
-void fcgi_free_mgmt_var_cb(void * ptr);
+void fcgi_free_mgmt_var_cb(zval *zv);
 
 /*
  * Local variables:
diff --git a/sapi/cli/php_cli.c b/sapi/cli/php_cli.c
index 7c971176b6..2156cb14fc 100644
--- a/sapi/cli/php_cli.c
+++ b/sapi/cli/php_cli.c
@@ -173,8 +173,9 @@ const opt_struct OPTIONS[] = {
 	{'-', 0, NULL} /* end of args */
 };
 
-static int print_module_info(zend_module_entry *module TSRMLS_DC) /* {{{ */
+static int print_module_info(zval *element TSRMLS_DC) /* {{{ */
 {
+	zend_module_entry *module = (zend_module_entry*)Z_PTR_P(element);
 	php_printf("%s\n", module->name);
 	return ZEND_HASH_APPLY_KEEP;
 }
@@ -182,21 +183,20 @@ static int print_module_info(zend_module_entry *module TSRMLS_DC) /* {{{ */
 
 static int module_name_cmp(const void *a, const void *b TSRMLS_DC) /* {{{ */
 {
-	Bucket *f = *((Bucket **) a);
-	Bucket *s = *((Bucket **) b);
+	Bucket *f = (Bucket *) a;
+	Bucket *s = (Bucket *) b;
 
-	return strcasecmp(((zend_module_entry *)f->pData)->name,
-				  ((zend_module_entry *)s->pData)->name);
+	return strcasecmp(((zend_module_entry *)Z_PTR(f->val))->name,
+				  ((zend_module_entry *)Z_PTR(s->val))->name);
 }
 /* }}} */
 
 static void print_modules(TSRMLS_D) /* {{{ */
 {
 	HashTable sorted_registry;
-	zend_module_entry tmp;
 
-	zend_hash_init(&sorted_registry, 50, NULL, NULL, 1);
-	zend_hash_copy(&sorted_registry, &module_registry, NULL, &tmp, sizeof(zend_module_entry));
+	zend_hash_init(&sorted_registry, 50, NULL, NULL, 0);
+	zend_hash_copy(&sorted_registry, &module_registry, NULL);
 	zend_hash_sort(&sorted_registry, zend_qsort, module_name_cmp, 0 TSRMLS_CC);
 	zend_hash_apply(&sorted_registry, (apply_func_t) print_module_info TSRMLS_CC);
 	zend_hash_destroy(&sorted_registry);
@@ -425,10 +425,8 @@ static int php_cli_startup(sapi_module_struct *sapi_module) /* {{{ */
 
 /* overwriteable ini defaults must be set in sapi_cli_ini_defaults() */
 #define INI_DEFAULT(name,value)\
-	Z_SET_REFCOUNT(tmp, 0);\
-	Z_UNSET_ISREF(tmp);	\
-	ZVAL_STRINGL(&tmp, zend_strndup(value, sizeof(value)-1), sizeof(value)-1, 0);\
-	zend_hash_update(configuration_hash, name, sizeof(name), &tmp, sizeof(zval), NULL);\
+	ZVAL_NEW_STR(&tmp, STR_INIT(value, sizeof(value)-1, 1));\
+	zend_hash_str_update(configuration_hash, name, sizeof(name)-1, &tmp);\
 
 static void sapi_cli_ini_defaults(HashTable *configuration_hash)
 {
@@ -553,23 +551,16 @@ static php_stream *s_in_process = NULL;
 
 static void cli_register_file_handles(TSRMLS_D) /* {{{ */
 {
-	zval *zin, *zout, *zerr;
+	zval zin, zout, zerr;
 	php_stream *s_in, *s_out, *s_err;
 	php_stream_context *sc_in=NULL, *sc_out=NULL, *sc_err=NULL;
 	zend_constant ic, oc, ec;
 	
-	MAKE_STD_ZVAL(zin);
-	MAKE_STD_ZVAL(zout);
-	MAKE_STD_ZVAL(zerr);
-
 	s_in  = php_stream_open_wrapper_ex("php://stdin",  "rb", 0, NULL, sc_in);
 	s_out = php_stream_open_wrapper_ex("php://stdout", "wb", 0, NULL, sc_out);
 	s_err = php_stream_open_wrapper_ex("php://stderr", "wb", 0, NULL, sc_err);
 
 	if (s_in==NULL || s_out==NULL || s_err==NULL) {
-		FREE_ZVAL(zin);
-		FREE_ZVAL(zout);
-		FREE_ZVAL(zerr);
 		if (s_in) php_stream_close(s_in);
 		if (s_out) php_stream_close(s_out);
 		if (s_err) php_stream_close(s_err);
@@ -584,34 +575,27 @@ static void cli_register_file_handles(TSRMLS_D) /* {{{ */
 
 	s_in_process = s_in;
 
-	php_stream_to_zval(s_in,  zin);
-	php_stream_to_zval(s_out, zout);
-	php_stream_to_zval(s_err, zerr);
+	php_stream_to_zval(s_in,  &zin);
+	php_stream_to_zval(s_out, &zout);
+	php_stream_to_zval(s_err, &zerr);
 	
-	ic.value = *zin;
+	ZVAL_COPY_VALUE(&ic.value, &zin);
 	ic.flags = CONST_CS;
-	ic.name = zend_strndup(ZEND_STRL("STDIN"));
-	ic.name_len = sizeof("STDIN");
+	ic.name = STR_INIT("STDIN", sizeof("STDIN")-1, 1);
 	ic.module_number = 0;
 	zend_register_constant(&ic TSRMLS_CC);
 
-	oc.value = *zout;
+	ZVAL_COPY_VALUE(&oc.value, &zout);
 	oc.flags = CONST_CS;
-	oc.name = zend_strndup(ZEND_STRL("STDOUT"));
-	oc.name_len = sizeof("STDOUT");
+	oc.name = STR_INIT("STDOUT", sizeof("STDOUT")-1, 1);
 	oc.module_number = 0;
 	zend_register_constant(&oc TSRMLS_CC);
 
-	ec.value = *zerr;
+	ZVAL_COPY_VALUE(&ec.value, &zerr);
 	ec.flags = CONST_CS;
-	ec.name = zend_strndup(ZEND_STRL("STDERR"));
-	ec.name_len = sizeof("STDERR");
+	ec.name = STR_INIT("STDERR", sizeof("STDERR")-1, 1);
 	ec.module_number = 0;
 	zend_register_constant(&ec TSRMLS_CC);
-
-	FREE_ZVAL(zin);
-	FREE_ZVAL(zout);
-	FREE_ZVAL(zerr);
 }
 /* }}} */
 
@@ -673,11 +657,11 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 	int lineno = 0;
 	const char *param_error=NULL;
 	int hide_argv = 0;
+	zend_string *key;
 
 	zend_try {
 	
 		CG(in_compilation) = 0; /* not initialized but needed for several options */
-		EG(uninitialized_zval_ptr) = NULL;
 
 		while ((c = php_getopt(argc, argv, OPTIONS, &php_optarg, &php_optind, 0, 2)) != -1) {
 			switch (c) {
@@ -979,7 +963,9 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 			}
 		}
 
-		zend_is_auto_global("_SERVER", sizeof("_SERVER")-1 TSRMLS_CC);
+		key = STR_INIT("_SERVER", sizeof("_SERVER")-1, 0);
+		zend_is_auto_global(key TSRMLS_CC);
+		STR_RELEASE(key);
 
 		PG(during_request_startup) = 0;
 		switch (behavior) {
@@ -1040,30 +1026,23 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 			{
 				char *input;
 				size_t len, index = 0;
-				zval *argn, *argi;
+				zval argn, argi;
 
 				cli_register_file_handles(TSRMLS_C);
 
 				if (exec_begin && zend_eval_string_ex(exec_begin, NULL, "Command line begin code", 1 TSRMLS_CC) == FAILURE) {
 					exit_status=254;
 				}
-				ALLOC_ZVAL(argi);
-				Z_TYPE_P(argi) = IS_LONG;
-				Z_LVAL_P(argi) = index;
-				INIT_PZVAL(argi);
-				zend_hash_update(&EG(symbol_table), "argi", sizeof("argi"), &argi, sizeof(zval *), NULL);
+				ZVAL_LONG(&argi, index);
+				zend_hash_str_update(&EG(symbol_table).ht, "argi", sizeof("argi")-1, &argi);
 				while (exit_status == SUCCESS && (input=php_stream_gets(s_in_process, NULL, 0)) != NULL) {
 					len = strlen(input);
-					while (len-- && (input[len]=='\n' || input[len]=='\r')) {
+					while (len > 0 && len-- && (input[len]=='\n' || input[len]=='\r')) {
 						input[len] = '\0';
 					}
-					ALLOC_ZVAL(argn);
-					Z_TYPE_P(argn) = IS_STRING;
-					Z_STRLEN_P(argn) = ++len;
-					Z_STRVAL_P(argn) = estrndup(input, len);
-					INIT_PZVAL(argn);
-					zend_hash_update(&EG(symbol_table), "argn", sizeof("argn"), &argn, sizeof(zval *), NULL);
-					Z_LVAL_P(argi) = ++index;
+					ZVAL_STRINGL(&argn, input, len);
+					zend_hash_str_update(&EG(symbol_table).ht, "argn", sizeof("argn")-1, &argn);
+					Z_LVAL(argi) = ++index;
 					if (exec_run) {
 						if (zend_eval_string_ex(exec_run, NULL, "Command line run code", 1 TSRMLS_CC) == FAILURE) {
 							exit_status=254;
@@ -1087,13 +1066,14 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 
 				break;
 			}
+
 			case PHP_MODE_REFLECTION_FUNCTION:
 			case PHP_MODE_REFLECTION_CLASS:
 			case PHP_MODE_REFLECTION_EXTENSION:
 			case PHP_MODE_REFLECTION_ZEND_EXTENSION:
 				{
 					zend_class_entry *pce = NULL;
-					zval *arg, *ref;
+					zval arg, ref;
 					zend_execute_data execute_data;
 
 					switch (behavior) {
@@ -1117,24 +1097,24 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 							break;
 					}
 					
-					MAKE_STD_ZVAL(arg);
-					ZVAL_STRING(arg, reflection_what, 1);
-					ALLOC_ZVAL(ref);
-					object_init_ex(ref, pce);
-					INIT_PZVAL(ref);
+					ZVAL_STRING(&arg, reflection_what);
+					object_init_ex(&ref, pce);
 
 					memset(&execute_data, 0, sizeof(zend_execute_data));
 					EG(current_execute_data) = &execute_data;
 					EX(function_state).function = pce->constructor;
-					zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, arg);
+					zend_call_method_with_1_params(&ref, pce, &pce->constructor, "__construct", NULL, &arg);
 
 					if (EG(exception)) {
-						zval *msg = zend_read_property(zend_exception_get_default(TSRMLS_C), EG(exception), "message", sizeof("message")-1, 0 TSRMLS_CC);
+						zval tmp, *msg;
+
+						ZVAL_OBJ(&tmp, EG(exception));
+						msg = zend_read_property(zend_exception_get_default(TSRMLS_C), &tmp, "message", sizeof("message")-1, 0 TSRMLS_CC);
 						zend_printf("Exception: %s\n", Z_STRVAL_P(msg));
-						zval_ptr_dtor(&EG(exception));
+						zval_ptr_dtor(&tmp);
 						EG(exception) = NULL;
 					} else {
-						zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, ref);
+						zend_call_method_with_1_params(NULL, reflection_ptr, NULL, "export", NULL, &ref);
 					}
 					zval_ptr_dtor(&ref);
 					zval_ptr_dtor(&arg);
@@ -1147,7 +1127,7 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 					char *lcname = zend_str_tolower_dup(reflection_what, len);
 					zend_module_entry *module;
 
-					if (zend_hash_find(&module_registry, lcname, len+1, (void**)&module) == FAILURE) {
+					if ((module = zend_hash_str_find_ptr(&module_registry, lcname, len)) == NULL) {
 						if (!strcmp(reflection_what, "main")) {
 							display_ini_entries(NULL);
 						} else {
@@ -1161,6 +1141,7 @@ static int do_cli(int argc, char **argv TSRMLS_DC) /* {{{ */
 					efree(lcname);
 					break;
 				}
+
 			case PHP_MODE_SHOW_INI_CONFIG:
 				{
 					zend_printf("Configuration File (php.ini) Path: %s\n", PHP_CONFIG_FILE_PATH);
diff --git a/sapi/cli/php_cli_process_title.c b/sapi/cli/php_cli_process_title.c
index dec5613670..298300f065 100644
--- a/sapi/cli/php_cli_process_title.c
+++ b/sapi/cli/php_cli_process_title.c
@@ -66,7 +66,7 @@ PHP_FUNCTION(cli_get_process_title)
                 RETURN_NULL();
         }
 
-        RETURN_STRINGL(title, length, 1);
+        RETURN_STRINGL(title, length);
 }
 /* }}} */
 
diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c
index e9bc9dcdc0..ccbbf0521b 100644
--- a/sapi/cli/php_cli_server.c
+++ b/sapi/cli/php_cli_server.c
@@ -369,9 +369,9 @@ int php_cli_server_get_system_time(char *buf) {
 }
 #endif
 
-static void char_ptr_dtor_p(char **p) /* {{{ */
-{
-	pefree(*p, 1);
+static void char_ptr_dtor_p(zval *zv) /* {{{ */
+{	
+	pefree(Z_PTR_P(zv), 1);
 } /* }}} */
 
 static char *get_last_error() /* {{{ */
@@ -452,11 +452,11 @@ static void append_http_status_line(smart_str *buffer, int protocol_version, int
 static void append_essential_headers(smart_str* buffer, php_cli_server_client *client, int persistent) /* {{{ */
 {
 	{
-		char **val;
-		if (SUCCESS == zend_hash_find(&client->request.headers, "host", sizeof("host"), (void**)&val)) {
+		char *val;
+		if (NULL != (val = zend_hash_str_find_ptr(&client->request.headers, "host", sizeof("host")-1))) {
 			smart_str_appendl_ex(buffer, "Host", sizeof("Host") - 1, persistent);
 			smart_str_appendl_ex(buffer, ": ", sizeof(": ") - 1, persistent);
-			smart_str_appends_ex(buffer, *val, persistent);
+			smart_str_appends_ex(buffer, val, persistent);
 			smart_str_appendl_ex(buffer, "\r\n", 2, persistent);
 		}
 	}
@@ -479,9 +479,8 @@ PHP_FUNCTION(apache_request_headers) /* {{{ */
 {
 	php_cli_server_client *client;
 	HashTable *headers;
-	char *key;
-	uint key_len;
-	char **value_pointer;
+	zend_string *key;
+	char *value;
 	HashPosition pos;
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -494,9 +493,10 @@ PHP_FUNCTION(apache_request_headers) /* {{{ */
 	array_init_size(return_value, zend_hash_num_elements(headers));
 
 	zend_hash_internal_pointer_reset_ex(headers, &pos);
-	while (zend_hash_get_current_data_ex(headers, (void **)&value_pointer, &pos) == SUCCESS) {
-		zend_hash_get_current_key_ex(headers, &key, &key_len, NULL, 0, &pos);
-		add_assoc_string_ex(return_value, key, key_len, *value_pointer, 1);
+	while ((value = zend_hash_get_current_data_ptr_ex(headers, &pos)) != NULL) {
+		zend_hash_get_current_key_ex(headers, &key, NULL, 0, &pos);
+//???
+		add_assoc_string_ex(return_value, key->val, key->len, value);
 		zend_hash_move_forward_ex(headers, &pos);
 	}
 }
@@ -522,7 +522,7 @@ static void add_response_header(sapi_header_struct *h, zval *return_value TSRMLS
 				do {
 					p++;
 				} while (*p == ' ' || *p == '\t');
-				add_assoc_stringl_ex(return_value, s, len+1, p, h->header_len - (p - h->header), 1);
+				add_assoc_stringl_ex(return_value, s, len, p, h->header_len - (p - h->header));
 				free_alloca(s, use_heap);
 			}
 		}
@@ -672,7 +672,7 @@ static int sapi_cli_server_send_headers(sapi_headers_struct *sapi_headers TSRMLS
 	}
 	smart_str_appendl(&buffer, "\r\n", 2);
 
-	php_cli_server_client_send_through(client, buffer.c, buffer.len);
+	php_cli_server_client_send_through(client, buffer.s->val, buffer.s->len);
 
 	smart_str_free(&buffer);
 	return SAPI_HEADER_SENT_SUCCESSFULLY;
@@ -682,11 +682,11 @@ static int sapi_cli_server_send_headers(sapi_headers_struct *sapi_headers TSRMLS
 static char *sapi_cli_server_read_cookies(TSRMLS_D) /* {{{ */
 {
 	php_cli_server_client *client = SG(server_context);
-	char **val;
-	if (FAILURE == zend_hash_find(&client->request.headers, "cookie", sizeof("cookie"), (void**)&val)) {
+	char *val;
+	if (NULL == (val = zend_hash_str_find_ptr(&client->request.headers, "cookie", sizeof("cookie")-1))) {
 		return NULL;
 	}
-	return *val;
+	return val;
 } /* }}} */
 
 static int sapi_cli_server_read_post(char *buf, uint count_bytes TSRMLS_DC) /* {{{ */
@@ -713,11 +713,11 @@ static void sapi_cli_server_register_variable(zval *track_vars_array, const char
 
 static int sapi_cli_server_register_entry_cb(char **entry TSRMLS_DC, int num_args, va_list args, zend_hash_key *hash_key) /* {{{ */ {
 	zval *track_vars_array = va_arg(args, zval *);
-	if (hash_key->nKeyLength) {
+	if (hash_key->key) {
 		char *real_key, *key;
 		uint i;
-		key = estrndup(hash_key->arKey, hash_key->nKeyLength);
-		for(i=0; i<hash_key->nKeyLength; i++) {
+		key = estrndup(hash_key->key->val, hash_key->key->len);
+		for(i=0; i<hash_key->key->len; i++) {
 			if (key[i] == '-') {
 				key[i] = '_';
 			} else {
@@ -1053,7 +1053,7 @@ static php_cli_server_chunk *php_cli_server_chunk_immortal_new(const char *buf,
 	return chunk;
 } /* }}} */
 
-static php_cli_server_chunk *php_cli_server_chunk_heap_new(char *block, char *buf, size_t len) /* {{{ */
+static php_cli_server_chunk *php_cli_server_chunk_heap_new(void *block, char *buf, size_t len) /* {{{ */
 {
 	php_cli_server_chunk *chunk = pemalloc(sizeof(php_cli_server_chunk), 1);
 	if (!chunk) {
@@ -1414,7 +1414,7 @@ static int php_cli_server_request_ctor(php_cli_server_request *req) /* {{{ */
 	req->path_info_len = 0;
 	req->query_string = NULL;
 	req->query_string_len = 0;
-	zend_hash_init(&req->headers, 0, NULL, (void(*)(void*))char_ptr_dtor_p, 1);
+	zend_hash_init(&req->headers, 0, NULL, char_ptr_dtor_p, 1);
 	zend_hash_init(&req->headers_original_case, 0, NULL, NULL, 1);
 	req->content = NULL;
 	req->content_len = 0;
@@ -1685,8 +1685,8 @@ static int php_cli_server_client_read_request_on_header_value(php_http_parser *p
 	}
 	{
 		char *header_name = zend_str_tolower_dup(client->current_header_name, client->current_header_name_len);
-		zend_hash_add(&client->request.headers, header_name, client->current_header_name_len + 1, &value, sizeof(char *), NULL);
-		zend_hash_add(&client->request.headers_original_case, client->current_header_name, client->current_header_name_len + 1, &value, sizeof(char *), NULL);
+		zend_hash_str_add_ptr(&client->request.headers, header_name, client->current_header_name_len, value);
+		zend_hash_str_add_ptr(&client->request.headers_original_case, client->current_header_name, client->current_header_name_len, value);
 		efree(header_name);
 	}
 
@@ -1836,7 +1836,7 @@ static size_t php_cli_server_client_send_through(php_cli_server_client *client,
 
 static void php_cli_server_client_populate_request_info(const php_cli_server_client *client, sapi_request_info *request_info) /* {{{ */
 {
-	char **val;
+	char *val;
 
 	request_info->request_method = php_http_method_str(client->request.request_method);
 	request_info->proto_num = client->request.protocol_version;
@@ -1845,8 +1845,8 @@ static void php_cli_server_client_populate_request_info(const php_cli_server_cli
 	request_info->query_string = client->request.query_string;
 	request_info->content_length = client->request.content_len;
 	request_info->auth_user = request_info->auth_password = request_info->auth_digest = NULL;
-	if (SUCCESS == zend_hash_find(&client->request.headers, "content-type", sizeof("content-type"), (void**)&val)) {
-		request_info->content_type = *val;
+	if (NULL != (val = zend_hash_str_find_ptr(&client->request.headers, "content-type", sizeof("content-type")-1))) {
+		request_info->content_type = val;
 	}
 } /* }}} */
 
@@ -1906,8 +1906,7 @@ static void php_cli_server_close_connection(php_cli_server *server, php_cli_serv
 
 static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server_client *client, int status TSRMLS_DC) /* {{{ */
 {
-	char *escaped_request_uri = NULL;
-	size_t escaped_request_uri_len;
+	zend_string *escaped_request_uri = NULL;
 	const char *status_string = get_status_string(status);
 	const char *content_template = get_template_string(status);
 	char *errstr = get_last_error();
@@ -1916,7 +1915,7 @@ static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server
 	php_cli_server_content_sender_ctor(&client->content_sender);
 	client->content_sender_initialized = 1;
 
-	escaped_request_uri = php_escape_html_entities_ex((unsigned char *)client->request.request_uri, client->request.request_uri_len, &escaped_request_uri_len, 0, ENT_QUOTES, NULL, 0 TSRMLS_CC);
+	escaped_request_uri = php_escape_html_entities_ex((unsigned char *)client->request.request_uri, client->request.request_uri_len, 0, ENT_QUOTES, NULL, 0 TSRMLS_CC);
 
 	{
 		static const char prologue_template[] = "<!doctype html><html><head><title>%d %s</title>";
@@ -1924,7 +1923,7 @@ static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server
 		if (!chunk) {
 			goto fail;
 		}
-		snprintf(chunk->data.heap.p, chunk->data.heap.len, prologue_template, status, status_string, escaped_request_uri);
+		snprintf(chunk->data.heap.p, chunk->data.heap.len, prologue_template, status, status_string, escaped_request_uri->val);
 		chunk->data.heap.len = strlen(chunk->data.heap.p);
 		php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
 	}
@@ -1944,11 +1943,11 @@ static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server
 		php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
 	}
 	{
-		php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(strlen(content_template) + escaped_request_uri_len + 3 + strlen(status_string) + 1);
+		php_cli_server_chunk *chunk = php_cli_server_chunk_heap_new_self_contained(strlen(content_template) + escaped_request_uri->len + 3 + strlen(status_string) + 1);
 		if (!chunk) {
 			goto fail;
 		}
-		snprintf(chunk->data.heap.p, chunk->data.heap.len, content_template, status_string, escaped_request_uri);
+		snprintf(chunk->data.heap.p, chunk->data.heap.len, content_template, status_string, escaped_request_uri->val);
 		chunk->data.heap.len = strlen(chunk->data.heap.p);
 		php_cli_server_buffer_append(&client->content_sender.buffer, chunk);
 	}
@@ -1965,7 +1964,7 @@ static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server
 		php_cli_server_chunk *chunk;
 		smart_str buffer = { 0 };
 		append_http_status_line(&buffer, client->request.protocol_version, status, 1);
-		if (!buffer.c) {
+		if (!buffer.s) {
 			/* out of memory */
 			goto fail;
 		}
@@ -1976,7 +1975,7 @@ static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server
 		smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
 		smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
 
-		chunk = php_cli_server_chunk_heap_new(buffer.c, buffer.c, buffer.len);
+		chunk = php_cli_server_chunk_heap_new(buffer.s, buffer.s->val, buffer.s->len);
 		if (!chunk) {
 			smart_str_free_ex(&buffer, 1);
 			goto fail;
@@ -1989,14 +1988,14 @@ static int php_cli_server_send_error_page(php_cli_server *server, php_cli_server
 	if (errstr) {
 		pefree(errstr, 1);
 	}
-	efree(escaped_request_uri);
+	STR_FREE(escaped_request_uri);
 	return SUCCESS;
 
 fail:
 	if (errstr) {
 		pefree(errstr, 1);
 	}
-	efree(escaped_request_uri);
+	STR_FREE(escaped_request_uri);
 	return FAILURE;
 } /* }}} */
 
@@ -2050,7 +2049,7 @@ static int php_cli_server_begin_send_static(php_cli_server *server, php_cli_serv
 		}
 
 		append_http_status_line(&buffer, client->request.protocol_version, status, 1);
-		if (!buffer.c) {
+		if (!buffer.s) {
 			/* out of memory */
 			php_cli_server_log_response(client, 500, NULL TSRMLS_CC);
 			return FAILURE;
@@ -2066,7 +2065,7 @@ static int php_cli_server_begin_send_static(php_cli_server *server, php_cli_serv
 		smart_str_append_generic_ex(&buffer, client->request.sb.st_size, 1, size_t, _unsigned);
 		smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
 		smart_str_appendl_ex(&buffer, "\r\n", 2, 1);
-		chunk = php_cli_server_chunk_heap_new(buffer.c, buffer.c, buffer.len);
+		chunk = php_cli_server_chunk_heap_new(buffer.s, buffer.s->val, buffer.s->len);
 		if (!chunk) {
 			smart_str_free_ex(&buffer, 1);
 			php_cli_server_log_response(client, 500, NULL TSRMLS_CC);
@@ -2081,10 +2080,10 @@ static int php_cli_server_begin_send_static(php_cli_server *server, php_cli_serv
 /* }}} */
 
 static int php_cli_server_request_startup(php_cli_server *server, php_cli_server_client *client TSRMLS_DC) { /* {{{ */
-	char **auth;
+	char *auth;
 	php_cli_server_client_populate_request_info(client, &SG(request_info));
-	if (SUCCESS == zend_hash_find(&client->request.headers, "authorization", sizeof("authorization"), (void**)&auth)) {
-		php_handle_auth_data(*auth TSRMLS_CC);
+	if (NULL != (auth = zend_hash_str_find_ptr(&client->request.headers, "authorization", sizeof("authorization")-1))) {
+		php_handle_auth_data(auth TSRMLS_CC);
 	}
 	SG(sapi_headers).http_response_code = 200;
 	if (FAILURE == php_request_startup(TSRMLS_C)) {
@@ -2126,10 +2125,10 @@ static int php_cli_server_dispatch_router(php_cli_server *server, php_cli_server
 	zfd.opened_path = NULL;
 
 	zend_try {
-		zval *retval = NULL;
+		zval retval;
 		if (SUCCESS == zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, &retval, 1, &zfd)) {
-			if (retval) {
-				decline = Z_TYPE_P(retval) == IS_BOOL && !Z_LVAL_P(retval);
+			if (Z_TYPE(retval) != IS_UNDEF) {
+				decline = Z_TYPE(retval) == IS_BOOL && !Z_LVAL(retval);
 				zval_ptr_dtor(&retval);
 			}
 		} else {
@@ -2221,12 +2220,14 @@ static void php_cli_server_dtor(php_cli_server *server TSRMLS_DC) /* {{{ */
 	}
 } /* }}} */
 
-static void php_cli_server_client_dtor_wrapper(php_cli_server_client **p) /* {{{ */
+static void php_cli_server_client_dtor_wrapper(zval *zv) /* {{{ */
 {
-	closesocket((*p)->sock);
-	php_cli_server_poller_remove(&(*p)->server->poller, POLLIN | POLLOUT, (*p)->sock);
-	php_cli_server_client_dtor(*p);
-	pefree(*p, 1);
+	php_cli_server_client *p = Z_PTR_P(zv);
+
+	closesocket(p->sock);
+	php_cli_server_poller_remove(&p->server->poller, POLLIN | POLLOUT, p->sock);
+	php_cli_server_client_dtor(p);
+	pefree(p, 1);
 } /* }}} */
 
 static int php_cli_server_ctor(php_cli_server *server, const char *addr, const char *document_root, const char *router TSRMLS_DC) /* {{{ */
@@ -2297,7 +2298,7 @@ static int php_cli_server_ctor(php_cli_server *server, const char *addr, const c
 	server->host = host;
 	server->port = port;
 
-	zend_hash_init(&server->clients, 0, NULL, (void(*)(void*))php_cli_server_client_dtor_wrapper, 1);
+	zend_hash_init(&server->clients, 0, NULL, php_cli_server_client_dtor_wrapper, 1);
 
 	{
 		size_t document_root_len = strlen(document_root);
@@ -2441,16 +2442,16 @@ static int php_cli_server_do_event_for_each_fd_callback(void *_params, int fd, i
 #ifdef DEBUG
 		php_cli_server_logf("%s Accepted" TSRMLS_CC, client->addr_str);
 #endif
-		zend_hash_index_update(&server->clients, client_sock, &client, sizeof(client), NULL);
+		zend_hash_index_update_ptr(&server->clients, client_sock, client);
 		php_cli_server_recv_event_read_request(server, client TSRMLS_CC);
 	} else {
-		php_cli_server_client **client;
-		if (SUCCESS == zend_hash_index_find(&server->clients, fd, (void **)&client)) {
+		php_cli_server_client *client;
+		if (NULL != (client = zend_hash_index_find_ptr(&server->clients, fd))) {
 			if (event & POLLIN) {
-				params->rhandler(server, *client TSRMLS_CC);
+				params->rhandler(server, client TSRMLS_CC);
 			}
 			if (event & POLLOUT) {
-				params->whandler(server, *client TSRMLS_CC);
+				params->whandler(server, client TSRMLS_CC);
 			}
 		}
 	}
diff --git a/sapi/cli/tests/006.phpt b/sapi/cli/tests/006.phpt
index 3d5c916e9c..e9e8b7e219 100644
--- a/sapi/cli/tests/006.phpt
+++ b/sapi/cli/tests/006.phpt
@@ -34,6 +34,9 @@ string(%d) "Extension [ <persistent> extension #%d pcre version <no_version> ] {
     Entry [ pcre.recursion_limit <ALL> ]
       Current = '%d'
     }
+    Entry [ pcre.jit <ALL> ]
+      Current = '%d'
+    }
   }
 
   - Constants [14] {
diff --git a/sapi/fpm/fpm/fpm_main.c b/sapi/fpm/fpm/fpm_main.c
index 807ea8bb5d..9b2878dd63 100644
--- a/sapi/fpm/fpm/fpm_main.c
+++ b/sapi/fpm/fpm/fpm_main.c
@@ -224,11 +224,11 @@ static int print_module_info(zend_module_entry *module, void *arg TSRMLS_DC)
 
 static int module_name_cmp(const void *a, const void *b TSRMLS_DC)
 {
-	Bucket *f = *((Bucket **) a);
-	Bucket *s = *((Bucket **) b);
+	Bucket *f = (Bucket *) a;
+	Bucket *s = (Bucket *) b;
 
-	return strcasecmp(	((zend_module_entry *)f->pData)->name,
-						((zend_module_entry *)s->pData)->name);
+	return strcasecmp(	((zend_module_entry *)f->xData)->name,
+						((zend_module_entry *)s->xData)->name);
 }
 
 static void print_modules(TSRMLS_D)
@@ -784,7 +784,7 @@ static int sapi_cgi_activate(TSRMLS_D)
 			server_name_len = strlen(server_name);
 			server_name = estrndup(server_name, server_name_len);
 			zend_str_tolower(server_name, server_name_len);
-			php_ini_activate_per_host_config(server_name, server_name_len + 1 TSRMLS_CC);
+			php_ini_activate_per_host_config(server_name, server_name_len TSRMLS_CC);
 			efree(server_name);
 		}
 	}
diff --git a/sapi/litespeed/lsapi_main.c b/sapi/litespeed/lsapi_main.c
index 63051c1645..56f1cb5d97 100644
--- a/sapi/litespeed/lsapi_main.c
+++ b/sapi/litespeed/lsapi_main.c
@@ -1092,7 +1092,7 @@ zend_module_entry litespeed_module_entry = {
 static int add_associate_array( const char * pKey, int keyLen, const char * pValue, int valLen,
                          void * arg )
 {
-    add_assoc_string_ex( (zval *)arg, (char *)pKey, keyLen+1, (char *)pValue, 1 );
+    add_assoc_string_ex( (zval *)arg, (char *)pKey, keyLen+1, (char *)pValue);
     return 1;
 }
 
@@ -1146,7 +1146,7 @@ PHP_FUNCTION(litespeed_response_headers)
                 headerBuf[len] = 0;
                 if ( len ) {
                     while( isspace(*++p));
-                    add_assoc_string_ex(return_value, headerBuf, len+1, p, 1 );
+                    add_assoc_string_ex(return_value, headerBuf, len+1, p);
                 }
             }
         }
@@ -1166,10 +1166,10 @@ PHP_FUNCTION(apache_get_modules)
         WRONG_PARAM_COUNT;
     }
     array_init(return_value);
-    add_next_index_string(return_value, "mod_rewrite", 1);
-    add_next_index_string(return_value, "mod_mime", 1);
-    add_next_index_string(return_value, "mod_headers", 1);
-    add_next_index_string(return_value, "mod_expires", 1);
+    add_next_index_string(return_value, "mod_rewrite");
+    add_next_index_string(return_value, "mod_mime");
+    add_next_index_string(return_value, "mod_headers");
+    add_next_index_string(return_value, "mod_expires");
 }
 /* }}} */
 
diff --git a/sapi/milter/php_milter.c b/sapi/milter/php_milter.c
index e0b2d0a0af..2f8e8117c2 100644
--- a/sapi/milter/php_milter.c
+++ b/sapi/milter/php_milter.c
@@ -290,7 +290,7 @@ static sfsistat mlfi_envfrom(SMFICTX *ctx, char **argv)
 	array_init(param[0]);
 
 	while (*argv) {
-		add_next_index_string(param[0], *argv, 1);
+		add_next_index_string(param[0], *argv);
 		argv++;
 	}
 
@@ -330,7 +330,7 @@ static sfsistat mlfi_envrcpt(SMFICTX *ctx, char **argv)
 	array_init(param[0]);
 
 	while (*argv) {
-		add_next_index_string(param[0], *argv, 1);
+		add_next_index_string(param[0], *argv);
 		argv++;
 	}
 
diff --git a/sapi/nsapi/nsapi.c b/sapi/nsapi/nsapi.c
index 5ed133c18d..496596d773 100644
--- a/sapi/nsapi/nsapi.c
+++ b/sapi/nsapi/nsapi.c
@@ -414,7 +414,7 @@ PHP_FUNCTION(nsapi_request_headers)
 	for (i=0; i < rc->rq->headers->hsize; i++) {
 		entry=rc->rq->headers->ht[i];
 		while (entry) {
-			add_assoc_string(return_value, entry->param->name, entry->param->value, 1);
+			add_assoc_string(return_value, entry->param->name, entry->param->value);
 			entry=entry->next;
 		}
   	}
@@ -438,7 +438,7 @@ PHP_FUNCTION(nsapi_response_headers)
 	for (i=0; i < rc->rq->srvhdrs->hsize; i++) {
 		entry=rc->rq->srvhdrs->ht[i];
 		while (entry) {
-			add_assoc_string(return_value, entry->param->name, entry->param->value, 1);
+			add_assoc_string(return_value, entry->param->name, entry->param->value);
 			entry=entry->next;
 		}
   	}
diff --git a/tests/classes/bug63462.phpt b/tests/classes/bug63462.phpt
index dc5edbd5e1..119bf592c2 100644
--- a/tests/classes/bug63462.phpt
+++ b/tests/classes/bug63462.phpt
@@ -2,8 +2,6 @@
 Test script to verify that magic methods should be called only once when accessing an unset property.
 --CREDITS--
 Marco Pivetta <ocramius@gmail.com>
---XFAIL--
-Bug 63462 is not yet fixed
 --FILE--
 <?php
 class Test {
@@ -54,13 +52,17 @@ $test->privateProperty   = 'value';
 
 --EXPECTF--
 __get nonExisting
-Notice: Undefined index: nonExisting in %__set__get_006.php on line %d
+
+Notice: Undefined property: Test::$nonExisting in %sbug63462.php on line %d
 __get publicProperty
-Notice: Undefined index: publicProperty in %__set__get_006.php on line %d
+
+Notice: Undefined property: Test::$publicProperty in %sbug63462.php on line %d
 __get protectedProperty
-Notice: Undefined index: protectedProperty in %__set__get_006.php on line %d
+
+Notice: Undefined property: Test::$protectedProperty in %sbug63462.php on line %d
 __get privateProperty
-Notice: Undefined index: privateProperty in %__set__get_006.php on line %d
+
+Notice: Undefined property: Test::$privateProperty in %sbug63462.php on line %d
 __isset nonExisting
 __isset publicProperty
 __isset protectedProperty
diff --git a/tests/classes/constants_error_002.phpt b/tests/classes/constants_error_002.phpt
index 610a42da9b..be27971b87 100644
--- a/tests/classes/constants_error_002.phpt
+++ b/tests/classes/constants_error_002.phpt
@@ -2,11 +2,11 @@
 Error case: class constant as an array
 --FILE--
 <?php
-class myclass
-{
-	const myConst = array();
-}
+  class myclass
+  {
+      const myConst = array();
+  }
 ?>
-===DONE===
 --EXPECTF--
-===DONE===
+
+Fatal error: Arrays are not allowed in class constants in %s on line 4
diff --git a/tests/classes/inheritance_007.phpt b/tests/classes/inheritance_007.phpt
index 0b2bde0350..46100449c4 100644
--- a/tests/classes/inheritance_007.phpt
+++ b/tests/classes/inheritance_007.phpt
@@ -20,14 +20,14 @@ $b->b();
 --EXPECTF--
 array(2) {
   [0]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(1) "B"
     ["class"]=>
     string(1) "A"
   }
   [1]=>
-  &object(ReflectionMethod)#%d (2) {
+  object(ReflectionMethod)#%d (2) {
     ["name"]=>
     string(1) "A"
     ["class"]=>