Merge branch 'refactoring2' of github.com:zend-dev/php into refactoring2

2 files changed, 241 insertions, 272 deletions

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index bc18cc9118..61d2276f13 100644
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -717,7 +717,8 @@ END_EXTERN_C()
 }
 
 #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/ext/spl/spl_array.c b/ext/spl/spl_array.c
index 541f7b67a7..3cd58c75f1 100644
--- a/ext/spl/spl_array.c
+++ b/ext/spl/spl_array.c
@@ -64,8 +64,8 @@ PHPAPI zend_class_entry  *spl_ce_RecursiveArrayIterator;
 
 typedef struct _spl_array_object {
 	zend_object       std;
-	zval              *array;
-	zval              *retval;
+	zval              array;
+	zval              retval;
 	HashPosition      pos;
 	ulong             pos_h;
 	int               ar_flags;
@@ -86,8 +86,8 @@ static inline HashTable *spl_array_get_hash_table(spl_array_object* intern, int
 			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  = (spl_array_object*)Z_OBJ_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,7 +95,7 @@ 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);
 	}
 } /* }}} */
 
@@ -123,16 +123,16 @@ SPL_API int spl_hash_verify_pos_ex(spl_array_object * intern, HashTable * ht TSR
 
 /*	HASH_PROTECT_RECURSION(ht);*/
 	if (ht->flags & HASH_FLAG_PACKED) {
-		if (intern->pos_h == intern->pos && ht->arData[intern->pos_h].xData) {
+		if (intern->pos_h == intern->pos && Z_TYPE(ht->arData[intern->pos_h].val) != IS_UNDEF) {
 			return SUCCESS;
 		}
 	} else {
-		idx = ht->arHash[intern->pos_h & ht->nTableMask].idx;
+		idx = ht->arHash[intern->pos_h & ht->nTableMask];
 		while (idx != INVALID_IDX) {		
 			if (idx == intern->pos) {
 				return SUCCESS;
 			}
-			idx = ht->arData[idx].next;
+			idx = ht->arData[idx].val.u.next;
 		}
 	}
 /*	HASH_UNPROTECT_RECURSION(ht); */
@@ -170,18 +170,14 @@ static void spl_array_object_free_storage(void *object TSRMLS_DC)
 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;
 	int inherited = 0;
 
 	intern = emalloc(sizeof(spl_array_object));
 	memset(intern, 0, sizeof(spl_array_object));
-	*obj = intern;
-	ALLOC_INIT_ZVAL(intern->retval);
 
 	zend_object_std_init(&intern->std, class_type TSRMLS_CC);
 	object_properties_init(&intern->std, class_type);
@@ -190,7 +186,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 = (spl_array_object*)Z_OBJ_P(orig);
 
 		intern->ar_flags &= ~ SPL_ARRAY_CLONE_MASK;
 		intern->ar_flags |= (other->ar_flags & SPL_ARRAY_CLONE_MASK);
@@ -198,32 +194,30 @@ 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);
+	zend_objects_store_put(&intern->std 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;
@@ -233,36 +227,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;
@@ -274,72 +268,70 @@ 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;
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
+	zval *retval;
 	long index;
 	HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
+	zend_string *offset_key;
 
-	if (!offset) {
-		return &EG(uninitialized_zval_ptr);
+	if (ZVAL_IS_UNDEF(offset)) {
+		return &EG(uninitialized_zval);
 	}
 
 	if ((type == BP_VAR_W || type == BP_VAR_RW) && (ht->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:
+		if ((retval = (zend_symtable_find(ht, offset_key))) == NULL) {
 			switch (type) {
 				case BP_VAR_R:
 					zend_error(E_NOTICE, "Undefined index: %s", Z_STRVAL_P(offset));
 				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));
 				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_UNDEF(&value);
+				    retval = zend_symtable_update(ht, Z_STR_P(offset), &value);
 				}
 			}
 		}
@@ -354,20 +346,20 @@ static zval **spl_array_get_dimension_ptr_ptr(int check_inherited, zval *object,
 		} else {
 			index = Z_LVAL_P(offset);
 		}
-		if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) {
+		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);
 			   }
 			}
 		}
@@ -375,58 +367,48 @@ 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) /* {{{ */
 {
-	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 = (spl_array_object*)Z_OBJ_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);
 
+	return 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) */
+	 * 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);
+		Z_SET_ISREF_P(ret);
 	}
-
-	return *ret;
+	*/
 } /* }}} */
 
 static zval *spl_array_read_dimension(zval *object, zval *offset, int type TSRMLS_DC) /* {{{ */
@@ -436,18 +418,20 @@ static zval *spl_array_read_dimension(zval *object, zval *offset, int type TSRML
 
 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 = (spl_array_object*)Z_OBJ_P(object);
 	long index;
 	HashTable *ht;
 
 	if (check_inherited && intern->fptr_offset_set) {
+		zval tmp;
 		if (!offset) {
-			ALLOC_INIT_ZVAL(offset);
+			ZVAL_UNDEF(&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;
 	}
 
@@ -458,7 +442,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
 			return;
 		}
 		Z_ADDREF_P(value);
-		zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);
+		zend_hash_next_index_insert(ht, value);
 		return;
 	}
 	switch(Z_TYPE_P(offset)) {
@@ -469,7 +453,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
 			return;
 		}
 		Z_ADDREF_P(value);
-		zend_symtable_update(ht, Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, (void**)&value, sizeof(void*), NULL);
+		zend_symtable_update(ht, Z_STR_P(offset), value);
 		return;
 	case IS_DOUBLE:
 	case IS_RESOURCE:
@@ -486,7 +470,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
 			index = Z_LVAL_P(offset);
 		}
 		Z_ADDREF_P(value);
-		zend_hash_index_update(ht, index, (void**)&value, sizeof(void*), NULL);
+		zend_hash_index_update(ht, index, value);
 		return;
 	case IS_NULL:
 		ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
@@ -495,7 +479,7 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
 			return;
 		}
 		Z_ADDREF_P(value);
-		zend_hash_next_index_insert(ht, (void**)&value, sizeof(void*), NULL);
+		zend_hash_next_index_insert(ht, value);
 		return;
 	default:
 		zend_error(E_WARNING, "Illegal offset type");
@@ -510,14 +494,14 @@ 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 = (spl_array_object*)Z_OBJ_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;
 	}
 
@@ -528,12 +512,12 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval
 			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) {
+			if (zend_symtable_del(ht, Z_STR_P(offset)) == FAILURE) {
 				zend_error(E_NOTICE,"Undefined index: %s", Z_STRVAL_P(offset));
 			} else {
 				spl_array_object *obj = intern;
@@ -541,12 +525,12 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval
 				while (1) {
 					if ((obj->ar_flags & SPL_ARRAY_IS_SELF) != 0) {
 						break;
-					} else if (Z_TYPE_P(obj->array) == IS_OBJECT) {
+					} else if (Z_TYPE(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);
+							obj = (spl_array_object*)Z_OBJ_P(&obj->array);
 					    	break;
 						} else {
-							obj = (spl_array_object*)zend_object_store_get_object(obj->array TSRMLS_CC);
+							obj = (spl_array_object*)Z_OBJ_P(&obj->array);
 					    }
 					} else {
 						obj = NULL;
@@ -559,7 +543,8 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval
 					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(&obj->std.properties_table[property_info->offset]);
+						ZVAL_UNDEF(&obj->std.properties_table[property_info->offset]);
 					}
 				}
 			}
@@ -597,21 +582,18 @@ 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);
 	long index;
-	zval *rv, **tmp;
+	zval rv, *tmp;
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
 
 	if (check_inherited && intern->fptr_offset_has) {
 		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)) {
-			zval_ptr_dtor(&rv);
+		zend_call_method_with_1_params(object, Z_OBJCE_P(object), &intern->fptr_offset_has, "offsetExists", &rv, offset);
+		zval_ptr_dtor(offset);
+		if (!ZVAL_IS_UNDEF(&rv) && zend_is_true(&rv TSRMLS_CC)) {
 			return 1;
 		}
-		if (rv) {
-			zval_ptr_dtor(&rv);
-		}
+		zval_ptr_dtor(&rv);
 		return 0;
 	}
 
@@ -619,14 +601,14 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
 		case IS_STRING:
 			{
 				HashTable *ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
-				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) {
 					switch (check_empty) {
 						case 0:
-							return Z_TYPE_PP(tmp) != IS_NULL;
+							return Z_TYPE_P(tmp) != IS_NULL;
 						case 2:
 							return 1;
 						default:
-							return zend_is_true(*tmp TSRMLS_CC);
+							return zend_is_true(tmp TSRMLS_CC);
 					}
 				}
 			}
@@ -642,14 +624,14 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
 				} 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) {
 					switch (check_empty) {
 						case 0:
-							return Z_TYPE_PP(tmp) != IS_NULL;
+							return Z_TYPE_P(tmp) != IS_NULL;
 						case 2:
 							return 1;
 						default:
-							return zend_is_true(*tmp TSRMLS_CC);
+							return zend_is_true(tmp TSRMLS_CC);
 					}
 				}
 				return 0;
@@ -704,7 +686,7 @@ 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;
 	}
@@ -726,7 +708,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (!aht) {
@@ -734,14 +716,14 @@ void spl_array_iterator_append(zval *object, zval *append_value TSRMLS_DC) /* {{
 		return;
 	}
 
-	if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+	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);
 		return;
 	}
 
 	spl_array_write_dimension(object, NULL, append_value TSRMLS_CC);
 	if (intern->pos == INVALID_IDX) {
-		if (aht->nNumUsed && aht->arData[aht->nNumUsed-1].xData) {
+		if (aht->nNumUsed && !ZVAL_IS_UNDEF(&aht->arData[aht->nNumUsed-1].val)) {
 			spl_array_set_pos(intern, aht, aht->nNumUsed - 1);
 		}
 	}
@@ -778,15 +760,15 @@ SPL_METHOD(Array, offsetUnset)
 SPL_METHOD(Array, getArrayCopy)
 {
 	zval *object = getThis(), *tmp;
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_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(HASH_OF(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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *result;
 
 	if (intern->nApplyCount > 1) {
@@ -801,11 +783,11 @@ 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;
+	zval *storage;
 	int name_len;
 	char *zname;
 	zend_class_entry *base;
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_P(obj);
 
 	*is_temp = 0;
 
@@ -813,7 +795,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) {
@@ -823,14 +805,14 @@ static HashTable* spl_array_get_debug_info(zval *obj, int *is_temp TSRMLS_DC) /*
 
 		if (intern->debug_info->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);
+			zend_symtable_str_update(intern->debug_info, zname, name_len, storage);
 			efree(zname);
 		}
 
@@ -841,10 +823,10 @@ 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) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_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, key TSRMLS_CC)) {
 		return spl_array_read_dimension(object, member, type TSRMLS_CC);
 	}
 	return std_object_handlers.read_property(object, member, type, key TSRMLS_CC);
@@ -852,7 +834,7 @@ static zval *spl_array_read_property(zval *object, zval *member, int type, const
 
 static void spl_array_write_property(zval *object, zval *member, zval *value, const zend_literal *key TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_P(object);
 
 	if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0
 	&& !std_object_handlers.has_property(object, member, 2, key TSRMLS_CC)) {
@@ -862,23 +844,25 @@ static void spl_array_write_property(zval *object, zval *member, zval *value, co
 	std_object_handlers.write_property(object, member, value, key 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, const zend_literal *key TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_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, key 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) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_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, key 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);
@@ -886,10 +870,10 @@ static int spl_array_has_property(zval *object, zval *member, int has_set_exists
 
 static void spl_array_unset_property(zval *object, zval *member, const zend_literal *key TSRMLS_DC) /* {{{ */
 {
-	spl_array_object *intern = (spl_array_object*)zend_object_store_get_object(object TSRMLS_CC);
+	spl_array_object *intern = (spl_array_object*)Z_OBJ_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, key TSRMLS_CC)) {
 		spl_array_unset_dimension(object, member TSRMLS_CC);
 		spl_array_rewind(intern TSRMLS_CC); /* because deletion might invalidate position */
 		return;
@@ -906,8 +890,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	= (spl_array_object*)Z_OBJ_P(o1);
+	intern2	= (spl_array_object*)Z_OBJ_P(o2);
 	ht1		= spl_array_get_hash_table(intern1, 0 TSRMLS_CC);
 	ht2		= spl_array_get_hash_table(intern2, 0 TSRMLS_CC);
 
@@ -923,14 +907,13 @@ 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;
 
-	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) {
+				if (!string_key->len || string_key->val[0]) {
 					return SUCCESS;
 				}
 			} else {
@@ -950,7 +933,7 @@ static int spl_array_next_no_verify(spl_array_object *intern, HashTable *aht TSR
 {
 	zend_hash_move_forward_ex(aht, &intern->pos);
 	spl_array_update_pos(aht, intern);
-	if (Z_TYPE_P(intern->array) == IS_OBJECT) {
+	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);
@@ -986,7 +969,7 @@ 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);
+	zval_ptr_dtor((zval*)iterator->intern.it.data);
 
 	efree(iterator);
 }
@@ -1010,18 +993,16 @@ 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);
 
 	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;
-		}
+		return zend_hash_get_current_data_ex(aht, &object->pos);
 	}
 }
 /* }}} */
@@ -1105,41 +1086,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 = (spl_array_object*)Z_OBJ_P(array);
 			ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK;
 		}
 		ar_flags |= SPL_ARRAY_USE_OTHER;
 		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;
 	}
-	if (object == *array) {
+	if (object == 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);
 		}
 	}
 
@@ -1160,7 +1141,7 @@ 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);
+	spl_array_object   *array_object = (spl_array_object*)Z_OBJ_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");
@@ -1186,7 +1167,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;
@@ -1197,9 +1178,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 = (spl_array_object*)Z_OBJ_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;
 	}
@@ -1222,7 +1203,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 = (spl_array_object*)Z_OBJ_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) {
@@ -1238,13 +1219,13 @@ 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 = (spl_array_object*)Z_OBJ_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
 	}
 
-	RETURN_STRING(intern->ce_get_iterator->name, 1);
+	RETURN_STR(intern->ce_get_iterator->name);
 }
 /* }}} */
 
@@ -1253,7 +1234,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 = (spl_array_object*)Z_OBJ_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1268,7 +1249,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 = (spl_array_object*)Z_OBJ_P(object);
 	long ar_flags = 0;
 
 	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &ar_flags) == FAILURE) {
@@ -1283,18 +1264,17 @@ 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 = (spl_array_object*)Z_OBJ_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(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) {
+	if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &array) == FAILURE) {
 		return;
 	}
 
 	spl_array_set_array(object, intern, array, 0L, 1 TSRMLS_CC);
-
 }
 /* }}} */
 
@@ -1303,8 +1283,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1316,8 +1295,7 @@ 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);
 }
@@ -1328,7 +1306,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 = (spl_array_object*)Z_OBJ_P(object);
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1344,7 +1322,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 	int result;
 
@@ -1383,7 +1361,7 @@ 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;
@@ -1402,17 +1380,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 = (spl_array_object*)Z_OBJ_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;
@@ -1427,7 +1404,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 = (spl_array_object*)Z_OBJ_P(getThis());
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1440,44 +1417,40 @@ 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 = (spl_array_object*)Z_OBJ_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;
+	array_init(&tmp);
+	zend_hash_copy(Z_ARRVAL(tmp), aht, (copy_ctor_func_t)zval_add_ref);
 
 	if (!use_arg) {
 		aht->nApplyCount++;
-		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval_ptr, 1, tmp, NULL TSRMLS_CC);
+		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 1, &tmp, NULL TSRMLS_CC);
 		aht->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);
+		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, arg? 2 : 1, &tmp, arg TSRMLS_CC);
 		aht->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);
+		zend_call_method(NULL, NULL, NULL, fname, fname_len, &retval, 2, &tmp, arg TSRMLS_CC);
 		aht->nApplyCount--;
 	}
-	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)) {
+		COPY_PZVAL_TO_ZVAL(*return_value, &retval);
 	}
 } /* }}} */
 
@@ -1522,8 +1495,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 = (spl_array_object*)Z_OBJ_P(object);
+	zval *entry;
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1534,10 +1507,10 @@ 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);
+	RETVAL_ZVAL(entry, 1, 0);
 }
 /* }}} */
 
@@ -1554,7 +1527,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (spl_array_object_verify_pos(intern, aht TSRMLS_CC) == FAILURE) {
@@ -1570,7 +1543,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1590,7 +1563,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1609,8 +1582,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1621,11 +1594,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));
 }
 /* }}} */
 
@@ -1633,8 +1606,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 = (spl_array_object*)Z_OBJ_P(object);
 	HashTable *aht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
 
 	if (zend_parse_parameters_none() == FAILURE) {
@@ -1645,23 +1618,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);
 }
 /* }}} */
 
@@ -1670,12 +1641,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 = (spl_array_object*)Z_OBJ_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;
@@ -1688,13 +1658,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);
@@ -1703,22 +1672,26 @@ 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 */
 
 	/* done */
 	PHP_VAR_SERIALIZE_DESTROY(var_hash);
 
 	if (buf.c) {
-		RETURN_STRINGL(buf.c, buf.len, 0);
+		RETVAL_STRINGL(buf.c, buf.len);
+		smart_str_free(&buf);
+		return;
 	}
 
+	zval_ptr_dtor(&members);
+
 	RETURN_NULL();
 } /* }}} */
 
@@ -1727,13 +1700,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 = (spl_array_object*)Z_OBJ_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) {
@@ -1754,15 +1727,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
@@ -1780,7 +1750,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;
 		}
@@ -1796,9 +1765,7 @@ 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;
 	}
 
@@ -1806,8 +1773,7 @@ SPL_METHOD(Array, 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 *));
-	zval_ptr_dtor(&pmembers);
+	zend_hash_copy(intern->std.properties, Z_ARRVAL(members), (copy_ctor_func_t) zval_add_ref);
 
 	/* done reading $serialized */
 
@@ -1955,6 +1921,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.free_obj = spl_array_object_free_storage;
+	spl_handler_ArrayObject.dtor_obj = zend_objects_destroy_object;
 
 	REGISTER_SPL_STD_CLASS_EX(ArrayIterator, spl_array_object_new, spl_funcs_ArrayIterator);
 	REGISTER_SPL_IMPLEMENTS(ArrayIterator, Iterator);