diff options
Diffstat (limited to 'ext/spl/spl_iterators.c')
| -rwxr-xr-x | ext/spl/spl_iterators.c | 978 |
1 files changed, 838 insertions, 140 deletions
diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c index 0ba01180b..58853c6f5 100755 --- a/ext/spl/spl_iterators.c +++ b/ext/spl/spl_iterators.c @@ -16,7 +16,7 @@ +----------------------------------------------------------------------+ */ -/* $Id: spl_iterators.c,v 1.73.2.33 2006/07/17 21:13:32 helly Exp $ */ +/* $Id: spl_iterators.c,v 1.73.2.30.2.17 2006/07/21 21:26:11 helly Exp $ */ #ifdef HAVE_CONFIG_H # include "config.h" @@ -55,6 +55,8 @@ PHPAPI zend_class_entry *spl_ce_NoRewindIterator; PHPAPI zend_class_entry *spl_ce_InfiniteIterator; PHPAPI zend_class_entry *spl_ce_EmptyIterator; PHPAPI zend_class_entry *spl_ce_AppendIterator; +PHPAPI zend_class_entry *spl_ce_RegexIterator; +PHPAPI zend_class_entry *spl_ce_RecursiveRegexIterator; zend_function_entry spl_funcs_RecursiveIterator[] = { SPL_ABSTRACT_ME(RecursiveIterator, hasChildren, NULL) @@ -191,6 +193,13 @@ next_step: switch (object->iterators[object->level].state) { case RS_NEXT: iterator->funcs->move_forward(iterator TSRMLS_CC); + if (EG(exception)) { + if (!(object->flags & RIT_CATCH_GET_CHILD)) { + return; + } else { + zend_clear_exception(TSRMLS_C); + } + } case RS_START: if (iterator->funcs->valid(iterator TSRMLS_CC) == FAILURE) { break; @@ -205,6 +214,14 @@ next_step: } else { zend_call_method_with_0_params(&zobject, ce, NULL, "haschildren", &retval); } + if (EG(exception)) { + if (!(object->flags & RIT_CATCH_GET_CHILD)) { + object->iterators[object->level].state = RS_NEXT; + return; + } else { + zend_clear_exception(TSRMLS_C); + } + } if (retval) { has_children = zend_is_true(retval); zval_ptr_dtor(&retval); @@ -233,6 +250,13 @@ next_step: zend_call_method_with_0_params(&zthis, object->ce, &object->nextElement, "nextelement", NULL); } object->iterators[object->level].state = RS_NEXT; + if (EG(exception)) { + if (!(object->flags & RIT_CATCH_GET_CHILD)) { + return; + } else { + zend_clear_exception(TSRMLS_C); + } + } return /* self */; case RS_SELF: if (object->nextElement && (object->mode == RIT_SELF_FIRST || object->mode == RIT_CHILD_FIRST)) { @@ -280,7 +304,7 @@ next_step: object->iterators[object->level].state = RS_NEXT; } object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator) * (++object->level+1)); - sub_iter = ce->get_iterator(ce, child TSRMLS_CC); + sub_iter = ce->get_iterator(ce, child, 0 TSRMLS_CC); object->iterators[object->level].iterator = sub_iter; object->iterators[object->level].zobject = child; object->iterators[object->level].ce = ce; @@ -290,6 +314,13 @@ next_step: } if (object->beginChildren) { zend_call_method_with_0_params(&zthis, object->ce, &object->beginChildren, "beginchildren", NULL); + if (EG(exception)) { + if (!(object->flags & RIT_CATCH_GET_CHILD)) { + return; + } else { + zend_clear_exception(TSRMLS_C); + } + } } goto next_step; } @@ -297,6 +328,13 @@ next_step: if (object->level > 0) { if (object->endChildren) { zend_call_method_with_0_params(&zthis, object->ce, &object->endChildren, "endchildren", NULL); + if (EG(exception)) { + if (!(object->flags & RIT_CATCH_GET_CHILD)) { + return; + } else { + zend_clear_exception(TSRMLS_C); + } + } } iterator->funcs->dtor(iterator TSRMLS_CC); zval_ptr_dtor(&object->iterators[object->level].zobject); @@ -315,7 +353,7 @@ static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zt sub_iter = object->iterators[object->level].iterator; sub_iter->funcs->dtor(sub_iter TSRMLS_CC); zval_ptr_dtor(&object->iterators[object->level--].zobject); - if (!object->endChildren || object->endChildren->common.scope != spl_ce_RecursiveIteratorIterator) { + if (!EG(exception) && (!object->endChildren || object->endChildren->common.scope != spl_ce_RecursiveIteratorIterator)) { zend_call_method_with_0_params(&zthis, object->ce, &object->endChildren, "endchildren", NULL); } } @@ -325,7 +363,7 @@ static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zt if (sub_iter->funcs->rewind) { sub_iter->funcs->rewind(sub_iter TSRMLS_CC); } - if (object->beginIteration && !object->in_iteration) { + if (!EG(exception) && object->beginIteration && !object->in_iteration) { zend_call_method_with_0_params(&zthis, object->ce, &object->beginIteration, "beginIteration", NULL); } object->in_iteration = 1; @@ -342,10 +380,16 @@ static void spl_recursive_it_rewind(zend_object_iterator *iter TSRMLS_DC) spl_recursive_it_rewind_ex((spl_recursive_it_object*)iter->data, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC); } -static zend_object_iterator *spl_recursive_it_get_iterator(zend_class_entry *ce, zval *zobject TSRMLS_DC) +static zend_object_iterator *spl_recursive_it_get_iterator(zend_class_entry *ce, zval *zobject, int by_ref TSRMLS_DC) { - spl_recursive_it_iterator *iterator = emalloc(sizeof(spl_recursive_it_iterator)); - spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC); + spl_recursive_it_iterator *iterator; + spl_recursive_it_object *object; + + if (by_ref) { + zend_error(E_ERROR, "An iterator cannot be used with foreach by reference"); + } + iterator = emalloc(sizeof(spl_recursive_it_iterator)); + object = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC); zobject->refcount++; iterator->intern.data = (void*)object; @@ -432,7 +476,7 @@ SPL_METHOD(RecursiveIteratorIterator, __construct) intern->nextElement = NULL; } ce_iterator = Z_OBJCE_P(iterator); /* respect inheritance, don't use spl_ce_RecursiveIterator */ - intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator TSRMLS_CC); + intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator, 0 TSRMLS_CC); if (inc_refcount) { iterator->refcount++; } @@ -565,7 +609,11 @@ SPL_METHOD(RecursiveIteratorIterator, callHasChildren) RETURN_FALSE; } else { zend_call_method_with_0_params(&zobject, ce, NULL, "haschildren", &retval); - RETURN_ZVAL(retval, 0, 1); + if (retval) { + RETURN_ZVAL(retval, 0, 1); + } else { + RETURN_FALSE; + } } } /* }}} */ @@ -827,6 +875,18 @@ int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS) static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more TSRMLS_DC); +static inline int spl_cit_check_flags(int flags) +{ + int cnt = 0; + + cnt += (flags & CIT_CALL_TOSTRING) ? 1 : 0; + cnt += (flags & CIT_TOSTRING_USE_KEY) ? 1 : 0; + cnt += (flags & CIT_TOSTRING_USE_CURRENT) ? 1 : 0; + cnt += (flags & CIT_TOSTRING_USE_INNER) ? 1 : 0; + + return cnt <= 1 ? SUCCESS : FAILURE; +} + 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; @@ -871,13 +931,14 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); return NULL; } - if (((flags & CIT_CALL_TOSTRING) && (flags & (CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT))) - || ((flags & (CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT)) == (CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT))) { + if (spl_cit_check_flags(flags) != SUCCESS) { php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); - zend_throw_exception(spl_ce_InvalidArgumentException, "Flags must contain only one of CATCH_GET_CHILD, CALL_TOSTRING, TOSTRING_USE_KEY, TOSTRING_USE_CURRENT", 0 TSRMLS_CC); + zend_throw_exception(spl_ce_InvalidArgumentException, "Flags must contain only one of CALL_TOSTRING, TOSTRING_USE_KEY, TOSTRING_USE_CURRENT, TOSTRING_USE_CURRENT", 0 TSRMLS_CC); return NULL; } intern->u.caching.flags |= flags & CIT_PUBLIC; + MAKE_STD_ZVAL(intern->u.caching.zcache); + array_init(intern->u.caching.zcache); break; } case DIT_IteratorIterator: { @@ -904,6 +965,13 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z } 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); + if (EG(exception)) { + if (retval) { + zval_ptr_dtor(&retval); + } + php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); + return NULL; + } if (!retval || Z_TYPE_P(retval) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(retval), zend_ce_traversable TSRMLS_CC)) { zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "%s::getIterator() must return an object that implememnts Traversable", ce->name); php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); @@ -919,9 +987,35 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z case DIT_AppendIterator: spl_instantiate(spl_ce_ArrayIterator, &intern->u.append.zarrayit, 1 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 TSRMLS_CC); + intern->u.append.iterator = spl_ce_ArrayIterator->get_iterator(spl_ce_ArrayIterator, intern->u.append.zarrayit, 0 TSRMLS_CC); php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); return intern; +#if HAVE_PCRE || HAVE_BUNDLED_PCRE + case DIT_RegexIterator: + case DIT_RecursiveRegexIterator: { + char *regex; + int regex_len; + 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, ®ex, ®ex_len, &mode, &intern->u.regex.flags, &intern->u.regex.preg_flags) == FAILURE) { + php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); + return NULL; + } + if (mode < 0 || mode >= REGIT_MODE_MAX) { + zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %ld", mode); + php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); + return NULL; + } + intern->u.regex.mode = mode; + intern->u.regex.regex = estrndup(regex, regex_len); + intern->u.regex.pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC); + intern->u.regex.pce->refcount++; + break;; + } +#endif default: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zobject, ce_inner) == FAILURE) { php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); @@ -930,7 +1024,7 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z break; } - php_set_error_handling(EH_THROW, zend_exception_get_default() TSRMLS_CC); + php_set_error_handling(EH_THROW, zend_exception_get_default(TSRMLS_C) TSRMLS_CC); if (inc_refcount) { zobject->refcount++; @@ -938,7 +1032,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.iterator = intern->inner.ce->get_iterator(intern->inner.ce, zobject TSRMLS_CC); + intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, zobject, 0 TSRMLS_CC); php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC); return intern; @@ -1146,7 +1240,9 @@ static inline void spl_filter_it_fetch(zval *zthis, spl_dual_it_object *intern T } zval_ptr_dtor(&retval); } - + if (EG(exception)) { + return; + } intern->inner.iterator->funcs->move_forward(intern->inner.iterator TSRMLS_CC); } spl_dual_it_free(intern TSRMLS_CC); @@ -1201,7 +1297,11 @@ SPL_METHOD(RecursiveFilterIterator, hasChildren) intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval); - RETURN_ZVAL(retval, 0, 1); + if (retval) { + RETURN_ZVAL(retval, 0, 1); + } else { + RETURN_FALSE; + } } /* }}} */ /* {{{ proto RecursiveFilterIterator RecursiveFilterIterator::getChildren() @@ -1214,8 +1314,12 @@ SPL_METHOD(RecursiveFilterIterator, getChildren) intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval); - spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), &return_value, 0, retval TSRMLS_CC); - zval_ptr_dtor(&retval); + if (!EG(exception) && retval) { + spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), &return_value, 0, retval TSRMLS_CC); + } + if (retval) { + zval_ptr_dtor(&retval); + } } /* }}} */ /* {{{ proto void ParentIterator::__construct(RecursiveIterator it) @@ -1235,7 +1339,11 @@ SPL_METHOD(ParentIterator, hasChildren) intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval); - RETURN_ZVAL(retval, 0, 1); + if (retval) { + RETURN_ZVAL(retval, 0, 1); + } else { + RETURN_FALSE; + } } /* }}} */ /* {{{ proto ParentIterator ParentIterator::getChildren() @@ -1248,10 +1356,218 @@ SPL_METHOD(ParentIterator, getChildren) intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval); - spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), &return_value, 0, retval TSRMLS_CC); - zval_ptr_dtor(&retval); + if (!EG(exception) && retval) { + spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), &return_value, 0, retval TSRMLS_CC); + } + if (retval) { + zval_ptr_dtor(&retval); + } +} /* }}} */ + +#if HAVE_PCRE || HAVE_BUNDLED_PCRE +/* {{{ proto void RegexIterator::__construct(Iterator it, string regex [, int mode [, int flags [, int preg_flags]]]) + Create an RegexIterator from another iterator and a regular expression */ +SPL_METHOD(RegexIterator, __construct) +{ + spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RegexIterator, zend_ce_iterator, DIT_RegexIterator); +} /* }}} */ + +/* {{{ proto bool RegexIterator::accept() + Match (string)current() against regular expression */ +SPL_METHOD(RegexIterator, accept) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + char *subject, tmp[32], *result; + int subject_len, use_copy, count, result_len; + zval subject_copy, zcount, *replacement; + + if (intern->u.regex.flags & REGIT_USE_KEY) { + if (intern->current.key_type == HASH_KEY_IS_LONG) { + subject_len = snprintf(tmp, sizeof(tmp), "%ld", intern->current.int_key); + subject = &tmp[0]; + use_copy = 0; + } else { + subject_len = intern->current.str_key_len - 1; + subject = estrndup(intern->current.str_key, subject_len); + use_copy = 1; + } + } else { + zend_make_printable_zval(intern->current.data, &subject_copy, &use_copy); + if (use_copy) { + subject = Z_STRVAL(subject_copy); + subject_len = Z_STRLEN(subject_copy); + } else { + subject = Z_STRVAL_P(intern->current.data); + subject_len = Z_STRLEN_P(intern->current.data); + } + } + + switch (intern->u.regex.mode) + { + case REGIT_MODE_MAX: /* won't happen but makes compiler happy */ + case REGIT_MODE_MATCH: + count = pcre_exec(intern->u.regex.pce->re, intern->u.regex.pce->extra, subject, subject_len, 0, 0, NULL, 0); + RETVAL_BOOL(count >= 0); + break; + + case REGIT_MODE_ALL_MATCHES: + case REGIT_MODE_GET_MATCH: + if (!use_copy) { + subject = estrndup(subject, subject_len); + use_copy = 1; + } + zval_ptr_dtor(&intern->current.data); + ALLOC_INIT_ZVAL(intern->current.data); + php_pcre_match_impl(intern->u.regex.pce, subject, subject_len, &zcount, + intern->current.data, intern->u.regex.mode == REGIT_MODE_ALL_MATCHES, intern->u.regex.use_flags, intern->u.regex.preg_flags, 0 TSRMLS_CC); + count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data)); + RETVAL_BOOL(count > 0); + break; + + case REGIT_MODE_SPLIT: + if (!use_copy) { + subject = estrndup(subject, subject_len); + use_copy = 1; + } + zval_ptr_dtor(&intern->current.data); + ALLOC_INIT_ZVAL(intern->current.data); + php_pcre_split_impl(intern->u.regex.pce, subject, subject_len, intern->current.data, -1, intern->u.regex.preg_flags TSRMLS_CC); + count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data)); + RETVAL_BOOL(count > 1); + break; + + case REGIT_MODE_REPLACE: + replacement = zend_read_property(intern->std.ce, getThis(), "replacement", sizeof("replacement")-1, 1 TSRMLS_CC); + result = php_pcre_replace_impl(intern->u.regex.pce, subject, subject_len, replacement, 0, &result_len, 0, NULL TSRMLS_CC); + + if (intern->u.regex.flags & REGIT_USE_KEY) { + if (intern->current.key_type != HASH_KEY_IS_LONG) { + efree(intern->current.str_key); + } + intern->current.key_type = HASH_KEY_IS_STRING; + intern->current.str_key = result; + intern->current.str_key_len = result_len + 1; + } else { + zval_ptr_dtor(&intern->current.data); + MAKE_STD_ZVAL(intern->current.data); + ZVAL_STRINGL(intern->current.data, result, result_len, 0); + } + } + + if (use_copy) { + efree(subject); + } +} /* }}} */ + +/* {{{ proto bool RegexIterator::getMode() + Returns current operation mode */ +SPL_METHOD(RegexIterator, getMode) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + RETURN_LONG(intern->u.regex.mode); +} /* }}} */ + +/* {{{ proto bool RegexIterator::setMode(int new_mode) + Set new operation mode */ +SPL_METHOD(RegexIterator, setMode) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + long mode; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mode) == FAILURE) { + return; + } + + if (mode < 0 || mode >= REGIT_MODE_MAX) { + zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %ld", mode); + return;// NULL + } + + intern->u.regex.mode = mode; +} /* }}} */ + +/* {{{ proto bool RegexIterator::getFlags() + Returns current operation flags */ +SPL_METHOD(RegexIterator, getFlags) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + RETURN_LONG(intern->u.regex.flags); +} /* }}} */ + +/* {{{ proto bool RegexIterator::setFlags(int new_flags) + Set operation flags */ +SPL_METHOD(RegexIterator, setFlags) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + long flags; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) { + return; + } + + intern->u.regex.flags = flags; +} /* }}} */ + +/* {{{ proto bool RegexIterator::getFlags() + Returns current PREG flags (if in use or NULL) */ +SPL_METHOD(RegexIterator, getPregFlags) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (intern->u.regex.use_flags) { + RETURN_LONG(intern->u.regex.preg_flags); + } else { + return; + } +} /* }}} */ + +/* {{{ proto bool RegexIterator::setFlags(int new_flags) + Set PREG flags */ +SPL_METHOD(RegexIterator, setPregFlags) +{ + spl_dual_it_object *intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + long preg_flags; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &preg_flags) == FAILURE) { + return; + } + + intern->u.regex.preg_flags = preg_flags; + intern->u.regex.use_flags = 1; +} /* }}} */ + +/* {{{ proto void RecursiveRegexIterator::__construct(RecursiveIterator it, string regex [, int mode [, int flags [, int preg_flags]]]) + Create an RecursiveRegexIterator from another recursive iterator and a regular expression */ +SPL_METHOD(RecursiveRegexIterator, __construct) +{ + spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveRegexIterator, spl_ce_RecursiveIterator, DIT_RecursiveRegexIterator); +} /* }}} */ + +/* {{{ proto RecursiveRegexIterator RecursiveRegexIterator::getChildren() + Return the inner iterator's children contained in a RecursiveRegexIterator */ +SPL_METHOD(RecursiveRegexIterator, getChildren) +{ + spl_dual_it_object *intern; + zval *retval, *regex; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval); + if (!EG(exception)) { + MAKE_STD_ZVAL(regex); + ZVAL_STRING(regex, intern->u.regex.regex, 1); + spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, retval, regex TSRMLS_CC); + zval_ptr_dtor(®ex); + } + if (retval) { + zval_ptr_dtor(&retval); + } } /* }}} */ +#endif + /* {{{ spl_dual_it_free_storage */ static void spl_dual_it_free_storage(void *_object TSRMLS_DC) { @@ -1269,9 +1585,29 @@ static void spl_dual_it_free_storage(void *_object TSRMLS_DC) if (object->dit_type == DIT_AppendIterator) { object->u.append.iterator->funcs->dtor(object->u.append.iterator TSRMLS_CC); - zval_ptr_dtor(&object->u.append.zarrayit); + if (object->u.append.zarrayit) { + zval_ptr_dtor(&object->u.append.zarrayit); + } + } + + if (object->dit_type == DIT_CachingIterator || object->dit_type == DIT_RecursiveCachingIterator) { + if (object->u.caching.zcache) { + zval_ptr_dtor(&object->u.caching.zcache); + object->u.caching.zcache = NULL; + } } +#if HAVE_PCRE || HAVE_BUNDLED_PCRE + if (object->dit_type == DIT_RegexIterator || object->dit_type == DIT_RecursiveRegexIterator) { + if (object->u.regex.pce) { + object->u.regex.pce->refcount--; + } + if (object->u.regex.regex) { + efree(object->u.regex.regex); + } + } +#endif + zend_object_std_dtor(&object->std TSRMLS_CC); efree(object); @@ -1337,6 +1673,60 @@ static zend_function_entry spl_funcs_ParentIterator[] = { {NULL, NULL, NULL} }; +#if HAVE_PCRE || HAVE_BUNDLED_PCRE +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it___construct, 0, 0, 2) + ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0) + ZEND_ARG_INFO(0, regex) + ZEND_ARG_INFO(0, mode) + ZEND_ARG_INFO(0, flags) + ZEND_ARG_INFO(0, preg_flags) +ZEND_END_ARG_INFO(); + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_mode, 0, 0, 1) + ZEND_ARG_INFO(0, mode) +ZEND_END_ARG_INFO(); + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_flags, 0, 0, 1) + ZEND_ARG_INFO(0, flags) +ZEND_END_ARG_INFO(); + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_preg_flags, 0, 0, 1) + ZEND_ARG_INFO(0, preg_flags) +ZEND_END_ARG_INFO(); + +static zend_function_entry spl_funcs_RegexIterator[] = { + SPL_ME(RegexIterator, __construct, arginfo_regex_it___construct, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, accept, NULL, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, getMode, NULL, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, setMode, arginfo_regex_it_set_mode, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, getFlags, NULL, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, setFlags, arginfo_regex_it_set_flags, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, getPregFlags, NULL, ZEND_ACC_PUBLIC) + SPL_ME(RegexIterator, setPregFlags, arginfo_regex_it_set_preg_flags, ZEND_ACC_PUBLIC) + {NULL, NULL, NULL} +}; + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_rec_regex_it___construct, 0, 0, 2) + ZEND_ARG_OBJ_INFO(0, iterator, RecursiveIterator, 0) + ZEND_ARG_INFO(0, regex) + ZEND_ARG_INFO(0, mode) + ZEND_ARG_INFO(0, flags) + ZEND_ARG_INFO(0, preg_flags) +ZEND_END_ARG_INFO(); + +static zend_function_entry spl_funcs_RecursiveRegexIterator[] = { + SPL_ME(RecursiveRegexIterator, __construct, arginfo_rec_regex_it___construct, ZEND_ACC_PUBLIC) + SPL_ME(ParentIterator, hasChildren, NULL, ZEND_ACC_PUBLIC) + SPL_ME(RecursiveRegexIterator, getChildren, NULL, ZEND_ACC_PUBLIC) + {NULL, NULL, NULL} +}; +#endif + static inline int spl_limit_it_valid(spl_dual_it_object *intern TSRMLS_DC) { /* FAILURE / SUCCESS */ @@ -1366,9 +1756,11 @@ static inline void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS spl_dual_it_free(intern TSRMLS_CC); zend_call_method_with_1_params(&intern->inner.zobject, intern->inner.ce, NULL, "seek", NULL, zpos); zval_ptr_dtor(&zpos); - intern->current.pos = pos; - if (spl_limit_it_valid(intern TSRMLS_CC) == SUCCESS) { - spl_dual_it_fetch(intern, 0 TSRMLS_CC); + if (!EG(exception)) { + intern->current.pos = pos; + if (spl_limit_it_valid(intern TSRMLS_CC) == SUCCESS) { + spl_dual_it_fetch(intern, 0 TSRMLS_CC); + } } } else { /* emulate the forward seek, by next() calls */ @@ -1503,66 +1895,79 @@ static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC) { if (spl_dual_it_fetch(intern, 1 TSRMLS_CC) == SUCCESS) { intern->u.caching.flags |= CIT_VALID; + /* Full cache ? */ + if (intern->u.caching.flags & CIT_FULL_CACHE) { + zval *zcacheval; + + MAKE_STD_ZVAL(zcacheval); + ZVAL_ZVAL(zcacheval, intern->current.data, 1, 0); + if (intern->current.key_type == HASH_KEY_IS_LONG) { + add_index_zval(intern->u.caching.zcache, intern->current.int_key, zcacheval); + } else { + zend_symtable_update(HASH_OF(intern->u.caching.zcache), intern->current.str_key, intern->current.str_key_len, &zcacheval, sizeof(void*), NULL); + } + } + /* Recursion ? */ if (intern->dit_type == DIT_RecursiveCachingIterator) { zval *retval, *zchildren, zflags; zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval); - if (zend_is_true(retval)) { - zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &zchildren); - if (EG(exception) && intern->u.caching.flags & CIT_CATCH_GET_CHILD) { + if (EG(exception)) { + if (retval) { + zval_ptr_dtor(&retval); + } + if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) { zend_clear_exception(TSRMLS_C); - if (zchildren) { + } else { + return; + } + } else { + if (zend_is_true(retval)) { + zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &zchildren); + if (EG(exception)) { + if (zchildren) { + zval_ptr_dtor(&zchildren); + } + if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) { + zend_clear_exception(TSRMLS_C); + } else { + zval_ptr_dtor(&retval); + return; + } + } else { + INIT_PZVAL(&zflags); + ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC); + spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, 1, zchildren, &zflags TSRMLS_CC); zval_ptr_dtor(&zchildren); } - } else { - INIT_PZVAL(&zflags); - ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC); - spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, 1, zchildren, &zflags TSRMLS_CC); - zval_ptr_dtor(&zchildren); } - } - zval_ptr_dtor(&retval); - } - if (intern->u.caching.flags & CIT_CALL_TOSTRING) { - if (Z_TYPE_P(intern->current.data) == IS_OBJECT) { - zval expr_copy; - if (intern->current.data->value.obj.handlers->cast_object && - intern->current.data->value.obj.handlers->cast_object(intern->current.data, &expr_copy, IS_STRING, 0 TSRMLS_CC) == SUCCESS) - { - ALLOC_ZVAL(intern->u.caching.zstr); - *intern->u.caching.zstr = expr_copy; - INIT_PZVAL(intern->u.caching.zstr); - zval_copy_ctor(intern->u.caching.zstr); - zval_dtor(&expr_copy); - } else { - zend_class_entry *ce_data = spl_get_class_entry(intern->current.data TSRMLS_CC); - if (ce_data && zend_hash_exists(&ce_data->function_table, "__tostring", sizeof("__tostring"))) { - zend_call_method_with_0_params(&intern->current.data, ce_data, NULL, "__tostring", &intern->u.caching.zstr); + zval_ptr_dtor(&retval); + if (EG(exception)) { + if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) { + zend_clear_exception(TSRMLS_C); } else { - ALLOC_ZVAL(intern->u.caching.zstr); - *intern->u.caching.zstr = *intern->current.data; - zval_copy_ctor(intern->u.caching.zstr); - INIT_PZVAL(intern->u.caching.zstr); - convert_to_string(intern->u.caching.zstr); + return; } } + } + } + 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; } else { - /* This version requires zend_make_printable_zval() being able to - * call __toString(). - */ - int use_copy; - zval expr_copy; - ALLOC_ZVAL(intern->u.caching.zstr); *intern->u.caching.zstr = *intern->current.data; - 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_dtor(&expr_copy); - } else { - INIT_PZVAL(intern->u.caching.zstr); - zval_copy_ctor(intern->u.caching.zstr); - } + } + 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_dtor(&expr_copy); + } else { + INIT_PZVAL(intern->u.caching.zstr); + zval_copy_ctor(intern->u.caching.zstr); } } spl_dual_it_next(intern, 0 TSRMLS_CC); @@ -1574,6 +1979,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)); spl_caching_it_next(intern TSRMLS_CC); } @@ -1636,7 +2042,7 @@ SPL_METHOD(CachingIterator, __toString) intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); - if (!(intern->u.caching.flags & (CIT_CALL_TOSTRING|CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT))) { + if (!(intern->u.caching.flags & (CIT_CALL_TOSTRING|CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT|CIT_TOSTRING_USE_INNER))) { zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not fetch string value (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name); } if (intern->u.caching.flags & CIT_TOSTRING_USE_KEY) { @@ -1648,8 +2054,10 @@ SPL_METHOD(CachingIterator, __toString) return; } } else if (intern->u.caching.flags & CIT_TOSTRING_USE_CURRENT) { - RETVAL_ZVAL(intern->current.data, 1, 0); - + *return_value = *intern->current.data; + zval_copy_ctor(return_value); + convert_to_string(return_value); + INIT_PZVAL(return_value); return; } if (intern->u.caching.zstr) { @@ -1659,12 +2067,186 @@ SPL_METHOD(CachingIterator, __toString) } } /* }}} */ +/* {{{ proto void CachingIterator::offsetSet(mixed index, mixed newval) + Set given index in cache */ +SPL_METHOD(CachingIterator, offsetSet) +{ + spl_dual_it_object *intern; + char *arKey; + uint nKeyLength; + zval *value; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name); + } + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &arKey, &nKeyLength, &value) == FAILURE) { + return; + } + + value->refcount++; + zend_symtable_update(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, &value, sizeof(value), NULL); +} +/* }}} */ + +/* {{{ proto string CachingIterator::offsetGet(mixed index) + Return the internal cache if used */ +SPL_METHOD(CachingIterator, offsetGet) +{ + spl_dual_it_object *intern; + char *arKey; + uint nKeyLength; + zval **value; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name); + } + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == 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); + return; + } + + RETURN_ZVAL(*value, 1, 0); +} +/* }}} */ + +/* {{{ proto void CachingIterator::offsetUnset(mixed index) + Unset given index in cache */ +SPL_METHOD(CachingIterator, offsetUnset) +{ + spl_dual_it_object *intern; + char *arKey; + uint nKeyLength; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name); + } + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) { + return; + } + + zend_symtable_del(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1); +} +/* }}} */ + +/* {{{ proto bool CachingIterator::offsetExists(mixed index) + Return whether the requested index exists */ +SPL_METHOD(CachingIterator, offsetExists) +{ + spl_dual_it_object *intern; + char *arKey; + uint nKeyLength; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name); + } + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) { + return; + } + + RETURN_BOOL(zend_symtable_exists(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1)); +} +/* }}} */ + +/* {{{ proto bool CachingIterator::getCache() + Return the cache */ +SPL_METHOD(CachingIterator, getCache) +{ + spl_dual_it_object *intern; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (!(intern->u.caching.flags & CIT_FULL_CACHE)) { + zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%v does not use a full cache (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name); + return; + } + + RETURN_ZVAL(intern->u.caching.zcache, 1, 0); +} +/* }}} */ + +/* {{{ proto int CachingIterator::getFlags() + Return the internal flags */ +SPL_METHOD(CachingIterator, getFlags) +{ + spl_dual_it_object *intern; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + RETURN_LONG(intern->u.caching.flags); +} +/* }}} */ + +/* {{{ proto void CachingIterator::setFlags() + Set the internal flags */ +SPL_METHOD(CachingIterator, setFlags) +{ + spl_dual_it_object *intern; + long flags; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) { + return; + } + + if (spl_cit_check_flags(flags) != SUCCESS) { + zend_throw_exception(spl_ce_InvalidArgumentException , "Flags must contain only one of CALL_TOSTRING, TOSTRING_USE_KEY, TOSTRING_USE_CURRENT, TOSTRING_USE_INNER", 0 TSRMLS_CC); + return; + } + if ((intern->u.caching.flags & CIT_CALL_TOSTRING) != 0 && (flags & CIT_CALL_TOSTRING) == 0) { + zend_throw_exception(spl_ce_InvalidArgumentException, "Unsetting flag CALL_TO_STRING is not possible", 0 TSRMLS_CC); + return; + } + if ((intern->u.caching.flags & CIT_TOSTRING_USE_INNER) != 0 && (flags & CIT_TOSTRING_USE_INNER) == 0) { + zend_throw_exception(spl_ce_InvalidArgumentException, "Unsetting flag TOSTRING_USE_INNER is not possible", 0 TSRMLS_CC); + return; + } + 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)); + } + intern->u.caching.flags = (intern->u.caching.flags & ~CIT_PUBLIC) | (flags & CIT_PUBLIC); +} +/* }}} */ + static ZEND_BEGIN_ARG_INFO(arginfo_caching_it___construct, 0) ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0) ZEND_ARG_INFO(0, flags) ZEND_END_ARG_INFO(); +static +ZEND_BEGIN_ARG_INFO(arginfo_caching_it_setFlags, 0) + ZEND_ARG_INFO(0, flags) +ZEND_END_ARG_INFO(); + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_caching_it_offsetGet, 0, 0, 1) + ZEND_ARG_INFO(0, index) +ZEND_END_ARG_INFO(); + +static +ZEND_BEGIN_ARG_INFO_EX(arginfo_caching_it_offsetSet, 0, 0, 2) + ZEND_ARG_INFO(0, index) + ZEND_ARG_INFO(0, newval) +ZEND_END_ARG_INFO(); + static zend_function_entry spl_funcs_CachingIterator[] = { SPL_ME(CachingIterator, __construct, arginfo_caching_it___construct, ZEND_ACC_PUBLIC) SPL_ME(CachingIterator, rewind, NULL, ZEND_ACC_PUBLIC) @@ -1675,6 +2257,13 @@ static zend_function_entry spl_funcs_CachingIterator[] = { SPL_ME(CachingIterator, hasNext, NULL, ZEND_ACC_PUBLIC) SPL_ME(CachingIterator, __toString, NULL, ZEND_ACC_PUBLIC) SPL_ME(dual_it, getInnerIterator, NULL, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, getFlags, NULL, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, setFlags, arginfo_caching_it_setFlags, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, offsetGet, arginfo_caching_it_offsetGet, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, offsetSet, arginfo_caching_it_offsetSet, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, offsetUnset, arginfo_caching_it_offsetGet, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, offsetExists, arginfo_caching_it_offsetGet, ZEND_ACC_PUBLIC) + SPL_ME(CachingIterator, getCache, NULL, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; @@ -1927,7 +2516,7 @@ int spl_append_it_next_iterator(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/ intern->inner.zobject = *it; intern->inner.ce = Z_OBJCE_PP(it); intern->inner.object = zend_object_store_get_object(*it TSRMLS_CC); - intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, *it TSRMLS_CC); + intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, *it, 0 TSRMLS_CC); spl_dual_it_rewind(intern TSRMLS_CC); return SUCCESS; } else { @@ -1972,7 +2561,7 @@ SPL_METHOD(AppendIterator, append) APPENDIT_CHECK_CTOR(intern); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &it, zend_ce_iterator) == FAILURE) { + 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); @@ -2024,6 +2613,30 @@ SPL_METHOD(AppendIterator, next) spl_append_it_next(intern TSRMLS_CC); } /* }}} */ +/* {{{ proto int AppendIterator::getIteratorIndex() + Get index of iterator */ +SPL_METHOD(AppendIterator, getIteratorIndex) +{ + spl_dual_it_object *intern; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + APPENDIT_CHECK_CTOR(intern); + spl_array_iterator_key(intern->u.append.zarrayit, return_value TSRMLS_CC); +} /* }}} */ + +/* {{{ proto ArrayIterator AppendIterator::getArrayIterator() + Get access to inner ArrayIterator */ +SPL_METHOD(AppendIterator, getArrayIterator) +{ + spl_dual_it_object *intern; + + intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC); + + APPENDIT_CHECK_CTOR(intern); + RETURN_ZVAL(intern->u.append.zarrayit, 1, 0); +} /* }}} */ + static ZEND_BEGIN_ARG_INFO(arginfo_append_it_append, 0) ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0) @@ -2038,66 +2651,105 @@ static zend_function_entry spl_funcs_AppendIterator[] = { SPL_ME(dual_it, current, NULL, ZEND_ACC_PUBLIC) SPL_ME(AppendIterator, next, NULL, ZEND_ACC_PUBLIC) SPL_ME(dual_it, getInnerIterator, NULL, ZEND_ACC_PUBLIC) + SPL_ME(AppendIterator, getIteratorIndex, NULL, ZEND_ACC_PUBLIC) + SPL_ME(AppendIterator, getArrayIterator, NULL, ZEND_ACC_PUBLIC) {NULL, NULL, NULL} }; -/* {{{ proto array iterator_to_array(Traversable it) - Copy the iterator into an array */ -PHP_FUNCTION(iterator_to_array) +PHPAPI int spl_iterator_apply(zval *obj, spl_iterator_apply_func_t apply_func, void *puser TSRMLS_DC) { - zval *obj, **data; zend_object_iterator *iter; - char *str_key; - uint str_key_len; - ulong int_key; - int key_type; + zend_class_entry *ce = Z_OBJCE_P(obj); - if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, zend_ce_traversable) == FAILURE) { - RETURN_FALSE; + iter = ce->get_iterator(ce, obj, 0 TSRMLS_CC); + + if (EG(exception)) { + goto done; } - - array_init(return_value); - - iter = Z_OBJCE_P(obj)->get_iterator(Z_OBJCE_P(obj), obj TSRMLS_CC); if (iter->funcs->rewind) { iter->funcs->rewind(iter TSRMLS_CC); + if (EG(exception)) { + goto done; + } } - if (EG(exception)) { - return; - } + while (iter->funcs->valid(iter TSRMLS_CC) == SUCCESS) { - iter->funcs->get_current_data(iter, &data TSRMLS_CC); if (EG(exception)) { - return; + goto done; } - (*data)->refcount++; - if (iter->funcs->get_current_key) { - key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC); - if (EG(exception)) { - return; - } - switch(key_type) { - case HASH_KEY_IS_STRING: - add_assoc_zval_ex(return_value, str_key, str_key_len, *data); - efree(str_key); - break; - case HASH_KEY_IS_LONG: - add_index_zval(return_value, int_key, *data); - break; - } - } else { - add_next_index_zval(return_value, *data); + if (apply_func(iter, puser TSRMLS_CC) == ZEND_HASH_APPLY_STOP || EG(exception)) { + goto done; } iter->funcs->move_forward(iter TSRMLS_CC); if (EG(exception)) { - return; + goto done; } } + +done: iter->funcs->dtor(iter TSRMLS_CC); + return EG(exception) ? FAILURE : SUCCESS; +} +/* }}} */ + +static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */ +{ + zval **data, *return_value = (zval*)puser; + char *str_key; + uint str_key_len; + ulong int_key; + int key_type; + + iter->funcs->get_current_data(iter, &data TSRMLS_CC); if (EG(exception)) { - return; + return ZEND_HASH_APPLY_STOP; + } + if (iter->funcs->get_current_key) { + key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC); + if (EG(exception)) { + return ZEND_HASH_APPLY_STOP; + } + (*data)->refcount++; + switch(key_type) { + case HASH_KEY_IS_STRING: + add_assoc_zval_ex(return_value, str_key, str_key_len, *data); + efree(str_key); + break; + case HASH_KEY_IS_LONG: + add_index_zval(return_value, int_key, *data); + break; + } + } else { + (*data)->refcount++; + add_next_index_zval(return_value, *data); } + return ZEND_HASH_APPLY_KEEP; +} +/* }}} */ + +/* {{{ proto array iterator_to_array(Traversable it) + Copy the iterator into an array */ +PHP_FUNCTION(iterator_to_array) +{ + zval *obj; + + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, zend_ce_traversable) == FAILURE) { + RETURN_FALSE; + } + + array_init(return_value); + + if (spl_iterator_apply(obj, spl_iterator_to_array_apply, (void*)return_value TSRMLS_CC) != SUCCESS) { + zval_dtor(return_value); + RETURN_NULL(); + } +} + +static int spl_iterator_count_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */ +{ + (*(long*)puser)++; + return ZEND_HASH_APPLY_KEEP; } /* }}} */ @@ -2105,38 +2757,64 @@ PHP_FUNCTION(iterator_to_array) Count the elements in an iterator */ PHP_FUNCTION(iterator_count) { - zval *obj; - zend_object_iterator *iter; - long count = 0; + zval *obj; + long count = 0; if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, zend_ce_traversable) == FAILURE) { RETURN_FALSE; } - iter = Z_OBJCE_P(obj)->get_iterator(Z_OBJCE_P(obj), obj TSRMLS_CC); + if (spl_iterator_apply(obj, spl_iterator_count_apply, (void*)&count TSRMLS_CC) == SUCCESS) { + RETURN_LONG(count); + } +} +/* }}} */ - if (iter->funcs->rewind) { - iter->funcs->rewind(iter TSRMLS_CC); +typedef struct { + zval *obj; + zval *args; + long count; + zend_fcall_info fci; + zend_fcall_info_cache fcc; +} spl_iterator_apply_info; + +static int spl_iterator_func_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */ +{ + zval *retval; + spl_iterator_apply_info *apply_info = (spl_iterator_apply_info*)puser; + int result; + + apply_info->count++; + zend_fcall_info_call(&apply_info->fci, &apply_info->fcc, &retval, NULL TSRMLS_CC); + if (retval) { + result = zend_is_true(retval) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_STOP; + zval_ptr_dtor(&retval); + } else { + result = ZEND_HASH_APPLY_STOP; } - if (EG(exception)) { + return result; +} +/* }}} */ + +/* {{{ proto int iterator_apply(Traversable it, mixed function [, mixed params]) + Calls a function for every element in an iterator */ +PHP_FUNCTION(iterator_apply) +{ + spl_iterator_apply_info apply_info; + + apply_info.args = NULL; + if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "Of|a!", &apply_info.obj, zend_ce_traversable, &apply_info.fci, &apply_info.fcc, &apply_info.args) == FAILURE) { return; } - while (iter->funcs->valid(iter TSRMLS_CC) == SUCCESS) { - if (EG(exception)) { - return; - } - count++; - iter->funcs->move_forward(iter TSRMLS_CC); - if (EG(exception)) { - return; - } - } - iter->funcs->dtor(iter TSRMLS_CC); - if (EG(exception)) { - return; + + apply_info.count = 0; + zend_fcall_info_args(&apply_info.fci, apply_info.args TSRMLS_CC); + if (spl_iterator_apply(apply_info.obj, spl_iterator_func_apply, (void*)&apply_info TSRMLS_CC) == SUCCESS) { + RETVAL_LONG(apply_info.count); + } else { + RETVAL_FALSE; } - - RETURN_LONG(count); + zend_fcall_info_args(&apply_info.fci, NULL TSRMLS_CC); } /* }}} */ @@ -2177,6 +2855,7 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_STD_CLASS_EX(IteratorIterator, spl_dual_it_new, spl_funcs_IteratorIterator); REGISTER_SPL_ITERATOR(IteratorIterator); + REGISTER_SPL_IMPLEMENTS(IteratorIterator, OuterIterator); REGISTER_SPL_SUB_CLASS_EX(FilterIterator, IteratorIterator, spl_dual_it_new, spl_funcs_FilterIterator); spl_ce_FilterIterator->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS; @@ -2192,11 +2871,14 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_SUB_CLASS_EX(LimitIterator, IteratorIterator, spl_dual_it_new, spl_funcs_LimitIterator); REGISTER_SPL_SUB_CLASS_EX(CachingIterator, IteratorIterator, spl_dual_it_new, spl_funcs_CachingIterator); + REGISTER_SPL_IMPLEMENTS(CachingIterator, ArrayAccess); REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CALL_TOSTRING", CIT_CALL_TOSTRING); REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CATCH_GET_CHILD", CIT_CATCH_GET_CHILD); REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_KEY", CIT_TOSTRING_USE_KEY); REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_CURRENT", CIT_TOSTRING_USE_CURRENT); + REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER); + REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE); REGISTER_SPL_SUB_CLASS_EX(RecursiveCachingIterator, CachingIterator, spl_dual_it_new, spl_funcs_RecursiveCachingIterator); REGISTER_SPL_IMPLEMENTS(RecursiveCachingIterator, RecursiveIterator); @@ -2206,8 +2888,24 @@ PHP_MINIT_FUNCTION(spl_iterators) REGISTER_SPL_SUB_CLASS_EX(AppendIterator, IteratorIterator, spl_dual_it_new, spl_funcs_AppendIterator); REGISTER_SPL_IMPLEMENTS(RecursiveIteratorIterator, OuterIterator); + REGISTER_SPL_SUB_CLASS_EX(InfiniteIterator, IteratorIterator, spl_dual_it_new, spl_funcs_InfiniteIterator); - +#if HAVE_PCRE || HAVE_BUNDLED_PCRE + REGISTER_SPL_SUB_CLASS_EX(RegexIterator, FilterIterator, spl_dual_it_new, spl_funcs_RegexIterator); + REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "USE_KEY", REGIT_USE_KEY); + REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "MATCH", REGIT_MODE_MATCH); + REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "GET_MATCH", REGIT_MODE_GET_MATCH); + REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "ALL_MATCHES", REGIT_MODE_ALL_MATCHES); + REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "SPLIT", REGIT_MODE_SPLIT); + REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "REPLACE", REGIT_MODE_REPLACE); + REGISTER_SPL_PROPERTY(RegexIterator, "replacement", 0); + REGISTER_SPL_SUB_CLASS_EX(RecursiveRegexIterator, RegexIterator, spl_dual_it_new, spl_funcs_RecursiveRegexIterator); + REGISTER_SPL_IMPLEMENTS(RecursiveRegexIterator, RecursiveIterator); +#else + spl_ce_RegexIterator = NULL; + spl_ce_RecursiveRegexIterator = NULL; +#endif + REGISTER_SPL_STD_CLASS_EX(EmptyIterator, NULL, spl_funcs_EmptyIterator); REGISTER_SPL_ITERATOR(EmptyIterator); |