clones/php-src
1
0
Fork 0
mirror of https://github.com/php/php-src.git synced 2024-09-21 18:07:23 +00:00
Code Issues Packages Projects Releases Wiki Activity

Implement CahingIterator and CachingRecursiveIterator as C-code.

Browse Source 
#Script examples/directorytree.php has a few memleaks though but besides
#that all works fine.
This commit is contained in:
Marcus Boerger 2003-12-08 08:39:18 +00:00
parent 1c13018702
commit f3a3990ca8
4 changed files with 361 additions and 54 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
ext/spl/php_spl.c
View File

@ -169,13 +169,15 @@ PHP_FUNCTION(spl_classes)
SPL_ADD_CLASS(ArrayObject);
SPL_ADD_CLASS(ArrayIterator);
SPL_ADD_CLASS(CachingIterator);
SPL_ADD_CLASS(CachingRecursiveIterator);
SPL_ADD_CLASS(DirectoryIterator);
SPL_ADD_CLASS(FilterIterator);
SPL_ADD_CLASS(LimitIterator);
SPL_ADD_CLASS(ParentIterator);
SPL_ADD_CLASS(RecursiveIterator);
SPL_ADD_CLASS(RecursiveIteratorIterator);
SPL_ADD_CLASS(FilterIterator);
SPL_ADD_CLASS(ParentIterator);
SPL_ADD_CLASS(SeekableIterator);
SPL_ADD_CLASS(LimitIterator);
}
/* }}} */

3
ext/spl/spl_functions.h
View File

@ -41,6 +41,9 @@ typedef zend_object_value (*create_object_func_t)(zend_class_entry *class_type T
#define REGISTER_SPL_IMPLEMENTS(class_name, interface_name) \
zend_class_implements(spl_ce_ ## class_name TSRMLS_CC, 1, spl_ce_ ## interface_name);
#define REGISTER_SPL_ITERATOR(class_name) \
zend_class_implements(spl_ce_ ## class_name TSRMLS_CC, 1, zend_ce_iterator);
#define REGISTER_SPL_FUNCTIONS(class_name, function_list) \
spl_register_functions(spl_ce_ ## class_name, function_list TSRMLS_CC);

379
ext/spl/spl_iterators.c
View File

@ -32,12 +32,16 @@
#include "spl_iterators.h"
#include "spl_directory.h"
#define INLINE inline
zend_class_entry *spl_ce_RecursiveIterator;
zend_class_entry *spl_ce_RecursiveIteratorIterator;
zend_class_entry *spl_ce_FilterIterator;
zend_class_entry *spl_ce_ParentIterator;
zend_class_entry *spl_ce_SeekableIterator;
zend_class_entry *spl_ce_LimitIterator;
zend_class_entry *spl_ce_CachingIterator;
zend_class_entry *spl_ce_CachingRecursiveIterator;
function_entry spl_funcs_RecursiveIterator[] = {
SPL_ABSTRACT_ME(RecursiveIterator, hasChildren, NULL)
@ -110,7 +114,8 @@ typedef struct _spl_recursive_it_iterator {
zval *zobject;
} spl_recursive_it_iterator;
static zend_object_handlers spl_handlers_iterators;
static zend_object_handlers spl_handlers_rec_it_it;
static zend_object_handlers spl_handlers_dual_it;
static void spl_recursive_it_dtor(zend_object_iterator *_iter TSRMLS_DC)
{
@ -406,8 +411,8 @@ SPL_METHOD(RecursiveIteratorIterator, getSubIterator)
RETURN_ZVAL(zobject, 1, 0);
}
/* {{{ spl_dtor_RecursiveIteratorIterator */
static void spl_dtor_RecursiveIteratorIterator(void *_object, zend_object_handle handle TSRMLS_DC)
/* {{{ spl_RecursiveIteratorIterator_dtor */
static void spl_RecursiveIteratorIterator_dtor(void *_object, zend_object_handle handle TSRMLS_DC)
{
spl_recursive_it_object *object = (spl_recursive_it_object *)_object;
zend_object_iterator *sub_iter;
@ -433,8 +438,8 @@ static int spl_recursive_it_gets_implemented(zend_class_entry *iface, zend_class
return SUCCESS;
}
/* {{{ spl_new_RecursiveIteratorIterator */
static zend_object_value spl_new_RecursiveIteratorIterator(zend_class_entry *class_type TSRMLS_DC)
/* {{{ spl_RecursiveIteratorIterator_new */
static zend_object_value spl_RecursiveIteratorIterator_new(zend_class_entry *class_type TSRMLS_DC)
{
zend_object_value retval;
spl_recursive_it_object *intern;
@ -448,8 +453,8 @@ static zend_object_value spl_new_RecursiveIteratorIterator(zend_class_entry *cla
zend_hash_init(intern->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
retval.handle = zend_objects_store_put(intern, spl_dtor_RecursiveIteratorIterator, NULL TSRMLS_CC);
retval.handlers = &spl_handlers_iterators;
retval.handle = zend_objects_store_put(intern, spl_RecursiveIteratorIterator_dtor, NULL TSRMLS_CC);
retval.handlers = &spl_handlers_rec_it_it;
return retval;
}
/* }}} */
@ -470,12 +475,71 @@ static int spl_dual_it_gets_implemented(zend_class_entry *interface, zend_class_
}
#endif
typedef enum {
dit_default = 0,
dit_limit
} dual_it_type;
static union _zend_function *spl_dual_it_get_method(zval *object, char *method, int method_len TSRMLS_DC)
{
union _zend_function *function_handler;
spl_dual_it_object *intern;
static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_inner, dual_it_type dit_type)
intern = (spl_dual_it_object*)zend_object_store_get_object(object TSRMLS_CC);
/*fprintf(stderr, "Call method(%s): %s::%s() ", Z_OBJCE_P(object)->name, intern->inner.ce->name, method);*/
function_handler = std_object_handlers.get_method(object, method, method_len TSRMLS_CC);
if (!function_handler) {
if (zend_hash_find(&intern->inner.ce->function_table, method, method_len+1, (void **) &function_handler) == FAILURE) {
if (Z_OBJ_HT_P(intern->inner.zobject)->get_method) {
function_handler = Z_OBJ_HT_P(intern->inner.zobject)->get_method(intern->inner.zobject, method, method_len TSRMLS_CC);
}
}
}
/*fprintf(stderr, "%sfound\n", function_handler ? "" : "not ");*/
return function_handler;
}
#if MBO_0
int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
{
zval ***func_params, func;
zval *retval_ptr;
int arg_count;
int current = 0;
int success;
void **p;
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
ZVAL_STRING(&func, method, 0);
if (!zend_is_callable(&func, 0, &method)) {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Method %s::%s() does not exist", intern->inner.ce->name, method);
return FAILURE;
}
p = EG(argument_stack).top_element-2;
arg_count = (ulong) *p;
func_params = safe_emalloc(sizeof(zval **), arg_count, 0);
current = 0;
while (arg_count-- > 0) {
func_params[current] = (zval **) p - (arg_count-current);
current++;
}
if (call_user_function_ex(EG(function_table), NULL, &func, &retval_ptr, arg_count, func_params, 0, NULL TSRMLS_CC) == SUCCESS && retval_ptr) {
RETURN_ZVAL(retval_ptr, 0, 1);
success = SUCCESS;
} else {
php_error_docref(NULL TSRMLS_CC, E_ERROR, "Unable to call %s::%s()", intern->inner.ce->name, method);
success = FAILURE;
}
efree(func_params);
return success;
}
#endif
static INLINE spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_inner, dual_it_type dit_type)
{
zval *zobject;
spl_dual_it_object *intern;
@ -484,8 +548,9 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
intern->dit_type = dit_type;
switch (dit_type) {
case dit_limit: {
case DIT_LimitIterator: {
intern->u.limit.count = -1; /* get all */
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|ll", &zobject, ce_inner, &intern->u.limit.offset, &intern->u.limit.count) == FAILURE) {
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
@ -503,6 +568,16 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
}
break;
}
case DIT_CachingIterator:
case DIT_CachingRecursiveIterator: {
long flags = CIT_CALL_TOSTRING;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|l", &zobject, ce_inner, &flags) == FAILURE) {
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
return NULL;
}
intern->u.caching.flags |= flags & CIT_PUBLIC;
break;
}
default:
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zobject, ce_inner) == FAILURE) {
php_set_error_handling(EH_NORMAL, NULL TSRMLS_CC);
@ -523,12 +598,12 @@ static spl_dual_it_object* spl_dual_it_construct(INTERNAL_FUNCTION_PARAMETERS, z
SPL_METHOD(dual_it, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, zend_ce_iterator, dit_default);
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, zend_ce_iterator, DIT_Default);
}
static void spl_dual_it_free(spl_dual_it_object *intern TSRMLS_DC)
static INLINE void spl_dual_it_free(spl_dual_it_object *intern TSRMLS_DC)
{
if (intern->current.data) {
if (intern->current.data && *intern->current.data) {
zval_ptr_dtor(intern->current.data);
intern->current.data = NULL;
}
@ -536,9 +611,19 @@ static void spl_dual_it_free(spl_dual_it_object *intern TSRMLS_DC)
efree(intern->current.str_key);
intern->current.str_key = NULL;
}
if (intern->dit_type == DIT_CachingIterator || intern->dit_type == DIT_CachingRecursiveIterator) {
if (intern->u.caching.zstr) {
zval_ptr_dtor(&intern->u.caching.zstr);
intern->u.caching.zstr = NULL;
}
if (intern->u.caching.zchildren) {
zval_ptr_dtor(&intern->u.caching.zchildren);
intern->u.caching.zchildren = NULL;
}
}
}
static void spl_dual_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
static INLINE void spl_dual_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
{
spl_dual_it_free(intern TSRMLS_CC);
intern->current.pos = 0;
@ -547,16 +632,16 @@ static void spl_dual_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
}
}
static int spl_dual_it_has_more(spl_dual_it_object *intern TSRMLS_DC)
static INLINE int spl_dual_it_has_more(spl_dual_it_object *intern TSRMLS_DC)
{
/* FAILURE / SUCCESS */
return intern->inner.iterator->funcs->has_more(intern->inner.iterator TSRMLS_CC);
}
static void spl_dual_it_fetch(spl_dual_it_object *intern TSRMLS_DC)
static INLINE void spl_dual_it_fetch(spl_dual_it_object *intern, int check_more TSRMLS_DC)
{
spl_dual_it_free(intern TSRMLS_CC);
if (spl_dual_it_has_more(intern TSRMLS_CC) == SUCCESS) {
if (!check_more || spl_dual_it_has_more(intern TSRMLS_CC) == SUCCESS) {
intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &intern->current.data TSRMLS_CC);
(*intern->current.data)->refcount++;
if (intern->inner.iterator->funcs->get_current_key) {
@ -568,9 +653,11 @@ static void spl_dual_it_fetch(spl_dual_it_object *intern TSRMLS_DC)
}
}
static void spl_dual_it_next(spl_dual_it_object *intern TSRMLS_DC)
static INLINE void spl_dual_it_next(spl_dual_it_object *intern, int do_free TSRMLS_DC)
{
spl_dual_it_free(intern TSRMLS_CC);
if (do_free) {
spl_dual_it_free(intern TSRMLS_CC);
}
intern->inner.iterator->funcs->move_forward(intern->inner.iterator TSRMLS_CC);
intern->current.pos++;
}
@ -581,7 +668,7 @@ SPL_METHOD(dual_it, rewind)
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
spl_dual_it_rewind(intern TSRMLS_CC);
spl_dual_it_fetch(intern TSRMLS_CC);
spl_dual_it_fetch(intern, 1 TSRMLS_CC);
}
SPL_METHOD(dual_it, hasMore)
@ -628,16 +715,16 @@ SPL_METHOD(dual_it, next)
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
spl_dual_it_next(intern TSRMLS_CC);
spl_dual_it_fetch(intern TSRMLS_CC);
spl_dual_it_next(intern, 1 TSRMLS_CC);
spl_dual_it_fetch(intern, 1 TSRMLS_CC);
}
static void spl_filter_it_fetch(zval *zobject, spl_dual_it_object *intern TSRMLS_DC)
static INLINE void spl_filter_it_fetch(zval *zobject, spl_dual_it_object *intern TSRMLS_DC)
{
zval *retval;
while (spl_dual_it_has_more(intern TSRMLS_CC) == SUCCESS) {
spl_dual_it_fetch(intern TSRMLS_CC);
spl_dual_it_fetch(intern, 1 TSRMLS_CC);
zend_call_method_with_0_params(&zobject, intern->std.ce, NULL, "accept", &retval);
if (zend_is_true(retval)) {
@ -666,13 +753,13 @@ SPL_METHOD(FilterIterator, next)
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
spl_dual_it_next(intern TSRMLS_CC);
spl_dual_it_next(intern, 1 TSRMLS_CC);
spl_filter_it_fetch(getThis(), intern TSRMLS_CC);
}
SPL_METHOD(ParentIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveIterator, dit_default);
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveIterator, DIT_Default);
}
SPL_METHOD(ParentIterator, hasChildren)
@ -698,8 +785,8 @@ SPL_METHOD(ParentIterator, getChildren)
zval_ptr_dtor(&retval);
}
/* {{{ spl_dtor_dual_it */
static void spl_dtor_dual_it(void *_object, zend_object_handle handle TSRMLS_DC)
/* {{{ spl_dual_it_dtor */
static INLINE void spl_dual_it_dtor(void *_object, zend_object_handle handle TSRMLS_DC)
{
spl_dual_it_object *object = (spl_dual_it_object *)_object;
@ -720,8 +807,8 @@ static void spl_dtor_dual_it(void *_object, zend_object_handle handle TSRMLS_DC)
}
/* }}} */
/* {{{ spl_new_dual_it */
static zend_object_value spl_new_dual_it(zend_class_entry *class_type TSRMLS_DC)
/* {{{ spl_dual_it_new */
static zend_object_value spl_dual_it_new(zend_class_entry *class_type TSRMLS_DC)
{
zend_object_value retval;
spl_dual_it_object *intern;
@ -735,8 +822,8 @@ static zend_object_value spl_new_dual_it(zend_class_entry *class_type TSRMLS_DC)
zend_hash_init(intern->std.properties, 0, NULL, ZVAL_PTR_DTOR, 0);
zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
retval.handle = zend_objects_store_put(intern, spl_dtor_dual_it, NULL TSRMLS_CC);
retval.handlers = &spl_handlers_iterators;
retval.handle = zend_objects_store_put(intern, spl_dual_it_dtor, NULL TSRMLS_CC);
retval.handlers = &spl_handlers_dual_it;
return retval;
}
/* }}} */
@ -770,7 +857,7 @@ static zend_function_entry spl_funcs_ParentIterator[] = {
{NULL, NULL, NULL}
};
static void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS_DC)
static INLINE void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS_DC)
{
zval zpos;
@ -795,17 +882,17 @@ static void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS_DC)
spl_dual_it_rewind(intern TSRMLS_CC);
}
while (pos > intern->current.pos && spl_dual_it_has_more(intern TSRMLS_CC) == SUCCESS) {
spl_dual_it_next(intern TSRMLS_CC);
spl_dual_it_next(intern, 1 TSRMLS_CC);
}
if (spl_dual_it_has_more(intern TSRMLS_CC) == SUCCESS) {
spl_dual_it_fetch(intern TSRMLS_CC);
spl_dual_it_fetch(intern, 1 TSRMLS_CC);
}
}
}
SPL_METHOD(LimitIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, zend_ce_iterator, dit_limit);
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, zend_ce_iterator, DIT_LimitIterator);
}
SPL_METHOD(LimitIterator, rewind)
@ -881,18 +968,199 @@ static zend_function_entry spl_funcs_LimitIterator[] = {
{NULL, NULL, NULL}
};
static INLINE int spl_caching_it_has_more(spl_dual_it_object *intern TSRMLS_DC)
{
return intern->u.caching.flags & CIT_HAS_MORE ? SUCCESS : FAILURE;
}
static INLINE int spl_caching_it_has_next(spl_dual_it_object *intern TSRMLS_DC)
{
return spl_dual_it_has_more(intern TSRMLS_CC);
}
static INLINE void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
{
if (spl_dual_it_has_more(intern TSRMLS_CC) == SUCCESS) {
intern->u.caching.flags |= CIT_HAS_MORE;
spl_dual_it_fetch(intern, 0 TSRMLS_CC);
if (intern->dit_type == DIT_CachingRecursiveIterator) {
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) {
zval_ptr_dtor(&EG(exception));
EG(exception) = NULL;
if (zchildren) {
zval_ptr_dtor(&zchildren);
}
} else {
INIT_PZVAL(&zflags);
ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC);
spl_instantiate_arg_ex2(spl_ce_CachingRecursiveIterator, &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) {
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);
} 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);
}
}
spl_dual_it_next(intern, 0 TSRMLS_CC);
} else {
intern->u.caching.flags &= ~CIT_HAS_MORE;
spl_dual_it_next(intern, 1 TSRMLS_CC);
}
}
static INLINE void spl_caching_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
{
spl_dual_it_rewind(intern TSRMLS_CC);
spl_caching_it_next(intern TSRMLS_CC);
}
SPL_METHOD(CachingIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, zend_ce_iterator, DIT_CachingIterator);
}
SPL_METHOD(CachingIterator, rewind)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
spl_caching_it_rewind(intern TSRMLS_CC);
}
SPL_METHOD(CachingIterator, hasMore)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
RETURN_BOOL(spl_caching_it_has_more(intern TSRMLS_CC) == SUCCESS);
}
SPL_METHOD(CachingIterator, next)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
spl_caching_it_next(intern TSRMLS_CC);
}
SPL_METHOD(CachingIterator, hasNext)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
RETURN_BOOL(spl_caching_it_has_next(intern TSRMLS_CC) == SUCCESS);
}
SPL_METHOD(CachingIterator, __toString)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
if (!(intern->u.caching.flags & CIT_CALL_TOSTRING)) {
zend_throw_exception_ex(zend_exception_get_default(), 0 TSRMLS_CC, "%s does not fetch string value (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
}
if (intern->u.caching.zstr) {
RETURN_STRINGL(Z_STRVAL_P(intern->u.caching.zstr), Z_STRLEN_P(intern->u.caching.zstr), 1);
} else {
RETURN_NULL();
}
}
static
ZEND_BEGIN_ARG_INFO(arginfo_caching_it___construct, 0)
ZEND_ARG_INFO(0, iterator)
ZEND_ARG_INFO(0, getStrVal)
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)
SPL_ME(CachingIterator, hasMore, NULL, ZEND_ACC_PUBLIC)
SPL_ME(dual_it, key, NULL, ZEND_ACC_PUBLIC)
SPL_ME(dual_it, current, NULL, ZEND_ACC_PUBLIC)
SPL_ME(CachingIterator, next, NULL, ZEND_ACC_PUBLIC)
SPL_ME(CachingIterator, hasNext, NULL, ZEND_ACC_PUBLIC)
SPL_ME(CachingIterator, __toString, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
SPL_METHOD(CachingRecursiveIterator, __construct)
{
spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveIterator, DIT_CachingRecursiveIterator);
}
SPL_METHOD(CachingRecursiveIterator, hasChildren)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
RETURN_BOOL(intern->u.caching.zchildren);
}
SPL_METHOD(CachingRecursiveIterator, getChildren)
{
spl_dual_it_object *intern;
intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
if (intern->u.caching.zchildren) {
RETURN_ZVAL(intern->u.caching.zchildren, 1, 0);
} else {
RETURN_NULL();
}
}
static
ZEND_BEGIN_ARG_INFO(arginfo_caching_rec_it___construct, 0)
ZEND_ARG_INFO(0, iterator)
ZEND_ARG_INFO(0, getStrVal)
ZEND_ARG_INFO(0, catch_getChildren)
ZEND_END_ARG_INFO();
static zend_function_entry spl_funcs_CachingRecursiveIterator[] = {
SPL_ME(CachingRecursiveIterator, __construct, arginfo_caching_rec_it___construct, ZEND_ACC_PUBLIC)
SPL_ME(CachingRecursiveIterator, hasChildren, NULL, ZEND_ACC_PUBLIC)
SPL_ME(CachingRecursiveIterator, getChildren, NULL, ZEND_ACC_PUBLIC)
{NULL, NULL, NULL}
};
/* {{{ PHP_MINIT_FUNCTION(spl_iterators)
*/
PHP_MINIT_FUNCTION(spl_iterators)
{
REGISTER_SPL_INTERFACE(RecursiveIterator);
zend_class_implements(spl_ce_RecursiveIterator TSRMLS_CC, 1, zend_ce_iterator);
REGISTER_SPL_ITERATOR(RecursiveIterator);
REGISTER_SPL_STD_CLASS_EX(RecursiveIteratorIterator, spl_new_RecursiveIteratorIterator, spl_funcs_RecursiveIteratorIterator);
zend_class_implements(spl_ce_RecursiveIteratorIterator TSRMLS_CC, 1, zend_ce_iterator);
REGISTER_SPL_STD_CLASS_EX(RecursiveIteratorIterator, spl_RecursiveIteratorIterator_new, spl_funcs_RecursiveIteratorIterator);
REGISTER_SPL_ITERATOR(RecursiveIteratorIterator);
memcpy(&spl_handlers_iterators, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
spl_handlers_iterators.clone_obj = NULL;
memcpy(&spl_handlers_rec_it_it, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
spl_handlers_rec_it_it.clone_obj = NULL;
memcpy(&spl_handlers_dual_it, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
spl_handlers_dual_it.get_method = spl_dual_it_get_method;
/*spl_handlers_dual_it.call_method = spl_dual_it_call_method;*/
spl_handlers_dual_it.clone_obj = NULL;
spl_ce_RecursiveIterator->interface_gets_implemented = spl_recursive_it_gets_implemented;
@ -903,19 +1171,28 @@ PHP_MINIT_FUNCTION(spl_iterators)
REGISTER_LONG_CONSTANT("RIT_SELF_FIRST", (long)RIT_SELF_FIRST, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("RIT_CHILD_FIRST", (long)RIT_CHILD_FIRST, CONST_CS | CONST_PERSISTENT);
REGISTER_SPL_STD_CLASS_EX(FilterIterator, spl_new_dual_it, spl_funcs_FilterIterator);
zend_class_implements(spl_ce_FilterIterator TSRMLS_CC, 1, zend_ce_iterator);
REGISTER_SPL_STD_CLASS_EX(FilterIterator, spl_dual_it_new, spl_funcs_FilterIterator);
REGISTER_SPL_ITERATOR(FilterIterator);
spl_ce_FilterIterator->ce_flags |= ZEND_ACC_ABSTRACT_CLASS;
REGISTER_SPL_SUB_CLASS_EX(ParentIterator, FilterIterator, spl_new_dual_it, spl_funcs_ParentIterator);
zend_class_implements(spl_ce_ParentIterator TSRMLS_CC, 1, spl_ce_RecursiveIterator);
REGISTER_SPL_SUB_CLASS_EX(ParentIterator, FilterIterator, spl_dual_it_new, spl_funcs_ParentIterator);
REGISTER_SPL_IMPLEMENTS(ParentIterator, RecursiveIterator);
REGISTER_SPL_INTERFACE(SeekableIterator);
zend_class_implements(spl_ce_SeekableIterator TSRMLS_CC, 1, zend_ce_iterator);
REGISTER_SPL_ITERATOR(SeekableIterator);
REGISTER_SPL_STD_CLASS_EX(LimitIterator, spl_new_dual_it, spl_funcs_LimitIterator);
zend_class_implements(spl_ce_LimitIterator TSRMLS_CC, 1, zend_ce_iterator);
REGISTER_SPL_STD_CLASS_EX(LimitIterator, spl_dual_it_new, spl_funcs_LimitIterator);
REGISTER_SPL_ITERATOR(LimitIterator);
REGISTER_SPL_STD_CLASS_EX(CachingIterator, spl_dual_it_new, spl_funcs_CachingIterator);
REGISTER_SPL_ITERATOR(CachingIterator);
REGISTER_LONG_CONSTANT("CIT_CALL_TOSTRING", (long)CIT_CALL_TOSTRING, CONST_CS | CONST_PERSISTENT);
REGISTER_LONG_CONSTANT("CIT_CATCH_GET_CHILD", (long)CIT_CATCH_GET_CHILD, CONST_CS | CONST_PERSISTENT);
REGISTER_SPL_SUB_CLASS_EX(CachingRecursiveIterator, CachingIterator, spl_dual_it_new, spl_funcs_CachingRecursiveIterator);
REGISTER_SPL_IMPLEMENTS(CachingRecursiveIterator, RecursiveIterator);
return SUCCESS;
}
/* }}} */

25
ext/spl/spl_iterators.h
View File

@ -28,9 +28,28 @@ extern zend_class_entry *spl_ce_FilterIterator;
extern zend_class_entry *spl_ce_ParentIterator;
extern zend_class_entry *spl_ce_SeekableIterator;
extern zend_class_entry *spl_ce_LimitIterator;
extern zend_class_entry *spl_ce_CachingIterator;
extern zend_class_entry *spl_ce_CachingRecursiveIterator;
PHP_MINIT_FUNCTION(spl_iterators);
typedef enum {
DIT_Default = 0,
DIT_LimitIterator,
DIT_CachingIterator,
DIT_CachingRecursiveIterator
} dual_it_type;
enum {
/* public */
CIT_CALL_TOSTRING = 1,
CIT_CATCH_GET_CHILD = 2,
CIT_PUBLIC = CIT_CALL_TOSTRING|CIT_CATCH_GET_CHILD,
/* private */
CIT_HAS_MORE = 4,
CIT_HAS_CHILDREN = 8
};
typedef struct _spl_dual_it_object {
zend_object std;
struct {
@ -47,11 +66,17 @@ typedef struct _spl_dual_it_object {
int key_type; /* HASH_KEY_IS_STRING or HASH_KEY_IS_LONG */
int pos;
} current;
dual_it_type dit_type;
union {
struct {
int offset;
int count;
} limit;
struct {
int flags; /* CIT_HAS_MORE, CIT_CALL_TOSTRING, CIT_CATCH_GET_CHILD */
zval *zstr;
zval *zchildren;
} caching;
} u;
} spl_dual_it_object;