Fixed bug #68128

Three issues are addressed:

- RecursiveRegexIterator::accept() should accept non-empty arrays without
  applying any regular expression and RegexIterator::accept() should not accept
  an array.
- RegexIterator::accept() should not accept an atom that fails to match
  anything, even when PREG_PATTERN_ORDER is used (which would return an array
  of empty arrays).
- RecursiveRegexIterator::getChildren() should pass all constructor arguments
  to its child iterator instead of just the regular expression.

Author: datibbaw

NEWS

@@ -15,6 +15,8 @@ PHP                                                                        NEWS
 - ODBC:
   . Fixed bug #68087 (ODBC not correctly reading DATE column when preceded by
     a VARCHAR column) (Keyur Govande)
+- SPL:
+  . Fixed bug #68128 (Regression in RecursiveRegexIterator) (Tjerk)
 
 ?? ??? 2014, PHP 5.5.18
 

ext/spl/spl_engine.h

@@ -49,6 +49,41 @@ static inline int spl_instantiate_arg_ex2(zend_class_entry *pce, zval **retval,
 }
 /* }}} */
 
+/* {{{ spl_instantiate_arg_n */
+static inline void spl_instantiate_arg_n(zend_class_entry *pce, zval **retval, int argc, zval ***argv TSRMLS_DC)
+{
+	zend_function *func = pce->constructor;
+	zend_fcall_info fci;
+	zend_fcall_info_cache fcc;
+	zval *dummy;
+	zval z_name;
+
+	spl_instantiate(pce, retval, 0 TSRMLS_CC);
+
+	ZVAL_STRING(&z_name, func->common.function_name, 0);
+
+	fci.size = sizeof(zend_fcall_info);
+	fci.function_table = &pce->function_table;
+	fci.function_name = &z_name;
+	fci.object_ptr = *retval;
+	fci.symbol_table = NULL;
+	fci.retval_ptr_ptr = &dummy;
+	fci.param_count = argc;
+	fci.params = argv;
+	fci.no_separation = 1;
+
+	fcc.initialized = 1;
+	fcc.function_handler = func;
+	fcc.calling_scope = EG(scope);
+	fcc.called_scope = pce;
+	fcc.object_ptr = *retval;
+
+	zend_call_function(&fci, &fcc TSRMLS_CC);
+
+	zval_ptr_dtor(&dummy);
+}
+/* }}} */
+
 #endif /* SPL_ENGINE_H */
 
 /*

ext/spl/spl_iterators.c

@@ -1979,8 +1979,10 @@ SPL_METHOD(RegexIterator, accept)
 
 	if (intern->current.data == NULL) {
 		RETURN_FALSE;
+	} else if (Z_TYPE_P(intern->current.data) == IS_ARRAY) {
+		RETURN_FALSE;
 	}
-	
+
 	if (intern->u.regex.flags & REGIT_USE_KEY) {
 		subject_ptr = intern->current.key;
 	} else {
@@ -2014,8 +2016,7 @@ SPL_METHOD(RegexIterator, accept)
 		ALLOC_INIT_ZVAL(intern->current.data);
 		php_pcre_match_impl(intern->u.regex.pce, subject, subject_len, &zcount, 
 			intern->current.data, intern->u.regex.mode == REGIT_MODE_ALL_MATCHES, intern->u.regex.use_flags, intern->u.regex.preg_flags, 0 TSRMLS_CC);
-		count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data));
-		RETVAL_BOOL(count > 0);
+		RETVAL_BOOL(Z_LVAL(zcount) > 0);
 		break;
 
 	case REGIT_MODE_SPLIT:
@@ -2193,7 +2194,7 @@ SPL_METHOD(RecursiveRegexIterator, __construct)
 SPL_METHOD(RecursiveRegexIterator, getChildren)
 {
 	spl_dual_it_object   *intern;
-	zval                 *retval, *regex;
+	zval                 *retval;
 
 	if (zend_parse_parameters_none() == FAILURE) {
 		return;
@@ -2203,16 +2204,61 @@ SPL_METHOD(RecursiveRegexIterator, getChildren)
 
 	zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval);
 	if (!EG(exception)) {
+		zval **args[5], *object, *regex, *mode, *flags, *preg_flags;
+
+		MAKE_STD_ZVAL(object);
 		MAKE_STD_ZVAL(regex);
+		MAKE_STD_ZVAL(mode);
+		MAKE_STD_ZVAL(flags);
+		MAKE_STD_ZVAL(preg_flags);
+
+		MAKE_COPY_ZVAL(&retval, object);
 		ZVAL_STRING(regex, intern->u.regex.regex, 1);
-		spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, retval, regex TSRMLS_CC);
+		ZVAL_LONG(mode, intern->u.regex.mode);
+		ZVAL_LONG(flags, intern->u.regex.flags);
+		ZVAL_LONG(preg_flags, intern->u.regex.preg_flags);
+
+		args[0] = &object;
+		args[1] = &regex;
+		args[2] = &mode;
+		args[3] = &flags;
+		args[4] = &preg_flags;
+
+		spl_instantiate_arg_n(Z_OBJCE_P(getThis()), &return_value, 5, args TSRMLS_CC);
+
+		zval_ptr_dtor(&object);
 		zval_ptr_dtor(&regex);
+		zval_ptr_dtor(&mode);
+		zval_ptr_dtor(&flags);
+		zval_ptr_dtor(&preg_flags);
 	}
 	if (retval) {
 		zval_ptr_dtor(&retval);
 	}
 } /* }}} */
 
+SPL_METHOD(RecursiveRegexIterator, accept)
+{
+	spl_dual_it_object *intern;
+	zval *rv;
+
+	if (zend_parse_parameters_none() == FAILURE) {
+		return;
+	}
+
+	SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
+
+	if (intern->current.data == NULL) {
+		RETURN_FALSE;
+	} else if (Z_TYPE_P(intern->current.data) == IS_ARRAY) {
+		RETURN_BOOL(zend_hash_num_elements(Z_ARRVAL_P(intern->current.data)) > 0);
+	}
+
+	zend_call_method_with_0_params(&(getThis()), spl_ce_RegexIterator, NULL, "accept", &rv);
+
+	RETURN_ZVAL(rv, 1, 1);
+}
+
 #endif
 
 /* {{{ spl_dual_it_dtor */
@@ -2403,6 +2449,7 @@ ZEND_END_ARG_INFO();
 
 static const zend_function_entry spl_funcs_RecursiveRegexIterator[] = {
 	SPL_ME(RecursiveRegexIterator,  __construct,      arginfo_rec_regex_it___construct, ZEND_ACC_PUBLIC)
+	SPL_ME(RecursiveRegexIterator,  accept,           arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
 	SPL_ME(RecursiveFilterIterator, hasChildren,      arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
 	SPL_ME(RecursiveRegexIterator,  getChildren,      arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
 	PHP_FE_END

ext/spl/tests/bug68128.phpt

@@ -0,0 +1,91 @@
+--TEST--
+Bug #68128 - RecursiveRegexIterator raises "Array to string conversion" notice
+--FILE--
+<?php
+
+$array = new ArrayIterator(array('a', array('b', 'c')));
+$regex = new RegexIterator($array, '/Array/');
+
+foreach ($regex as $match) {
+    var_dump($match);
+}
+
+$rArrayIterator = new RecursiveArrayIterator(array('test1', array('tet3', 'test4', 'test5')));
+$rRegexIterator = new RecursiveRegexIterator($rArrayIterator, '/^(t)est(\d*)/',
+    RecursiveRegexIterator::ALL_MATCHES, 0, PREG_PATTERN_ORDER);
+
+foreach ($rRegexIterator as $key1 => $value1) {
+
+    if ($rRegexIterator->hasChildren()) {
+
+        // print all children
+        echo "Children: ";
+        foreach ($rRegexIterator->getChildren() as $key => $value) {
+			print_r($value);
+        }
+        echo "\n";
+    } else {
+        echo "No children ";
+		print_r($value1);
+		echo "\n";
+    }
+}
+
+?>
+--EXPECT--
+No children Array
+(
+    [0] => Array
+        (
+            [0] => test1
+        )
+
+    [1] => Array
+        (
+            [0] => t
+        )
+
+    [2] => Array
+        (
+            [0] => 1
+        )
+
+)
+
+Children: Array
+(
+    [0] => Array
+        (
+            [0] => test4
+        )
+
+    [1] => Array
+        (
+            [0] => t
+        )
+
+    [2] => Array
+        (
+            [0] => 4
+        )
+
+)
+Array
+(
+    [0] => Array
+        (
+            [0] => test5
+        )
+
+    [1] => Array
+        (
+            [0] => t
+        )
+
+    [2] => Array
+        (
+            [0] => 5
+        )
+
+)
+

ext/spl/tests/iterator_048.phpt

@@ -13,11 +13,6 @@ class MyRecursiveRegexIterator extends RecursiveRegexIterator
 			var_dump($v);
 		}
 	}
-
-	function accept()
-	{
-		return $this->hasChildren() || parent::accept();
-	}
 }
 
 $ar = new RecursiveArrayIterator(array('Foo', array('Bar'), 'FooBar', array('Baz'), 'Biz'));

ext/spl/tests/iterator_050.phpt

@@ -46,8 +46,6 @@ array(3) {
   [2]=>
   %s(1) "2"
 }
-
-Notice: Array to string conversion in %siterator_050.php on line %d
 int(0)
 array(2) {
   [0]=>
@@ -69,8 +67,6 @@ array(2) {
   [1]=>
   %s(1) "1"
 }
-
-Notice: Array to string conversion in %siterator_050.php on line %d
 object(ArrayIterator)#%d (1) {
   %s"storage"%s"ArrayIterator":private]=>
   array(9) {