Annotation of embedaddon/php/ext/spl/spl_iterators.c, revision 1.1
1.1 ! misho 1: /*
! 2: +----------------------------------------------------------------------+
! 3: | PHP Version 5 |
! 4: +----------------------------------------------------------------------+
! 5: | Copyright (c) 1997-2012 The PHP Group |
! 6: +----------------------------------------------------------------------+
! 7: | This source file is subject to version 3.01 of the PHP license, |
! 8: | that is bundled with this package in the file LICENSE, and is |
! 9: | available through the world-wide-web at the following url: |
! 10: | http://www.php.net/license/3_01.txt |
! 11: | If you did not receive a copy of the PHP license and are unable to |
! 12: | obtain it through the world-wide-web, please send a note to |
! 13: | license@php.net so we can mail you a copy immediately. |
! 14: +----------------------------------------------------------------------+
! 15: | Authors: Marcus Boerger <helly@php.net> |
! 16: +----------------------------------------------------------------------+
! 17: */
! 18:
! 19: /* $Id: spl_iterators.c 321634 2012-01-01 13:15:04Z felipe $ */
! 20:
! 21: #ifdef HAVE_CONFIG_H
! 22: # include "config.h"
! 23: #endif
! 24:
! 25: #include "php.h"
! 26: #include "php_ini.h"
! 27: #include "ext/standard/info.h"
! 28: #include "zend_exceptions.h"
! 29: #include "zend_interfaces.h"
! 30:
! 31: #include "php_spl.h"
! 32: #include "spl_functions.h"
! 33: #include "spl_engine.h"
! 34: #include "spl_iterators.h"
! 35: #include "spl_directory.h"
! 36: #include "spl_array.h"
! 37: #include "spl_exceptions.h"
! 38: #include "ext/standard/php_smart_str.h"
! 39:
! 40: #ifdef accept
! 41: #undef accept
! 42: #endif
! 43:
! 44: PHPAPI zend_class_entry *spl_ce_RecursiveIterator;
! 45: PHPAPI zend_class_entry *spl_ce_RecursiveIteratorIterator;
! 46: PHPAPI zend_class_entry *spl_ce_FilterIterator;
! 47: PHPAPI zend_class_entry *spl_ce_RecursiveFilterIterator;
! 48: PHPAPI zend_class_entry *spl_ce_ParentIterator;
! 49: PHPAPI zend_class_entry *spl_ce_SeekableIterator;
! 50: PHPAPI zend_class_entry *spl_ce_LimitIterator;
! 51: PHPAPI zend_class_entry *spl_ce_CachingIterator;
! 52: PHPAPI zend_class_entry *spl_ce_RecursiveCachingIterator;
! 53: PHPAPI zend_class_entry *spl_ce_OuterIterator;
! 54: PHPAPI zend_class_entry *spl_ce_IteratorIterator;
! 55: PHPAPI zend_class_entry *spl_ce_NoRewindIterator;
! 56: PHPAPI zend_class_entry *spl_ce_InfiniteIterator;
! 57: PHPAPI zend_class_entry *spl_ce_EmptyIterator;
! 58: PHPAPI zend_class_entry *spl_ce_AppendIterator;
! 59: PHPAPI zend_class_entry *spl_ce_RegexIterator;
! 60: PHPAPI zend_class_entry *spl_ce_RecursiveRegexIterator;
! 61: PHPAPI zend_class_entry *spl_ce_Countable;
! 62: PHPAPI zend_class_entry *spl_ce_RecursiveTreeIterator;
! 63:
! 64: ZEND_BEGIN_ARG_INFO(arginfo_recursive_it_void, 0)
! 65: ZEND_END_ARG_INFO()
! 66:
! 67: const zend_function_entry spl_funcs_RecursiveIterator[] = {
! 68: SPL_ABSTRACT_ME(RecursiveIterator, hasChildren, arginfo_recursive_it_void)
! 69: SPL_ABSTRACT_ME(RecursiveIterator, getChildren, arginfo_recursive_it_void)
! 70: PHP_FE_END
! 71: };
! 72:
! 73: typedef enum {
! 74: RIT_LEAVES_ONLY = 0,
! 75: RIT_SELF_FIRST = 1,
! 76: RIT_CHILD_FIRST = 2
! 77: } RecursiveIteratorMode;
! 78:
! 79: #define RIT_CATCH_GET_CHILD CIT_CATCH_GET_CHILD
! 80:
! 81: typedef enum {
! 82: RTIT_BYPASS_CURRENT = 4,
! 83: RTIT_BYPASS_KEY = 8
! 84: } RecursiveTreeIteratorFlags;
! 85:
! 86: typedef enum {
! 87: RS_NEXT = 0,
! 88: RS_TEST = 1,
! 89: RS_SELF = 2,
! 90: RS_CHILD = 3,
! 91: RS_START = 4
! 92: } RecursiveIteratorState;
! 93:
! 94: typedef struct _spl_sub_iterator {
! 95: zend_object_iterator *iterator;
! 96: zval *zobject;
! 97: zend_class_entry *ce;
! 98: RecursiveIteratorState state;
! 99: } spl_sub_iterator;
! 100:
! 101: typedef struct _spl_recursive_it_object {
! 102: zend_object std;
! 103: spl_sub_iterator *iterators;
! 104: int level;
! 105: RecursiveIteratorMode mode;
! 106: int flags;
! 107: int max_depth;
! 108: zend_bool in_iteration;
! 109: zend_function *beginIteration;
! 110: zend_function *endIteration;
! 111: zend_function *callHasChildren;
! 112: zend_function *callGetChildren;
! 113: zend_function *beginChildren;
! 114: zend_function *endChildren;
! 115: zend_function *nextElement;
! 116: zend_class_entry *ce;
! 117: smart_str prefix[6];
! 118: } spl_recursive_it_object;
! 119:
! 120: typedef struct _spl_recursive_it_iterator {
! 121: zend_object_iterator intern;
! 122: zval *zobject;
! 123: } spl_recursive_it_iterator;
! 124:
! 125: static zend_object_handlers spl_handlers_rec_it_it;
! 126: static zend_object_handlers spl_handlers_dual_it;
! 127:
! 128: #define SPL_FETCH_AND_CHECK_DUAL_IT(var, objzval) \
! 129: do { \
! 130: spl_dual_it_object *it = zend_object_store_get_object((objzval) TSRMLS_CC); \
! 131: if (it->dit_type == DIT_Unknown) { \
! 132: zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, \
! 133: "The object is in an invalid state as the parent constructor was not called"); \
! 134: return; \
! 135: } \
! 136: (var) = it; \
! 137: } while (0)
! 138:
! 139: static void spl_recursive_it_dtor(zend_object_iterator *_iter TSRMLS_DC)
! 140: {
! 141: spl_recursive_it_iterator *iter = (spl_recursive_it_iterator*)_iter;
! 142: spl_recursive_it_object *object = (spl_recursive_it_object*)_iter->data;
! 143: zend_object_iterator *sub_iter;
! 144:
! 145: while (object->level > 0) {
! 146: sub_iter = object->iterators[object->level].iterator;
! 147: sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
! 148: zval_ptr_dtor(&object->iterators[object->level--].zobject);
! 149: }
! 150: object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator));
! 151: object->level = 0;
! 152:
! 153: zval_ptr_dtor(&iter->zobject);
! 154: efree(iter);
! 155: }
! 156:
! 157: static int spl_recursive_it_valid_ex(spl_recursive_it_object *object, zval *zthis TSRMLS_DC)
! 158: {
! 159: zend_object_iterator *sub_iter;
! 160: int level = object->level;
! 161:
! 162: while (level >=0) {
! 163: sub_iter = object->iterators[level].iterator;
! 164: if (sub_iter->funcs->valid(sub_iter TSRMLS_CC) == SUCCESS) {
! 165: return SUCCESS;
! 166: }
! 167: level--;
! 168: }
! 169: if (object->endIteration && object->in_iteration) {
! 170: zend_call_method_with_0_params(&zthis, object->ce, &object->endIteration, "endIteration", NULL);
! 171: }
! 172: object->in_iteration = 0;
! 173: return FAILURE;
! 174: }
! 175:
! 176: static int spl_recursive_it_valid(zend_object_iterator *iter TSRMLS_DC)
! 177: {
! 178: spl_recursive_it_object *object = (spl_recursive_it_object*)iter->data;
! 179:
! 180: return spl_recursive_it_valid_ex(object, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC);
! 181: }
! 182:
! 183: static void spl_recursive_it_get_current_data(zend_object_iterator *iter, zval ***data TSRMLS_DC)
! 184: {
! 185: spl_recursive_it_object *object = (spl_recursive_it_object*)iter->data;
! 186: zend_object_iterator *sub_iter = object->iterators[object->level].iterator;
! 187:
! 188: sub_iter->funcs->get_current_data(sub_iter, data TSRMLS_CC);
! 189: }
! 190:
! 191: static int spl_recursive_it_get_current_key(zend_object_iterator *iter, char **str_key, uint *str_key_len, ulong *int_key TSRMLS_DC)
! 192: {
! 193: spl_recursive_it_object *object = (spl_recursive_it_object*)iter->data;
! 194: zend_object_iterator *sub_iter = object->iterators[object->level].iterator;
! 195:
! 196: if (sub_iter->funcs->get_current_key) {
! 197: return sub_iter->funcs->get_current_key(sub_iter, str_key, str_key_len, int_key TSRMLS_CC);
! 198: } else {
! 199: *int_key = iter->index;
! 200: return HASH_KEY_IS_LONG;
! 201: }
! 202: }
! 203:
! 204: static void spl_recursive_it_move_forward_ex(spl_recursive_it_object *object, zval *zthis TSRMLS_DC)
! 205: {
! 206: zend_object_iterator *iterator;
! 207: zval *zobject;
! 208: zend_class_entry *ce;
! 209: zval *retval, *child;
! 210: zend_object_iterator *sub_iter;
! 211: int has_children;
! 212:
! 213: while (!EG(exception)) {
! 214: next_step:
! 215: iterator = object->iterators[object->level].iterator;
! 216: switch (object->iterators[object->level].state) {
! 217: case RS_NEXT:
! 218: iterator->funcs->move_forward(iterator TSRMLS_CC);
! 219: if (EG(exception)) {
! 220: if (!(object->flags & RIT_CATCH_GET_CHILD)) {
! 221: return;
! 222: } else {
! 223: zend_clear_exception(TSRMLS_C);
! 224: }
! 225: }
! 226: case RS_START:
! 227: if (iterator->funcs->valid(iterator TSRMLS_CC) == FAILURE) {
! 228: break;
! 229: }
! 230: object->iterators[object->level].state = RS_TEST;
! 231: /* break; */
! 232: case RS_TEST:
! 233: ce = object->iterators[object->level].ce;
! 234: zobject = object->iterators[object->level].zobject;
! 235: if (object->callHasChildren) {
! 236: zend_call_method_with_0_params(&zthis, object->ce, &object->callHasChildren, "callHasChildren", &retval);
! 237: } else {
! 238: zend_call_method_with_0_params(&zobject, ce, NULL, "haschildren", &retval);
! 239: }
! 240: if (EG(exception)) {
! 241: if (!(object->flags & RIT_CATCH_GET_CHILD)) {
! 242: object->iterators[object->level].state = RS_NEXT;
! 243: return;
! 244: } else {
! 245: zend_clear_exception(TSRMLS_C);
! 246: }
! 247: }
! 248: if (retval) {
! 249: has_children = zend_is_true(retval);
! 250: zval_ptr_dtor(&retval);
! 251: if (has_children) {
! 252: if (object->max_depth == -1 || object->max_depth > object->level) {
! 253: switch (object->mode) {
! 254: case RIT_LEAVES_ONLY:
! 255: case RIT_CHILD_FIRST:
! 256: object->iterators[object->level].state = RS_CHILD;
! 257: goto next_step;
! 258: case RIT_SELF_FIRST:
! 259: object->iterators[object->level].state = RS_SELF;
! 260: goto next_step;
! 261: }
! 262: } else {
! 263: /* do not recurse into */
! 264: if (object->mode == RIT_LEAVES_ONLY) {
! 265: /* this is not a leave, so skip it */
! 266: object->iterators[object->level].state = RS_NEXT;
! 267: goto next_step;
! 268: }
! 269: }
! 270: }
! 271: }
! 272: if (object->nextElement) {
! 273: zend_call_method_with_0_params(&zthis, object->ce, &object->nextElement, "nextelement", NULL);
! 274: }
! 275: object->iterators[object->level].state = RS_NEXT;
! 276: if (EG(exception)) {
! 277: if (!(object->flags & RIT_CATCH_GET_CHILD)) {
! 278: return;
! 279: } else {
! 280: zend_clear_exception(TSRMLS_C);
! 281: }
! 282: }
! 283: return /* self */;
! 284: case RS_SELF:
! 285: if (object->nextElement && (object->mode == RIT_SELF_FIRST || object->mode == RIT_CHILD_FIRST)) {
! 286: zend_call_method_with_0_params(&zthis, object->ce, &object->nextElement, "nextelement", NULL);
! 287: }
! 288: if (object->mode == RIT_SELF_FIRST) {
! 289: object->iterators[object->level].state = RS_CHILD;
! 290: } else {
! 291: object->iterators[object->level].state = RS_NEXT;
! 292: }
! 293: return /* self */;
! 294: case RS_CHILD:
! 295: ce = object->iterators[object->level].ce;
! 296: zobject = object->iterators[object->level].zobject;
! 297: if (object->callGetChildren) {
! 298: zend_call_method_with_0_params(&zthis, object->ce, &object->callGetChildren, "callGetChildren", &child);
! 299: } else {
! 300: zend_call_method_with_0_params(&zobject, ce, NULL, "getchildren", &child);
! 301: }
! 302:
! 303: if (EG(exception)) {
! 304: if (!(object->flags & RIT_CATCH_GET_CHILD)) {
! 305: return;
! 306: } else {
! 307: zend_clear_exception(TSRMLS_C);
! 308: if (child) {
! 309: zval_ptr_dtor(&child);
! 310: }
! 311: object->iterators[object->level].state = RS_NEXT;
! 312: goto next_step;
! 313: }
! 314: }
! 315:
! 316: ce = child && Z_TYPE_P(child) == IS_OBJECT ? Z_OBJCE_P(child) : NULL;
! 317: if (!ce || !instanceof_function(ce, spl_ce_RecursiveIterator TSRMLS_CC)) {
! 318: if (child) {
! 319: zval_ptr_dtor(&child);
! 320: }
! 321: zend_throw_exception(spl_ce_UnexpectedValueException, "Objects returned by RecursiveIterator::getChildren() must implement RecursiveIterator", 0 TSRMLS_CC);
! 322: return;
! 323: }
! 324: if (object->mode == RIT_CHILD_FIRST) {
! 325: object->iterators[object->level].state = RS_SELF;
! 326: } else {
! 327: object->iterators[object->level].state = RS_NEXT;
! 328: }
! 329: object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator) * (++object->level+1));
! 330: sub_iter = ce->get_iterator(ce, child, 0 TSRMLS_CC);
! 331: object->iterators[object->level].iterator = sub_iter;
! 332: object->iterators[object->level].zobject = child;
! 333: object->iterators[object->level].ce = ce;
! 334: object->iterators[object->level].state = RS_START;
! 335: if (sub_iter->funcs->rewind) {
! 336: sub_iter->funcs->rewind(sub_iter TSRMLS_CC);
! 337: }
! 338: if (object->beginChildren) {
! 339: zend_call_method_with_0_params(&zthis, object->ce, &object->beginChildren, "beginchildren", NULL);
! 340: if (EG(exception)) {
! 341: if (!(object->flags & RIT_CATCH_GET_CHILD)) {
! 342: return;
! 343: } else {
! 344: zend_clear_exception(TSRMLS_C);
! 345: }
! 346: }
! 347: }
! 348: goto next_step;
! 349: }
! 350: /* no more elements */
! 351: if (object->level > 0) {
! 352: if (object->endChildren) {
! 353: zend_call_method_with_0_params(&zthis, object->ce, &object->endChildren, "endchildren", NULL);
! 354: if (EG(exception)) {
! 355: if (!(object->flags & RIT_CATCH_GET_CHILD)) {
! 356: return;
! 357: } else {
! 358: zend_clear_exception(TSRMLS_C);
! 359: }
! 360: }
! 361: }
! 362: iterator->funcs->dtor(iterator TSRMLS_CC);
! 363: zval_ptr_dtor(&object->iterators[object->level].zobject);
! 364: object->level--;
! 365: } else {
! 366: return; /* done completeley */
! 367: }
! 368: }
! 369: }
! 370:
! 371: static void spl_recursive_it_rewind_ex(spl_recursive_it_object *object, zval *zthis TSRMLS_DC)
! 372: {
! 373: zend_object_iterator *sub_iter;
! 374:
! 375: if (!object->iterators) {
! 376: php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_P(zthis)->name);
! 377: }
! 378:
! 379: while (object->level) {
! 380: sub_iter = object->iterators[object->level].iterator;
! 381: sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
! 382: zval_ptr_dtor(&object->iterators[object->level--].zobject);
! 383: if (!EG(exception) && (!object->endChildren || object->endChildren->common.scope != spl_ce_RecursiveIteratorIterator)) {
! 384: zend_call_method_with_0_params(&zthis, object->ce, &object->endChildren, "endchildren", NULL);
! 385: }
! 386: }
! 387: object->iterators = erealloc(object->iterators, sizeof(spl_sub_iterator));
! 388: object->iterators[0].state = RS_START;
! 389: sub_iter = object->iterators[0].iterator;
! 390: if (sub_iter->funcs->rewind) {
! 391: sub_iter->funcs->rewind(sub_iter TSRMLS_CC);
! 392: }
! 393: if (!EG(exception) && object->beginIteration && !object->in_iteration) {
! 394: zend_call_method_with_0_params(&zthis, object->ce, &object->beginIteration, "beginIteration", NULL);
! 395: }
! 396: object->in_iteration = 1;
! 397: spl_recursive_it_move_forward_ex(object, zthis TSRMLS_CC);
! 398: }
! 399:
! 400: static void spl_recursive_it_move_forward(zend_object_iterator *iter TSRMLS_DC)
! 401: {
! 402: spl_recursive_it_move_forward_ex((spl_recursive_it_object*)iter->data, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC);
! 403: }
! 404:
! 405: static void spl_recursive_it_rewind(zend_object_iterator *iter TSRMLS_DC)
! 406: {
! 407: spl_recursive_it_rewind_ex((spl_recursive_it_object*)iter->data, ((spl_recursive_it_iterator*)iter)->zobject TSRMLS_CC);
! 408: }
! 409:
! 410: static zend_object_iterator *spl_recursive_it_get_iterator(zend_class_entry *ce, zval *zobject, int by_ref TSRMLS_DC)
! 411: {
! 412: spl_recursive_it_iterator *iterator;
! 413: spl_recursive_it_object *object;
! 414:
! 415: if (by_ref) {
! 416: zend_error(E_ERROR, "An iterator cannot be used with foreach by reference");
! 417: }
! 418: iterator = emalloc(sizeof(spl_recursive_it_iterator));
! 419: object = (spl_recursive_it_object*)zend_object_store_get_object(zobject TSRMLS_CC);
! 420: if (object->iterators == NULL) {
! 421: zend_error(E_ERROR, "The object to be iterated is in an invalid state: "
! 422: "the parent constructor has not been called");
! 423: }
! 424:
! 425: Z_ADDREF_P(zobject);
! 426: iterator->intern.data = (void*)object;
! 427: iterator->intern.funcs = ce->iterator_funcs.funcs;
! 428: iterator->zobject = zobject;
! 429: return (zend_object_iterator*)iterator;
! 430: }
! 431:
! 432: zend_object_iterator_funcs spl_recursive_it_iterator_funcs = {
! 433: spl_recursive_it_dtor,
! 434: spl_recursive_it_valid,
! 435: spl_recursive_it_get_current_data,
! 436: spl_recursive_it_get_current_key,
! 437: spl_recursive_it_move_forward,
! 438: spl_recursive_it_rewind
! 439: };
! 440:
! 441: static void spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAMETERS, zend_class_entry *ce_base, zend_class_entry *ce_inner, recursive_it_it_type rit_type)
! 442: {
! 443: zval *object = getThis();
! 444: spl_recursive_it_object *intern;
! 445: zval *iterator;
! 446: zend_class_entry *ce_iterator;
! 447: long mode, flags;
! 448: int inc_refcount = 1;
! 449: zend_error_handling error_handling;
! 450:
! 451: zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
! 452:
! 453: switch(rit_type) {
! 454: case RIT_RecursiveTreeIterator: {
! 455:
! 456: zval *caching_it, *caching_it_flags, *user_caching_it_flags = NULL;
! 457: mode = RIT_SELF_FIRST;
! 458: flags = RTIT_BYPASS_KEY;
! 459:
! 460: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|lzl", &iterator, &flags, &user_caching_it_flags, &mode) == SUCCESS) {
! 461: if (instanceof_function(Z_OBJCE_P(iterator), zend_ce_aggregate TSRMLS_CC)) {
! 462: zval *aggregate = iterator;
! 463: zend_call_method_with_0_params(&aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", &iterator);
! 464: inc_refcount = 0;
! 465: }
! 466:
! 467: MAKE_STD_ZVAL(caching_it_flags);
! 468: if (user_caching_it_flags) {
! 469: ZVAL_ZVAL(caching_it_flags, user_caching_it_flags, 1, 0);
! 470: } else {
! 471: ZVAL_LONG(caching_it_flags, CIT_CATCH_GET_CHILD);
! 472: }
! 473: spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &caching_it, 1, iterator, caching_it_flags TSRMLS_CC);
! 474: zval_ptr_dtor(&caching_it_flags);
! 475: if (inc_refcount == 0 && iterator) {
! 476: zval_ptr_dtor(&iterator);
! 477: }
! 478: iterator = caching_it;
! 479: inc_refcount = 0;
! 480: } else {
! 481: iterator = NULL;
! 482: }
! 483: break;
! 484: }
! 485: case RIT_RecursiveIteratorIterator:
! 486: default: {
! 487: mode = RIT_LEAVES_ONLY;
! 488: flags = 0;
! 489:
! 490: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "o|ll", &iterator, &mode, &flags) == SUCCESS) {
! 491: if (instanceof_function(Z_OBJCE_P(iterator), zend_ce_aggregate TSRMLS_CC)) {
! 492: zval *aggregate = iterator;
! 493: zend_call_method_with_0_params(&aggregate, Z_OBJCE_P(aggregate), &Z_OBJCE_P(aggregate)->iterator_funcs.zf_new_iterator, "getiterator", &iterator);
! 494: inc_refcount = 0;
! 495: }
! 496: } else {
! 497: iterator = NULL;
! 498: }
! 499: break;
! 500: }
! 501: }
! 502: if (!iterator || !instanceof_function(Z_OBJCE_P(iterator), spl_ce_RecursiveIterator TSRMLS_CC)) {
! 503: if (iterator && !inc_refcount) {
! 504: zval_ptr_dtor(&iterator);
! 505: }
! 506: zend_throw_exception(spl_ce_InvalidArgumentException, "An instance of RecursiveIterator or IteratorAggregate creating it is required", 0 TSRMLS_CC);
! 507: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 508: return;
! 509: }
! 510:
! 511: intern = (spl_recursive_it_object*)zend_object_store_get_object(object TSRMLS_CC);
! 512: intern->iterators = emalloc(sizeof(spl_sub_iterator));
! 513: intern->level = 0;
! 514: intern->mode = mode;
! 515: intern->flags = flags;
! 516: intern->max_depth = -1;
! 517: intern->in_iteration = 0;
! 518: intern->ce = Z_OBJCE_P(object);
! 519:
! 520: zend_hash_find(&intern->ce->function_table, "beginiteration", sizeof("beginiteration"), (void **) &intern->beginIteration);
! 521: if (intern->beginIteration->common.scope == ce_base) {
! 522: intern->beginIteration = NULL;
! 523: }
! 524: zend_hash_find(&intern->ce->function_table, "enditeration", sizeof("enditeration"), (void **) &intern->endIteration);
! 525: if (intern->endIteration->common.scope == ce_base) {
! 526: intern->endIteration = NULL;
! 527: }
! 528: zend_hash_find(&intern->ce->function_table, "callhaschildren", sizeof("callHasChildren"), (void **) &intern->callHasChildren);
! 529: if (intern->callHasChildren->common.scope == ce_base) {
! 530: intern->callHasChildren = NULL;
! 531: }
! 532: zend_hash_find(&intern->ce->function_table, "callgetchildren", sizeof("callGetChildren"), (void **) &intern->callGetChildren);
! 533: if (intern->callGetChildren->common.scope == ce_base) {
! 534: intern->callGetChildren = NULL;
! 535: }
! 536: zend_hash_find(&intern->ce->function_table, "beginchildren", sizeof("beginchildren"), (void **) &intern->beginChildren);
! 537: if (intern->beginChildren->common.scope == ce_base) {
! 538: intern->beginChildren = NULL;
! 539: }
! 540: zend_hash_find(&intern->ce->function_table, "endchildren", sizeof("endchildren"), (void **) &intern->endChildren);
! 541: if (intern->endChildren->common.scope == ce_base) {
! 542: intern->endChildren = NULL;
! 543: }
! 544: zend_hash_find(&intern->ce->function_table, "nextelement", sizeof("nextElement"), (void **) &intern->nextElement);
! 545: if (intern->nextElement->common.scope == ce_base) {
! 546: intern->nextElement = NULL;
! 547: }
! 548: ce_iterator = Z_OBJCE_P(iterator); /* respect inheritance, don't use spl_ce_RecursiveIterator */
! 549: intern->iterators[0].iterator = ce_iterator->get_iterator(ce_iterator, iterator, 0 TSRMLS_CC);
! 550: if (inc_refcount) {
! 551: Z_ADDREF_P(iterator);
! 552: }
! 553: intern->iterators[0].zobject = iterator;
! 554: intern->iterators[0].ce = ce_iterator;
! 555: intern->iterators[0].state = RS_START;
! 556:
! 557: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 558:
! 559: if (EG(exception)) {
! 560: zend_object_iterator *sub_iter;
! 561:
! 562: while (intern->level >= 0) {
! 563: sub_iter = intern->iterators[intern->level].iterator;
! 564: sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
! 565: zval_ptr_dtor(&intern->iterators[intern->level--].zobject);
! 566: }
! 567: efree(intern->iterators);
! 568: intern->iterators = NULL;
! 569: }
! 570: }
! 571:
! 572: /* {{{ proto void RecursiveIteratorIterator::__construct(RecursiveIterator|IteratorAggregate it [, int mode = RIT_LEAVES_ONLY [, int flags = 0]]) throws InvalidArgumentException
! 573: Creates a RecursiveIteratorIterator from a RecursiveIterator. */
! 574: SPL_METHOD(RecursiveIteratorIterator, __construct)
! 575: {
! 576: spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveIteratorIterator, zend_ce_iterator, RIT_RecursiveIteratorIterator);
! 577: } /* }}} */
! 578:
! 579: /* {{{ proto void RecursiveIteratorIterator::rewind()
! 580: Rewind the iterator to the first element of the top level inner iterator. */
! 581: SPL_METHOD(RecursiveIteratorIterator, rewind)
! 582: {
! 583: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 584:
! 585: if (zend_parse_parameters_none() == FAILURE) {
! 586: return;
! 587: }
! 588:
! 589: spl_recursive_it_rewind_ex(object, getThis() TSRMLS_CC);
! 590: } /* }}} */
! 591:
! 592: /* {{{ proto bool RecursiveIteratorIterator::valid()
! 593: Check whether the current position is valid */
! 594: SPL_METHOD(RecursiveIteratorIterator, valid)
! 595: {
! 596: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 597:
! 598: if (zend_parse_parameters_none() == FAILURE) {
! 599: return;
! 600: }
! 601:
! 602: RETURN_BOOL(spl_recursive_it_valid_ex(object, getThis() TSRMLS_CC) == SUCCESS);
! 603: } /* }}} */
! 604:
! 605: /* {{{ proto mixed RecursiveIteratorIterator::key()
! 606: Access the current key */
! 607: SPL_METHOD(RecursiveIteratorIterator, key)
! 608: {
! 609: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 610: zend_object_iterator *iterator = object->iterators[object->level].iterator;
! 611:
! 612: if (zend_parse_parameters_none() == FAILURE) {
! 613: return;
! 614: }
! 615:
! 616: if (iterator->funcs->get_current_key) {
! 617: char *str_key;
! 618: uint str_key_len;
! 619: ulong int_key;
! 620:
! 621: switch (iterator->funcs->get_current_key(iterator, &str_key, &str_key_len, &int_key TSRMLS_CC)) {
! 622: case HASH_KEY_IS_LONG:
! 623: RETURN_LONG(int_key);
! 624: break;
! 625: case HASH_KEY_IS_STRING:
! 626: RETURN_STRINGL(str_key, str_key_len-1, 0);
! 627: break;
! 628: default:
! 629: RETURN_NULL();
! 630: }
! 631: } else {
! 632: RETURN_NULL();
! 633: }
! 634: } /* }}} */
! 635:
! 636: /* {{{ proto mixed RecursiveIteratorIterator::current()
! 637: Access the current element value */
! 638: SPL_METHOD(RecursiveIteratorIterator, current)
! 639: {
! 640: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 641: zend_object_iterator *iterator = object->iterators[object->level].iterator;
! 642: zval **data;
! 643:
! 644: if (zend_parse_parameters_none() == FAILURE) {
! 645: return;
! 646: }
! 647:
! 648: iterator->funcs->get_current_data(iterator, &data TSRMLS_CC);
! 649: if (data && *data) {
! 650: RETURN_ZVAL(*data, 1, 0);
! 651: }
! 652: } /* }}} */
! 653:
! 654: /* {{{ proto void RecursiveIteratorIterator::next()
! 655: Move forward to the next element */
! 656: SPL_METHOD(RecursiveIteratorIterator, next)
! 657: {
! 658: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 659:
! 660: if (zend_parse_parameters_none() == FAILURE) {
! 661: return;
! 662: }
! 663:
! 664: spl_recursive_it_move_forward_ex(object, getThis() TSRMLS_CC);
! 665: } /* }}} */
! 666:
! 667: /* {{{ proto int RecursiveIteratorIterator::getDepth()
! 668: Get the current depth of the recursive iteration */
! 669: SPL_METHOD(RecursiveIteratorIterator, getDepth)
! 670: {
! 671: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 672:
! 673: if (zend_parse_parameters_none() == FAILURE) {
! 674: return;
! 675: }
! 676:
! 677: RETURN_LONG(object->level);
! 678: } /* }}} */
! 679:
! 680: /* {{{ proto RecursiveIterator RecursiveIteratorIterator::getSubIterator([int level])
! 681: The current active sub iterator or the iterator at specified level */
! 682: SPL_METHOD(RecursiveIteratorIterator, getSubIterator)
! 683: {
! 684: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 685: long level = object->level;
! 686:
! 687: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &level) == FAILURE) {
! 688: return;
! 689: }
! 690: if (level < 0 || level > object->level) {
! 691: RETURN_NULL();
! 692: }
! 693: RETURN_ZVAL(object->iterators[level].zobject, 1, 0);
! 694: } /* }}} */
! 695:
! 696: /* {{{ proto RecursiveIterator RecursiveIteratorIterator::getInnerIterator()
! 697: The current active sub iterator */
! 698: SPL_METHOD(RecursiveIteratorIterator, getInnerIterator)
! 699: {
! 700: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 701: long level = object->level;
! 702:
! 703: if (zend_parse_parameters_none() == FAILURE) {
! 704: return;
! 705: }
! 706:
! 707: RETURN_ZVAL(object->iterators[level].zobject, 1, 0);
! 708: } /* }}} */
! 709:
! 710: /* {{{ proto RecursiveIterator RecursiveIteratorIterator::beginIteration()
! 711: Called when iteration begins (after first rewind() call) */
! 712: SPL_METHOD(RecursiveIteratorIterator, beginIteration)
! 713: {
! 714: if (zend_parse_parameters_none() == FAILURE) {
! 715: return;
! 716: }
! 717: /* nothing to do */
! 718: } /* }}} */
! 719:
! 720: /* {{{ proto RecursiveIterator RecursiveIteratorIterator::endIteration()
! 721: Called when iteration ends (when valid() first returns false */
! 722: SPL_METHOD(RecursiveIteratorIterator, endIteration)
! 723: {
! 724: if (zend_parse_parameters_none() == FAILURE) {
! 725: return;
! 726: }
! 727: /* nothing to do */
! 728: } /* }}} */
! 729:
! 730: /* {{{ proto bool RecursiveIteratorIterator::callHasChildren()
! 731: Called for each element to test whether it has children */
! 732: SPL_METHOD(RecursiveIteratorIterator, callHasChildren)
! 733: {
! 734: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 735: zend_class_entry *ce = object->iterators[object->level].ce;
! 736: zval *retval, *zobject;
! 737:
! 738: if (zend_parse_parameters_none() == FAILURE) {
! 739: return;
! 740: }
! 741:
! 742: zobject = object->iterators[object->level].zobject;
! 743: if (!zobject) {
! 744: RETURN_FALSE;
! 745: } else {
! 746: zend_call_method_with_0_params(&zobject, ce, NULL, "haschildren", &retval);
! 747: if (retval) {
! 748: RETURN_ZVAL(retval, 0, 1);
! 749: } else {
! 750: RETURN_FALSE;
! 751: }
! 752: }
! 753: } /* }}} */
! 754:
! 755: /* {{{ proto RecursiveIterator RecursiveIteratorIterator::callGetChildren()
! 756: Return children of current element */
! 757: SPL_METHOD(RecursiveIteratorIterator, callGetChildren)
! 758: {
! 759: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 760: zend_class_entry *ce = object->iterators[object->level].ce;
! 761: zval *retval, *zobject;
! 762:
! 763: if (zend_parse_parameters_none() == FAILURE) {
! 764: return;
! 765: }
! 766:
! 767: zobject = object->iterators[object->level].zobject;
! 768: if (!zobject) {
! 769: return;
! 770: } else {
! 771: zend_call_method_with_0_params(&zobject, ce, NULL, "getchildren", &retval);
! 772: if (retval) {
! 773: RETURN_ZVAL(retval, 0, 1);
! 774: }
! 775: }
! 776: } /* }}} */
! 777:
! 778: /* {{{ proto void RecursiveIteratorIterator::beginChildren()
! 779: Called when recursing one level down */
! 780: SPL_METHOD(RecursiveIteratorIterator, beginChildren)
! 781: {
! 782: if (zend_parse_parameters_none() == FAILURE) {
! 783: return;
! 784: }
! 785: /* nothing to do */
! 786: } /* }}} */
! 787:
! 788: /* {{{ proto void RecursiveIteratorIterator::endChildren()
! 789: Called when end recursing one level */
! 790: SPL_METHOD(RecursiveIteratorIterator, endChildren)
! 791: {
! 792: if (zend_parse_parameters_none() == FAILURE) {
! 793: return;
! 794: }
! 795: /* nothing to do */
! 796: } /* }}} */
! 797:
! 798: /* {{{ proto void RecursiveIteratorIterator::nextElement()
! 799: Called when the next element is available */
! 800: SPL_METHOD(RecursiveIteratorIterator, nextElement)
! 801: {
! 802: if (zend_parse_parameters_none() == FAILURE) {
! 803: return;
! 804: }
! 805: /* nothing to do */
! 806: } /* }}} */
! 807:
! 808: /* {{{ proto void RecursiveIteratorIterator::setMaxDepth([$max_depth = -1])
! 809: Set the maximum allowed depth (or any depth if pmax_depth = -1] */
! 810: SPL_METHOD(RecursiveIteratorIterator, setMaxDepth)
! 811: {
! 812: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 813: long max_depth = -1;
! 814:
! 815: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &max_depth) == FAILURE) {
! 816: return;
! 817: }
! 818: if (max_depth < -1) {
! 819: zend_throw_exception(spl_ce_OutOfRangeException, "Parameter max_depth must be >= -1", 0 TSRMLS_CC);
! 820: return;
! 821: }
! 822: object->max_depth = max_depth;
! 823: } /* }}} */
! 824:
! 825: /* {{{ proto int|false RecursiveIteratorIterator::getMaxDepth()
! 826: Return the maximum accepted depth or false if any depth is allowed */
! 827: SPL_METHOD(RecursiveIteratorIterator, getMaxDepth)
! 828: {
! 829: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 830:
! 831: if (zend_parse_parameters_none() == FAILURE) {
! 832: return;
! 833: }
! 834:
! 835: if (object->max_depth == -1) {
! 836: RETURN_FALSE;
! 837: } else {
! 838: RETURN_LONG(object->max_depth);
! 839: }
! 840: } /* }}} */
! 841:
! 842: static union _zend_function *spl_recursive_it_get_method(zval **object_ptr, char *method, int method_len TSRMLS_DC)
! 843: {
! 844: union _zend_function *function_handler;
! 845: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(*object_ptr TSRMLS_CC);
! 846: long level = object->level;
! 847: zval *zobj;
! 848:
! 849: if (!object->iterators) {
! 850: php_error_docref(NULL TSRMLS_CC, E_ERROR, "The %s instance wasn't initialized properly", Z_OBJCE_PP(object_ptr)->name);
! 851: }
! 852: zobj = object->iterators[level].zobject;
! 853:
! 854: function_handler = std_object_handlers.get_method(object_ptr, method, method_len TSRMLS_CC);
! 855: if (!function_handler) {
! 856: if (zend_hash_find(&Z_OBJCE_P(zobj)->function_table, method, method_len+1, (void **) &function_handler) == FAILURE) {
! 857: if (Z_OBJ_HT_P(zobj)->get_method) {
! 858: *object_ptr = zobj;
! 859: function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len TSRMLS_CC);
! 860: }
! 861: }
! 862: }
! 863: return function_handler;
! 864: }
! 865:
! 866: /* {{{ spl_RecursiveIteratorIterator_dtor */
! 867: static void spl_RecursiveIteratorIterator_dtor(zend_object *_object, zend_object_handle handle TSRMLS_DC)
! 868: {
! 869: spl_recursive_it_object *object = (spl_recursive_it_object *)_object;
! 870: zend_object_iterator *sub_iter;
! 871:
! 872: /* call standard dtor */
! 873: zend_objects_destroy_object(_object, handle TSRMLS_CC);
! 874:
! 875: if (object->iterators) {
! 876: while (object->level >= 0) {
! 877: sub_iter = object->iterators[object->level].iterator;
! 878: sub_iter->funcs->dtor(sub_iter TSRMLS_CC);
! 879: zval_ptr_dtor(&object->iterators[object->level--].zobject);
! 880: }
! 881: efree(object->iterators);
! 882: object->iterators = NULL;
! 883: }
! 884: }
! 885: /* }}} */
! 886:
! 887: /* {{{ spl_RecursiveIteratorIterator_dtor */
! 888: static void spl_RecursiveIteratorIterator_free_storage(void *_object TSRMLS_DC)
! 889: {
! 890: spl_recursive_it_object *object = (spl_recursive_it_object *)_object;
! 891:
! 892: zend_object_std_dtor(&object->std TSRMLS_CC);
! 893: smart_str_free(&object->prefix[0]);
! 894: smart_str_free(&object->prefix[1]);
! 895: smart_str_free(&object->prefix[2]);
! 896: smart_str_free(&object->prefix[3]);
! 897: smart_str_free(&object->prefix[4]);
! 898: smart_str_free(&object->prefix[5]);
! 899:
! 900: efree(object);
! 901: }
! 902: /* }}} */
! 903:
! 904: /* {{{ spl_RecursiveIteratorIterator_new_ex */
! 905: static zend_object_value spl_RecursiveIteratorIterator_new_ex(zend_class_entry *class_type, int init_prefix TSRMLS_DC)
! 906: {
! 907: zend_object_value retval;
! 908: spl_recursive_it_object *intern;
! 909: zval *tmp;
! 910:
! 911: intern = emalloc(sizeof(spl_recursive_it_object));
! 912: memset(intern, 0, sizeof(spl_recursive_it_object));
! 913:
! 914: if (init_prefix) {
! 915: smart_str_appendl(&intern->prefix[0], "", 0);
! 916: smart_str_appendl(&intern->prefix[1], "| ", 2);
! 917: smart_str_appendl(&intern->prefix[2], " ", 2);
! 918: smart_str_appendl(&intern->prefix[3], "|-", 2);
! 919: smart_str_appendl(&intern->prefix[4], "\\-", 2);
! 920: smart_str_appendl(&intern->prefix[5], "", 0);
! 921: }
! 922:
! 923: zend_object_std_init(&intern->std, class_type TSRMLS_CC);
! 924: zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
! 925:
! 926: retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)spl_RecursiveIteratorIterator_dtor, (zend_objects_free_object_storage_t) spl_RecursiveIteratorIterator_free_storage, NULL TSRMLS_CC);
! 927: retval.handlers = &spl_handlers_rec_it_it;
! 928: return retval;
! 929: }
! 930: /* }}} */
! 931:
! 932: /* {{{ spl_RecursiveIteratorIterator_new */
! 933: static zend_object_value spl_RecursiveIteratorIterator_new(zend_class_entry *class_type TSRMLS_DC)
! 934: {
! 935: return spl_RecursiveIteratorIterator_new_ex(class_type, 0 TSRMLS_CC);
! 936: }
! 937: /* }}} */
! 938:
! 939: /* {{{ spl_RecursiveTreeIterator_new */
! 940: static zend_object_value spl_RecursiveTreeIterator_new(zend_class_entry *class_type TSRMLS_DC)
! 941: {
! 942: return spl_RecursiveIteratorIterator_new_ex(class_type, 1 TSRMLS_CC);
! 943: }
! 944: /* }}} */
! 945:
! 946: ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_it___construct, 0, 0, 1)
! 947: ZEND_ARG_OBJ_INFO(0, iterator, Traversable, 0)
! 948: ZEND_ARG_INFO(0, mode)
! 949: ZEND_ARG_INFO(0, flags)
! 950: ZEND_END_ARG_INFO();
! 951:
! 952: ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_it_getSubIterator, 0, 0, 0)
! 953: ZEND_ARG_INFO(0, level)
! 954: ZEND_END_ARG_INFO();
! 955:
! 956: ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_it_setMaxDepth, 0, 0, 0)
! 957: ZEND_ARG_INFO(0, max_depth)
! 958: ZEND_END_ARG_INFO();
! 959:
! 960: static const zend_function_entry spl_funcs_RecursiveIteratorIterator[] = {
! 961: SPL_ME(RecursiveIteratorIterator, __construct, arginfo_recursive_it___construct, ZEND_ACC_PUBLIC)
! 962: SPL_ME(RecursiveIteratorIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 963: SPL_ME(RecursiveIteratorIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 964: SPL_ME(RecursiveIteratorIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 965: SPL_ME(RecursiveIteratorIterator, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 966: SPL_ME(RecursiveIteratorIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 967: SPL_ME(RecursiveIteratorIterator, getDepth, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 968: SPL_ME(RecursiveIteratorIterator, getSubIterator, arginfo_recursive_it_getSubIterator, ZEND_ACC_PUBLIC)
! 969: SPL_ME(RecursiveIteratorIterator, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 970: SPL_ME(RecursiveIteratorIterator, beginIteration, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 971: SPL_ME(RecursiveIteratorIterator, endIteration, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 972: SPL_ME(RecursiveIteratorIterator, callHasChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 973: SPL_ME(RecursiveIteratorIterator, callGetChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 974: SPL_ME(RecursiveIteratorIterator, beginChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 975: SPL_ME(RecursiveIteratorIterator, endChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 976: SPL_ME(RecursiveIteratorIterator, nextElement, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 977: SPL_ME(RecursiveIteratorIterator, setMaxDepth, arginfo_recursive_it_setMaxDepth, ZEND_ACC_PUBLIC)
! 978: SPL_ME(RecursiveIteratorIterator, getMaxDepth, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 979: PHP_FE_END
! 980: };
! 981:
! 982: static void spl_recursive_tree_iterator_get_prefix(spl_recursive_it_object *object, zval *return_value TSRMLS_DC)
! 983: {
! 984: smart_str str = {0};
! 985: zval *has_next;
! 986: int level;
! 987:
! 988: smart_str_appendl(&str, object->prefix[0].c, object->prefix[0].len);
! 989:
! 990: for (level = 0; level < object->level; ++level) {
! 991: zend_call_method_with_0_params(&object->iterators[level].zobject, object->iterators[level].ce, NULL, "hasnext", &has_next);
! 992: if (has_next) {
! 993: if (Z_LVAL_P(has_next)) {
! 994: smart_str_appendl(&str, object->prefix[1].c, object->prefix[1].len);
! 995: } else {
! 996: smart_str_appendl(&str, object->prefix[2].c, object->prefix[2].len);
! 997: }
! 998: zval_ptr_dtor(&has_next);
! 999: }
! 1000: }
! 1001: zend_call_method_with_0_params(&object->iterators[level].zobject, object->iterators[level].ce, NULL, "hasnext", &has_next);
! 1002: if (has_next) {
! 1003: if (Z_LVAL_P(has_next)) {
! 1004: smart_str_appendl(&str, object->prefix[3].c, object->prefix[3].len);
! 1005: } else {
! 1006: smart_str_appendl(&str, object->prefix[4].c, object->prefix[4].len);
! 1007: }
! 1008: zval_ptr_dtor(&has_next);
! 1009: }
! 1010:
! 1011: smart_str_appendl(&str, object->prefix[5].c, object->prefix[5].len);
! 1012: smart_str_0(&str);
! 1013:
! 1014: RETVAL_STRINGL(str.c, str.len, 0);
! 1015: }
! 1016:
! 1017: static void spl_recursive_tree_iterator_get_entry(spl_recursive_it_object * object, zval * return_value TSRMLS_DC)
! 1018: {
! 1019: zend_object_iterator *iterator = object->iterators[object->level].iterator;
! 1020: zval **data;
! 1021: zend_error_handling error_handling;
! 1022:
! 1023: iterator->funcs->get_current_data(iterator, &data TSRMLS_CC);
! 1024:
! 1025: zend_replace_error_handling(EH_THROW, spl_ce_UnexpectedValueException, &error_handling TSRMLS_CC);
! 1026: if (data && *data) {
! 1027: RETVAL_ZVAL(*data, 1, 0);
! 1028: }
! 1029: if (Z_TYPE_P(return_value) == IS_ARRAY) {
! 1030: zval_dtor(return_value);
! 1031: ZVAL_STRINGL(return_value, "Array", sizeof("Array")-1, 1);
! 1032: } else {
! 1033: convert_to_string(return_value);
! 1034: }
! 1035: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1036: }
! 1037:
! 1038: static void spl_recursive_tree_iterator_get_postfix(spl_recursive_it_object * object, zval * return_value TSRMLS_DC)
! 1039: {
! 1040: RETVAL_STRINGL("", 0, 1);
! 1041: }
! 1042:
! 1043: /* {{{ proto void RecursiveTreeIterator::__construct(RecursiveIterator|IteratorAggregate it [, int flags = RTIT_BYPASS_KEY [, int cit_flags = CIT_CATCH_GET_CHILD [, mode = RIT_SELF_FIRST ]]]) throws InvalidArgumentException
! 1044: RecursiveIteratorIterator to generate ASCII graphic trees for the entries in a RecursiveIterator */
! 1045: SPL_METHOD(RecursiveTreeIterator, __construct)
! 1046: {
! 1047: spl_recursive_it_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveTreeIterator, zend_ce_iterator, RIT_RecursiveTreeIterator);
! 1048: } /* }}} */
! 1049:
! 1050: /* {{{ proto void RecursiveTreeIterator::setPrefixPart(int part, string prefix) throws OutOfRangeException
! 1051: Sets prefix parts as used in getPrefix() */
! 1052: SPL_METHOD(RecursiveTreeIterator, setPrefixPart)
! 1053: {
! 1054: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1055: long part;
! 1056: char* prefix;
! 1057: int prefix_len;
! 1058:
! 1059: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ls", &part, &prefix, &prefix_len) == FAILURE) {
! 1060: return;
! 1061: }
! 1062: if (0 > part || part > 5) {
! 1063: zend_throw_exception_ex(spl_ce_OutOfRangeException, 0 TSRMLS_CC, "Use RecursiveTreeIterator::PREFIX_* constant");
! 1064: return;
! 1065: }
! 1066:
! 1067: smart_str_free(&object->prefix[part]);
! 1068: smart_str_appendl(&object->prefix[part], prefix, prefix_len);
! 1069: } /* }}} */
! 1070:
! 1071: /* {{{ proto string RecursiveTreeIterator::getPrefix()
! 1072: Returns the string to place in front of current element */
! 1073: SPL_METHOD(RecursiveTreeIterator, getPrefix)
! 1074: {
! 1075: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1076:
! 1077: if (zend_parse_parameters_none() == FAILURE) {
! 1078: return;
! 1079: }
! 1080: spl_recursive_tree_iterator_get_prefix(object, return_value TSRMLS_CC);
! 1081: } /* }}} */
! 1082:
! 1083: /* {{{ proto string RecursiveTreeIterator::getEntry()
! 1084: Returns the string presentation built for current element */
! 1085: SPL_METHOD(RecursiveTreeIterator, getEntry)
! 1086: {
! 1087: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1088:
! 1089: if (zend_parse_parameters_none() == FAILURE) {
! 1090: return;
! 1091: }
! 1092:
! 1093: spl_recursive_tree_iterator_get_entry(object, return_value TSRMLS_CC);
! 1094: } /* }}} */
! 1095:
! 1096: /* {{{ proto string RecursiveTreeIterator::getPostfix()
! 1097: Returns the string to place after the current element */
! 1098: SPL_METHOD(RecursiveTreeIterator, getPostfix)
! 1099: {
! 1100: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1101:
! 1102: if (zend_parse_parameters_none() == FAILURE) {
! 1103: return;
! 1104: }
! 1105:
! 1106: spl_recursive_tree_iterator_get_postfix(object, return_value TSRMLS_CC);
! 1107: } /* }}} */
! 1108:
! 1109: /* {{{ proto mixed RecursiveTreeIterator::current()
! 1110: Returns the current element prefixed and postfixed */
! 1111: SPL_METHOD(RecursiveTreeIterator, current)
! 1112: {
! 1113: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1114: zval prefix, entry, postfix;
! 1115: char *str, *ptr;
! 1116: size_t str_len;
! 1117:
! 1118: if (zend_parse_parameters_none() == FAILURE) {
! 1119: return;
! 1120: }
! 1121:
! 1122: if (object->flags & RTIT_BYPASS_CURRENT) {
! 1123: zend_object_iterator *iterator = object->iterators[object->level].iterator;
! 1124: zval **data;
! 1125:
! 1126: iterator->funcs->get_current_data(iterator, &data TSRMLS_CC);
! 1127: if (data && *data) {
! 1128: RETURN_ZVAL(*data, 1, 0);
! 1129: } else {
! 1130: RETURN_NULL();
! 1131: }
! 1132: }
! 1133:
! 1134: spl_recursive_tree_iterator_get_prefix(object, &prefix TSRMLS_CC);
! 1135: spl_recursive_tree_iterator_get_entry(object, &entry TSRMLS_CC);
! 1136: spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC);
! 1137:
! 1138: str_len = Z_STRLEN(prefix) + Z_STRLEN(entry) + Z_STRLEN(postfix);
! 1139: str = (char *) emalloc(str_len + 1U);
! 1140: ptr = str;
! 1141:
! 1142: memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix));
! 1143: ptr += Z_STRLEN(prefix);
! 1144: memcpy(ptr, Z_STRVAL(entry), Z_STRLEN(entry));
! 1145: ptr += Z_STRLEN(entry);
! 1146: memcpy(ptr, Z_STRVAL(postfix), Z_STRLEN(postfix));
! 1147: ptr += Z_STRLEN(postfix);
! 1148: *ptr = 0;
! 1149:
! 1150: zval_dtor(&prefix);
! 1151: zval_dtor(&entry);
! 1152: zval_dtor(&postfix);
! 1153:
! 1154: RETURN_STRINGL(str, str_len, 0);
! 1155: } /* }}} */
! 1156:
! 1157: /* {{{ proto mixed RecursiveTreeIterator::key()
! 1158: Returns the current key prefixed and postfixed */
! 1159: SPL_METHOD(RecursiveTreeIterator, key)
! 1160: {
! 1161: spl_recursive_it_object *object = (spl_recursive_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1162: zend_object_iterator *iterator = object->iterators[object->level].iterator;
! 1163: zval prefix, key, postfix, key_copy;
! 1164: char *str, *ptr;
! 1165: size_t str_len;
! 1166:
! 1167: if (zend_parse_parameters_none() == FAILURE) {
! 1168: return;
! 1169: }
! 1170:
! 1171: if (iterator->funcs->get_current_key) {
! 1172: char *str_key;
! 1173: uint str_key_len;
! 1174: ulong int_key;
! 1175:
! 1176: switch (iterator->funcs->get_current_key(iterator, &str_key, &str_key_len, &int_key TSRMLS_CC)) {
! 1177: case HASH_KEY_IS_LONG:
! 1178: ZVAL_LONG(&key, int_key);
! 1179: break;
! 1180: case HASH_KEY_IS_STRING:
! 1181: ZVAL_STRINGL(&key, str_key, str_key_len-1, 0);
! 1182: break;
! 1183: default:
! 1184: ZVAL_NULL(&key);
! 1185: }
! 1186: } else {
! 1187: ZVAL_NULL(&key);
! 1188: }
! 1189:
! 1190: if (object->flags & RTIT_BYPASS_KEY) {
! 1191: zval *key_ptr = &key;
! 1192: RETVAL_ZVAL(key_ptr, 1, 0);
! 1193: zval_dtor(&key);
! 1194: return;
! 1195: }
! 1196:
! 1197: if (Z_TYPE(key) != IS_STRING) {
! 1198: int use_copy;
! 1199: zend_make_printable_zval(&key, &key_copy, &use_copy);
! 1200: if (use_copy) {
! 1201: key = key_copy;
! 1202: }
! 1203: }
! 1204:
! 1205: spl_recursive_tree_iterator_get_prefix(object, &prefix TSRMLS_CC);
! 1206: spl_recursive_tree_iterator_get_postfix(object, &postfix TSRMLS_CC);
! 1207:
! 1208: str_len = Z_STRLEN(prefix) + Z_STRLEN(key) + Z_STRLEN(postfix);
! 1209: str = (char *) emalloc(str_len + 1U);
! 1210: ptr = str;
! 1211:
! 1212: memcpy(ptr, Z_STRVAL(prefix), Z_STRLEN(prefix));
! 1213: ptr += Z_STRLEN(prefix);
! 1214: memcpy(ptr, Z_STRVAL(key), Z_STRLEN(key));
! 1215: ptr += Z_STRLEN(key);
! 1216: memcpy(ptr, Z_STRVAL(postfix), Z_STRLEN(postfix));
! 1217: ptr += Z_STRLEN(postfix);
! 1218: *ptr = 0;
! 1219:
! 1220: zval_dtor(&prefix);
! 1221: zval_dtor(&key);
! 1222: zval_dtor(&postfix);
! 1223:
! 1224: RETVAL_STRINGL(str, str_len, 0);
! 1225: } /* }}} */
! 1226:
! 1227: ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_tree_it___construct, 0, 0, 1)
! 1228: ZEND_ARG_OBJ_INFO(0, iterator, Traversable, 0)
! 1229: ZEND_ARG_INFO(0, flags)
! 1230: ZEND_ARG_INFO(0, caching_it_flags)
! 1231: ZEND_ARG_INFO(0, mode)
! 1232: ZEND_END_ARG_INFO();
! 1233:
! 1234: ZEND_BEGIN_ARG_INFO_EX(arginfo_recursive_tree_it_setPrefixPart, 0, 0, 2)
! 1235: ZEND_ARG_INFO(0, part)
! 1236: ZEND_ARG_INFO(0, value)
! 1237: ZEND_END_ARG_INFO();
! 1238:
! 1239: static const zend_function_entry spl_funcs_RecursiveTreeIterator[] = {
! 1240: SPL_ME(RecursiveTreeIterator, __construct, arginfo_recursive_tree_it___construct, ZEND_ACC_PUBLIC)
! 1241: SPL_ME(RecursiveIteratorIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1242: SPL_ME(RecursiveIteratorIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1243: SPL_ME(RecursiveTreeIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1244: SPL_ME(RecursiveTreeIterator, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1245: SPL_ME(RecursiveIteratorIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1246: SPL_ME(RecursiveIteratorIterator, beginIteration, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1247: SPL_ME(RecursiveIteratorIterator, endIteration, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1248: SPL_ME(RecursiveIteratorIterator, callHasChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1249: SPL_ME(RecursiveIteratorIterator, callGetChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1250: SPL_ME(RecursiveIteratorIterator, beginChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1251: SPL_ME(RecursiveIteratorIterator, endChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1252: SPL_ME(RecursiveIteratorIterator, nextElement, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1253: SPL_ME(RecursiveTreeIterator, getPrefix, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1254: SPL_ME(RecursiveTreeIterator, setPrefixPart, arginfo_recursive_tree_it_setPrefixPart, ZEND_ACC_PUBLIC)
! 1255: SPL_ME(RecursiveTreeIterator, getEntry, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1256: SPL_ME(RecursiveTreeIterator, getPostfix, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 1257: PHP_FE_END
! 1258: };
! 1259:
! 1260: #if MBO_0
! 1261: static int spl_dual_it_gets_implemented(zend_class_entry *interface, zend_class_entry *class_type TSRMLS_DC)
! 1262: {
! 1263: class_type->iterator_funcs.zf_valid = NULL;
! 1264: class_type->iterator_funcs.zf_current = NULL;
! 1265: class_type->iterator_funcs.zf_key = NULL;
! 1266: class_type->iterator_funcs.zf_next = NULL;
! 1267: class_type->iterator_funcs.zf_rewind = NULL;
! 1268: if (!class_type->iterator_funcs.funcs) {
! 1269: class_type->iterator_funcs.funcs = &zend_interface_iterator_funcs_iterator;
! 1270: }
! 1271:
! 1272: return SUCCESS;
! 1273: }
! 1274: #endif
! 1275:
! 1276: static union _zend_function *spl_dual_it_get_method(zval **object_ptr, char *method, int method_len TSRMLS_DC)
! 1277: {
! 1278: union _zend_function *function_handler;
! 1279: spl_dual_it_object *intern;
! 1280:
! 1281: intern = (spl_dual_it_object*)zend_object_store_get_object(*object_ptr TSRMLS_CC);
! 1282:
! 1283: function_handler = std_object_handlers.get_method(object_ptr, method, method_len TSRMLS_CC);
! 1284: if (!function_handler && intern->inner.ce) {
! 1285: if (zend_hash_find(&intern->inner.ce->function_table, method, method_len+1, (void **) &function_handler) == FAILURE) {
! 1286: if (Z_OBJ_HT_P(intern->inner.zobject)->get_method) {
! 1287: *object_ptr = intern->inner.zobject;
! 1288: function_handler = Z_OBJ_HT_P(*object_ptr)->get_method(object_ptr, method, method_len TSRMLS_CC);
! 1289: }
! 1290: }
! 1291: }
! 1292: return function_handler;
! 1293: }
! 1294:
! 1295: #if MBO_0
! 1296: int spl_dual_it_call_method(char *method, INTERNAL_FUNCTION_PARAMETERS)
! 1297: {
! 1298: zval ***func_params, func;
! 1299: zval *retval_ptr;
! 1300: int arg_count;
! 1301: int current = 0;
! 1302: int success;
! 1303: void **p;
! 1304: spl_dual_it_object *intern;
! 1305:
! 1306: intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1307:
! 1308: ZVAL_STRING(&func, method, 0);
! 1309: if (!zend_is_callable(&func, 0, &method TSRMLS_CC)) {
! 1310: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Method %s::%s() does not exist", intern->inner.ce->name, method);
! 1311: return FAILURE;
! 1312: }
! 1313:
! 1314: p = EG(argument_stack).top_element-2;
! 1315: arg_count = (ulong) *p;
! 1316:
! 1317: func_params = safe_emalloc(sizeof(zval **), arg_count, 0);
! 1318:
! 1319: current = 0;
! 1320: while (arg_count-- > 0) {
! 1321: func_params[current] = (zval **) p - (arg_count-current);
! 1322: current++;
! 1323: }
! 1324: arg_count = current; /* restore */
! 1325:
! 1326: if (call_user_function_ex(EG(function_table), NULL, &func, &retval_ptr, arg_count, func_params, 0, NULL TSRMLS_CC) == SUCCESS && retval_ptr) {
! 1327: RETURN_ZVAL(retval_ptr, 0, 1);
! 1328:
! 1329: success = SUCCESS;
! 1330: } else {
! 1331: php_error_docref(NULL TSRMLS_CC, E_ERROR, "Unable to call %s::%s()", intern->inner.ce->name, method);
! 1332: success = FAILURE;
! 1333: }
! 1334:
! 1335: efree(func_params);
! 1336: return success;
! 1337: }
! 1338: #endif
! 1339:
! 1340: #define SPL_CHECK_CTOR(intern, classname) \
! 1341: if (intern->dit_type == DIT_Unknown) { \
! 1342: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "Classes derived from %s must call %s::__construct()", \
! 1343: (spl_ce_##classname)->name, (spl_ce_##classname)->name); \
! 1344: return; \
! 1345: }
! 1346:
! 1347: #define APPENDIT_CHECK_CTOR(intern) SPL_CHECK_CTOR(intern, AppendIterator)
! 1348:
! 1349: static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more TSRMLS_DC);
! 1350:
! 1351: static inline int spl_cit_check_flags(int flags)
! 1352: {
! 1353: int cnt = 0;
! 1354:
! 1355: cnt += (flags & CIT_CALL_TOSTRING) ? 1 : 0;
! 1356: cnt += (flags & CIT_TOSTRING_USE_KEY) ? 1 : 0;
! 1357: cnt += (flags & CIT_TOSTRING_USE_CURRENT) ? 1 : 0;
! 1358: cnt += (flags & CIT_TOSTRING_USE_INNER) ? 1 : 0;
! 1359:
! 1360: return cnt <= 1 ? SUCCESS : FAILURE;
! 1361: }
! 1362:
! 1363: 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)
! 1364: {
! 1365: zval *zobject, *retval;
! 1366: spl_dual_it_object *intern;
! 1367: zend_class_entry *ce = NULL;
! 1368: int inc_refcount = 1;
! 1369: zend_error_handling error_handling;
! 1370:
! 1371: intern = (spl_dual_it_object*)zend_object_store_get_object(getThis() TSRMLS_CC);
! 1372:
! 1373: if (intern->dit_type != DIT_Unknown) {
! 1374: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s::getIterator() must be called exactly once per instance", ce_base->name);
! 1375: return NULL;
! 1376: }
! 1377:
! 1378: zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
! 1379:
! 1380: intern->dit_type = dit_type;
! 1381: switch (dit_type) {
! 1382: case DIT_LimitIterator: {
! 1383: intern->u.limit.offset = 0; /* start at beginning */
! 1384: intern->u.limit.count = -1; /* get all */
! 1385: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|ll", &zobject, ce_inner, &intern->u.limit.offset, &intern->u.limit.count) == FAILURE) {
! 1386: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1387: return NULL;
! 1388: }
! 1389: if (intern->u.limit.offset < 0) {
! 1390: zend_throw_exception(spl_ce_OutOfRangeException, "Parameter offset must be >= 0", 0 TSRMLS_CC);
! 1391: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1392: return NULL;
! 1393: }
! 1394: if (intern->u.limit.count < 0 && intern->u.limit.count != -1) {
! 1395: zend_throw_exception(spl_ce_OutOfRangeException, "Parameter count must either be -1 or a value greater than or equal 0", 0 TSRMLS_CC);
! 1396: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1397: return NULL;
! 1398: }
! 1399: break;
! 1400: }
! 1401: case DIT_CachingIterator:
! 1402: case DIT_RecursiveCachingIterator: {
! 1403: long flags = CIT_CALL_TOSTRING;
! 1404: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|l", &zobject, ce_inner, &flags) == FAILURE) {
! 1405: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1406: return NULL;
! 1407: }
! 1408: if (spl_cit_check_flags(flags) != SUCCESS) {
! 1409: 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);
! 1410: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1411: return NULL;
! 1412: }
! 1413: intern->u.caching.flags |= flags & CIT_PUBLIC;
! 1414: MAKE_STD_ZVAL(intern->u.caching.zcache);
! 1415: array_init(intern->u.caching.zcache);
! 1416: break;
! 1417: }
! 1418: case DIT_IteratorIterator: {
! 1419: zend_class_entry **pce_cast;
! 1420: char * class_name = NULL;
! 1421: int class_name_len = 0;
! 1422:
! 1423: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|s", &zobject, ce_inner, &class_name, &class_name_len) == FAILURE) {
! 1424: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1425: return NULL;
! 1426: }
! 1427: ce = Z_OBJCE_P(zobject);
! 1428: if (!instanceof_function(ce, zend_ce_iterator TSRMLS_CC)) {
! 1429: if (ZEND_NUM_ARGS() > 1) {
! 1430: if (zend_lookup_class(class_name, class_name_len, &pce_cast TSRMLS_CC) == FAILURE
! 1431: || !instanceof_function(ce, *pce_cast TSRMLS_CC)
! 1432: || !(*pce_cast)->get_iterator
! 1433: ) {
! 1434: zend_throw_exception(spl_ce_LogicException, "Class to downcast to not found or not base class or does not implement Traversable", 0 TSRMLS_CC);
! 1435: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1436: return NULL;
! 1437: }
! 1438: ce = *pce_cast;
! 1439: }
! 1440: if (instanceof_function(ce, zend_ce_aggregate TSRMLS_CC)) {
! 1441: zend_call_method_with_0_params(&zobject, ce, &ce->iterator_funcs.zf_new_iterator, "getiterator", &retval);
! 1442: if (EG(exception)) {
! 1443: if (retval) {
! 1444: zval_ptr_dtor(&retval);
! 1445: }
! 1446: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1447: return NULL;
! 1448: }
! 1449: if (!retval || Z_TYPE_P(retval) != IS_OBJECT || !instanceof_function(Z_OBJCE_P(retval), zend_ce_traversable TSRMLS_CC)) {
! 1450: zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "%s::getIterator() must return an object that implements Traversable", ce->name);
! 1451: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1452: return NULL;
! 1453: }
! 1454: zobject = retval;
! 1455: ce = Z_OBJCE_P(zobject);
! 1456: inc_refcount = 0;
! 1457: }
! 1458: }
! 1459: break;
! 1460: }
! 1461: case DIT_AppendIterator:
! 1462: spl_instantiate(spl_ce_ArrayIterator, &intern->u.append.zarrayit, 1 TSRMLS_CC);
! 1463: zend_call_method_with_0_params(&intern->u.append.zarrayit, spl_ce_ArrayIterator, &spl_ce_ArrayIterator->constructor, "__construct", NULL);
! 1464: intern->u.append.iterator = spl_ce_ArrayIterator->get_iterator(spl_ce_ArrayIterator, intern->u.append.zarrayit, 0 TSRMLS_CC);
! 1465: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1466: return intern;
! 1467: #if HAVE_PCRE || HAVE_BUNDLED_PCRE
! 1468: case DIT_RegexIterator:
! 1469: case DIT_RecursiveRegexIterator: {
! 1470: char *regex;
! 1471: int regex_len;
! 1472: long mode = REGIT_MODE_MATCH;
! 1473:
! 1474: intern->u.regex.use_flags = ZEND_NUM_ARGS() >= 5;
! 1475: intern->u.regex.flags = 0;
! 1476: intern->u.regex.preg_flags = 0;
! 1477: 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) {
! 1478: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1479: return NULL;
! 1480: }
! 1481: if (mode < 0 || mode >= REGIT_MODE_MAX) {
! 1482: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %ld", mode);
! 1483: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1484: return NULL;
! 1485: }
! 1486: intern->u.regex.mode = mode;
! 1487: intern->u.regex.regex = estrndup(regex, regex_len);
! 1488: intern->u.regex.pce = pcre_get_compiled_regex_cache(regex, regex_len TSRMLS_CC);
! 1489: if (intern->u.regex.pce == NULL) {
! 1490: /* pcre_get_compiled_regex_cache has already sent error */
! 1491: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1492: return NULL;
! 1493: }
! 1494: intern->u.regex.pce->refcount++;
! 1495: break;
! 1496: }
! 1497: #endif
! 1498: default:
! 1499: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &zobject, ce_inner) == FAILURE) {
! 1500: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1501: return NULL;
! 1502: }
! 1503: break;
! 1504: }
! 1505:
! 1506: zend_restore_error_handling(&error_handling TSRMLS_CC);
! 1507:
! 1508: if (inc_refcount) {
! 1509: Z_ADDREF_P(zobject);
! 1510: }
! 1511: intern->inner.zobject = zobject;
! 1512: intern->inner.ce = dit_type == DIT_IteratorIterator ? ce : Z_OBJCE_P(zobject);
! 1513: intern->inner.object = zend_object_store_get_object(zobject TSRMLS_CC);
! 1514: intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, zobject, 0 TSRMLS_CC);
! 1515:
! 1516: return intern;
! 1517: }
! 1518:
! 1519: /* {{{ proto void FilterIterator::__construct(Iterator it)
! 1520: Create an Iterator from another iterator */
! 1521: SPL_METHOD(FilterIterator, __construct)
! 1522: {
! 1523: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_FilterIterator, zend_ce_iterator, DIT_FilterIterator);
! 1524: } /* }}} */
! 1525:
! 1526: /* {{{ proto Iterator FilterIterator::getInnerIterator()
! 1527: proto Iterator CachingIterator::getInnerIterator()
! 1528: proto Iterator LimitIterator::getInnerIterator()
! 1529: proto Iterator ParentIterator::getInnerIterator()
! 1530: Get the inner iterator */
! 1531: SPL_METHOD(dual_it, getInnerIterator)
! 1532: {
! 1533: spl_dual_it_object *intern;
! 1534:
! 1535: if (zend_parse_parameters_none() == FAILURE) {
! 1536: return;
! 1537: }
! 1538:
! 1539: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1540:
! 1541: if (intern->inner.zobject) {
! 1542: RETVAL_ZVAL(intern->inner.zobject, 1, 0);
! 1543: } else {
! 1544: RETURN_NULL();
! 1545: }
! 1546: } /* }}} */
! 1547:
! 1548: static inline void spl_dual_it_require(spl_dual_it_object *intern TSRMLS_DC)
! 1549: {
! 1550: if (!intern->inner.iterator) {
! 1551: php_error_docref(NULL TSRMLS_CC, E_ERROR, "The inner constructor wasn't initialized with an iterator instance");
! 1552: }
! 1553: }
! 1554:
! 1555: static inline void spl_dual_it_free(spl_dual_it_object *intern TSRMLS_DC)
! 1556: {
! 1557: if (intern->inner.iterator && intern->inner.iterator->funcs->invalidate_current) {
! 1558: intern->inner.iterator->funcs->invalidate_current(intern->inner.iterator TSRMLS_CC);
! 1559: }
! 1560: if (intern->current.data) {
! 1561: zval_ptr_dtor(&intern->current.data);
! 1562: intern->current.data = NULL;
! 1563: }
! 1564: if (intern->current.str_key) {
! 1565: efree(intern->current.str_key);
! 1566: intern->current.str_key = NULL;
! 1567: }
! 1568: if (intern->dit_type == DIT_CachingIterator || intern->dit_type == DIT_RecursiveCachingIterator) {
! 1569: if (intern->u.caching.zstr) {
! 1570: zval_ptr_dtor(&intern->u.caching.zstr);
! 1571: intern->u.caching.zstr = NULL;
! 1572: }
! 1573: if (intern->u.caching.zchildren) {
! 1574: zval_ptr_dtor(&intern->u.caching.zchildren);
! 1575: intern->u.caching.zchildren = NULL;
! 1576: }
! 1577: }
! 1578: }
! 1579:
! 1580: static inline void spl_dual_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
! 1581: {
! 1582: spl_dual_it_free(intern TSRMLS_CC);
! 1583: intern->current.pos = 0;
! 1584: if (intern->inner.iterator->funcs->rewind) {
! 1585: intern->inner.iterator->funcs->rewind(intern->inner.iterator TSRMLS_CC);
! 1586: }
! 1587: }
! 1588:
! 1589: static inline int spl_dual_it_valid(spl_dual_it_object *intern TSRMLS_DC)
! 1590: {
! 1591: if (!intern->inner.iterator) {
! 1592: return FAILURE;
! 1593: }
! 1594: /* FAILURE / SUCCESS */
! 1595: return intern->inner.iterator->funcs->valid(intern->inner.iterator TSRMLS_CC);
! 1596: }
! 1597:
! 1598: static inline int spl_dual_it_fetch(spl_dual_it_object *intern, int check_more TSRMLS_DC)
! 1599: {
! 1600: zval **data;
! 1601:
! 1602: spl_dual_it_free(intern TSRMLS_CC);
! 1603: if (!check_more || spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 1604: intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC);
! 1605: if (data && *data) {
! 1606: intern->current.data = *data;
! 1607: Z_ADDREF_P(intern->current.data);
! 1608: }
! 1609: if (intern->inner.iterator->funcs->get_current_key) {
! 1610: intern->current.key_type = intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &intern->current.str_key, &intern->current.str_key_len, &intern->current.int_key TSRMLS_CC);
! 1611: } else {
! 1612: intern->current.key_type = HASH_KEY_IS_LONG;
! 1613: intern->current.int_key = intern->current.pos;
! 1614: }
! 1615: return EG(exception) ? FAILURE : SUCCESS;
! 1616: }
! 1617: return FAILURE;
! 1618: }
! 1619:
! 1620: static inline void spl_dual_it_next(spl_dual_it_object *intern, int do_free TSRMLS_DC)
! 1621: {
! 1622: if (do_free) {
! 1623: spl_dual_it_free(intern TSRMLS_CC);
! 1624: } else {
! 1625: spl_dual_it_require(intern TSRMLS_CC);
! 1626: }
! 1627: intern->inner.iterator->funcs->move_forward(intern->inner.iterator TSRMLS_CC);
! 1628: intern->current.pos++;
! 1629: }
! 1630:
! 1631: /* {{{ proto void ParentIterator::rewind()
! 1632: proto void IteratorIterator::rewind()
! 1633: Rewind the iterator
! 1634: */
! 1635: SPL_METHOD(dual_it, rewind)
! 1636: {
! 1637: spl_dual_it_object *intern;
! 1638:
! 1639: if (zend_parse_parameters_none() == FAILURE) {
! 1640: return;
! 1641: }
! 1642:
! 1643: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1644:
! 1645: spl_dual_it_rewind(intern TSRMLS_CC);
! 1646: spl_dual_it_fetch(intern, 1 TSRMLS_CC);
! 1647: } /* }}} */
! 1648:
! 1649: /* {{{ proto bool FilterIterator::valid()
! 1650: proto bool ParentIterator::valid()
! 1651: proto bool IteratorIterator::valid()
! 1652: proto bool NoRewindIterator::valid()
! 1653: Check whether the current element is valid */
! 1654: SPL_METHOD(dual_it, valid)
! 1655: {
! 1656: spl_dual_it_object *intern;
! 1657:
! 1658: if (zend_parse_parameters_none() == FAILURE) {
! 1659: return;
! 1660: }
! 1661:
! 1662: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1663:
! 1664: RETURN_BOOL(intern->current.data);
! 1665: } /* }}} */
! 1666:
! 1667: /* {{{ proto mixed FilterIterator::key()
! 1668: proto mixed CachingIterator::key()
! 1669: proto mixed LimitIterator::key()
! 1670: proto mixed ParentIterator::key()
! 1671: proto mixed IteratorIterator::key()
! 1672: proto mixed NoRewindIterator::key()
! 1673: proto mixed AppendIterator::key()
! 1674: Get the current key */
! 1675: SPL_METHOD(dual_it, key)
! 1676: {
! 1677: spl_dual_it_object *intern;
! 1678:
! 1679: if (zend_parse_parameters_none() == FAILURE) {
! 1680: return;
! 1681: }
! 1682:
! 1683: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1684:
! 1685: if (intern->current.data) {
! 1686: if (intern->current.key_type == HASH_KEY_IS_STRING) {
! 1687: RETURN_STRINGL(intern->current.str_key, intern->current.str_key_len-1, 1);
! 1688: } else {
! 1689: RETURN_LONG(intern->current.int_key);
! 1690: }
! 1691: }
! 1692: RETURN_NULL();
! 1693: } /* }}} */
! 1694:
! 1695: /* {{{ proto mixed FilterIterator::current()
! 1696: proto mixed CachingIterator::current()
! 1697: proto mixed LimitIterator::current()
! 1698: proto mixed ParentIterator::current()
! 1699: proto mixed IteratorIterator::current()
! 1700: proto mixed NoRewindIterator::current()
! 1701: proto mixed AppendIterator::current()
! 1702: Get the current element value */
! 1703: SPL_METHOD(dual_it, current)
! 1704: {
! 1705: spl_dual_it_object *intern;
! 1706:
! 1707: if (zend_parse_parameters_none() == FAILURE) {
! 1708: return;
! 1709: }
! 1710:
! 1711: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1712:
! 1713: if (intern->current.data) {
! 1714: RETVAL_ZVAL(intern->current.data, 1, 0);
! 1715: } else {
! 1716: RETURN_NULL();
! 1717: }
! 1718: } /* }}} */
! 1719:
! 1720: /* {{{ proto void ParentIterator::next()
! 1721: proto void IteratorIterator::next()
! 1722: proto void NoRewindIterator::next()
! 1723: Move the iterator forward */
! 1724: SPL_METHOD(dual_it, next)
! 1725: {
! 1726: spl_dual_it_object *intern;
! 1727:
! 1728: if (zend_parse_parameters_none() == FAILURE) {
! 1729: return;
! 1730: }
! 1731:
! 1732: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1733:
! 1734: spl_dual_it_next(intern, 1 TSRMLS_CC);
! 1735: spl_dual_it_fetch(intern, 1 TSRMLS_CC);
! 1736: } /* }}} */
! 1737:
! 1738: static inline void spl_filter_it_fetch(zval *zthis, spl_dual_it_object *intern TSRMLS_DC)
! 1739: {
! 1740: zval *retval;
! 1741:
! 1742: while (spl_dual_it_fetch(intern, 1 TSRMLS_CC) == SUCCESS) {
! 1743: zend_call_method_with_0_params(&zthis, intern->std.ce, NULL, "accept", &retval);
! 1744: if (retval) {
! 1745: if (zend_is_true(retval)) {
! 1746: zval_ptr_dtor(&retval);
! 1747: return;
! 1748: }
! 1749: zval_ptr_dtor(&retval);
! 1750: }
! 1751: if (EG(exception)) {
! 1752: return;
! 1753: }
! 1754: intern->inner.iterator->funcs->move_forward(intern->inner.iterator TSRMLS_CC);
! 1755: }
! 1756: spl_dual_it_free(intern TSRMLS_CC);
! 1757: }
! 1758:
! 1759: static inline void spl_filter_it_rewind(zval *zthis, spl_dual_it_object *intern TSRMLS_DC)
! 1760: {
! 1761: spl_dual_it_rewind(intern TSRMLS_CC);
! 1762: spl_filter_it_fetch(zthis, intern TSRMLS_CC);
! 1763: }
! 1764:
! 1765: static inline void spl_filter_it_next(zval *zthis, spl_dual_it_object *intern TSRMLS_DC)
! 1766: {
! 1767: spl_dual_it_next(intern, 1 TSRMLS_CC);
! 1768: spl_filter_it_fetch(zthis, intern TSRMLS_CC);
! 1769: }
! 1770:
! 1771: /* {{{ proto void FilterIterator::rewind()
! 1772: Rewind the iterator */
! 1773: SPL_METHOD(FilterIterator, rewind)
! 1774: {
! 1775: spl_dual_it_object *intern;
! 1776:
! 1777: if (zend_parse_parameters_none() == FAILURE) {
! 1778: return;
! 1779: }
! 1780:
! 1781: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1782: spl_filter_it_rewind(getThis(), intern TSRMLS_CC);
! 1783: } /* }}} */
! 1784:
! 1785: /* {{{ proto void FilterIterator::next()
! 1786: Move the iterator forward */
! 1787: SPL_METHOD(FilterIterator, next)
! 1788: {
! 1789: spl_dual_it_object *intern;
! 1790:
! 1791: if (zend_parse_parameters_none() == FAILURE) {
! 1792: return;
! 1793: }
! 1794:
! 1795: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1796: spl_filter_it_next(getThis(), intern TSRMLS_CC);
! 1797: } /* }}} */
! 1798:
! 1799: /* {{{ proto void RecursiveFilterIterator::__construct(RecursiveIterator it)
! 1800: Create a RecursiveFilterIterator from a RecursiveIterator */
! 1801: SPL_METHOD(RecursiveFilterIterator, __construct)
! 1802: {
! 1803: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveFilterIterator, spl_ce_RecursiveIterator, DIT_RecursiveFilterIterator);
! 1804: } /* }}} */
! 1805:
! 1806: /* {{{ proto bool RecursiveFilterIterator::hasChildren()
! 1807: Check whether the inner iterator's current element has children */
! 1808: SPL_METHOD(RecursiveFilterIterator, hasChildren)
! 1809: {
! 1810: spl_dual_it_object *intern;
! 1811: zval *retval;
! 1812:
! 1813: if (zend_parse_parameters_none() == FAILURE) {
! 1814: return;
! 1815: }
! 1816:
! 1817: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1818:
! 1819: zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval);
! 1820: if (retval) {
! 1821: RETURN_ZVAL(retval, 0, 1);
! 1822: } else {
! 1823: RETURN_FALSE;
! 1824: }
! 1825: } /* }}} */
! 1826:
! 1827: /* {{{ proto RecursiveFilterIterator RecursiveFilterIterator::getChildren()
! 1828: Return the inner iterator's children contained in a RecursiveFilterIterator */
! 1829: SPL_METHOD(RecursiveFilterIterator, getChildren)
! 1830: {
! 1831: spl_dual_it_object *intern;
! 1832: zval *retval;
! 1833:
! 1834: if (zend_parse_parameters_none() == FAILURE) {
! 1835: return;
! 1836: }
! 1837:
! 1838: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1839:
! 1840: zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval);
! 1841: if (!EG(exception) && retval) {
! 1842: spl_instantiate_arg_ex1(Z_OBJCE_P(getThis()), &return_value, 0, retval TSRMLS_CC);
! 1843: }
! 1844: if (retval) {
! 1845: zval_ptr_dtor(&retval);
! 1846: }
! 1847: } /* }}} */
! 1848:
! 1849: /* {{{ proto void ParentIterator::__construct(RecursiveIterator it)
! 1850: Create a ParentIterator from a RecursiveIterator */
! 1851: SPL_METHOD(ParentIterator, __construct)
! 1852: {
! 1853: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_ParentIterator, spl_ce_RecursiveIterator, DIT_ParentIterator);
! 1854: } /* }}} */
! 1855:
! 1856: #if HAVE_PCRE || HAVE_BUNDLED_PCRE
! 1857: /* {{{ proto void RegexIterator::__construct(Iterator it, string regex [, int mode [, int flags [, int preg_flags]]])
! 1858: Create an RegexIterator from another iterator and a regular expression */
! 1859: SPL_METHOD(RegexIterator, __construct)
! 1860: {
! 1861: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RegexIterator, zend_ce_iterator, DIT_RegexIterator);
! 1862: } /* }}} */
! 1863:
! 1864: /* {{{ proto bool RegexIterator::accept()
! 1865: Match (string)current() against regular expression */
! 1866: SPL_METHOD(RegexIterator, accept)
! 1867: {
! 1868: spl_dual_it_object *intern;
! 1869: char *subject, tmp[32], *result;
! 1870: int subject_len, use_copy, count = 0, result_len;
! 1871: zval subject_copy, zcount, *replacement, tmp_replacement;
! 1872:
! 1873: if (zend_parse_parameters_none() == FAILURE) {
! 1874: return;
! 1875: }
! 1876:
! 1877: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1878:
! 1879: if (intern->current.data == NULL) {
! 1880: RETURN_FALSE;
! 1881: }
! 1882:
! 1883: if (intern->u.regex.flags & REGIT_USE_KEY) {
! 1884: if (intern->current.key_type == HASH_KEY_IS_LONG) {
! 1885: subject_len = slprintf(tmp, sizeof(tmp), "%ld", intern->current.int_key);
! 1886: subject = &tmp[0];
! 1887: use_copy = 0;
! 1888: } else {
! 1889: subject_len = intern->current.str_key_len - 1;
! 1890: subject = estrndup(intern->current.str_key, subject_len);
! 1891: use_copy = 1;
! 1892: }
! 1893: } else {
! 1894: zend_make_printable_zval(intern->current.data, &subject_copy, &use_copy);
! 1895: if (use_copy) {
! 1896: subject = Z_STRVAL(subject_copy);
! 1897: subject_len = Z_STRLEN(subject_copy);
! 1898: } else {
! 1899: subject = Z_STRVAL_P(intern->current.data);
! 1900: subject_len = Z_STRLEN_P(intern->current.data);
! 1901: }
! 1902: }
! 1903:
! 1904: switch (intern->u.regex.mode)
! 1905: {
! 1906: case REGIT_MODE_MAX: /* won't happen but makes compiler happy */
! 1907: case REGIT_MODE_MATCH:
! 1908: count = pcre_exec(intern->u.regex.pce->re, intern->u.regex.pce->extra, subject, subject_len, 0, 0, NULL, 0);
! 1909: RETVAL_BOOL(count >= 0);
! 1910: break;
! 1911:
! 1912: case REGIT_MODE_ALL_MATCHES:
! 1913: case REGIT_MODE_GET_MATCH:
! 1914: if (!use_copy) {
! 1915: subject = estrndup(subject, subject_len);
! 1916: use_copy = 1;
! 1917: }
! 1918: zval_ptr_dtor(&intern->current.data);
! 1919: ALLOC_INIT_ZVAL(intern->current.data);
! 1920: php_pcre_match_impl(intern->u.regex.pce, subject, subject_len, &zcount,
! 1921: intern->current.data, intern->u.regex.mode == REGIT_MODE_ALL_MATCHES, intern->u.regex.use_flags, intern->u.regex.preg_flags, 0 TSRMLS_CC);
! 1922: count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data));
! 1923: RETVAL_BOOL(count > 0);
! 1924: break;
! 1925:
! 1926: case REGIT_MODE_SPLIT:
! 1927: if (!use_copy) {
! 1928: subject = estrndup(subject, subject_len);
! 1929: use_copy = 1;
! 1930: }
! 1931: zval_ptr_dtor(&intern->current.data);
! 1932: ALLOC_INIT_ZVAL(intern->current.data);
! 1933: php_pcre_split_impl(intern->u.regex.pce, subject, subject_len, intern->current.data, -1, intern->u.regex.preg_flags TSRMLS_CC);
! 1934: count = zend_hash_num_elements(Z_ARRVAL_P(intern->current.data));
! 1935: RETVAL_BOOL(count > 1);
! 1936: break;
! 1937:
! 1938: case REGIT_MODE_REPLACE:
! 1939: replacement = zend_read_property(intern->std.ce, getThis(), "replacement", sizeof("replacement")-1, 1 TSRMLS_CC);
! 1940: if (Z_TYPE_P(replacement) != IS_STRING) {
! 1941: tmp_replacement = *replacement;
! 1942: zval_copy_ctor(&tmp_replacement);
! 1943: convert_to_string(&tmp_replacement);
! 1944: replacement = &tmp_replacement;
! 1945: }
! 1946: result = php_pcre_replace_impl(intern->u.regex.pce, subject, subject_len, replacement, 0, &result_len, -1, &count TSRMLS_CC);
! 1947:
! 1948: if (intern->u.regex.flags & REGIT_USE_KEY) {
! 1949: if (intern->current.key_type != HASH_KEY_IS_LONG) {
! 1950: efree(intern->current.str_key);
! 1951: }
! 1952: intern->current.key_type = HASH_KEY_IS_STRING;
! 1953: intern->current.str_key = result;
! 1954: intern->current.str_key_len = result_len + 1;
! 1955: } else {
! 1956: zval_ptr_dtor(&intern->current.data);
! 1957: MAKE_STD_ZVAL(intern->current.data);
! 1958: ZVAL_STRINGL(intern->current.data, result, result_len, 0);
! 1959: }
! 1960:
! 1961: if (replacement == &tmp_replacement) {
! 1962: zval_dtor(replacement);
! 1963: }
! 1964: RETVAL_BOOL(count > 0);
! 1965: }
! 1966:
! 1967: if (intern->u.regex.flags & REGIT_INVERTED) {
! 1968: RETVAL_BOOL(Z_LVAL_P(return_value));
! 1969: }
! 1970:
! 1971: if (use_copy) {
! 1972: efree(subject);
! 1973: }
! 1974: } /* }}} */
! 1975:
! 1976: /* {{{ proto bool RegexIterator::getMode()
! 1977: Returns current operation mode */
! 1978: SPL_METHOD(RegexIterator, getMode)
! 1979: {
! 1980: spl_dual_it_object *intern;
! 1981:
! 1982: if (zend_parse_parameters_none() == FAILURE) {
! 1983: return;
! 1984: }
! 1985:
! 1986: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 1987:
! 1988: RETURN_LONG(intern->u.regex.mode);
! 1989: } /* }}} */
! 1990:
! 1991: /* {{{ proto bool RegexIterator::setMode(int new_mode)
! 1992: Set new operation mode */
! 1993: SPL_METHOD(RegexIterator, setMode)
! 1994: {
! 1995: spl_dual_it_object *intern;
! 1996: long mode;
! 1997:
! 1998: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &mode) == FAILURE) {
! 1999: return;
! 2000: }
! 2001:
! 2002: if (mode < 0 || mode >= REGIT_MODE_MAX) {
! 2003: zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0 TSRMLS_CC, "Illegal mode %ld", mode);
! 2004: return;/* NULL */
! 2005: }
! 2006:
! 2007: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2008:
! 2009: intern->u.regex.mode = mode;
! 2010: } /* }}} */
! 2011:
! 2012: /* {{{ proto bool RegexIterator::getFlags()
! 2013: Returns current operation flags */
! 2014: SPL_METHOD(RegexIterator, getFlags)
! 2015: {
! 2016: spl_dual_it_object *intern;
! 2017:
! 2018: if (zend_parse_parameters_none() == FAILURE) {
! 2019: return;
! 2020: }
! 2021:
! 2022: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2023:
! 2024: RETURN_LONG(intern->u.regex.flags);
! 2025: } /* }}} */
! 2026:
! 2027: /* {{{ proto bool RegexIterator::setFlags(int new_flags)
! 2028: Set operation flags */
! 2029: SPL_METHOD(RegexIterator, setFlags)
! 2030: {
! 2031: spl_dual_it_object *intern;
! 2032: long flags;
! 2033:
! 2034: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) {
! 2035: return;
! 2036: }
! 2037:
! 2038: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2039:
! 2040: intern->u.regex.flags = flags;
! 2041: } /* }}} */
! 2042:
! 2043: /* {{{ proto bool RegexIterator::getFlags()
! 2044: Returns current PREG flags (if in use or NULL) */
! 2045: SPL_METHOD(RegexIterator, getPregFlags)
! 2046: {
! 2047: spl_dual_it_object *intern;
! 2048:
! 2049: if (zend_parse_parameters_none() == FAILURE) {
! 2050: return;
! 2051: }
! 2052:
! 2053: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2054:
! 2055: if (intern->u.regex.use_flags) {
! 2056: RETURN_LONG(intern->u.regex.preg_flags);
! 2057: } else {
! 2058: return;
! 2059: }
! 2060: } /* }}} */
! 2061:
! 2062: /* {{{ proto bool RegexIterator::setPregFlags(int new_flags)
! 2063: Set PREG flags */
! 2064: SPL_METHOD(RegexIterator, setPregFlags)
! 2065: {
! 2066: spl_dual_it_object *intern;
! 2067: long preg_flags;
! 2068:
! 2069: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &preg_flags) == FAILURE) {
! 2070: return;
! 2071: }
! 2072:
! 2073: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2074:
! 2075: intern->u.regex.preg_flags = preg_flags;
! 2076: intern->u.regex.use_flags = 1;
! 2077: } /* }}} */
! 2078:
! 2079: /* {{{ proto void RecursiveRegexIterator::__construct(RecursiveIterator it, string regex [, int mode [, int flags [, int preg_flags]]])
! 2080: Create an RecursiveRegexIterator from another recursive iterator and a regular expression */
! 2081: SPL_METHOD(RecursiveRegexIterator, __construct)
! 2082: {
! 2083: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveRegexIterator, spl_ce_RecursiveIterator, DIT_RecursiveRegexIterator);
! 2084: } /* }}} */
! 2085:
! 2086: /* {{{ proto RecursiveRegexIterator RecursiveRegexIterator::getChildren()
! 2087: Return the inner iterator's children contained in a RecursiveRegexIterator */
! 2088: SPL_METHOD(RecursiveRegexIterator, getChildren)
! 2089: {
! 2090: spl_dual_it_object *intern;
! 2091: zval *retval, *regex;
! 2092:
! 2093: if (zend_parse_parameters_none() == FAILURE) {
! 2094: return;
! 2095: }
! 2096:
! 2097: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2098:
! 2099: zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &retval);
! 2100: if (!EG(exception)) {
! 2101: MAKE_STD_ZVAL(regex);
! 2102: ZVAL_STRING(regex, intern->u.regex.regex, 1);
! 2103: spl_instantiate_arg_ex2(Z_OBJCE_P(getThis()), &return_value, 0, retval, regex TSRMLS_CC);
! 2104: zval_ptr_dtor(®ex);
! 2105: }
! 2106: if (retval) {
! 2107: zval_ptr_dtor(&retval);
! 2108: }
! 2109: } /* }}} */
! 2110:
! 2111: #endif
! 2112:
! 2113: /* {{{ spl_dual_it_dtor */
! 2114: static void spl_dual_it_dtor(zend_object *_object, zend_object_handle handle TSRMLS_DC)
! 2115: {
! 2116: spl_dual_it_object *object = (spl_dual_it_object *)_object;
! 2117:
! 2118: /* call standard dtor */
! 2119: zend_objects_destroy_object(_object, handle TSRMLS_CC);
! 2120:
! 2121: spl_dual_it_free(object TSRMLS_CC);
! 2122:
! 2123: if (object->inner.iterator) {
! 2124: object->inner.iterator->funcs->dtor(object->inner.iterator TSRMLS_CC);
! 2125: }
! 2126: }
! 2127: /* }}} */
! 2128:
! 2129: /* {{{ spl_dual_it_free_storage */
! 2130: static void spl_dual_it_free_storage(void *_object TSRMLS_DC)
! 2131: {
! 2132: spl_dual_it_object *object = (spl_dual_it_object *)_object;
! 2133:
! 2134: if (object->inner.zobject) {
! 2135: zval_ptr_dtor(&object->inner.zobject);
! 2136: }
! 2137:
! 2138: if (object->dit_type == DIT_AppendIterator) {
! 2139: object->u.append.iterator->funcs->dtor(object->u.append.iterator TSRMLS_CC);
! 2140: if (object->u.append.zarrayit) {
! 2141: zval_ptr_dtor(&object->u.append.zarrayit);
! 2142: }
! 2143: }
! 2144:
! 2145: if (object->dit_type == DIT_CachingIterator || object->dit_type == DIT_RecursiveCachingIterator) {
! 2146: if (object->u.caching.zcache) {
! 2147: zval_ptr_dtor(&object->u.caching.zcache);
! 2148: object->u.caching.zcache = NULL;
! 2149: }
! 2150: }
! 2151:
! 2152: #if HAVE_PCRE || HAVE_BUNDLED_PCRE
! 2153: if (object->dit_type == DIT_RegexIterator || object->dit_type == DIT_RecursiveRegexIterator) {
! 2154: if (object->u.regex.pce) {
! 2155: object->u.regex.pce->refcount--;
! 2156: }
! 2157: if (object->u.regex.regex) {
! 2158: efree(object->u.regex.regex);
! 2159: }
! 2160: }
! 2161: #endif
! 2162:
! 2163: zend_object_std_dtor(&object->std TSRMLS_CC);
! 2164:
! 2165: efree(object);
! 2166: }
! 2167: /* }}} */
! 2168:
! 2169: /* {{{ spl_dual_it_new */
! 2170: static zend_object_value spl_dual_it_new(zend_class_entry *class_type TSRMLS_DC)
! 2171: {
! 2172: zend_object_value retval;
! 2173: spl_dual_it_object *intern;
! 2174: zval *tmp;
! 2175:
! 2176: intern = emalloc(sizeof(spl_dual_it_object));
! 2177: memset(intern, 0, sizeof(spl_dual_it_object));
! 2178: intern->dit_type = DIT_Unknown;
! 2179:
! 2180: zend_object_std_init(&intern->std, class_type TSRMLS_CC);
! 2181: zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
! 2182:
! 2183: retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)spl_dual_it_dtor, (zend_objects_free_object_storage_t) spl_dual_it_free_storage, NULL TSRMLS_CC);
! 2184: retval.handlers = &spl_handlers_dual_it;
! 2185: return retval;
! 2186: }
! 2187: /* }}} */
! 2188:
! 2189: ZEND_BEGIN_ARG_INFO(arginfo_filter_it___construct, 0)
! 2190: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 2191: ZEND_END_ARG_INFO();
! 2192:
! 2193: static const zend_function_entry spl_funcs_FilterIterator[] = {
! 2194: SPL_ME(FilterIterator, __construct, arginfo_filter_it___construct, ZEND_ACC_PUBLIC)
! 2195: SPL_ME(FilterIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2196: SPL_ME(dual_it, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2197: SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2198: SPL_ME(dual_it, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2199: SPL_ME(FilterIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2200: SPL_ME(dual_it, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2201: SPL_ABSTRACT_ME(FilterIterator, accept, arginfo_recursive_it_void)
! 2202: PHP_FE_END
! 2203: };
! 2204:
! 2205: ZEND_BEGIN_ARG_INFO(arginfo_parent_it___construct, 0)
! 2206: ZEND_ARG_OBJ_INFO(0, iterator, RecursiveIterator, 0)
! 2207: ZEND_END_ARG_INFO();
! 2208:
! 2209: static const zend_function_entry spl_funcs_RecursiveFilterIterator[] = {
! 2210: SPL_ME(RecursiveFilterIterator, __construct, arginfo_parent_it___construct, ZEND_ACC_PUBLIC)
! 2211: SPL_ME(RecursiveFilterIterator, hasChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2212: SPL_ME(RecursiveFilterIterator, getChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2213: PHP_FE_END
! 2214: };
! 2215:
! 2216: static const zend_function_entry spl_funcs_ParentIterator[] = {
! 2217: SPL_ME(ParentIterator, __construct, arginfo_parent_it___construct, ZEND_ACC_PUBLIC)
! 2218: SPL_MA(ParentIterator, accept, RecursiveFilterIterator, hasChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2219: PHP_FE_END
! 2220: };
! 2221:
! 2222: #if HAVE_PCRE || HAVE_BUNDLED_PCRE
! 2223: ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it___construct, 0, 0, 2)
! 2224: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 2225: ZEND_ARG_INFO(0, regex)
! 2226: ZEND_ARG_INFO(0, mode)
! 2227: ZEND_ARG_INFO(0, flags)
! 2228: ZEND_ARG_INFO(0, preg_flags)
! 2229: ZEND_END_ARG_INFO();
! 2230:
! 2231: ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_mode, 0, 0, 1)
! 2232: ZEND_ARG_INFO(0, mode)
! 2233: ZEND_END_ARG_INFO();
! 2234:
! 2235: ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_flags, 0, 0, 1)
! 2236: ZEND_ARG_INFO(0, flags)
! 2237: ZEND_END_ARG_INFO();
! 2238:
! 2239: ZEND_BEGIN_ARG_INFO_EX(arginfo_regex_it_set_preg_flags, 0, 0, 1)
! 2240: ZEND_ARG_INFO(0, preg_flags)
! 2241: ZEND_END_ARG_INFO();
! 2242:
! 2243: static const zend_function_entry spl_funcs_RegexIterator[] = {
! 2244: SPL_ME(RegexIterator, __construct, arginfo_regex_it___construct, ZEND_ACC_PUBLIC)
! 2245: SPL_ME(RegexIterator, accept, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2246: SPL_ME(RegexIterator, getMode, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2247: SPL_ME(RegexIterator, setMode, arginfo_regex_it_set_mode, ZEND_ACC_PUBLIC)
! 2248: SPL_ME(RegexIterator, getFlags, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2249: SPL_ME(RegexIterator, setFlags, arginfo_regex_it_set_flags, ZEND_ACC_PUBLIC)
! 2250: SPL_ME(RegexIterator, getPregFlags, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2251: SPL_ME(RegexIterator, setPregFlags, arginfo_regex_it_set_preg_flags, ZEND_ACC_PUBLIC)
! 2252: PHP_FE_END
! 2253: };
! 2254:
! 2255: ZEND_BEGIN_ARG_INFO_EX(arginfo_rec_regex_it___construct, 0, 0, 2)
! 2256: ZEND_ARG_OBJ_INFO(0, iterator, RecursiveIterator, 0)
! 2257: ZEND_ARG_INFO(0, regex)
! 2258: ZEND_ARG_INFO(0, mode)
! 2259: ZEND_ARG_INFO(0, flags)
! 2260: ZEND_ARG_INFO(0, preg_flags)
! 2261: ZEND_END_ARG_INFO();
! 2262:
! 2263: static const zend_function_entry spl_funcs_RecursiveRegexIterator[] = {
! 2264: SPL_ME(RecursiveRegexIterator, __construct, arginfo_rec_regex_it___construct, ZEND_ACC_PUBLIC)
! 2265: SPL_ME(RecursiveFilterIterator, hasChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2266: SPL_ME(RecursiveRegexIterator, getChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2267: PHP_FE_END
! 2268: };
! 2269: #endif
! 2270:
! 2271: static inline int spl_limit_it_valid(spl_dual_it_object *intern TSRMLS_DC)
! 2272: {
! 2273: /* FAILURE / SUCCESS */
! 2274: if (intern->u.limit.count != -1 && intern->current.pos >= intern->u.limit.offset + intern->u.limit.count) {
! 2275: return FAILURE;
! 2276: } else {
! 2277: return spl_dual_it_valid(intern TSRMLS_CC);
! 2278: }
! 2279: }
! 2280:
! 2281: static inline void spl_limit_it_seek(spl_dual_it_object *intern, long pos TSRMLS_DC)
! 2282: {
! 2283: zval *zpos;
! 2284:
! 2285: spl_dual_it_free(intern TSRMLS_CC);
! 2286: if (pos < intern->u.limit.offset) {
! 2287: zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %ld which is below the offset %ld", pos, intern->u.limit.offset);
! 2288: return;
! 2289: }
! 2290: if (pos >= intern->u.limit.offset + intern->u.limit.count && intern->u.limit.count != -1) {
! 2291: zend_throw_exception_ex(spl_ce_OutOfBoundsException, 0 TSRMLS_CC, "Cannot seek to %ld which is behind offset %ld plus count %ld", pos, intern->u.limit.offset, intern->u.limit.count);
! 2292: return;
! 2293: }
! 2294: if (pos != intern->current.pos && instanceof_function(intern->inner.ce, spl_ce_SeekableIterator TSRMLS_CC)) {
! 2295: MAKE_STD_ZVAL(zpos);
! 2296: ZVAL_LONG(zpos, pos);
! 2297: spl_dual_it_free(intern TSRMLS_CC);
! 2298: zend_call_method_with_1_params(&intern->inner.zobject, intern->inner.ce, NULL, "seek", NULL, zpos);
! 2299: zval_ptr_dtor(&zpos);
! 2300: if (!EG(exception)) {
! 2301: intern->current.pos = pos;
! 2302: if (spl_limit_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 2303: spl_dual_it_fetch(intern, 0 TSRMLS_CC);
! 2304: }
! 2305: }
! 2306: } else {
! 2307: /* emulate the forward seek, by next() calls */
! 2308: /* a back ward seek is done by a previous rewind() */
! 2309: if (pos < intern->current.pos) {
! 2310: spl_dual_it_rewind(intern TSRMLS_CC);
! 2311: }
! 2312: while (pos > intern->current.pos && spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 2313: spl_dual_it_next(intern, 1 TSRMLS_CC);
! 2314: }
! 2315: if (spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 2316: spl_dual_it_fetch(intern, 1 TSRMLS_CC);
! 2317: }
! 2318: }
! 2319: }
! 2320:
! 2321: /* {{{ proto LimitIterator::__construct(Iterator it [, int offset, int count])
! 2322: Construct a LimitIterator from an Iterator with a given starting offset and optionally a maximum count */
! 2323: SPL_METHOD(LimitIterator, __construct)
! 2324: {
! 2325: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_LimitIterator, zend_ce_iterator, DIT_LimitIterator);
! 2326: } /* }}} */
! 2327:
! 2328: /* {{{ proto void LimitIterator::rewind()
! 2329: Rewind the iterator to the specified starting offset */
! 2330: SPL_METHOD(LimitIterator, rewind)
! 2331: {
! 2332: spl_dual_it_object *intern;
! 2333:
! 2334: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2335: spl_dual_it_rewind(intern TSRMLS_CC);
! 2336: spl_limit_it_seek(intern, intern->u.limit.offset TSRMLS_CC);
! 2337: } /* }}} */
! 2338:
! 2339: /* {{{ proto bool LimitIterator::valid()
! 2340: Check whether the current element is valid */
! 2341: SPL_METHOD(LimitIterator, valid)
! 2342: {
! 2343: spl_dual_it_object *intern;
! 2344:
! 2345: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2346:
! 2347: /* RETURN_BOOL(spl_limit_it_valid(intern TSRMLS_CC) == SUCCESS);*/
! 2348: RETURN_BOOL((intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) && intern->current.data);
! 2349: } /* }}} */
! 2350:
! 2351: /* {{{ proto void LimitIterator::next()
! 2352: Move the iterator forward */
! 2353: SPL_METHOD(LimitIterator, next)
! 2354: {
! 2355: spl_dual_it_object *intern;
! 2356:
! 2357: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2358:
! 2359: spl_dual_it_next(intern, 1 TSRMLS_CC);
! 2360: if (intern->u.limit.count == -1 || intern->current.pos < intern->u.limit.offset + intern->u.limit.count) {
! 2361: spl_dual_it_fetch(intern, 1 TSRMLS_CC);
! 2362: }
! 2363: } /* }}} */
! 2364:
! 2365: /* {{{ proto void LimitIterator::seek(int position)
! 2366: Seek to the given position */
! 2367: SPL_METHOD(LimitIterator, seek)
! 2368: {
! 2369: spl_dual_it_object *intern;
! 2370: long pos;
! 2371:
! 2372: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &pos) == FAILURE) {
! 2373: return;
! 2374: }
! 2375:
! 2376: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2377: spl_limit_it_seek(intern, pos TSRMLS_CC);
! 2378: RETURN_LONG(intern->current.pos);
! 2379: } /* }}} */
! 2380:
! 2381: /* {{{ proto int LimitIterator::getPosition()
! 2382: Return the current position */
! 2383: SPL_METHOD(LimitIterator, getPosition)
! 2384: {
! 2385: spl_dual_it_object *intern;
! 2386: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2387: RETURN_LONG(intern->current.pos);
! 2388: } /* }}} */
! 2389:
! 2390: ZEND_BEGIN_ARG_INFO(arginfo_seekable_it_seek, 0)
! 2391: ZEND_ARG_INFO(0, position)
! 2392: ZEND_END_ARG_INFO();
! 2393:
! 2394: static const zend_function_entry spl_funcs_SeekableIterator[] = {
! 2395: SPL_ABSTRACT_ME(SeekableIterator, seek, arginfo_seekable_it_seek)
! 2396: PHP_FE_END
! 2397: };
! 2398:
! 2399: ZEND_BEGIN_ARG_INFO_EX(arginfo_limit_it___construct, 0, 0, 1)
! 2400: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 2401: ZEND_ARG_INFO(0, offset)
! 2402: ZEND_ARG_INFO(0, count)
! 2403: ZEND_END_ARG_INFO();
! 2404:
! 2405: ZEND_BEGIN_ARG_INFO(arginfo_limit_it_seek, 0)
! 2406: ZEND_ARG_INFO(0, position)
! 2407: ZEND_END_ARG_INFO();
! 2408:
! 2409: static const zend_function_entry spl_funcs_LimitIterator[] = {
! 2410: SPL_ME(LimitIterator, __construct, arginfo_limit_it___construct, ZEND_ACC_PUBLIC)
! 2411: SPL_ME(LimitIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2412: SPL_ME(LimitIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2413: SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2414: SPL_ME(dual_it, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2415: SPL_ME(LimitIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2416: SPL_ME(LimitIterator, seek, arginfo_limit_it_seek, ZEND_ACC_PUBLIC)
! 2417: SPL_ME(LimitIterator, getPosition, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2418: SPL_ME(dual_it, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2419: PHP_FE_END
! 2420: };
! 2421:
! 2422: static inline int spl_caching_it_valid(spl_dual_it_object *intern TSRMLS_DC)
! 2423: {
! 2424: return intern->u.caching.flags & CIT_VALID ? SUCCESS : FAILURE;
! 2425: }
! 2426:
! 2427: static inline int spl_caching_it_has_next(spl_dual_it_object *intern TSRMLS_DC)
! 2428: {
! 2429: return spl_dual_it_valid(intern TSRMLS_CC);
! 2430: }
! 2431:
! 2432: static inline void spl_caching_it_next(spl_dual_it_object *intern TSRMLS_DC)
! 2433: {
! 2434: if (spl_dual_it_fetch(intern, 1 TSRMLS_CC) == SUCCESS) {
! 2435: intern->u.caching.flags |= CIT_VALID;
! 2436: /* Full cache ? */
! 2437: if (intern->u.caching.flags & CIT_FULL_CACHE) {
! 2438: zval *zcacheval;
! 2439:
! 2440: MAKE_STD_ZVAL(zcacheval);
! 2441: ZVAL_ZVAL(zcacheval, intern->current.data, 1, 0);
! 2442: if (intern->current.key_type == HASH_KEY_IS_LONG) {
! 2443: add_index_zval(intern->u.caching.zcache, intern->current.int_key, zcacheval);
! 2444: } else {
! 2445: zend_symtable_update(HASH_OF(intern->u.caching.zcache), intern->current.str_key, intern->current.str_key_len, &zcacheval, sizeof(void*), NULL);
! 2446: }
! 2447: }
! 2448: /* Recursion ? */
! 2449: if (intern->dit_type == DIT_RecursiveCachingIterator) {
! 2450: zval *retval, *zchildren, zflags;
! 2451: zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "haschildren", &retval);
! 2452: if (EG(exception)) {
! 2453: if (retval) {
! 2454: zval_ptr_dtor(&retval);
! 2455: }
! 2456: if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
! 2457: zend_clear_exception(TSRMLS_C);
! 2458: } else {
! 2459: return;
! 2460: }
! 2461: } else {
! 2462: if (zend_is_true(retval)) {
! 2463: zend_call_method_with_0_params(&intern->inner.zobject, intern->inner.ce, NULL, "getchildren", &zchildren);
! 2464: if (EG(exception)) {
! 2465: if (zchildren) {
! 2466: zval_ptr_dtor(&zchildren);
! 2467: }
! 2468: if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
! 2469: zend_clear_exception(TSRMLS_C);
! 2470: } else {
! 2471: zval_ptr_dtor(&retval);
! 2472: return;
! 2473: }
! 2474: } else {
! 2475: INIT_PZVAL(&zflags);
! 2476: ZVAL_LONG(&zflags, intern->u.caching.flags & CIT_PUBLIC);
! 2477: spl_instantiate_arg_ex2(spl_ce_RecursiveCachingIterator, &intern->u.caching.zchildren, 1, zchildren, &zflags TSRMLS_CC);
! 2478: zval_ptr_dtor(&zchildren);
! 2479: }
! 2480: }
! 2481: zval_ptr_dtor(&retval);
! 2482: if (EG(exception)) {
! 2483: if (intern->u.caching.flags & CIT_CATCH_GET_CHILD) {
! 2484: zend_clear_exception(TSRMLS_C);
! 2485: } else {
! 2486: return;
! 2487: }
! 2488: }
! 2489: }
! 2490: }
! 2491: if (intern->u.caching.flags & (CIT_TOSTRING_USE_INNER|CIT_CALL_TOSTRING)) {
! 2492: int use_copy;
! 2493: zval expr_copy;
! 2494: ALLOC_ZVAL(intern->u.caching.zstr);
! 2495: if (intern->u.caching.flags & CIT_TOSTRING_USE_INNER) {
! 2496: *intern->u.caching.zstr = *intern->inner.zobject;
! 2497: } else {
! 2498: *intern->u.caching.zstr = *intern->current.data;
! 2499: }
! 2500: zend_make_printable_zval(intern->u.caching.zstr, &expr_copy, &use_copy);
! 2501: if (use_copy) {
! 2502: *intern->u.caching.zstr = expr_copy;
! 2503: INIT_PZVAL(intern->u.caching.zstr);
! 2504: zval_copy_ctor(intern->u.caching.zstr);
! 2505: zval_dtor(&expr_copy);
! 2506: } else {
! 2507: INIT_PZVAL(intern->u.caching.zstr);
! 2508: zval_copy_ctor(intern->u.caching.zstr);
! 2509: }
! 2510: }
! 2511: spl_dual_it_next(intern, 0 TSRMLS_CC);
! 2512: } else {
! 2513: intern->u.caching.flags &= ~CIT_VALID;
! 2514: }
! 2515: }
! 2516:
! 2517: static inline void spl_caching_it_rewind(spl_dual_it_object *intern TSRMLS_DC)
! 2518: {
! 2519: spl_dual_it_rewind(intern TSRMLS_CC);
! 2520: zend_hash_clean(HASH_OF(intern->u.caching.zcache));
! 2521: spl_caching_it_next(intern TSRMLS_CC);
! 2522: }
! 2523:
! 2524: /* {{{ proto void CachingIterator::__construct(Iterator it [, flags = CIT_CALL_TOSTRING])
! 2525: Construct a CachingIterator from an Iterator */
! 2526: SPL_METHOD(CachingIterator, __construct)
! 2527: {
! 2528: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_CachingIterator, zend_ce_iterator, DIT_CachingIterator);
! 2529: } /* }}} */
! 2530:
! 2531: /* {{{ proto void CachingIterator::rewind()
! 2532: Rewind the iterator */
! 2533: SPL_METHOD(CachingIterator, rewind)
! 2534: {
! 2535: spl_dual_it_object *intern;
! 2536:
! 2537: if (zend_parse_parameters_none() == FAILURE) {
! 2538: return;
! 2539: }
! 2540:
! 2541: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2542:
! 2543: spl_caching_it_rewind(intern TSRMLS_CC);
! 2544: } /* }}} */
! 2545:
! 2546: /* {{{ proto bool CachingIterator::valid()
! 2547: Check whether the current element is valid */
! 2548: SPL_METHOD(CachingIterator, valid)
! 2549: {
! 2550: spl_dual_it_object *intern;
! 2551:
! 2552: if (zend_parse_parameters_none() == FAILURE) {
! 2553: return;
! 2554: }
! 2555:
! 2556: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2557:
! 2558: RETURN_BOOL(spl_caching_it_valid(intern TSRMLS_CC) == SUCCESS);
! 2559: } /* }}} */
! 2560:
! 2561: /* {{{ proto void CachingIterator::next()
! 2562: Move the iterator forward */
! 2563: SPL_METHOD(CachingIterator, next)
! 2564: {
! 2565: spl_dual_it_object *intern;
! 2566:
! 2567: if (zend_parse_parameters_none() == FAILURE) {
! 2568: return;
! 2569: }
! 2570:
! 2571: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2572:
! 2573: spl_caching_it_next(intern TSRMLS_CC);
! 2574: } /* }}} */
! 2575:
! 2576: /* {{{ proto bool CachingIterator::hasNext()
! 2577: Check whether the inner iterator has a valid next element */
! 2578: SPL_METHOD(CachingIterator, hasNext)
! 2579: {
! 2580: spl_dual_it_object *intern;
! 2581:
! 2582: if (zend_parse_parameters_none() == FAILURE) {
! 2583: return;
! 2584: }
! 2585:
! 2586: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2587:
! 2588: RETURN_BOOL(spl_caching_it_has_next(intern TSRMLS_CC) == SUCCESS);
! 2589: } /* }}} */
! 2590:
! 2591: /* {{{ proto string CachingIterator::__toString()
! 2592: Return the string representation of the current element */
! 2593: SPL_METHOD(CachingIterator, __toString)
! 2594: {
! 2595: spl_dual_it_object *intern;
! 2596:
! 2597: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2598:
! 2599: if (!(intern->u.caching.flags & (CIT_CALL_TOSTRING|CIT_TOSTRING_USE_KEY|CIT_TOSTRING_USE_CURRENT|CIT_TOSTRING_USE_INNER))) {
! 2600: zend_throw_exception_ex(spl_ce_BadMethodCallException, 0 TSRMLS_CC, "%s does not fetch string value (see CachingIterator::__construct)", Z_OBJCE_P(getThis())->name);
! 2601: return;
! 2602: }
! 2603: if (intern->u.caching.flags & CIT_TOSTRING_USE_KEY) {
! 2604: if (intern->current.key_type == HASH_KEY_IS_STRING) {
! 2605: RETURN_STRINGL(intern->current.str_key, intern->current.str_key_len-1, 1);
! 2606: } else {
! 2607: RETVAL_LONG(intern->current.int_key);
! 2608: convert_to_string(return_value);
! 2609: return;
! 2610: }
! 2611: } else if (intern->u.caching.flags & CIT_TOSTRING_USE_CURRENT) {
! 2612: MAKE_COPY_ZVAL(&intern->current.data, return_value);
! 2613: convert_to_string(return_value);
! 2614: return;
! 2615: }
! 2616: if (intern->u.caching.zstr) {
! 2617: RETURN_STRINGL(Z_STRVAL_P(intern->u.caching.zstr), Z_STRLEN_P(intern->u.caching.zstr), 1);
! 2618: } else {
! 2619: RETURN_NULL();
! 2620: }
! 2621: } /* }}} */
! 2622:
! 2623: /* {{{ proto void CachingIterator::offsetSet(mixed index, mixed newval)
! 2624: Set given index in cache */
! 2625: SPL_METHOD(CachingIterator, offsetSet)
! 2626: {
! 2627: spl_dual_it_object *intern;
! 2628: char *arKey;
! 2629: uint nKeyLength;
! 2630: zval *value;
! 2631:
! 2632: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2633:
! 2634: if (!(intern->u.caching.flags & CIT_FULL_CACHE)) {
! 2635: 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);
! 2636: return;
! 2637: }
! 2638:
! 2639: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "sz", &arKey, &nKeyLength, &value) == FAILURE) {
! 2640: return;
! 2641: }
! 2642:
! 2643: Z_ADDREF_P(value);
! 2644: zend_symtable_update(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, &value, sizeof(value), NULL);
! 2645: }
! 2646: /* }}} */
! 2647:
! 2648: /* {{{ proto string CachingIterator::offsetGet(mixed index)
! 2649: Return the internal cache if used */
! 2650: SPL_METHOD(CachingIterator, offsetGet)
! 2651: {
! 2652: spl_dual_it_object *intern;
! 2653: char *arKey;
! 2654: uint nKeyLength;
! 2655: zval **value;
! 2656:
! 2657: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2658:
! 2659: if (!(intern->u.caching.flags & CIT_FULL_CACHE)) {
! 2660: 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);
! 2661: return;
! 2662: }
! 2663:
! 2664: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) {
! 2665: return;
! 2666: }
! 2667:
! 2668: if (zend_symtable_find(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1, (void**)&value) == FAILURE) {
! 2669: zend_error(E_NOTICE, "Undefined index: %s", arKey);
! 2670: return;
! 2671: }
! 2672:
! 2673: RETURN_ZVAL(*value, 1, 0);
! 2674: }
! 2675: /* }}} */
! 2676:
! 2677: /* {{{ proto void CachingIterator::offsetUnset(mixed index)
! 2678: Unset given index in cache */
! 2679: SPL_METHOD(CachingIterator, offsetUnset)
! 2680: {
! 2681: spl_dual_it_object *intern;
! 2682: char *arKey;
! 2683: uint nKeyLength;
! 2684:
! 2685: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2686:
! 2687: if (!(intern->u.caching.flags & CIT_FULL_CACHE)) {
! 2688: 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);
! 2689: return;
! 2690: }
! 2691:
! 2692: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) {
! 2693: return;
! 2694: }
! 2695:
! 2696: zend_symtable_del(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1);
! 2697: }
! 2698: /* }}} */
! 2699:
! 2700: /* {{{ proto bool CachingIterator::offsetExists(mixed index)
! 2701: Return whether the requested index exists */
! 2702: SPL_METHOD(CachingIterator, offsetExists)
! 2703: {
! 2704: spl_dual_it_object *intern;
! 2705: char *arKey;
! 2706: uint nKeyLength;
! 2707:
! 2708: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2709:
! 2710: if (!(intern->u.caching.flags & CIT_FULL_CACHE)) {
! 2711: 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);
! 2712: return;
! 2713: }
! 2714:
! 2715: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &arKey, &nKeyLength) == FAILURE) {
! 2716: return;
! 2717: }
! 2718:
! 2719: RETURN_BOOL(zend_symtable_exists(HASH_OF(intern->u.caching.zcache), arKey, nKeyLength+1));
! 2720: }
! 2721: /* }}} */
! 2722:
! 2723: /* {{{ proto bool CachingIterator::getCache()
! 2724: Return the cache */
! 2725: SPL_METHOD(CachingIterator, getCache)
! 2726: {
! 2727: spl_dual_it_object *intern;
! 2728:
! 2729: if (zend_parse_parameters_none() == FAILURE) {
! 2730: return;
! 2731: }
! 2732:
! 2733: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2734:
! 2735: if (!(intern->u.caching.flags & CIT_FULL_CACHE)) {
! 2736: 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);
! 2737: return;
! 2738: }
! 2739:
! 2740: RETURN_ZVAL(intern->u.caching.zcache, 1, 0);
! 2741: }
! 2742: /* }}} */
! 2743:
! 2744: /* {{{ proto int CachingIterator::getFlags()
! 2745: Return the internal flags */
! 2746: SPL_METHOD(CachingIterator, getFlags)
! 2747: {
! 2748: spl_dual_it_object *intern;
! 2749:
! 2750: if (zend_parse_parameters_none() == FAILURE) {
! 2751: return;
! 2752: }
! 2753:
! 2754: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2755:
! 2756: RETURN_LONG(intern->u.caching.flags);
! 2757: }
! 2758: /* }}} */
! 2759:
! 2760: /* {{{ proto void CachingIterator::setFlags(int flags)
! 2761: Set the internal flags */
! 2762: SPL_METHOD(CachingIterator, setFlags)
! 2763: {
! 2764: spl_dual_it_object *intern;
! 2765: long flags;
! 2766:
! 2767: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2768:
! 2769: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &flags) == FAILURE) {
! 2770: return;
! 2771: }
! 2772:
! 2773: if (spl_cit_check_flags(flags) != SUCCESS) {
! 2774: 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);
! 2775: return;
! 2776: }
! 2777: if ((intern->u.caching.flags & CIT_CALL_TOSTRING) != 0 && (flags & CIT_CALL_TOSTRING) == 0) {
! 2778: zend_throw_exception(spl_ce_InvalidArgumentException, "Unsetting flag CALL_TO_STRING is not possible", 0 TSRMLS_CC);
! 2779: return;
! 2780: }
! 2781: if ((intern->u.caching.flags & CIT_TOSTRING_USE_INNER) != 0 && (flags & CIT_TOSTRING_USE_INNER) == 0) {
! 2782: zend_throw_exception(spl_ce_InvalidArgumentException, "Unsetting flag TOSTRING_USE_INNER is not possible", 0 TSRMLS_CC);
! 2783: return;
! 2784: }
! 2785: if ((flags & CIT_FULL_CACHE) != 0 && (intern->u.caching.flags & CIT_FULL_CACHE) == 0) {
! 2786: /* clear on (re)enable */
! 2787: zend_hash_clean(HASH_OF(intern->u.caching.zcache));
! 2788: }
! 2789: intern->u.caching.flags = (intern->u.caching.flags & ~CIT_PUBLIC) | (flags & CIT_PUBLIC);
! 2790: }
! 2791: /* }}} */
! 2792:
! 2793: /* {{{ proto void CachingIterator::count()
! 2794: Number of cached elements */
! 2795: SPL_METHOD(CachingIterator, count)
! 2796: {
! 2797: spl_dual_it_object *intern;
! 2798:
! 2799: if (zend_parse_parameters_none() == FAILURE) {
! 2800: return;
! 2801: }
! 2802:
! 2803: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2804:
! 2805: if (!(intern->u.caching.flags & CIT_FULL_CACHE)) {
! 2806: 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);
! 2807: return;
! 2808: }
! 2809:
! 2810: RETURN_LONG(zend_hash_num_elements(HASH_OF(intern->u.caching.zcache)));
! 2811: }
! 2812: /* }}} */
! 2813:
! 2814: ZEND_BEGIN_ARG_INFO_EX(arginfo_caching_it___construct, 0, 0, 1)
! 2815: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 2816: ZEND_ARG_INFO(0, flags)
! 2817: ZEND_END_ARG_INFO();
! 2818:
! 2819: ZEND_BEGIN_ARG_INFO(arginfo_caching_it_setFlags, 0)
! 2820: ZEND_ARG_INFO(0, flags)
! 2821: ZEND_END_ARG_INFO();
! 2822:
! 2823: ZEND_BEGIN_ARG_INFO(arginfo_caching_it_offsetGet, 0)
! 2824: ZEND_ARG_INFO(0, index)
! 2825: ZEND_END_ARG_INFO();
! 2826:
! 2827: ZEND_BEGIN_ARG_INFO(arginfo_caching_it_offsetSet, 0)
! 2828: ZEND_ARG_INFO(0, index)
! 2829: ZEND_ARG_INFO(0, newval)
! 2830: ZEND_END_ARG_INFO();
! 2831:
! 2832: static const zend_function_entry spl_funcs_CachingIterator[] = {
! 2833: SPL_ME(CachingIterator, __construct, arginfo_caching_it___construct, ZEND_ACC_PUBLIC)
! 2834: SPL_ME(CachingIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2835: SPL_ME(CachingIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2836: SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2837: SPL_ME(dual_it, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2838: SPL_ME(CachingIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2839: SPL_ME(CachingIterator, hasNext, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2840: SPL_ME(CachingIterator, __toString, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2841: SPL_ME(dual_it, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2842: SPL_ME(CachingIterator, getFlags, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2843: SPL_ME(CachingIterator, setFlags, arginfo_caching_it_setFlags, ZEND_ACC_PUBLIC)
! 2844: SPL_ME(CachingIterator, offsetGet, arginfo_caching_it_offsetGet, ZEND_ACC_PUBLIC)
! 2845: SPL_ME(CachingIterator, offsetSet, arginfo_caching_it_offsetSet, ZEND_ACC_PUBLIC)
! 2846: SPL_ME(CachingIterator, offsetUnset, arginfo_caching_it_offsetGet, ZEND_ACC_PUBLIC)
! 2847: SPL_ME(CachingIterator, offsetExists, arginfo_caching_it_offsetGet, ZEND_ACC_PUBLIC)
! 2848: SPL_ME(CachingIterator, getCache, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2849: SPL_ME(CachingIterator, count, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2850: PHP_FE_END
! 2851: };
! 2852:
! 2853: /* {{{ proto void RecursiveCachingIterator::__construct(RecursiveIterator it [, flags = CIT_CALL_TOSTRING])
! 2854: Create an iterator from a RecursiveIterator */
! 2855: SPL_METHOD(RecursiveCachingIterator, __construct)
! 2856: {
! 2857: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_RecursiveCachingIterator, spl_ce_RecursiveIterator, DIT_RecursiveCachingIterator);
! 2858: } /* }}} */
! 2859:
! 2860: /* {{{ proto bool RecursiveCachingIterator::hasChildren()
! 2861: Check whether the current element of the inner iterator has children */
! 2862: SPL_METHOD(RecursiveCachingIterator, hasChildren)
! 2863: {
! 2864: spl_dual_it_object *intern;
! 2865:
! 2866: if (zend_parse_parameters_none() == FAILURE) {
! 2867: return;
! 2868: }
! 2869:
! 2870: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2871:
! 2872: RETURN_BOOL(intern->u.caching.zchildren);
! 2873: } /* }}} */
! 2874:
! 2875: /* {{{ proto RecursiveCachingIterator RecursiveCachingIterator::getChildren()
! 2876: Return the inner iterator's children as a RecursiveCachingIterator */
! 2877: SPL_METHOD(RecursiveCachingIterator, getChildren)
! 2878: {
! 2879: spl_dual_it_object *intern;
! 2880:
! 2881: if (zend_parse_parameters_none() == FAILURE) {
! 2882: return;
! 2883: }
! 2884:
! 2885: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2886:
! 2887: if (intern->u.caching.zchildren) {
! 2888: RETURN_ZVAL(intern->u.caching.zchildren, 1, 0);
! 2889: } else {
! 2890: RETURN_NULL();
! 2891: }
! 2892: } /* }}} */
! 2893:
! 2894: ZEND_BEGIN_ARG_INFO_EX(arginfo_caching_rec_it___construct, 0, ZEND_RETURN_VALUE, 1)
! 2895: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 2896: ZEND_ARG_INFO(0, flags)
! 2897: ZEND_END_ARG_INFO();
! 2898:
! 2899: static const zend_function_entry spl_funcs_RecursiveCachingIterator[] = {
! 2900: SPL_ME(RecursiveCachingIterator, __construct, arginfo_caching_rec_it___construct, ZEND_ACC_PUBLIC)
! 2901: SPL_ME(RecursiveCachingIterator, hasChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2902: SPL_ME(RecursiveCachingIterator, getChildren, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2903: PHP_FE_END
! 2904: };
! 2905:
! 2906: /* {{{ proto void IteratorIterator::__construct(Traversable it)
! 2907: Create an iterator from anything that is traversable */
! 2908: SPL_METHOD(IteratorIterator, __construct)
! 2909: {
! 2910: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_IteratorIterator, zend_ce_traversable, DIT_IteratorIterator);
! 2911: } /* }}} */
! 2912:
! 2913: ZEND_BEGIN_ARG_INFO(arginfo_iterator_it___construct, 0)
! 2914: ZEND_ARG_OBJ_INFO(0, iterator, Traversable, 0)
! 2915: ZEND_END_ARG_INFO();
! 2916:
! 2917: static const zend_function_entry spl_funcs_IteratorIterator[] = {
! 2918: SPL_ME(IteratorIterator, __construct, arginfo_iterator_it___construct, ZEND_ACC_PUBLIC)
! 2919: SPL_ME(dual_it, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2920: SPL_ME(dual_it, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2921: SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2922: SPL_ME(dual_it, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2923: SPL_ME(dual_it, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2924: SPL_ME(dual_it, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 2925: PHP_FE_END
! 2926: };
! 2927:
! 2928: /* {{{ proto void NoRewindIterator::__construct(Iterator it)
! 2929: Create an iterator from another iterator */
! 2930: SPL_METHOD(NoRewindIterator, __construct)
! 2931: {
! 2932: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_NoRewindIterator, zend_ce_iterator, DIT_NoRewindIterator);
! 2933: } /* }}} */
! 2934:
! 2935: /* {{{ proto void NoRewindIterator::rewind()
! 2936: Prevent a call to inner iterators rewind() */
! 2937: SPL_METHOD(NoRewindIterator, rewind)
! 2938: {
! 2939: if (zend_parse_parameters_none() == FAILURE) {
! 2940: return;
! 2941: }
! 2942: /* nothing to do */
! 2943: } /* }}} */
! 2944:
! 2945: /* {{{ proto bool NoRewindIterator::valid()
! 2946: Return inner iterators valid() */
! 2947: SPL_METHOD(NoRewindIterator, valid)
! 2948: {
! 2949: spl_dual_it_object *intern;
! 2950:
! 2951: if (zend_parse_parameters_none() == FAILURE) {
! 2952: return;
! 2953: }
! 2954:
! 2955: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2956: RETURN_BOOL(intern->inner.iterator->funcs->valid(intern->inner.iterator TSRMLS_CC) == SUCCESS);
! 2957: } /* }}} */
! 2958:
! 2959: /* {{{ proto mixed NoRewindIterator::key()
! 2960: Return inner iterators key() */
! 2961: SPL_METHOD(NoRewindIterator, key)
! 2962: {
! 2963: spl_dual_it_object *intern;
! 2964:
! 2965: if (zend_parse_parameters_none() == FAILURE) {
! 2966: return;
! 2967: }
! 2968:
! 2969: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 2970:
! 2971: if (intern->inner.iterator->funcs->get_current_key) {
! 2972: char *str_key;
! 2973: uint str_key_len;
! 2974: ulong int_key;
! 2975: switch (intern->inner.iterator->funcs->get_current_key(intern->inner.iterator, &str_key, &str_key_len, &int_key TSRMLS_CC)) {
! 2976: case HASH_KEY_IS_LONG:
! 2977: RETURN_LONG(int_key);
! 2978: break;
! 2979: case HASH_KEY_IS_STRING:
! 2980: RETURN_STRINGL(str_key, str_key_len-1, 0);
! 2981: break;
! 2982: default:
! 2983: RETURN_NULL();
! 2984: }
! 2985: } else {
! 2986: RETURN_NULL();
! 2987: }
! 2988: } /* }}} */
! 2989:
! 2990: /* {{{ proto mixed NoRewindIterator::current()
! 2991: Return inner iterators current() */
! 2992: SPL_METHOD(NoRewindIterator, current)
! 2993: {
! 2994: spl_dual_it_object *intern;
! 2995: zval **data;
! 2996:
! 2997: if (zend_parse_parameters_none() == FAILURE) {
! 2998: return;
! 2999: }
! 3000:
! 3001: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3002: intern->inner.iterator->funcs->get_current_data(intern->inner.iterator, &data TSRMLS_CC);
! 3003: if (data && *data) {
! 3004: RETURN_ZVAL(*data, 1, 0);
! 3005: }
! 3006: } /* }}} */
! 3007:
! 3008: /* {{{ proto void NoRewindIterator::next()
! 3009: Return inner iterators next() */
! 3010: SPL_METHOD(NoRewindIterator, next)
! 3011: {
! 3012: spl_dual_it_object *intern;
! 3013:
! 3014: if (zend_parse_parameters_none() == FAILURE) {
! 3015: return;
! 3016: }
! 3017:
! 3018: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3019: intern->inner.iterator->funcs->move_forward(intern->inner.iterator TSRMLS_CC);
! 3020: } /* }}} */
! 3021:
! 3022: ZEND_BEGIN_ARG_INFO(arginfo_norewind_it___construct, 0)
! 3023: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 3024: ZEND_END_ARG_INFO();
! 3025:
! 3026: static const zend_function_entry spl_funcs_NoRewindIterator[] = {
! 3027: SPL_ME(NoRewindIterator, __construct, arginfo_norewind_it___construct, ZEND_ACC_PUBLIC)
! 3028: SPL_ME(NoRewindIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3029: SPL_ME(NoRewindIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3030: SPL_ME(NoRewindIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3031: SPL_ME(NoRewindIterator, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3032: SPL_ME(NoRewindIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3033: SPL_ME(dual_it, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3034: PHP_FE_END
! 3035: };
! 3036:
! 3037: /* {{{ proto void InfiniteIterator::__construct(Iterator it)
! 3038: Create an iterator from another iterator */
! 3039: SPL_METHOD(InfiniteIterator, __construct)
! 3040: {
! 3041: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_InfiniteIterator, zend_ce_iterator, DIT_InfiniteIterator);
! 3042: } /* }}} */
! 3043:
! 3044: /* {{{ proto void InfiniteIterator::next()
! 3045: Prevent a call to inner iterators rewind() (internally the current data will be fetched if valid()) */
! 3046: SPL_METHOD(InfiniteIterator, next)
! 3047: {
! 3048: spl_dual_it_object *intern;
! 3049:
! 3050: if (zend_parse_parameters_none() == FAILURE) {
! 3051: return;
! 3052: }
! 3053:
! 3054: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3055:
! 3056: spl_dual_it_next(intern, 1 TSRMLS_CC);
! 3057: if (spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 3058: spl_dual_it_fetch(intern, 0 TSRMLS_CC);
! 3059: } else {
! 3060: spl_dual_it_rewind(intern TSRMLS_CC);
! 3061: if (spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 3062: spl_dual_it_fetch(intern, 0 TSRMLS_CC);
! 3063: }
! 3064: }
! 3065: } /* }}} */
! 3066:
! 3067: static const zend_function_entry spl_funcs_InfiniteIterator[] = {
! 3068: SPL_ME(InfiniteIterator, __construct, arginfo_norewind_it___construct, ZEND_ACC_PUBLIC)
! 3069: SPL_ME(InfiniteIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3070: PHP_FE_END
! 3071: };
! 3072:
! 3073: /* {{{ proto void EmptyIterator::rewind()
! 3074: Does nothing */
! 3075: SPL_METHOD(EmptyIterator, rewind)
! 3076: {
! 3077: if (zend_parse_parameters_none() == FAILURE) {
! 3078: return;
! 3079: }
! 3080: } /* }}} */
! 3081:
! 3082: /* {{{ proto false EmptyIterator::valid()
! 3083: Return false */
! 3084: SPL_METHOD(EmptyIterator, valid)
! 3085: {
! 3086: if (zend_parse_parameters_none() == FAILURE) {
! 3087: return;
! 3088: }
! 3089: RETURN_FALSE;
! 3090: } /* }}} */
! 3091:
! 3092: /* {{{ proto void EmptyIterator::key()
! 3093: Throws exception BadMethodCallException */
! 3094: SPL_METHOD(EmptyIterator, key)
! 3095: {
! 3096: if (zend_parse_parameters_none() == FAILURE) {
! 3097: return;
! 3098: }
! 3099: zend_throw_exception(spl_ce_BadMethodCallException, "Accessing the key of an EmptyIterator", 0 TSRMLS_CC);
! 3100: } /* }}} */
! 3101:
! 3102: /* {{{ proto void EmptyIterator::current()
! 3103: Throws exception BadMethodCallException */
! 3104: SPL_METHOD(EmptyIterator, current)
! 3105: {
! 3106: if (zend_parse_parameters_none() == FAILURE) {
! 3107: return;
! 3108: }
! 3109: zend_throw_exception(spl_ce_BadMethodCallException, "Accessing the value of an EmptyIterator", 0 TSRMLS_CC);
! 3110: } /* }}} */
! 3111:
! 3112: /* {{{ proto void EmptyIterator::next()
! 3113: Does nothing */
! 3114: SPL_METHOD(EmptyIterator, next)
! 3115: {
! 3116: if (zend_parse_parameters_none() == FAILURE) {
! 3117: return;
! 3118: }
! 3119: } /* }}} */
! 3120:
! 3121: static const zend_function_entry spl_funcs_EmptyIterator[] = {
! 3122: SPL_ME(EmptyIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3123: SPL_ME(EmptyIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3124: SPL_ME(EmptyIterator, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3125: SPL_ME(EmptyIterator, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3126: SPL_ME(EmptyIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3127: PHP_FE_END
! 3128: };
! 3129:
! 3130: int spl_append_it_next_iterator(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/
! 3131: {
! 3132: spl_dual_it_free(intern TSRMLS_CC);
! 3133:
! 3134: if (intern->inner.zobject) {
! 3135: zval_ptr_dtor(&intern->inner.zobject);
! 3136: intern->inner.zobject = NULL;
! 3137: intern->inner.ce = NULL;
! 3138: intern->inner.object = NULL;
! 3139: if (intern->inner.iterator) {
! 3140: intern->inner.iterator->funcs->dtor(intern->inner.iterator TSRMLS_CC);
! 3141: intern->inner.iterator = NULL;
! 3142: }
! 3143: }
! 3144: if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator TSRMLS_CC) == SUCCESS) {
! 3145: zval **it;
! 3146:
! 3147: intern->u.append.iterator->funcs->get_current_data(intern->u.append.iterator, &it TSRMLS_CC);
! 3148: Z_ADDREF_PP(it);
! 3149: intern->inner.zobject = *it;
! 3150: intern->inner.ce = Z_OBJCE_PP(it);
! 3151: intern->inner.object = zend_object_store_get_object(*it TSRMLS_CC);
! 3152: intern->inner.iterator = intern->inner.ce->get_iterator(intern->inner.ce, *it, 0 TSRMLS_CC);
! 3153: spl_dual_it_rewind(intern TSRMLS_CC);
! 3154: return SUCCESS;
! 3155: } else {
! 3156: return FAILURE;
! 3157: }
! 3158: } /* }}} */
! 3159:
! 3160: void spl_append_it_fetch(spl_dual_it_object *intern TSRMLS_DC) /* {{{*/
! 3161: {
! 3162: while (spl_dual_it_valid(intern TSRMLS_CC) != SUCCESS) {
! 3163: intern->u.append.iterator->funcs->move_forward(intern->u.append.iterator TSRMLS_CC);
! 3164: if (spl_append_it_next_iterator(intern TSRMLS_CC) != SUCCESS) {
! 3165: return;
! 3166: }
! 3167: }
! 3168: spl_dual_it_fetch(intern, 0 TSRMLS_CC);
! 3169: } /* }}} */
! 3170:
! 3171: void spl_append_it_next(spl_dual_it_object *intern TSRMLS_DC) /* {{{ */
! 3172: {
! 3173: if (spl_dual_it_valid(intern TSRMLS_CC) == SUCCESS) {
! 3174: spl_dual_it_next(intern, 1 TSRMLS_CC);
! 3175: }
! 3176: spl_append_it_fetch(intern TSRMLS_CC);
! 3177: } /* }}} */
! 3178:
! 3179: /* {{{ proto void AppendIterator::__construct()
! 3180: Create an AppendIterator */
! 3181: SPL_METHOD(AppendIterator, __construct)
! 3182: {
! 3183: spl_dual_it_construct(INTERNAL_FUNCTION_PARAM_PASSTHRU, spl_ce_AppendIterator, zend_ce_iterator, DIT_AppendIterator);
! 3184: } /* }}} */
! 3185:
! 3186: /* {{{ proto void AppendIterator::append(Iterator it)
! 3187: Append an iterator */
! 3188: SPL_METHOD(AppendIterator, append)
! 3189: {
! 3190: spl_dual_it_object *intern;
! 3191: zval *it;
! 3192:
! 3193: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3194:
! 3195: if (zend_parse_parameters_ex(ZEND_PARSE_PARAMS_QUIET, ZEND_NUM_ARGS() TSRMLS_CC, "O", &it, zend_ce_iterator) == FAILURE) {
! 3196: return;
! 3197: }
! 3198: spl_array_iterator_append(intern->u.append.zarrayit, it TSRMLS_CC);
! 3199:
! 3200: if (!intern->inner.iterator || spl_dual_it_valid(intern TSRMLS_CC) != SUCCESS) {
! 3201: if (intern->u.append.iterator->funcs->valid(intern->u.append.iterator TSRMLS_CC) != SUCCESS) {
! 3202: intern->u.append.iterator->funcs->rewind(intern->u.append.iterator TSRMLS_CC);
! 3203: }
! 3204: do {
! 3205: spl_append_it_next_iterator(intern TSRMLS_CC);
! 3206: } while (intern->inner.zobject != it);
! 3207: spl_append_it_fetch(intern TSRMLS_CC);
! 3208: }
! 3209: } /* }}} */
! 3210:
! 3211: /* {{{ proto void AppendIterator::rewind()
! 3212: Rewind to the first iterator and rewind the first iterator, too */
! 3213: SPL_METHOD(AppendIterator, rewind)
! 3214: {
! 3215: spl_dual_it_object *intern;
! 3216:
! 3217: if (zend_parse_parameters_none() == FAILURE) {
! 3218: return;
! 3219: }
! 3220:
! 3221: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3222:
! 3223: intern->u.append.iterator->funcs->rewind(intern->u.append.iterator TSRMLS_CC);
! 3224: if (spl_append_it_next_iterator(intern TSRMLS_CC) == SUCCESS) {
! 3225: spl_append_it_fetch(intern TSRMLS_CC);
! 3226: }
! 3227: } /* }}} */
! 3228:
! 3229: /* {{{ proto bool AppendIterator::valid()
! 3230: Check if the current state is valid */
! 3231: SPL_METHOD(AppendIterator, valid)
! 3232: {
! 3233: spl_dual_it_object *intern;
! 3234:
! 3235: if (zend_parse_parameters_none() == FAILURE) {
! 3236: return;
! 3237: }
! 3238:
! 3239: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3240:
! 3241: RETURN_BOOL(intern->current.data);
! 3242: } /* }}} */
! 3243:
! 3244: /* {{{ proto void AppendIterator::next()
! 3245: Forward to next element */
! 3246: SPL_METHOD(AppendIterator, next)
! 3247: {
! 3248: spl_dual_it_object *intern;
! 3249:
! 3250: if (zend_parse_parameters_none() == FAILURE) {
! 3251: return;
! 3252: }
! 3253:
! 3254: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3255:
! 3256: spl_append_it_next(intern TSRMLS_CC);
! 3257: } /* }}} */
! 3258:
! 3259: /* {{{ proto int AppendIterator::getIteratorIndex()
! 3260: Get index of iterator */
! 3261: SPL_METHOD(AppendIterator, getIteratorIndex)
! 3262: {
! 3263: spl_dual_it_object *intern;
! 3264:
! 3265: if (zend_parse_parameters_none() == FAILURE) {
! 3266: return;
! 3267: }
! 3268:
! 3269: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3270:
! 3271: APPENDIT_CHECK_CTOR(intern);
! 3272: spl_array_iterator_key(intern->u.append.zarrayit, return_value TSRMLS_CC);
! 3273: } /* }}} */
! 3274:
! 3275: /* {{{ proto ArrayIterator AppendIterator::getArrayIterator()
! 3276: Get access to inner ArrayIterator */
! 3277: SPL_METHOD(AppendIterator, getArrayIterator)
! 3278: {
! 3279: spl_dual_it_object *intern;
! 3280:
! 3281: if (zend_parse_parameters_none() == FAILURE) {
! 3282: return;
! 3283: }
! 3284:
! 3285: SPL_FETCH_AND_CHECK_DUAL_IT(intern, getThis());
! 3286:
! 3287: RETURN_ZVAL(intern->u.append.zarrayit, 1, 0);
! 3288: } /* }}} */
! 3289:
! 3290: ZEND_BEGIN_ARG_INFO(arginfo_append_it_append, 0)
! 3291: ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
! 3292: ZEND_END_ARG_INFO();
! 3293:
! 3294: static const zend_function_entry spl_funcs_AppendIterator[] = {
! 3295: SPL_ME(AppendIterator, __construct, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3296: SPL_ME(AppendIterator, append, arginfo_append_it_append, ZEND_ACC_PUBLIC)
! 3297: SPL_ME(AppendIterator, rewind, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3298: SPL_ME(AppendIterator, valid, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3299: SPL_ME(dual_it, key, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3300: SPL_ME(dual_it, current, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3301: SPL_ME(AppendIterator, next, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3302: SPL_ME(dual_it, getInnerIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3303: SPL_ME(AppendIterator, getIteratorIndex, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3304: SPL_ME(AppendIterator, getArrayIterator, arginfo_recursive_it_void, ZEND_ACC_PUBLIC)
! 3305: PHP_FE_END
! 3306: };
! 3307:
! 3308: PHPAPI int spl_iterator_apply(zval *obj, spl_iterator_apply_func_t apply_func, void *puser TSRMLS_DC)
! 3309: {
! 3310: zend_object_iterator *iter;
! 3311: zend_class_entry *ce = Z_OBJCE_P(obj);
! 3312:
! 3313: iter = ce->get_iterator(ce, obj, 0 TSRMLS_CC);
! 3314:
! 3315: if (EG(exception)) {
! 3316: goto done;
! 3317: }
! 3318:
! 3319: iter->index = 0;
! 3320: if (iter->funcs->rewind) {
! 3321: iter->funcs->rewind(iter TSRMLS_CC);
! 3322: if (EG(exception)) {
! 3323: goto done;
! 3324: }
! 3325: }
! 3326:
! 3327: while (iter->funcs->valid(iter TSRMLS_CC) == SUCCESS) {
! 3328: if (EG(exception)) {
! 3329: goto done;
! 3330: }
! 3331: if (apply_func(iter, puser TSRMLS_CC) == ZEND_HASH_APPLY_STOP || EG(exception)) {
! 3332: goto done;
! 3333: }
! 3334: iter->index++;
! 3335: iter->funcs->move_forward(iter TSRMLS_CC);
! 3336: if (EG(exception)) {
! 3337: goto done;
! 3338: }
! 3339: }
! 3340:
! 3341: done:
! 3342: if (iter) {
! 3343: iter->funcs->dtor(iter TSRMLS_CC);
! 3344: }
! 3345: return EG(exception) ? FAILURE : SUCCESS;
! 3346: }
! 3347: /* }}} */
! 3348:
! 3349: static int spl_iterator_to_array_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
! 3350: {
! 3351: zval **data, *return_value = (zval*)puser;
! 3352: char *str_key;
! 3353: uint str_key_len;
! 3354: ulong int_key;
! 3355: int key_type;
! 3356:
! 3357: iter->funcs->get_current_data(iter, &data TSRMLS_CC);
! 3358: if (EG(exception)) {
! 3359: return ZEND_HASH_APPLY_STOP;
! 3360: }
! 3361: if (data == NULL || *data == NULL) {
! 3362: return ZEND_HASH_APPLY_STOP;
! 3363: }
! 3364: if (iter->funcs->get_current_key) {
! 3365: key_type = iter->funcs->get_current_key(iter, &str_key, &str_key_len, &int_key TSRMLS_CC);
! 3366: if (EG(exception)) {
! 3367: return ZEND_HASH_APPLY_STOP;
! 3368: }
! 3369: Z_ADDREF_PP(data);
! 3370: switch(key_type) {
! 3371: case HASH_KEY_IS_STRING:
! 3372: add_assoc_zval_ex(return_value, str_key, str_key_len, *data);
! 3373: efree(str_key);
! 3374: break;
! 3375: case HASH_KEY_IS_LONG:
! 3376: add_index_zval(return_value, int_key, *data);
! 3377: break;
! 3378: }
! 3379: } else {
! 3380: Z_ADDREF_PP(data);
! 3381: add_next_index_zval(return_value, *data);
! 3382: }
! 3383: return ZEND_HASH_APPLY_KEEP;
! 3384: }
! 3385: /* }}} */
! 3386:
! 3387: static int spl_iterator_to_values_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
! 3388: {
! 3389: zval **data, *return_value = (zval*)puser;
! 3390:
! 3391: iter->funcs->get_current_data(iter, &data TSRMLS_CC);
! 3392: if (EG(exception)) {
! 3393: return ZEND_HASH_APPLY_STOP;
! 3394: }
! 3395: if (data == NULL || *data == NULL) {
! 3396: return ZEND_HASH_APPLY_STOP;
! 3397: }
! 3398: Z_ADDREF_PP(data);
! 3399: add_next_index_zval(return_value, *data);
! 3400: return ZEND_HASH_APPLY_KEEP;
! 3401: }
! 3402: /* }}} */
! 3403:
! 3404: /* {{{ proto array iterator_to_array(Traversable it [, bool use_keys = true])
! 3405: Copy the iterator into an array */
! 3406: PHP_FUNCTION(iterator_to_array)
! 3407: {
! 3408: zval *obj;
! 3409: zend_bool use_keys = 1;
! 3410:
! 3411: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|b", &obj, zend_ce_traversable, &use_keys) == FAILURE) {
! 3412: RETURN_FALSE;
! 3413: }
! 3414:
! 3415: array_init(return_value);
! 3416:
! 3417: if (spl_iterator_apply(obj, use_keys ? spl_iterator_to_array_apply : spl_iterator_to_values_apply, (void*)return_value TSRMLS_CC) != SUCCESS) {
! 3418: zval_dtor(return_value);
! 3419: RETURN_NULL();
! 3420: }
! 3421: } /* }}} */
! 3422:
! 3423: static int spl_iterator_count_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
! 3424: {
! 3425: (*(long*)puser)++;
! 3426: return ZEND_HASH_APPLY_KEEP;
! 3427: }
! 3428: /* }}} */
! 3429:
! 3430: /* {{{ proto int iterator_count(Traversable it)
! 3431: Count the elements in an iterator */
! 3432: PHP_FUNCTION(iterator_count)
! 3433: {
! 3434: zval *obj;
! 3435: long count = 0;
! 3436:
! 3437: if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, zend_ce_traversable) == FAILURE) {
! 3438: RETURN_FALSE;
! 3439: }
! 3440:
! 3441: if (spl_iterator_apply(obj, spl_iterator_count_apply, (void*)&count TSRMLS_CC) == SUCCESS) {
! 3442: RETURN_LONG(count);
! 3443: }
! 3444: }
! 3445: /* }}} */
! 3446:
! 3447: typedef struct {
! 3448: zval *obj;
! 3449: zval *args;
! 3450: long count;
! 3451: zend_fcall_info fci;
! 3452: zend_fcall_info_cache fcc;
! 3453: } spl_iterator_apply_info;
! 3454:
! 3455: static int spl_iterator_func_apply(zend_object_iterator *iter, void *puser TSRMLS_DC) /* {{{ */
! 3456: {
! 3457: zval *retval;
! 3458: spl_iterator_apply_info *apply_info = (spl_iterator_apply_info*)puser;
! 3459: int result;
! 3460:
! 3461: apply_info->count++;
! 3462: zend_fcall_info_call(&apply_info->fci, &apply_info->fcc, &retval, NULL TSRMLS_CC);
! 3463: if (retval) {
! 3464: result = zend_is_true(retval) ? ZEND_HASH_APPLY_KEEP : ZEND_HASH_APPLY_STOP;
! 3465: zval_ptr_dtor(&retval);
! 3466: } else {
! 3467: result = ZEND_HASH_APPLY_STOP;
! 3468: }
! 3469: return result;
! 3470: }
! 3471: /* }}} */
! 3472:
! 3473: /* {{{ proto int iterator_apply(Traversable it, mixed function [, mixed params])
! 3474: Calls a function for every element in an iterator */
! 3475: PHP_FUNCTION(iterator_apply)
! 3476: {
! 3477: spl_iterator_apply_info apply_info;
! 3478:
! 3479: apply_info.args = NULL;
! 3480: 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) {
! 3481: return;
! 3482: }
! 3483:
! 3484: apply_info.count = 0;
! 3485: zend_fcall_info_args(&apply_info.fci, apply_info.args TSRMLS_CC);
! 3486: if (spl_iterator_apply(apply_info.obj, spl_iterator_func_apply, (void*)&apply_info TSRMLS_CC) == SUCCESS) {
! 3487: RETVAL_LONG(apply_info.count);
! 3488: } else {
! 3489: RETVAL_FALSE;
! 3490: }
! 3491: zend_fcall_info_args(&apply_info.fci, NULL TSRMLS_CC);
! 3492: }
! 3493: /* }}} */
! 3494:
! 3495: static const zend_function_entry spl_funcs_OuterIterator[] = {
! 3496: SPL_ABSTRACT_ME(OuterIterator, getInnerIterator, arginfo_recursive_it_void)
! 3497: PHP_FE_END
! 3498: };
! 3499:
! 3500: static const zend_function_entry spl_funcs_Countable[] = {
! 3501: SPL_ABSTRACT_ME(Countable, count, arginfo_recursive_it_void)
! 3502: PHP_FE_END
! 3503: };
! 3504:
! 3505: /* {{{ PHP_MINIT_FUNCTION(spl_iterators)
! 3506: */
! 3507: PHP_MINIT_FUNCTION(spl_iterators)
! 3508: {
! 3509: REGISTER_SPL_INTERFACE(RecursiveIterator);
! 3510: REGISTER_SPL_ITERATOR(RecursiveIterator);
! 3511:
! 3512: REGISTER_SPL_STD_CLASS_EX(RecursiveIteratorIterator, spl_RecursiveIteratorIterator_new, spl_funcs_RecursiveIteratorIterator);
! 3513: REGISTER_SPL_ITERATOR(RecursiveIteratorIterator);
! 3514:
! 3515: memcpy(&spl_handlers_rec_it_it, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
! 3516: spl_handlers_rec_it_it.get_method = spl_recursive_it_get_method;
! 3517: spl_handlers_rec_it_it.clone_obj = NULL;
! 3518:
! 3519: memcpy(&spl_handlers_dual_it, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
! 3520: spl_handlers_dual_it.get_method = spl_dual_it_get_method;
! 3521: /*spl_handlers_dual_it.call_method = spl_dual_it_call_method;*/
! 3522: spl_handlers_dual_it.clone_obj = NULL;
! 3523:
! 3524: spl_ce_RecursiveIteratorIterator->get_iterator = spl_recursive_it_get_iterator;
! 3525: spl_ce_RecursiveIteratorIterator->iterator_funcs.funcs = &spl_recursive_it_iterator_funcs;
! 3526:
! 3527: REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "LEAVES_ONLY", RIT_LEAVES_ONLY);
! 3528: REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "SELF_FIRST", RIT_SELF_FIRST);
! 3529: REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "CHILD_FIRST", RIT_CHILD_FIRST);
! 3530: REGISTER_SPL_CLASS_CONST_LONG(RecursiveIteratorIterator, "CATCH_GET_CHILD", RIT_CATCH_GET_CHILD);
! 3531:
! 3532: REGISTER_SPL_INTERFACE(OuterIterator);
! 3533: REGISTER_SPL_ITERATOR(OuterIterator);
! 3534:
! 3535: REGISTER_SPL_STD_CLASS_EX(IteratorIterator, spl_dual_it_new, spl_funcs_IteratorIterator);
! 3536: REGISTER_SPL_ITERATOR(IteratorIterator);
! 3537: REGISTER_SPL_IMPLEMENTS(IteratorIterator, OuterIterator);
! 3538:
! 3539: REGISTER_SPL_SUB_CLASS_EX(FilterIterator, IteratorIterator, spl_dual_it_new, spl_funcs_FilterIterator);
! 3540: spl_ce_FilterIterator->ce_flags |= ZEND_ACC_EXPLICIT_ABSTRACT_CLASS;
! 3541:
! 3542: REGISTER_SPL_SUB_CLASS_EX(RecursiveFilterIterator, FilterIterator, spl_dual_it_new, spl_funcs_RecursiveFilterIterator);
! 3543: REGISTER_SPL_IMPLEMENTS(RecursiveFilterIterator, RecursiveIterator);
! 3544:
! 3545: REGISTER_SPL_SUB_CLASS_EX(ParentIterator, RecursiveFilterIterator, spl_dual_it_new, spl_funcs_ParentIterator);
! 3546:
! 3547: REGISTER_SPL_INTERFACE(Countable);
! 3548: REGISTER_SPL_INTERFACE(SeekableIterator);
! 3549: REGISTER_SPL_ITERATOR(SeekableIterator);
! 3550:
! 3551: REGISTER_SPL_SUB_CLASS_EX(LimitIterator, IteratorIterator, spl_dual_it_new, spl_funcs_LimitIterator);
! 3552:
! 3553: REGISTER_SPL_SUB_CLASS_EX(CachingIterator, IteratorIterator, spl_dual_it_new, spl_funcs_CachingIterator);
! 3554: REGISTER_SPL_IMPLEMENTS(CachingIterator, ArrayAccess);
! 3555: REGISTER_SPL_IMPLEMENTS(CachingIterator, Countable);
! 3556:
! 3557: REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CALL_TOSTRING", CIT_CALL_TOSTRING);
! 3558: REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "CATCH_GET_CHILD", CIT_CATCH_GET_CHILD);
! 3559: REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_KEY", CIT_TOSTRING_USE_KEY);
! 3560: REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_CURRENT", CIT_TOSTRING_USE_CURRENT);
! 3561: REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "TOSTRING_USE_INNER", CIT_TOSTRING_USE_INNER);
! 3562: REGISTER_SPL_CLASS_CONST_LONG(CachingIterator, "FULL_CACHE", CIT_FULL_CACHE);
! 3563:
! 3564: REGISTER_SPL_SUB_CLASS_EX(RecursiveCachingIterator, CachingIterator, spl_dual_it_new, spl_funcs_RecursiveCachingIterator);
! 3565: REGISTER_SPL_IMPLEMENTS(RecursiveCachingIterator, RecursiveIterator);
! 3566:
! 3567: REGISTER_SPL_SUB_CLASS_EX(NoRewindIterator, IteratorIterator, spl_dual_it_new, spl_funcs_NoRewindIterator);
! 3568:
! 3569: REGISTER_SPL_SUB_CLASS_EX(AppendIterator, IteratorIterator, spl_dual_it_new, spl_funcs_AppendIterator);
! 3570:
! 3571: REGISTER_SPL_IMPLEMENTS(RecursiveIteratorIterator, OuterIterator);
! 3572:
! 3573: REGISTER_SPL_SUB_CLASS_EX(InfiniteIterator, IteratorIterator, spl_dual_it_new, spl_funcs_InfiniteIterator);
! 3574: #if HAVE_PCRE || HAVE_BUNDLED_PCRE
! 3575: REGISTER_SPL_SUB_CLASS_EX(RegexIterator, FilterIterator, spl_dual_it_new, spl_funcs_RegexIterator);
! 3576: REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "USE_KEY", REGIT_USE_KEY);
! 3577: REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "MATCH", REGIT_MODE_MATCH);
! 3578: REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "GET_MATCH", REGIT_MODE_GET_MATCH);
! 3579: REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "ALL_MATCHES", REGIT_MODE_ALL_MATCHES);
! 3580: REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "SPLIT", REGIT_MODE_SPLIT);
! 3581: REGISTER_SPL_CLASS_CONST_LONG(RegexIterator, "REPLACE", REGIT_MODE_REPLACE);
! 3582: REGISTER_SPL_PROPERTY(RegexIterator, "replacement", 0);
! 3583: REGISTER_SPL_SUB_CLASS_EX(RecursiveRegexIterator, RegexIterator, spl_dual_it_new, spl_funcs_RecursiveRegexIterator);
! 3584: REGISTER_SPL_IMPLEMENTS(RecursiveRegexIterator, RecursiveIterator);
! 3585: #else
! 3586: spl_ce_RegexIterator = NULL;
! 3587: spl_ce_RecursiveRegexIterator = NULL;
! 3588: #endif
! 3589:
! 3590: REGISTER_SPL_STD_CLASS_EX(EmptyIterator, NULL, spl_funcs_EmptyIterator);
! 3591: REGISTER_SPL_ITERATOR(EmptyIterator);
! 3592:
! 3593: REGISTER_SPL_SUB_CLASS_EX(RecursiveTreeIterator, RecursiveIteratorIterator, spl_RecursiveTreeIterator_new, spl_funcs_RecursiveTreeIterator);
! 3594: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_CURRENT", RTIT_BYPASS_CURRENT);
! 3595: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "BYPASS_KEY", RTIT_BYPASS_KEY);
! 3596: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_LEFT", 0);
! 3597: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_MID_HAS_NEXT", 1);
! 3598: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_MID_LAST", 2);
! 3599: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_END_HAS_NEXT", 3);
! 3600: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_END_LAST", 4);
! 3601: REGISTER_SPL_CLASS_CONST_LONG(RecursiveTreeIterator, "PREFIX_RIGHT", 5);
! 3602:
! 3603: return SUCCESS;
! 3604: }
! 3605: /* }}} */
! 3606:
! 3607: /*
! 3608: * Local variables:
! 3609: * tab-width: 4
! 3610: * c-basic-offset: 4
! 3611: * End:
! 3612: * vim600: fdm=marker
! 3613: * vim: noet sw=4 ts=4
! 3614: */
FreeBSD-CVSweb <freebsd-cvsweb@FreeBSD.org>
![[BACK]](/icons/cvsweb/back.gif){kind=icon}
Return to spl_iterators.c CVS log ![[TXT]](/icons/cvsweb/text.gif){kind=icon}
![[DIR]](/icons/cvsweb/dir.gif){kind=icon}
Up to [ELWIX - Embedded LightWeight unIX -] / embedaddon / php / ext / spl