Use better data structures (incomplete)

2 files changed, 172 insertions, 201 deletions

diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index c82117eef6..719344ad06 100644
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -374,7 +374,7 @@ static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zt
 	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) {
@@ -832,7 +832,7 @@ static union _zend_function *spl_recursive_it_get_method(zval *object_ptr, zend_
 	zval                    *zobj;
 
 	if (!object->iterators) {
-		php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_P(object_ptr)->name);
+		php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_P(object_ptr)->name->val);
 	}
 	zobj = &object->iterators[level].zobject;
 
@@ -870,7 +870,7 @@ static void spl_RecursiveIteratorIterator_dtor(zend_object *_object TSRMLS_DC)
 /* }}} */
 
 /* {{{ 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;
 
@@ -1137,8 +1137,8 @@ SPL_METHOD(RecursiveTreeIterator, current)
 		}
 	}
 
-	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) {
@@ -1369,7 +1369,7 @@ 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;
@@ -1418,12 +1418,11 @@ 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;
+			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) == FAILURE) {
@@ -1433,31 +1432,29 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 			ce = Z_OBJCE_P(zobject);
 			if (!instanceof_function(ce, zend_ce_iterator TSRMLS_CC)) {
 				if (ZEND_NUM_ARGS() > 1) {
-					if (!(pce_cast = zend_lookup_class(class_name TSRMLS_CC))
-					|| !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)) {
+					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);
 						zend_restore_error_handling(&error_handling TSRMLS_CC);
 						return NULL;
 					}
-					zobject = retval;
+					ZVAL_COPY_VALUE(zobject, &retval);
 					ce = Z_OBJCE_P(zobject);
 					inc_refcount = 0;
 				}
@@ -1465,22 +1462,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 +1486,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);
@@ -1510,9 +1505,7 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 				efree(cfi);
 				return NULL;
 			}
-			if (cfi->fci.function_name) {
-				Z_ADDREF_P(cfi->fci.function_name);
-			}
+			Z_ADDREF(cfi->fci.function_name);
 			if (cfi->fci.object_ptr) {
 				Z_ADDREF_P(cfi->fci.object_ptr);
 			}
@@ -1534,7 +1527,7 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
 	}
 	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;
@@ -1588,22 +1581,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_STRING) {
 			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 +1621,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 +1688,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 +1709,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 +1733,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 +1760,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 +1839,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 +1848,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 +1860,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 +1869,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, 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,7 +1880,7 @@ SPL_METHOD(RecursiveFilterIterator, getChildren)
 SPL_METHOD(RecursiveCallbackFilterIterator, getChildren)
 {
 	spl_dual_it_object   *intern;
-	zval                 *retval;
+	zval                  retval;
 	
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -1900,12 +1889,10 @@ SPL_METHOD(RecursiveCallbackFilterIterator, getChildren)
 	intern = (spl_dual_it_object*)Z_OBJ_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, 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 +1913,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 = (spl_dual_it_object*)Z_OBJ_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);
 }
 /* }}} */
 
@@ -1975,14 +1962,14 @@ 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;
 	}
 
 	zend_make_printable_zval(subject_ptr, &subject_copy, &use_copy);
@@ -2009,10 +1996,9 @@ SPL_METHOD(RegexIterator, accept)
 			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));
+			&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;
 
@@ -2022,9 +2008,8 @@ SPL_METHOD(RegexIterator, accept)
 			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));
+		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;
 
@@ -2040,12 +2025,12 @@ SPL_METHOD(RegexIterator, accept)
 		
 		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);
+//???			ZVAL_STRINGL(intern->current.key, result, result_len, 0);
+			ZVAL_STRINGL(&intern->current.key, result, result_len);
 		} else {
 			zval_ptr_dtor(&intern->current.data);
-			MAKE_STD_ZVAL(intern->current.data);
-			ZVAL_STRINGL(intern->current.data, result, result_len, 0);
+//???			ZVAL_STRINGL(intern->current.data, result, result_len, 0);
+			ZVAL_STRINGL(&intern->current.data, result, result_len);
 		}
 
 		if (replacement == &tmp_replacement) {
@@ -2059,7 +2044,8 @@ SPL_METHOD(RegexIterator, accept)
 	}
 
 	if (use_copy) {
-		str_efree(subject);
+//???		str_efree(subject);
+		efree(subject);
 	}
 } /* }}} */
 
@@ -2067,13 +2053,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 = (spl_dual_it_object*)Z_OBJ_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 +2177,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,25 +2187,22 @@ 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, 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;
 
 	/* 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);
 
@@ -2230,26 +2213,26 @@ static void spl_dual_it_dtor(zend_object *_object, zend_object_handle handle TSR
 /* }}} */
 
 /* {{{ 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;
 
 
 	if (object->inner.zobject) {
-		zval_ptr_dtor(&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) {
+		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);
 		}
 	}
 
@@ -2266,11 +2249,9 @@ static void spl_dual_it_free_storage(void *_object TSRMLS_DC)
 
 	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);
-			}
+			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);
+				zval_ptr_dtor(object->u.cbfilter->fci.object_ptr);
 			}
 			efree(object->u.cbfilter);
 		}
@@ -2418,7 +2399,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) {
@@ -2430,10 +2411,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;
@@ -2483,7 +2463,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()
@@ -2573,19 +2553,18 @@ 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);
 
-			zval_ptr_dtor(zcacheval);
+			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)) {
 				zval_ptr_dtor(&retval);
@@ -2606,10 +2585,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);
-						ALLOC_ZVAL(intern->u.caching.zchildren);
-						spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, intern->u.caching.zchildren, &zchildren, &zflags TSRMLS_CC);
+						spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, &zchildren, &zflags TSRMLS_CC);
 						zval_ptr_dtor(&zchildren);
 					}
 				}
@@ -2626,21 +2603,20 @@ 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_VALUE(&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);
+//???				INIT_PZVAL(intern->u.caching.zstr);
+				zval_copy_ctor(&intern->u.caching.zstr);
 			}
 		}
 		spl_dual_it_next(intern, 0 TSRMLS_CC);	
@@ -2652,7 +2628,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,16 +2712,16 @@ SPL_METHOD(CachingIterator, __toString)
 		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();
 	}
@@ -2756,8 +2732,7 @@ 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());
@@ -2767,12 +2742,12 @@ SPL_METHOD(CachingIterator, offsetSet)
 		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);
+	zend_symtable_update(HASH_OF(&intern->u.caching.zcache), key, value);
 }
 /* }}} */
 
@@ -2781,9 +2756,8 @@ 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());
 
@@ -2792,16 +2766,16 @@ SPL_METHOD(CachingIterator, offsetGet)
 		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);
 }
 /* }}} */
 
@@ -2810,8 +2784,7 @@ 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());
 
@@ -2820,11 +2793,11 @@ SPL_METHOD(CachingIterator, offsetUnset)
 		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);
 }
 /* }}} */
 
@@ -2833,8 +2806,7 @@ 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());
 
@@ -2843,11 +2815,11 @@ SPL_METHOD(CachingIterator, offsetExists)
 		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,7 +2840,7 @@ SPL_METHOD(CachingIterator, getCache)
 		return;
 	}
 
-	RETURN_ZVAL(intern->u.caching.zcache, 1, 0);
+	RETURN_ZVAL(&intern->u.caching.zcache, 1, 0);
 }
 /* }}} */
 
@@ -2915,7 +2887,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,7 +2910,7 @@ SPL_METHOD(CachingIterator, count)
 		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)));
 }
 /* }}} */
 
@@ -3000,7 +2972,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()
@@ -3015,8 +2987,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();
 	}
@@ -3111,16 +3083,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);
 	}
 } /* }}} */
 
@@ -3251,7 +3223,7 @@ int spl_append_it_next_iterator(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/
 	spl_dual_it_free(intern TSRMLS_CC);
 
 	if (intern->inner.zobject) {
-		zval_ptr_dtor(&intern->inner.zobject);
+		zval_ptr_dtor(intern->inner.zobject);
 		intern->inner.zobject = NULL;
 		intern->inner.ce = NULL;
 		intern->inner.object = NULL;
@@ -3265,9 +3237,9 @@ int spl_append_it_next_iterator(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/
 
 		it  = intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator TSRMLS_CC);
 		Z_ADDREF_P(it);
-		intern->inner.zobject = *it;
+		intern->inner.zobject = it;
 		intern->inner.ce = Z_OBJCE_P(it);
-		intern->inner.object = Z_OBJCE_P(it);
+		intern->inner.object = Z_OBJ_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;
@@ -3314,7 +3286,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) {
@@ -3357,7 +3329,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()
@@ -3388,7 +3360,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()
@@ -3403,7 +3375,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) 
@@ -3467,13 +3439,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) {
@@ -3482,11 +3454,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);
 		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;
 }
@@ -3494,17 +3466,17 @@ 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);
+	Z_ADDREF_P(data);
+	add_next_index_zval(return_value, data);
 	return ZEND_HASH_APPLY_KEEP;
 }
 /* }}} */
@@ -3569,7 +3541,7 @@ static int spl_iterator_func_apply(zend_object_iterator *iter, void *puser TSRML
 	apply_info->count++;
 	zend_fcall_info_call(&apply_info->fci, &apply_info->fcc, &retval, NULL TSRMLS_CC);
 	if (Z_TYPE(retval) != IS_UNDEF) {
-		result = zend_is_true(retval TSRMLS_CC) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_STOP;
+		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;
diff --git a/ext/spl/spl_iterators.h b/ext/spl/spl_iterators.h
index 3991ddad33..1da5b85181 100644
--- a/ext/spl/spl_iterators.h
+++ b/ext/spl/spl_iterators.h
@@ -132,8 +132,8 @@ typedef struct _spl_dual_it_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,8 +159,7 @@ 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;