1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) Zend Technologies Ltd. (http://www.zend.com) |
6 +----------------------------------------------------------------------+
7 | This source file is subject to version 2.00 of the Zend 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.zend.com/license/2_00.txt. |
11 | If you did not receive a copy of the Zend license and are unable to |
12 | obtain it through the world-wide-web, please send a note to |
13 | license@zend.com so we can mail you a copy immediately. |
14 +----------------------------------------------------------------------+
15 | Authors: Marcus Boerger <helly@php.net> |
16 +----------------------------------------------------------------------+
17 */
18
19 #include "zend.h"
20 #include "zend_API.h"
21 #include "zend_interfaces.h"
22 #include "zend_exceptions.h"
23 #include "zend_interfaces_arginfo.h"
24
25 ZEND_API zend_class_entry *zend_ce_traversable;
26 ZEND_API zend_class_entry *zend_ce_aggregate;
27 ZEND_API zend_class_entry *zend_ce_iterator;
28 ZEND_API zend_class_entry *zend_ce_arrayaccess;
29 ZEND_API zend_class_entry *zend_ce_serializable;
30 ZEND_API zend_class_entry *zend_ce_countable;
31 ZEND_API zend_class_entry *zend_ce_stringable;
32 ZEND_API zend_class_entry *zend_ce_internal_iterator;
33
34 static zend_object_handlers zend_internal_iterator_handlers;
35
36 /* {{{ zend_call_method
37 Only returns the returned zval if retval_ptr != NULL */
zend_call_method(zend_object * object,zend_class_entry * obj_ce,zend_function ** fn_proxy,const char * function_name,size_t function_name_len,zval * retval_ptr,uint32_t param_count,zval * arg1,zval * arg2)38 ZEND_API zval* zend_call_method(zend_object *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval_ptr, uint32_t param_count, zval* arg1, zval* arg2)
39 {
40 zend_function *fn;
41 zend_class_entry *called_scope;
42 zval params[2];
43
44 if (param_count > 0) {
45 ZVAL_COPY_VALUE(¶ms[0], arg1);
46 }
47 if (param_count > 1) {
48 ZVAL_COPY_VALUE(¶ms[1], arg2);
49 }
50
51 if (!obj_ce) {
52 obj_ce = object ? object->ce : NULL;
53 }
54 if (!fn_proxy || !*fn_proxy) {
55 if (EXPECTED(obj_ce)) {
56 fn = zend_hash_str_find_ptr_lc(
57 &obj_ce->function_table, function_name, function_name_len);
58 if (UNEXPECTED(fn == NULL)) {
59 /* error at c-level */
60 zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s::%s", ZSTR_VAL(obj_ce->name), function_name);
61 }
62 } else {
63 fn = zend_fetch_function_str(function_name, function_name_len);
64 if (UNEXPECTED(fn == NULL)) {
65 /* error at c-level */
66 zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for function %s", function_name);
67 }
68 }
69 if (fn_proxy) {
70 *fn_proxy = fn;
71 }
72 } else {
73 fn = *fn_proxy;
74 }
75
76 if (object) {
77 called_scope = object->ce;
78 } else {
79 called_scope = obj_ce;
80 }
81
82 zend_call_known_function(fn, object, called_scope, retval_ptr, param_count, params, NULL);
83 return retval_ptr;
84 }
85 /* }}} */
86
87 /* iterator interface, c-level functions used by engine */
88
89 /* {{{ zend_user_it_new_iterator */
zend_user_it_new_iterator(zend_class_entry * ce,zval * object,zval * retval)90 ZEND_API void zend_user_it_new_iterator(zend_class_entry *ce, zval *object, zval *retval)
91 {
92 zend_call_known_instance_method_with_0_params(
93 ce->iterator_funcs_ptr->zf_new_iterator, Z_OBJ_P(object), retval);
94 }
95 /* }}} */
96
97 /* {{{ zend_user_it_invalidate_current */
zend_user_it_invalidate_current(zend_object_iterator * _iter)98 ZEND_API void zend_user_it_invalidate_current(zend_object_iterator *_iter)
99 {
100 zend_user_iterator *iter = (zend_user_iterator*)_iter;
101
102 if (!Z_ISUNDEF(iter->value)) {
103 zval_ptr_dtor(&iter->value);
104 ZVAL_UNDEF(&iter->value);
105 }
106 }
107 /* }}} */
108
109 /* {{{ zend_user_it_dtor */
zend_user_it_dtor(zend_object_iterator * _iter)110 static void zend_user_it_dtor(zend_object_iterator *_iter)
111 {
112 zend_user_iterator *iter = (zend_user_iterator*)_iter;
113 zval *object = &iter->it.data;
114
115 zend_user_it_invalidate_current(_iter);
116 zval_ptr_dtor(object);
117 }
118 /* }}} */
119
120 /* {{{ zend_user_it_valid */
zend_user_it_valid(zend_object_iterator * _iter)121 ZEND_API zend_result zend_user_it_valid(zend_object_iterator *_iter)
122 {
123 if (_iter) {
124 zend_user_iterator *iter = (zend_user_iterator*)_iter;
125 zval *object = &iter->it.data;
126 zval more;
127
128 zend_call_known_instance_method_with_0_params(iter->ce->iterator_funcs_ptr->zf_valid, Z_OBJ_P(object), &more);
129 bool result = i_zend_is_true(&more);
130 zval_ptr_dtor(&more);
131 return result ? SUCCESS : FAILURE;
132 }
133 return FAILURE;
134 }
135 /* }}} */
136
137 /* {{{ zend_user_it_get_current_data */
zend_user_it_get_current_data(zend_object_iterator * _iter)138 ZEND_API zval *zend_user_it_get_current_data(zend_object_iterator *_iter)
139 {
140 zend_user_iterator *iter = (zend_user_iterator*)_iter;
141 zval *object = &iter->it.data;
142
143 if (Z_ISUNDEF(iter->value)) {
144 zend_call_known_instance_method_with_0_params(iter->ce->iterator_funcs_ptr->zf_current, Z_OBJ_P(object), &iter->value);
145 }
146 return &iter->value;
147 }
148 /* }}} */
149
150 /* {{{ zend_user_it_get_current_key */
zend_user_it_get_current_key(zend_object_iterator * _iter,zval * key)151 ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key)
152 {
153 zend_user_iterator *iter = (zend_user_iterator*)_iter;
154 zval *object = &iter->it.data;
155 zend_call_known_instance_method_with_0_params(iter->ce->iterator_funcs_ptr->zf_key, Z_OBJ_P(object), key);
156 if (UNEXPECTED(Z_ISREF_P(key))) {
157 zend_unwrap_reference(key);
158 }
159 }
160 /* }}} */
161
162 /* {{{ zend_user_it_move_forward */
zend_user_it_move_forward(zend_object_iterator * _iter)163 ZEND_API void zend_user_it_move_forward(zend_object_iterator *_iter)
164 {
165 zend_user_iterator *iter = (zend_user_iterator*)_iter;
166 zval *object = &iter->it.data;
167
168 zend_user_it_invalidate_current(_iter);
169 zend_call_known_instance_method_with_0_params(iter->ce->iterator_funcs_ptr->zf_next, Z_OBJ_P(object), NULL);
170 }
171 /* }}} */
172
173 /* {{{ zend_user_it_rewind */
zend_user_it_rewind(zend_object_iterator * _iter)174 ZEND_API void zend_user_it_rewind(zend_object_iterator *_iter)
175 {
176 zend_user_iterator *iter = (zend_user_iterator*)_iter;
177 zval *object = &iter->it.data;
178
179 zend_user_it_invalidate_current(_iter);
180 zend_call_known_instance_method_with_0_params(iter->ce->iterator_funcs_ptr->zf_rewind, Z_OBJ_P(object), NULL);
181 }
182 /* }}} */
183
zend_user_it_get_gc(zend_object_iterator * _iter,zval ** table,int * n)184 ZEND_API HashTable *zend_user_it_get_gc(zend_object_iterator *_iter, zval **table, int *n)
185 {
186 zend_user_iterator *iter = (zend_user_iterator*)_iter;
187 if (Z_ISUNDEF(iter->value)) {
188 *table = &iter->it.data;
189 *n = 1;
190 } else {
191 zend_get_gc_buffer *gc_buffer = zend_get_gc_buffer_create();
192 zend_get_gc_buffer_add_zval(gc_buffer, &iter->it.data);
193 zend_get_gc_buffer_add_zval(gc_buffer, &iter->value);
194 zend_get_gc_buffer_use(gc_buffer, table, n);
195 }
196 return NULL;
197 }
198
199 static const zend_object_iterator_funcs zend_interface_iterator_funcs_iterator = {
200 zend_user_it_dtor,
201 // FIXME: Adjust the actual function prototype in zend_object_iterator_funcs
202 (int (*)(zend_object_iterator *)) zend_user_it_valid,
203 zend_user_it_get_current_data,
204 zend_user_it_get_current_key,
205 zend_user_it_move_forward,
206 zend_user_it_rewind,
207 zend_user_it_invalidate_current,
208 zend_user_it_get_gc,
209 };
210
211 /* {{{ zend_user_it_get_iterator */
212 /* by_ref is int due to Iterator API */
zend_user_it_get_iterator(zend_class_entry * ce,zval * object,int by_ref)213 static zend_object_iterator *zend_user_it_get_iterator(zend_class_entry *ce, zval *object, int by_ref)
214 {
215 zend_user_iterator *iterator;
216
217 if (by_ref) {
218 zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");
219 return NULL;
220 }
221
222 iterator = emalloc(sizeof(zend_user_iterator));
223
224 zend_iterator_init((zend_object_iterator*)iterator);
225
226 ZVAL_OBJ_COPY(&iterator->it.data, Z_OBJ_P(object));
227 iterator->it.funcs = &zend_interface_iterator_funcs_iterator;
228 iterator->ce = Z_OBJCE_P(object);
229 ZVAL_UNDEF(&iterator->value);
230 return (zend_object_iterator*)iterator;
231 }
232 /* }}} */
233
234 /* {{{ zend_user_it_get_new_iterator */
235 /* by_ref is int due to Iterator API */
zend_user_it_get_new_iterator(zend_class_entry * ce,zval * object,int by_ref)236 ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *ce, zval *object, int by_ref)
237 {
238 zval iterator;
239 zend_object_iterator *new_iterator;
240 zend_class_entry *ce_it;
241
242 zend_user_it_new_iterator(ce, object, &iterator);
243 ce_it = (Z_TYPE(iterator) == IS_OBJECT) ? Z_OBJCE(iterator) : NULL;
244
245 if (!ce_it || !ce_it->get_iterator || (ce_it->get_iterator == zend_user_it_get_new_iterator && Z_OBJ(iterator) == Z_OBJ_P(object))) {
246 if (!EG(exception)) {
247 zend_throw_exception_ex(NULL, 0, "Objects returned by %s::getIterator() must be traversable or implement interface Iterator", ce ? ZSTR_VAL(ce->name) : ZSTR_VAL(Z_OBJCE_P(object)->name));
248 }
249 zval_ptr_dtor(&iterator);
250 return NULL;
251 }
252
253 new_iterator = ce_it->get_iterator(ce_it, &iterator, by_ref);
254 zval_ptr_dtor(&iterator);
255 return new_iterator;
256 }
257 /* }}} */
258
259 /* {{{ zend_implement_traversable */
zend_implement_traversable(zend_class_entry * interface,zend_class_entry * class_type)260 static int zend_implement_traversable(zend_class_entry *interface, zend_class_entry *class_type)
261 {
262 /* Abstract class can implement Traversable only, in which case the extending class must
263 * implement Iterator or IteratorAggregate. */
264 if (class_type->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS) {
265 return SUCCESS;
266 }
267
268 /* Check that class_type implements at least one of 'IteratorAggregate' or 'Iterator' */
269 if (class_type->num_interfaces) {
270 ZEND_ASSERT(class_type->ce_flags & ZEND_ACC_RESOLVED_INTERFACES);
271 for (uint32_t i = 0; i < class_type->num_interfaces; i++) {
272 if (class_type->interfaces[i] == zend_ce_aggregate || class_type->interfaces[i] == zend_ce_iterator) {
273 return SUCCESS;
274 }
275 }
276 }
277 zend_error_noreturn(E_CORE_ERROR, "%s %s must implement interface %s as part of either %s or %s",
278 zend_get_object_type_uc(class_type),
279 ZSTR_VAL(class_type->name),
280 ZSTR_VAL(zend_ce_traversable->name),
281 ZSTR_VAL(zend_ce_iterator->name),
282 ZSTR_VAL(zend_ce_aggregate->name));
283 return FAILURE;
284 }
285 /* }}} */
286
287 /* {{{ zend_implement_aggregate */
zend_implement_aggregate(zend_class_entry * interface,zend_class_entry * class_type)288 static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entry *class_type)
289 {
290 if (zend_class_implements_interface(class_type, zend_ce_iterator)) {
291 zend_error_noreturn(E_ERROR,
292 "Class %s cannot implement both Iterator and IteratorAggregate at the same time",
293 ZSTR_VAL(class_type->name));
294 }
295
296 /* Always initialize iterator_funcs_ptr. */
297 ZEND_ASSERT(!class_type->iterator_funcs_ptr && "Iterator funcs already set?");
298 zend_class_iterator_funcs *funcs_ptr = class_type->type == ZEND_INTERNAL_CLASS
299 ? pemalloc(sizeof(zend_class_iterator_funcs), 1)
300 : zend_arena_alloc(&CG(arena), sizeof(zend_class_iterator_funcs));
301 class_type->iterator_funcs_ptr = funcs_ptr;
302
303 memset(funcs_ptr, 0, sizeof(zend_class_iterator_funcs));
304 funcs_ptr->zf_new_iterator = zend_hash_str_find_ptr(
305 &class_type->function_table, "getiterator", sizeof("getiterator") - 1);
306
307 if (class_type->get_iterator && class_type->get_iterator != zend_user_it_get_new_iterator) {
308 /* get_iterator was explicitly assigned for an internal class. */
309 if (!class_type->parent || class_type->parent->get_iterator != class_type->get_iterator) {
310 ZEND_ASSERT(class_type->type == ZEND_INTERNAL_CLASS);
311 return SUCCESS;
312 }
313
314 /* The getIterator() method has not been overwritten, use inherited get_iterator(). */
315 if (funcs_ptr->zf_new_iterator->common.scope != class_type) {
316 return SUCCESS;
317 }
318
319 /* getIterator() has been overwritten, switch to zend_user_it_get_new_iterator. */
320 }
321
322 class_type->get_iterator = zend_user_it_get_new_iterator;
323 return SUCCESS;
324 }
325 /* }}} */
326
327 /* {{{ zend_implement_iterator */
zend_implement_iterator(zend_class_entry * interface,zend_class_entry * class_type)328 static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry *class_type)
329 {
330 if (zend_class_implements_interface(class_type, zend_ce_aggregate)) {
331 zend_error_noreturn(E_ERROR,
332 "Class %s cannot implement both Iterator and IteratorAggregate at the same time",
333 ZSTR_VAL(class_type->name));
334 }
335
336 ZEND_ASSERT(!class_type->iterator_funcs_ptr && "Iterator funcs already set?");
337 zend_class_iterator_funcs *funcs_ptr = class_type->type == ZEND_INTERNAL_CLASS
338 ? pemalloc(sizeof(zend_class_iterator_funcs), 1)
339 : zend_arena_alloc(&CG(arena), sizeof(zend_class_iterator_funcs));
340 class_type->iterator_funcs_ptr = funcs_ptr;
341
342 memset(funcs_ptr, 0, sizeof(zend_class_iterator_funcs));
343 funcs_ptr->zf_rewind = zend_hash_str_find_ptr(
344 &class_type->function_table, "rewind", sizeof("rewind") - 1);
345 funcs_ptr->zf_valid = zend_hash_str_find_ptr(
346 &class_type->function_table, "valid", sizeof("valid") - 1);
347 funcs_ptr->zf_key = zend_hash_find_ptr(
348 &class_type->function_table, ZSTR_KNOWN(ZEND_STR_KEY));
349 funcs_ptr->zf_current = zend_hash_str_find_ptr(
350 &class_type->function_table, "current", sizeof("current") - 1);
351 funcs_ptr->zf_next = zend_hash_str_find_ptr(
352 &class_type->function_table, "next", sizeof("next") - 1);
353
354 if (class_type->get_iterator && class_type->get_iterator != zend_user_it_get_iterator) {
355 if (!class_type->parent || class_type->parent->get_iterator != class_type->get_iterator) {
356 /* get_iterator was explicitly assigned for an internal class. */
357 ZEND_ASSERT(class_type->type == ZEND_INTERNAL_CLASS);
358 return SUCCESS;
359 }
360
361 /* None of the Iterator methods have been overwritten, use inherited get_iterator(). */
362 if (funcs_ptr->zf_rewind->common.scope != class_type &&
363 funcs_ptr->zf_valid->common.scope != class_type &&
364 funcs_ptr->zf_key->common.scope != class_type &&
365 funcs_ptr->zf_current->common.scope != class_type &&
366 funcs_ptr->zf_next->common.scope != class_type) {
367 return SUCCESS;
368 }
369
370 /* One of the Iterator methods has been overwritten,
371 * switch to zend_user_it_get_iterator. */
372 }
373
374 class_type->get_iterator = zend_user_it_get_iterator;
375 return SUCCESS;
376 }
377 /* }}} */
378
379 /* {{{ zend_implement_arrayaccess */
zend_implement_arrayaccess(zend_class_entry * interface,zend_class_entry * class_type)380 static int zend_implement_arrayaccess(zend_class_entry *interface, zend_class_entry *class_type)
381 {
382 ZEND_ASSERT(!class_type->arrayaccess_funcs_ptr && "ArrayAccess funcs already set?");
383 zend_class_arrayaccess_funcs *funcs_ptr = class_type->type == ZEND_INTERNAL_CLASS
384 ? pemalloc(sizeof(zend_class_arrayaccess_funcs), 1)
385 : zend_arena_alloc(&CG(arena), sizeof(zend_class_arrayaccess_funcs));
386 class_type->arrayaccess_funcs_ptr = funcs_ptr;
387
388 funcs_ptr->zf_offsetget = zend_hash_str_find_ptr(
389 &class_type->function_table, "offsetget", sizeof("offsetget") - 1);
390 funcs_ptr->zf_offsetexists = zend_hash_str_find_ptr(
391 &class_type->function_table, "offsetexists", sizeof("offsetexists") - 1);
392 funcs_ptr->zf_offsetset = zend_hash_str_find_ptr(
393 &class_type->function_table, "offsetset", sizeof("offsetset") - 1);
394 funcs_ptr->zf_offsetunset = zend_hash_str_find_ptr(
395 &class_type->function_table, "offsetunset", sizeof("offsetunset") - 1);
396
397 return SUCCESS;
398 }
399 /* }}} */
400
401 /* {{{ zend_user_serialize */
zend_user_serialize(zval * object,unsigned char ** buffer,size_t * buf_len,zend_serialize_data * data)402 ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data)
403 {
404 zend_class_entry * ce = Z_OBJCE_P(object);
405 zval retval;
406 zend_result result;
407
408 zend_call_method_with_0_params(
409 Z_OBJ_P(object), Z_OBJCE_P(object), NULL, "serialize", &retval);
410
411 if (Z_TYPE(retval) == IS_UNDEF || EG(exception)) {
412 result = FAILURE;
413 } else {
414 switch(Z_TYPE(retval)) {
415 case IS_NULL:
416 /* we could also make this '*buf_len = 0' but this allows to skip variables */
417 zval_ptr_dtor(&retval);
418 return FAILURE;
419 case IS_STRING:
420 *buffer = (unsigned char*)estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
421 *buf_len = Z_STRLEN(retval);
422 result = SUCCESS;
423 break;
424 default: /* failure */
425 result = FAILURE;
426 break;
427 }
428 zval_ptr_dtor(&retval);
429 }
430
431 if (result == FAILURE && !EG(exception)) {
432 zend_throw_exception_ex(NULL, 0, "%s::serialize() must return a string or NULL", ZSTR_VAL(ce->name));
433 }
434 return result;
435 }
436 /* }}} */
437
438 /* {{{ zend_user_unserialize */
zend_user_unserialize(zval * object,zend_class_entry * ce,const unsigned char * buf,size_t buf_len,zend_unserialize_data * data)439 ZEND_API int zend_user_unserialize(zval *object, zend_class_entry *ce, const unsigned char *buf, size_t buf_len, zend_unserialize_data *data)
440 {
441 zval zdata;
442
443 if (UNEXPECTED(object_init_ex(object, ce) != SUCCESS)) {
444 return FAILURE;
445 }
446
447 ZVAL_STRINGL(&zdata, (char*)buf, buf_len);
448 zend_call_method_with_1_params(
449 Z_OBJ_P(object), Z_OBJCE_P(object), NULL, "unserialize", NULL, &zdata);
450 zval_ptr_dtor(&zdata);
451
452 if (EG(exception)) {
453 return FAILURE;
454 } else {
455 return SUCCESS;
456 }
457 }
458 /* }}} */
459
460 /* {{{ zend_implement_serializable */
zend_implement_serializable(zend_class_entry * interface,zend_class_entry * class_type)461 static int zend_implement_serializable(zend_class_entry *interface, zend_class_entry *class_type)
462 {
463 if (class_type->parent
464 && (class_type->parent->serialize || class_type->parent->unserialize)
465 && !zend_class_implements_interface(class_type->parent, zend_ce_serializable)) {
466 return FAILURE;
467 }
468 if (!class_type->serialize) {
469 class_type->serialize = zend_user_serialize;
470 }
471 if (!class_type->unserialize) {
472 class_type->unserialize = zend_user_unserialize;
473 }
474 if (!(class_type->ce_flags & ZEND_ACC_EXPLICIT_ABSTRACT_CLASS)
475 && (!class_type->__serialize || !class_type->__unserialize)) {
476 zend_error(E_DEPRECATED, "%s implements the Serializable interface, which is deprecated. Implement __serialize() and __unserialize() instead (or in addition, if support for old PHP versions is necessary)", ZSTR_VAL(class_type->name));
477 }
478 return SUCCESS;
479 }
480 /* }}}*/
481
482 typedef struct {
483 zend_object std;
484 zend_object_iterator *iter;
485 bool rewind_called;
486 } zend_internal_iterator;
487
zend_internal_iterator_create(zend_class_entry * ce)488 static zend_object *zend_internal_iterator_create(zend_class_entry *ce) {
489 zend_internal_iterator *intern = emalloc(sizeof(zend_internal_iterator));
490 zend_object_std_init(&intern->std, ce);
491 intern->iter = NULL;
492 intern->rewind_called = 0;
493 return &intern->std;
494 }
495
zend_create_internal_iterator_zval(zval * return_value,zval * obj)496 ZEND_API zend_result zend_create_internal_iterator_zval(zval *return_value, zval *obj) {
497 zend_class_entry *scope = EG(current_execute_data)->func->common.scope;
498 ZEND_ASSERT(scope->get_iterator != zend_user_it_get_new_iterator);
499 zend_object_iterator *iter = scope->get_iterator(Z_OBJCE_P(obj), obj, /* by_ref */ 0);
500 if (!iter) {
501 return FAILURE;
502 }
503
504 zend_internal_iterator *intern =
505 (zend_internal_iterator *) zend_internal_iterator_create(zend_ce_internal_iterator);
506 intern->iter = iter;
507 intern->iter->index = 0;
508 ZVAL_OBJ(return_value, &intern->std);
509 return SUCCESS;
510 }
511
zend_internal_iterator_free(zend_object * obj)512 static void zend_internal_iterator_free(zend_object *obj) {
513 zend_internal_iterator *intern = (zend_internal_iterator *) obj;
514 if (intern->iter) {
515 zend_iterator_dtor(intern->iter);
516 }
517 zend_object_std_dtor(&intern->std);
518 }
519
zend_internal_iterator_fetch(zval * This)520 static zend_internal_iterator *zend_internal_iterator_fetch(zval *This) {
521 zend_internal_iterator *intern = (zend_internal_iterator *) Z_OBJ_P(This);
522 if (!intern->iter) {
523 zend_throw_error(NULL, "The InternalIterator object has not been properly initialized");
524 return NULL;
525 }
526 return intern;
527 }
528
529 /* Many iterators will not behave correctly if rewind() is not called, make sure it happens. */
zend_internal_iterator_ensure_rewound(zend_internal_iterator * intern)530 static zend_result zend_internal_iterator_ensure_rewound(zend_internal_iterator *intern) {
531 if (!intern->rewind_called) {
532 zend_object_iterator *iter = intern->iter;
533 intern->rewind_called = 1;
534 if (iter->funcs->rewind) {
535 iter->funcs->rewind(iter);
536 if (UNEXPECTED(EG(exception))) {
537 return FAILURE;
538 }
539 }
540 }
541 return SUCCESS;
542 }
543
544
ZEND_METHOD(InternalIterator,__construct)545 ZEND_METHOD(InternalIterator, __construct) {
546 zend_throw_error(NULL, "Cannot manually construct InternalIterator");
547 }
548
ZEND_METHOD(InternalIterator,current)549 ZEND_METHOD(InternalIterator, current) {
550 ZEND_PARSE_PARAMETERS_NONE();
551
552 zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
553 if (!intern) {
554 RETURN_THROWS();
555 }
556
557 if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
558 RETURN_THROWS();
559 }
560
561 zval *data = intern->iter->funcs->get_current_data(intern->iter);
562 if (data) {
563 RETURN_COPY_DEREF(data);
564 }
565 }
566
ZEND_METHOD(InternalIterator,key)567 ZEND_METHOD(InternalIterator, key) {
568 ZEND_PARSE_PARAMETERS_NONE();
569
570 zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
571 if (!intern) {
572 RETURN_THROWS();
573 }
574
575 if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
576 RETURN_THROWS();
577 }
578
579 if (intern->iter->funcs->get_current_key) {
580 intern->iter->funcs->get_current_key(intern->iter, return_value);
581 } else {
582 RETURN_LONG(intern->iter->index);
583 }
584 }
585
ZEND_METHOD(InternalIterator,next)586 ZEND_METHOD(InternalIterator, next) {
587 ZEND_PARSE_PARAMETERS_NONE();
588
589 zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
590 if (!intern) {
591 RETURN_THROWS();
592 }
593
594 if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
595 RETURN_THROWS();
596 }
597
598 /* Advance index first to match foreach behavior. */
599 intern->iter->index++;
600 intern->iter->funcs->move_forward(intern->iter);
601 }
602
ZEND_METHOD(InternalIterator,valid)603 ZEND_METHOD(InternalIterator, valid) {
604 ZEND_PARSE_PARAMETERS_NONE();
605
606 zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
607 if (!intern) {
608 RETURN_THROWS();
609 }
610
611 if (zend_internal_iterator_ensure_rewound(intern) == FAILURE) {
612 RETURN_THROWS();
613 }
614
615 RETURN_BOOL(intern->iter->funcs->valid(intern->iter) == SUCCESS);
616 }
617
ZEND_METHOD(InternalIterator,rewind)618 ZEND_METHOD(InternalIterator, rewind) {
619 ZEND_PARSE_PARAMETERS_NONE();
620
621 zend_internal_iterator *intern = zend_internal_iterator_fetch(ZEND_THIS);
622 if (!intern) {
623 RETURN_THROWS();
624 }
625
626 intern->rewind_called = 1;
627 if (!intern->iter->funcs->rewind) {
628 /* Allow calling rewind() if no iteration has happened yet,
629 * even if the iterator does not support rewinding. */
630 if (intern->iter->index != 0) {
631 zend_throw_error(NULL, "Iterator does not support rewinding");
632 RETURN_THROWS();
633 }
634 intern->iter->index = 0;
635 return;
636 }
637
638 intern->iter->funcs->rewind(intern->iter);
639 intern->iter->index = 0;
640 }
641
642 /* {{{ zend_register_interfaces */
zend_register_interfaces(void)643 ZEND_API void zend_register_interfaces(void)
644 {
645 zend_ce_traversable = register_class_Traversable();
646 zend_ce_traversable->interface_gets_implemented = zend_implement_traversable;
647
648 zend_ce_aggregate = register_class_IteratorAggregate(zend_ce_traversable);
649 zend_ce_aggregate->interface_gets_implemented = zend_implement_aggregate;
650
651 zend_ce_iterator = register_class_Iterator(zend_ce_traversable);
652 zend_ce_iterator->interface_gets_implemented = zend_implement_iterator;
653
654 zend_ce_serializable = register_class_Serializable();
655 zend_ce_serializable->interface_gets_implemented = zend_implement_serializable;
656
657 zend_ce_arrayaccess = register_class_ArrayAccess();
658 zend_ce_arrayaccess->interface_gets_implemented = zend_implement_arrayaccess;
659
660 zend_ce_countable = register_class_Countable();
661
662 zend_ce_stringable = register_class_Stringable();
663
664 zend_ce_internal_iterator = register_class_InternalIterator(zend_ce_iterator);
665 zend_ce_internal_iterator->create_object = zend_internal_iterator_create;
666 zend_ce_internal_iterator->default_object_handlers = &zend_internal_iterator_handlers;
667
668 memcpy(&zend_internal_iterator_handlers, zend_get_std_object_handlers(),
669 sizeof(zend_object_handlers));
670 zend_internal_iterator_handlers.free_obj = zend_internal_iterator_free;
671 }
672 /* }}} */
673