1 /*
2 +----------------------------------------------------------------------+
3 | PHP Version 5 |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1997-2013 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 | Etienne Kneuss <colder@php.net> |
17 +----------------------------------------------------------------------+
18 */
19
20 /* $Id$ */
21
22 #ifdef HAVE_CONFIG_H
23 # include "config.h"
24 #endif
25
26 #include "php.h"
27 #include "php_ini.h"
28 #include "ext/standard/info.h"
29 #include "ext/standard/php_var.h"
30 #include "ext/standard/php_smart_str.h"
31 #include "zend_interfaces.h"
32 #include "zend_exceptions.h"
33
34 #include "php_spl.h"
35 #include "spl_functions.h"
36 #include "spl_engine.h"
37 #include "spl_observer.h"
38 #include "spl_iterators.h"
39 #include "spl_array.h"
40 #include "spl_exceptions.h"
41
42 SPL_METHOD(SplObserver, update);
43 SPL_METHOD(SplSubject, attach);
44 SPL_METHOD(SplSubject, detach);
45 SPL_METHOD(SplSubject, notify);
46
47 ZEND_BEGIN_ARG_INFO(arginfo_SplObserver_update, 0)
48 ZEND_ARG_OBJ_INFO(0, SplSubject, SplSubject, 0)
49 ZEND_END_ARG_INFO();
50
51 static const zend_function_entry spl_funcs_SplObserver[] = {
52 SPL_ABSTRACT_ME(SplObserver, update, arginfo_SplObserver_update)
53 {NULL, NULL, NULL}
54 };
55
56 ZEND_BEGIN_ARG_INFO(arginfo_SplSubject_attach, 0)
57 ZEND_ARG_OBJ_INFO(0, SplObserver, SplObserver, 0)
58 ZEND_END_ARG_INFO();
59
60 ZEND_BEGIN_ARG_INFO(arginfo_SplSubject_void, 0)
61 ZEND_END_ARG_INFO();
62
63 /*ZEND_BEGIN_ARG_INFO_EX(arginfo_SplSubject_notify, 0, 0, 1)
64 ZEND_ARG_OBJ_INFO(0, ignore, SplObserver, 1)
65 ZEND_END_ARG_INFO();*/
66
67 static const zend_function_entry spl_funcs_SplSubject[] = {
68 SPL_ABSTRACT_ME(SplSubject, attach, arginfo_SplSubject_attach)
69 SPL_ABSTRACT_ME(SplSubject, detach, arginfo_SplSubject_attach)
70 SPL_ABSTRACT_ME(SplSubject, notify, arginfo_SplSubject_void)
71 {NULL, NULL, NULL}
72 };
73
74 PHPAPI zend_class_entry *spl_ce_SplObserver;
75 PHPAPI zend_class_entry *spl_ce_SplSubject;
76 PHPAPI zend_class_entry *spl_ce_SplObjectStorage;
77 PHPAPI zend_class_entry *spl_ce_MultipleIterator;
78
79 PHPAPI zend_object_handlers spl_handler_SplObjectStorage;
80
81 typedef struct _spl_SplObjectStorage { /* {{{ */
82 zend_object std;
83 HashTable storage;
84 long index;
85 HashPosition pos;
86 long flags;
87 HashTable *debug_info;
88 } spl_SplObjectStorage; /* }}} */
89
90 /* {{{ storage is an assoc aray of [zend_object_value]=>[zval *obj, zval *inf] */
91 typedef struct _spl_SplObjectStorageElement {
92 zval* obj;
93 zval* inf;
94 } spl_SplObjectStorageElement; /* }}} */
95
spl_SplOjectStorage_free_storage(void * object TSRMLS_DC)96 void spl_SplOjectStorage_free_storage(void *object TSRMLS_DC) /* {{{ */
97 {
98 spl_SplObjectStorage *intern = (spl_SplObjectStorage *)object;
99
100 zend_object_std_dtor(&intern->std TSRMLS_CC);
101
102 zend_hash_destroy(&intern->storage);
103
104 if (intern->debug_info != NULL) {
105 zend_hash_destroy(intern->debug_info);
106 efree(intern->debug_info);
107 }
108
109 efree(object);
110 } /* }}} */
111
spl_object_storage_dtor(spl_SplObjectStorageElement * element)112 static void spl_object_storage_dtor(spl_SplObjectStorageElement *element) /* {{{ */
113 {
114 zval_ptr_dtor(&element->obj);
115 zval_ptr_dtor(&element->inf);
116 } /* }}} */
117
118
spl_object_storage_get(spl_SplObjectStorage * intern,zval * obj TSRMLS_DC)119 spl_SplObjectStorageElement* spl_object_storage_get(spl_SplObjectStorage *intern, zval *obj TSRMLS_DC) /* {{{ */
120 {
121 spl_SplObjectStorageElement *element;
122 zend_object_value *pzvalue;
123 #if HAVE_PACKED_OBJECT_VALUE
124 pzvalue = &Z_OBJVAL_P(obj);
125 #else
126 zend_object_value zvalue;
127 memset(&zvalue, 0, sizeof(zend_object_value));
128 zvalue.handle = Z_OBJ_HANDLE_P(obj);
129 zvalue.handlers = Z_OBJ_HT_P(obj);
130 pzvalue = &zvalue;
131 #endif
132 if (zend_hash_find(&intern->storage, (char*)pzvalue, sizeof(zend_object_value), (void**)&element) == SUCCESS) {
133 return element;
134 } else {
135 return NULL;
136 }
137 } /* }}} */
138
spl_object_storage_attach(spl_SplObjectStorage * intern,zval * obj,zval * inf TSRMLS_DC)139 void spl_object_storage_attach(spl_SplObjectStorage *intern, zval *obj, zval *inf TSRMLS_DC) /* {{{ */
140 {
141 spl_SplObjectStorageElement *pelement, element;
142 pelement = spl_object_storage_get(intern, obj TSRMLS_CC);
143 if (inf) {
144 Z_ADDREF_P(inf);
145 } else {
146 ALLOC_INIT_ZVAL(inf);
147 }
148 if (pelement) {
149 zval_ptr_dtor(&pelement->inf);
150 pelement->inf = inf;
151 return;
152 }
153 Z_ADDREF_P(obj);
154 element.obj = obj;
155 element.inf = inf;
156 #if HAVE_PACKED_OBJECT_VALUE
157 zend_hash_update(&intern->storage, (char*)&Z_OBJVAL_P(obj), sizeof(zend_object_value), &element, sizeof(spl_SplObjectStorageElement), NULL);
158 #else
159 {
160 zend_object_value zvalue;
161 memset(&zvalue, 0, sizeof(zend_object_value));
162 zvalue.handle = Z_OBJ_HANDLE_P(obj);
163 zvalue.handlers = Z_OBJ_HT_P(obj);
164 zend_hash_update(&intern->storage, (char*)&zvalue, sizeof(zend_object_value), &element, sizeof(spl_SplObjectStorageElement), NULL);
165 }
166 #endif
167 } /* }}} */
168
spl_object_storage_detach(spl_SplObjectStorage * intern,zval * obj TSRMLS_DC)169 int spl_object_storage_detach(spl_SplObjectStorage *intern, zval *obj TSRMLS_DC) /* {{{ */
170 {
171 #if HAVE_PACKED_OBJECT_VALUE
172 return zend_hash_del(&intern->storage, (char*)&Z_OBJVAL_P(obj), sizeof(zend_object_value));
173 #else
174 {
175 zend_object_value zvalue;
176 memset(&zvalue, 0, sizeof(zend_object_value));
177 zvalue.handle = Z_OBJ_HANDLE_P(obj);
178 zvalue.handlers = Z_OBJ_HT_P(obj);
179 return zend_hash_del(&intern->storage, (char*)&zvalue, sizeof(zend_object_value));
180 }
181 #endif
182 } /* }}}*/
183
spl_object_storage_addall(spl_SplObjectStorage * intern,spl_SplObjectStorage * other TSRMLS_DC)184 void spl_object_storage_addall(spl_SplObjectStorage *intern, spl_SplObjectStorage *other TSRMLS_DC) { /* {{{ */
185 HashPosition pos;
186 spl_SplObjectStorageElement *element;
187
188 zend_hash_internal_pointer_reset_ex(&other->storage, &pos);
189 while (zend_hash_get_current_data_ex(&other->storage, (void **)&element, &pos) == SUCCESS) {
190 spl_object_storage_attach(intern, element->obj, element->inf TSRMLS_CC);
191 zend_hash_move_forward_ex(&other->storage, &pos);
192 }
193
194 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
195 intern->index = 0;
196 } /* }}} */
197
spl_object_storage_new_ex(zend_class_entry * class_type,spl_SplObjectStorage ** obj,zval * orig TSRMLS_DC)198 static zend_object_value spl_object_storage_new_ex(zend_class_entry *class_type, spl_SplObjectStorage **obj, zval *orig TSRMLS_DC) /* {{{ */
199 {
200 zend_object_value retval;
201 spl_SplObjectStorage *intern;
202 zval *tmp;
203
204 intern = emalloc(sizeof(spl_SplObjectStorage));
205 memset(intern, 0, sizeof(spl_SplObjectStorage));
206 *obj = intern;
207
208 zend_object_std_init(&intern->std, class_type TSRMLS_CC);
209 zend_hash_copy(intern->std.properties, &class_type->default_properties, (copy_ctor_func_t) zval_property_ctor, (void *) &tmp, sizeof(zval *));
210
211 zend_hash_init(&intern->storage, 0, NULL, (void (*)(void *))spl_object_storage_dtor, 0);
212
213 retval.handle = zend_objects_store_put(intern, (zend_objects_store_dtor_t)zend_objects_destroy_object, (zend_objects_free_object_storage_t) spl_SplOjectStorage_free_storage, NULL TSRMLS_CC);
214 retval.handlers = &spl_handler_SplObjectStorage;
215
216 if (orig) {
217 spl_SplObjectStorage *other = (spl_SplObjectStorage*)zend_object_store_get_object(orig TSRMLS_CC);
218 spl_object_storage_addall(intern, other TSRMLS_CC);
219 }
220
221 return retval;
222 }
223 /* }}} */
224
225 /* {{{ spl_object_storage_clone */
spl_object_storage_clone(zval * zobject TSRMLS_DC)226 static zend_object_value spl_object_storage_clone(zval *zobject TSRMLS_DC)
227 {
228 zend_object_value new_obj_val;
229 zend_object *old_object;
230 zend_object *new_object;
231 zend_object_handle handle = Z_OBJ_HANDLE_P(zobject);
232 spl_SplObjectStorage *intern;
233
234 old_object = zend_objects_get_address(zobject TSRMLS_CC);
235 new_obj_val = spl_object_storage_new_ex(old_object->ce, &intern, zobject TSRMLS_CC);
236 new_object = &intern->std;
237
238 zend_objects_clone_members(new_object, new_obj_val, old_object, handle TSRMLS_CC);
239
240 return new_obj_val;
241 }
242 /* }}} */
243
spl_object_storage_debug_info(zval * obj,int * is_temp TSRMLS_DC)244 static HashTable* spl_object_storage_debug_info(zval *obj, int *is_temp TSRMLS_DC) /* {{{ */
245 {
246 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(obj TSRMLS_CC);
247 spl_SplObjectStorageElement *element;
248 HashTable *props;
249 HashPosition pos;
250 zval *tmp, *storage;
251 char md5str[33];
252 int name_len;
253 char *zname;
254
255 *is_temp = 0;
256
257 props = Z_OBJPROP_P(obj);
258 zend_hash_del(props, "\x00gcdata", sizeof("\x00gcdata"));
259
260 if (intern->debug_info == NULL) {
261 ALLOC_HASHTABLE(intern->debug_info);
262 ZEND_INIT_SYMTABLE_EX(intern->debug_info, zend_hash_num_elements(props) + 1, 0);
263 }
264
265 if (intern->debug_info->nApplyCount == 0) {
266 zend_hash_copy(intern->debug_info, props, (copy_ctor_func_t) zval_add_ref, (void *) &tmp, sizeof(zval *));
267
268 MAKE_STD_ZVAL(storage);
269 array_init(storage);
270
271 zend_hash_internal_pointer_reset_ex(&intern->storage, &pos);
272 while (zend_hash_get_current_data_ex(&intern->storage, (void **)&element, &pos) == SUCCESS) {
273 php_spl_object_hash(element->obj, md5str TSRMLS_CC);
274 MAKE_STD_ZVAL(tmp);
275 array_init(tmp);
276 /* Incrementing the refcount of obj and inf would confuse the garbage collector.
277 * Prefer to null the destructor */
278 Z_ARRVAL_P(tmp)->pDestructor = NULL;
279 add_assoc_zval_ex(tmp, "obj", sizeof("obj"), element->obj);
280 add_assoc_zval_ex(tmp, "inf", sizeof("inf"), element->inf);
281 add_assoc_zval_ex(storage, md5str, 33, tmp);
282 zend_hash_move_forward_ex(&intern->storage, &pos);
283 }
284
285 zname = spl_gen_private_prop_name(spl_ce_SplObjectStorage, "storage", sizeof("storage")-1, &name_len TSRMLS_CC);
286 zend_symtable_update(intern->debug_info, zname, name_len+1, &storage, sizeof(zval *), NULL);
287 efree(zname);
288 }
289
290 return intern->debug_info;
291 }
292 /* }}} */
293
294 /* overriden for garbage collection
295 * This is very hacky, but unfortunately the garbage collector can only query objects for
296 * dependencies through get_properties */
spl_object_storage_get_properties(zval * obj TSRMLS_DC)297 static HashTable *spl_object_storage_get_properties(zval *obj TSRMLS_DC) /* {{{ */
298 {
299 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(obj TSRMLS_CC);
300 spl_SplObjectStorageElement *element;
301 HashTable *props;
302 HashPosition pos;
303 zval *gcdata_arr = NULL,
304 **gcdata_arr_pp;
305
306 props = std_object_handlers.get_properties(obj TSRMLS_CC);
307
308 if (!GC_G(gc_active)) {
309 zend_hash_del(props, "\x00gcdata", sizeof("\x00gcdata"));
310 return props;
311 }
312
313 if (props->nApplyCount > 0) {
314 return props;
315 }
316
317 /* clean \x00gcdata, as it may be out of date */
318 if (zend_hash_find(props, "\x00gcdata", sizeof("\x00gcdata"), (void**) &gcdata_arr_pp) == SUCCESS) {
319 gcdata_arr = *gcdata_arr_pp;
320 zend_hash_clean(Z_ARRVAL_P(gcdata_arr));
321 }
322
323 if (gcdata_arr == NULL) {
324 MAKE_STD_ZVAL(gcdata_arr);
325 array_init(gcdata_arr);
326 /* don't decrease refcount of members when destroying */
327 Z_ARRVAL_P(gcdata_arr)->pDestructor = NULL;
328
329 /* name starts with \x00 to make tampering in user-land more difficult */
330 zend_hash_add(props, "\x00gcdata", sizeof("\x00gcdata"), &gcdata_arr, sizeof(gcdata_arr), NULL);
331 }
332
333 zend_hash_internal_pointer_reset_ex(&intern->storage, &pos);
334 while (zend_hash_get_current_data_ex(&intern->storage, (void **)&element, &pos) == SUCCESS) {
335 add_next_index_zval(gcdata_arr, element->obj);
336 add_next_index_zval(gcdata_arr, element->inf);
337 zend_hash_move_forward_ex(&intern->storage, &pos);
338 }
339
340 return props;
341 }
342 /* }}} */
343
spl_object_storage_compare_info(spl_SplObjectStorageElement * e1,spl_SplObjectStorageElement * e2 TSRMLS_DC)344 static int spl_object_storage_compare_info(spl_SplObjectStorageElement *e1, spl_SplObjectStorageElement *e2 TSRMLS_DC) /* {{{ */
345 {
346 zval result;
347
348 if (compare_function(&result, e1->inf, e2->inf TSRMLS_CC) == FAILURE) {
349 return 1;
350 }
351
352 return Z_LVAL(result);
353 }
354 /* }}} */
355
spl_object_storage_compare_objects(zval * o1,zval * o2 TSRMLS_DC)356 static int spl_object_storage_compare_objects(zval *o1, zval *o2 TSRMLS_DC) /* {{{ */
357 {
358 zend_object *zo1 = (zend_object *)zend_object_store_get_object(o1 TSRMLS_CC);
359 zend_object *zo2 = (zend_object *)zend_object_store_get_object(o2 TSRMLS_CC);
360
361 if (zo1->ce != spl_ce_SplObjectStorage || zo2->ce != spl_ce_SplObjectStorage) {
362 return 1;
363 }
364
365 return zend_hash_compare(&((spl_SplObjectStorage *)zo1)->storage, &((spl_SplObjectStorage *)zo2)->storage, (compare_func_t) spl_object_storage_compare_info, 0 TSRMLS_CC);
366 }
367 /* }}} */
368
369 /* {{{ spl_array_object_new */
spl_SplObjectStorage_new(zend_class_entry * class_type TSRMLS_DC)370 static zend_object_value spl_SplObjectStorage_new(zend_class_entry *class_type TSRMLS_DC)
371 {
372 spl_SplObjectStorage *tmp;
373 return spl_object_storage_new_ex(class_type, &tmp, NULL TSRMLS_CC);
374 }
375 /* }}} */
376
spl_object_storage_contains(spl_SplObjectStorage * intern,zval * obj TSRMLS_DC)377 int spl_object_storage_contains(spl_SplObjectStorage *intern, zval *obj TSRMLS_DC) /* {{{ */
378 {
379 #if HAVE_PACKED_OBJECT_VALUE
380 return zend_hash_exists(&intern->storage, (char*)&Z_OBJVAL_P(obj), sizeof(zend_object_value));
381 #else
382 {
383 zend_object_value zvalue;
384 memset(&zvalue, 0, sizeof(zend_object_value));
385 zvalue.handle = Z_OBJ_HANDLE_P(obj);
386 zvalue.handlers = Z_OBJ_HT_P(obj);
387 return zend_hash_exists(&intern->storage, (char*)&zvalue, sizeof(zend_object_value));
388 }
389 #endif
390 } /* }}} */
391
392 /* {{{ proto void SplObjectStorage::attach($obj, $inf = NULL)
393 Attaches an object to the storage if not yet contained */
SPL_METHOD(SplObjectStorage,attach)394 SPL_METHOD(SplObjectStorage, attach)
395 {
396 zval *obj, *inf = NULL;
397
398 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
399
400 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o|z!", &obj, &inf) == FAILURE) {
401 return;
402 }
403 spl_object_storage_attach(intern, obj, inf TSRMLS_CC);
404 } /* }}} */
405
406 /* {{{ proto void SplObjectStorage::detach($obj)
407 Detaches an object from the storage */
SPL_METHOD(SplObjectStorage,detach)408 SPL_METHOD(SplObjectStorage, detach)
409 {
410 zval *obj;
411 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
412
413 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
414 return;
415 }
416 spl_object_storage_detach(intern, obj TSRMLS_CC);
417
418 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
419 intern->index = 0;
420 } /* }}} */
421
422 /* {{{ proto mixed SplObjectStorage::offsetGet($object)
423 Returns associated information for a stored object */
SPL_METHOD(SplObjectStorage,offsetGet)424 SPL_METHOD(SplObjectStorage, offsetGet)
425 {
426 zval *obj;
427 spl_SplObjectStorageElement *element;
428 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
429
430 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
431 return;
432 }
433 element = spl_object_storage_get(intern, obj TSRMLS_CC);
434 if (!element) {
435 zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Object not found");
436 } else {
437 RETURN_ZVAL(element->inf,1, 0);
438 }
439 } /* }}} */
440
441 /* {{{ proto bool SplObjectStorage::addAll(SplObjectStorage $os)
442 Add all elements contained in $os */
SPL_METHOD(SplObjectStorage,addAll)443 SPL_METHOD(SplObjectStorage, addAll)
444 {
445 zval *obj;
446 spl_SplObjectStorage *intern = (spl_SplObjectStorage *)zend_object_store_get_object(getThis() TSRMLS_CC);
447 spl_SplObjectStorage *other;
448
449 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
450 return;
451 }
452
453 other = (spl_SplObjectStorage *)zend_object_store_get_object(obj TSRMLS_CC);
454
455 spl_object_storage_addall(intern, other TSRMLS_CC);
456
457 RETURN_LONG(zend_hash_num_elements(&intern->storage));
458 } /* }}} */
459
460 /* {{{ proto bool SplObjectStorage::removeAll(SplObjectStorage $os)
461 Remove all elements contained in $os */
SPL_METHOD(SplObjectStorage,removeAll)462 SPL_METHOD(SplObjectStorage, removeAll)
463 {
464 zval *obj;
465 spl_SplObjectStorage *intern = (spl_SplObjectStorage *)zend_object_store_get_object(getThis() TSRMLS_CC);
466 spl_SplObjectStorage *other;
467 spl_SplObjectStorageElement *element;
468
469 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
470 return;
471 }
472
473 other = (spl_SplObjectStorage *)zend_object_store_get_object(obj TSRMLS_CC);
474
475 zend_hash_internal_pointer_reset(&other->storage);
476 while (zend_hash_get_current_data(&other->storage, (void **)&element) == SUCCESS) {
477 if (spl_object_storage_detach(intern, element->obj TSRMLS_CC) == FAILURE) {
478 zend_hash_move_forward(&other->storage);
479 }
480 }
481
482 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
483 intern->index = 0;
484
485 RETURN_LONG(zend_hash_num_elements(&intern->storage));
486 } /* }}} */
487
488 /* {{{ proto bool SplObjectStorage::removeAllExcept(SplObjectStorage $os)
489 Remove elements not common to both this SplObjectStorage instance and $os */
SPL_METHOD(SplObjectStorage,removeAllExcept)490 SPL_METHOD(SplObjectStorage, removeAllExcept)
491 {
492 zval *obj;
493 spl_SplObjectStorage *intern = (spl_SplObjectStorage *)zend_object_store_get_object(getThis() TSRMLS_CC);
494 spl_SplObjectStorage *other;
495 spl_SplObjectStorageElement *element;
496
497 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O", &obj, spl_ce_SplObjectStorage) == FAILURE) {
498 return;
499 }
500
501 other = (spl_SplObjectStorage *)zend_object_store_get_object(obj TSRMLS_CC);
502
503 zend_hash_internal_pointer_reset(&intern->storage);
504 while (zend_hash_get_current_data(&intern->storage, (void **)&element) == SUCCESS) {
505 if (!spl_object_storage_contains(other, element->obj TSRMLS_CC)) {
506 spl_object_storage_detach(intern, element->obj TSRMLS_CC);
507 }
508 zend_hash_move_forward(&intern->storage);
509 }
510
511 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
512 intern->index = 0;
513
514 RETURN_LONG(zend_hash_num_elements(&intern->storage));
515 }
516 /* }}} */
517
518 /* {{{ proto bool SplObjectStorage::contains($obj)
519 Determine whethe an object is contained in the storage */
SPL_METHOD(SplObjectStorage,contains)520 SPL_METHOD(SplObjectStorage, contains)
521 {
522 zval *obj;
523 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
524
525 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "o", &obj) == FAILURE) {
526 return;
527 }
528 RETURN_BOOL(spl_object_storage_contains(intern, obj TSRMLS_CC));
529 } /* }}} */
530
531 /* {{{ proto int SplObjectStorage::count()
532 Determine number of objects in storage */
SPL_METHOD(SplObjectStorage,count)533 SPL_METHOD(SplObjectStorage, count)
534 {
535 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
536
537 if (zend_parse_parameters_none() == FAILURE) {
538 return;
539 }
540
541 RETURN_LONG(zend_hash_num_elements(&intern->storage));
542 } /* }}} */
543
544 /* {{{ proto void SplObjectStorage::rewind()
545 Rewind to first position */
SPL_METHOD(SplObjectStorage,rewind)546 SPL_METHOD(SplObjectStorage, rewind)
547 {
548 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
549
550 if (zend_parse_parameters_none() == FAILURE) {
551 return;
552 }
553
554 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
555 intern->index = 0;
556 } /* }}} */
557
558 /* {{{ proto bool SplObjectStorage::valid()
559 Returns whether current position is valid */
SPL_METHOD(SplObjectStorage,valid)560 SPL_METHOD(SplObjectStorage, valid)
561 {
562 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
563
564 if (zend_parse_parameters_none() == FAILURE) {
565 return;
566 }
567
568 RETURN_BOOL(zend_hash_has_more_elements_ex(&intern->storage, &intern->pos) == SUCCESS);
569 } /* }}} */
570
571 /* {{{ proto mixed SplObjectStorage::key()
572 Returns current key */
SPL_METHOD(SplObjectStorage,key)573 SPL_METHOD(SplObjectStorage, key)
574 {
575 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
576
577 if (zend_parse_parameters_none() == FAILURE) {
578 return;
579 }
580
581 RETURN_LONG(intern->index);
582 } /* }}} */
583
584 /* {{{ proto mixed SplObjectStorage::current()
585 Returns current element */
SPL_METHOD(SplObjectStorage,current)586 SPL_METHOD(SplObjectStorage, current)
587 {
588 spl_SplObjectStorageElement *element;
589 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
590
591 if (zend_parse_parameters_none() == FAILURE) {
592 return;
593 }
594
595 if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == FAILURE) {
596 return;
597 }
598 RETVAL_ZVAL(element->obj, 1, 0);
599 } /* }}} */
600
601 /* {{{ proto mixed SplObjectStorage::getInfo()
602 Returns associated information to current element */
SPL_METHOD(SplObjectStorage,getInfo)603 SPL_METHOD(SplObjectStorage, getInfo)
604 {
605 spl_SplObjectStorageElement *element;
606 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
607
608 if (zend_parse_parameters_none() == FAILURE) {
609 return;
610 }
611
612 if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == FAILURE) {
613 return;
614 }
615 RETVAL_ZVAL(element->inf, 1, 0);
616 } /* }}} */
617
618 /* {{{ proto mixed SplObjectStorage::setInfo(mixed $inf)
619 Sets associated information of current element to $inf */
SPL_METHOD(SplObjectStorage,setInfo)620 SPL_METHOD(SplObjectStorage, setInfo)
621 {
622 spl_SplObjectStorageElement *element;
623 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
624 zval *inf;
625
626 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &inf) == FAILURE) {
627 return;
628 }
629
630 if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == FAILURE) {
631 return;
632 }
633 zval_ptr_dtor(&element->inf);
634 element->inf = inf;
635 Z_ADDREF_P(inf);
636 } /* }}} */
637
638 /* {{{ proto void SplObjectStorage::next()
639 Moves position forward */
SPL_METHOD(SplObjectStorage,next)640 SPL_METHOD(SplObjectStorage, next)
641 {
642 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
643
644 if (zend_parse_parameters_none() == FAILURE) {
645 return;
646 }
647
648 zend_hash_move_forward_ex(&intern->storage, &intern->pos);
649 intern->index++;
650 } /* }}} */
651
652 /* {{{ proto string SplObjectStorage::serialize()
653 Serializes storage */
SPL_METHOD(SplObjectStorage,serialize)654 SPL_METHOD(SplObjectStorage, serialize)
655 {
656 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
657
658 spl_SplObjectStorageElement *element;
659 zval members, *pmembers;
660 HashPosition pos;
661 php_serialize_data_t var_hash;
662 smart_str buf = {0};
663
664 if (zend_parse_parameters_none() == FAILURE) {
665 return;
666 }
667
668 PHP_VAR_SERIALIZE_INIT(var_hash);
669
670 /* storage */
671 smart_str_appendl(&buf, "x:i:", 4);
672 smart_str_append_long(&buf, zend_hash_num_elements(&intern->storage));
673 smart_str_appendc(&buf, ';');
674
675 zend_hash_internal_pointer_reset_ex(&intern->storage, &pos);
676
677 while(zend_hash_has_more_elements_ex(&intern->storage, &pos) == SUCCESS) {
678 if (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &pos) == FAILURE) {
679 smart_str_free(&buf);
680 PHP_VAR_SERIALIZE_DESTROY(var_hash);
681 RETURN_NULL();
682 }
683 php_var_serialize(&buf, &element->obj, &var_hash TSRMLS_CC);
684 smart_str_appendc(&buf, ',');
685 php_var_serialize(&buf, &element->inf, &var_hash TSRMLS_CC);
686 smart_str_appendc(&buf, ';');
687 zend_hash_move_forward_ex(&intern->storage, &pos);
688 }
689
690 /* members */
691 smart_str_appendl(&buf, "m:", 2);
692 INIT_PZVAL(&members);
693 Z_ARRVAL(members) = intern->std.properties;
694 Z_TYPE(members) = IS_ARRAY;
695 pmembers = &members;
696 php_var_serialize(&buf, &pmembers, &var_hash TSRMLS_CC); /* finishes the string */
697
698 /* done */
699 PHP_VAR_SERIALIZE_DESTROY(var_hash);
700
701 if (buf.c) {
702 RETURN_STRINGL(buf.c, buf.len, 0);
703 } else {
704 RETURN_NULL();
705 }
706
707 } /* }}} */
708
709 /* {{{ proto void SplObjectStorage::unserialize(string serialized)
710 Unserializes storage */
SPL_METHOD(SplObjectStorage,unserialize)711 SPL_METHOD(SplObjectStorage, unserialize)
712 {
713 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
714
715 char *buf;
716 int buf_len;
717 const unsigned char *p, *s;
718 php_unserialize_data_t var_hash;
719 zval *pentry, *pmembers, *pcount = NULL, *pinf;
720 long count;
721
722 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "s", &buf, &buf_len) == FAILURE) {
723 return;
724 }
725
726 if (buf_len == 0) {
727 zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Empty serialized string cannot be empty");
728 return;
729 }
730
731 /* storage */
732 s = p = (const unsigned char*)buf;
733 PHP_VAR_UNSERIALIZE_INIT(var_hash);
734
735 if (*p!= 'x' || *++p != ':') {
736 goto outexcept;
737 }
738 ++p;
739
740 ALLOC_INIT_ZVAL(pcount);
741 if (!php_var_unserialize(&pcount, &p, s + buf_len, NULL TSRMLS_CC) || Z_TYPE_P(pcount) != IS_LONG) {
742 zval_ptr_dtor(&pcount);
743 goto outexcept;
744 }
745
746 --p; /* for ';' */
747 count = Z_LVAL_P(pcount);
748 zval_ptr_dtor(&pcount);
749
750 while(count-- > 0) {
751 spl_SplObjectStorageElement *pelement;
752
753 if (*p != ';') {
754 goto outexcept;
755 }
756 ++p;
757 if(*p != 'O' && *p != 'C' && *p != 'r') {
758 goto outexcept;
759 }
760 ALLOC_INIT_ZVAL(pentry);
761 if (!php_var_unserialize(&pentry, &p, s + buf_len, &var_hash TSRMLS_CC)) {
762 zval_ptr_dtor(&pentry);
763 goto outexcept;
764 }
765 if(Z_TYPE_P(pentry) != IS_OBJECT) {
766 zval_ptr_dtor(&pentry);
767 goto outexcept;
768 }
769 ALLOC_INIT_ZVAL(pinf);
770 if (*p == ',') { /* new version has inf */
771 ++p;
772 if (!php_var_unserialize(&pinf, &p, s + buf_len, &var_hash TSRMLS_CC)) {
773 zval_ptr_dtor(&pinf);
774 goto outexcept;
775 }
776 }
777
778 pelement = spl_object_storage_get(intern, pentry TSRMLS_CC);
779 if(pelement) {
780 if(pelement->inf) {
781 var_push_dtor(&var_hash, &pelement->inf);
782 }
783 if(pelement->obj) {
784 var_push_dtor(&var_hash, &pelement->obj);
785 }
786 }
787 spl_object_storage_attach(intern, pentry, pinf TSRMLS_CC);
788 zval_ptr_dtor(&pentry);
789 zval_ptr_dtor(&pinf);
790 }
791
792 if (*p != ';') {
793 goto outexcept;
794 }
795 ++p;
796
797 /* members */
798 if (*p!= 'm' || *++p != ':') {
799 goto outexcept;
800 }
801 ++p;
802
803 ALLOC_INIT_ZVAL(pmembers);
804 if (!php_var_unserialize(&pmembers, &p, s + buf_len, &var_hash TSRMLS_CC) || Z_TYPE_P(pmembers) != IS_ARRAY) {
805 zval_ptr_dtor(&pmembers);
806 goto outexcept;
807 }
808
809 /* copy members */
810 zend_hash_copy(intern->std.properties, Z_ARRVAL_P(pmembers), (copy_ctor_func_t) zval_add_ref, (void *) NULL, sizeof(zval *));
811 zval_ptr_dtor(&pmembers);
812
813 /* done reading $serialized */
814
815 PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
816 return;
817
818 outexcept:
819 PHP_VAR_UNSERIALIZE_DESTROY(var_hash);
820 zend_throw_exception_ex(spl_ce_UnexpectedValueException, 0 TSRMLS_CC, "Error at offset %ld of %d bytes", (long)((char*)p - buf), buf_len);
821 return;
822
823 } /* }}} */
824
825 ZEND_BEGIN_ARG_INFO(arginfo_Object, 0)
826 ZEND_ARG_INFO(0, object)
827 ZEND_END_ARG_INFO();
828
829 ZEND_BEGIN_ARG_INFO_EX(arginfo_attach, 0, 0, 1)
830 ZEND_ARG_INFO(0, object)
831 ZEND_ARG_INFO(0, inf)
832 ZEND_END_ARG_INFO();
833
834 ZEND_BEGIN_ARG_INFO(arginfo_Serialized, 0)
835 ZEND_ARG_INFO(0, serialized)
836 ZEND_END_ARG_INFO();
837
838 ZEND_BEGIN_ARG_INFO(arginfo_setInfo, 0)
839 ZEND_ARG_INFO(0, info)
840 ZEND_END_ARG_INFO();
841
842 ZEND_BEGIN_ARG_INFO_EX(arginfo_offsetGet, 0, 0, 1)
843 ZEND_ARG_INFO(0, object)
844 ZEND_END_ARG_INFO()
845
846 ZEND_BEGIN_ARG_INFO(arginfo_splobject_void, 0)
847 ZEND_END_ARG_INFO()
848
849 static const zend_function_entry spl_funcs_SplObjectStorage[] = {
850 SPL_ME(SplObjectStorage, attach, arginfo_attach, 0)
851 SPL_ME(SplObjectStorage, detach, arginfo_Object, 0)
852 SPL_ME(SplObjectStorage, contains, arginfo_Object, 0)
853 SPL_ME(SplObjectStorage, addAll, arginfo_Object, 0)
854 SPL_ME(SplObjectStorage, removeAll, arginfo_Object, 0)
855 SPL_ME(SplObjectStorage, removeAllExcept, arginfo_Object, 0)
856 SPL_ME(SplObjectStorage, getInfo, arginfo_splobject_void,0)
857 SPL_ME(SplObjectStorage, setInfo, arginfo_setInfo, 0)
858 /* Countable */
859 SPL_ME(SplObjectStorage, count, arginfo_splobject_void,0)
860 /* Iterator */
861 SPL_ME(SplObjectStorage, rewind, arginfo_splobject_void,0)
862 SPL_ME(SplObjectStorage, valid, arginfo_splobject_void,0)
863 SPL_ME(SplObjectStorage, key, arginfo_splobject_void,0)
864 SPL_ME(SplObjectStorage, current, arginfo_splobject_void,0)
865 SPL_ME(SplObjectStorage, next, arginfo_splobject_void,0)
866 /* Serializable */
867 SPL_ME(SplObjectStorage, unserialize, arginfo_Serialized, 0)
868 SPL_ME(SplObjectStorage, serialize, arginfo_splobject_void,0)
869 /* ArrayAccess */
870 SPL_MA(SplObjectStorage, offsetExists, SplObjectStorage, contains, arginfo_offsetGet, 0)
871 SPL_MA(SplObjectStorage, offsetSet, SplObjectStorage, attach, arginfo_attach, 0)
872 SPL_MA(SplObjectStorage, offsetUnset, SplObjectStorage, detach, arginfo_offsetGet, 0)
873 SPL_ME(SplObjectStorage, offsetGet, arginfo_offsetGet, 0)
874 {NULL, NULL, NULL}
875 };
876
877 typedef enum {
878 MIT_NEED_ANY = 0,
879 MIT_NEED_ALL = 1,
880 MIT_KEYS_NUMERIC = 0,
881 MIT_KEYS_ASSOC = 2
882 } MultipleIteratorFlags;
883
884 #define SPL_MULTIPLE_ITERATOR_GET_ALL_CURRENT 1
885 #define SPL_MULTIPLE_ITERATOR_GET_ALL_KEY 2
886
887 /* {{{ proto void MultipleIterator::__construct([int flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC])
888 Iterator that iterates over several iterators one after the other */
SPL_METHOD(MultipleIterator,__construct)889 SPL_METHOD(MultipleIterator, __construct)
890 {
891 spl_SplObjectStorage *intern;
892 long flags = MIT_NEED_ALL|MIT_KEYS_NUMERIC;
893 zend_error_handling error_handling;
894
895 zend_replace_error_handling(EH_THROW, spl_ce_InvalidArgumentException, &error_handling TSRMLS_CC);
896
897 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "|l", &flags) == FAILURE) {
898 zend_restore_error_handling(&error_handling TSRMLS_CC);
899 return;
900 }
901
902 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
903 intern->flags = flags;
904 zend_restore_error_handling(&error_handling TSRMLS_CC);
905 }
906 /* }}} */
907
908 /* {{{ proto int MultipleIterator::getFlags()
909 Return current flags */
SPL_METHOD(MultipleIterator,getFlags)910 SPL_METHOD(MultipleIterator, getFlags)
911 {
912 spl_SplObjectStorage *intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
913
914 if (zend_parse_parameters_none() == FAILURE) {
915 return;
916 }
917 RETURN_LONG(intern->flags);
918 }
919 /* }}} */
920
921 /* {{{ proto int MultipleIterator::setFlags(int flags)
922 Set flags */
SPL_METHOD(MultipleIterator,setFlags)923 SPL_METHOD(MultipleIterator, setFlags)
924 {
925 spl_SplObjectStorage *intern;
926 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
927
928 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "l", &intern->flags) == FAILURE) {
929 return;
930 }
931 }
932 /* }}} */
933
934 /* {{{ proto void attachIterator(Iterator iterator[, mixed info]) throws InvalidArgumentException
935 Attach a new iterator */
SPL_METHOD(MultipleIterator,attachIterator)936 SPL_METHOD(MultipleIterator, attachIterator)
937 {
938 spl_SplObjectStorage *intern;
939 zval *iterator = NULL, *info = NULL;
940
941 if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "O|z!", &iterator, zend_ce_iterator, &info) == FAILURE) {
942 return;
943 }
944
945 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
946
947 if (info != NULL) {
948 spl_SplObjectStorageElement *element;
949 zval compare_result;
950
951 if (Z_TYPE_P(info) != IS_LONG && Z_TYPE_P(info) != IS_STRING) {
952 zend_throw_exception(spl_ce_InvalidArgumentException, "Info must be NULL, integer or string", 0 TSRMLS_CC);
953 return;
954 }
955
956 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
957 while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS) {
958 is_identical_function(&compare_result, info, element->inf TSRMLS_CC);
959 if (Z_LVAL(compare_result)) {
960 zend_throw_exception(spl_ce_InvalidArgumentException, "Key duplication error", 0 TSRMLS_CC);
961 return;
962 }
963 zend_hash_move_forward_ex(&intern->storage, &intern->pos);
964 }
965 }
966
967 spl_object_storage_attach(intern, iterator, info TSRMLS_CC);
968 }
969 /* }}} */
970
971 /* {{{ proto void MultipleIterator::rewind()
972 Rewind all attached iterator instances */
SPL_METHOD(MultipleIterator,rewind)973 SPL_METHOD(MultipleIterator, rewind)
974 {
975 spl_SplObjectStorage *intern;
976 spl_SplObjectStorageElement *element;
977 zval *it;
978
979 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
980
981 if (zend_parse_parameters_none() == FAILURE) {
982 return;
983 }
984
985 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
986 while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
987 it = element->obj;
988 zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_rewind, "rewind", NULL);
989 zend_hash_move_forward_ex(&intern->storage, &intern->pos);
990 }
991 }
992 /* }}} */
993
994 /* {{{ proto void MultipleIterator::next()
995 Move all attached iterator instances forward */
SPL_METHOD(MultipleIterator,next)996 SPL_METHOD(MultipleIterator, next)
997 {
998 spl_SplObjectStorage *intern;
999 spl_SplObjectStorageElement *element;
1000 zval *it;
1001
1002 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
1003
1004 if (zend_parse_parameters_none() == FAILURE) {
1005 return;
1006 }
1007
1008 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
1009 while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
1010 it = element->obj;
1011 zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_next, "next", NULL);
1012 zend_hash_move_forward_ex(&intern->storage, &intern->pos);
1013 }
1014 }
1015 /* }}} */
1016
1017 /* {{{ proto bool MultipleIterator::valid()
1018 Return whether all or one sub iterator is valid depending on flags */
SPL_METHOD(MultipleIterator,valid)1019 SPL_METHOD(MultipleIterator, valid)
1020 {
1021 spl_SplObjectStorage *intern;
1022 spl_SplObjectStorageElement *element;
1023 zval *it, *retval = NULL;
1024 long expect, valid;
1025
1026 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
1027
1028 if (zend_parse_parameters_none() == FAILURE) {
1029 return;
1030 }
1031
1032 if (!zend_hash_num_elements(&intern->storage)) {
1033 RETURN_FALSE;
1034 }
1035
1036 expect = (intern->flags & MIT_NEED_ALL) ? 1 : 0;
1037
1038 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
1039 while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
1040 it = element->obj;
1041 zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
1042
1043 if (retval) {
1044 valid = Z_LVAL_P(retval);
1045 zval_ptr_dtor(&retval);
1046 } else {
1047 valid = 0;
1048 }
1049
1050 if (expect != valid) {
1051 RETURN_BOOL(!expect);
1052 }
1053
1054 zend_hash_move_forward_ex(&intern->storage, &intern->pos);
1055 }
1056
1057 RETURN_BOOL(expect);
1058 }
1059 /* }}} */
1060
spl_multiple_iterator_get_all(spl_SplObjectStorage * intern,int get_type,zval * return_value TSRMLS_DC)1061 static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_type, zval *return_value TSRMLS_DC) /* {{{ */
1062 {
1063 spl_SplObjectStorageElement *element;
1064 zval *it, *retval = NULL;
1065 int valid = 1, num_elements;
1066
1067 num_elements = zend_hash_num_elements(&intern->storage);
1068 if (num_elements < 1) {
1069 RETURN_FALSE;
1070 }
1071
1072 array_init_size(return_value, num_elements);
1073
1074 zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
1075 while (zend_hash_get_current_data_ex(&intern->storage, (void**)&element, &intern->pos) == SUCCESS && !EG(exception)) {
1076 it = element->obj;
1077 zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
1078
1079 if (retval) {
1080 valid = Z_LVAL_P(retval);
1081 zval_ptr_dtor(&retval);
1082 } else {
1083 valid = 0;
1084 }
1085
1086 if (valid) {
1087 if (SPL_MULTIPLE_ITERATOR_GET_ALL_CURRENT == get_type) {
1088 zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_current, "current", &retval);
1089 } else {
1090 zend_call_method_with_0_params(&it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_key, "key", &retval);
1091 }
1092 if (!retval) {
1093 zend_throw_exception(spl_ce_RuntimeException, "Failed to call sub iterator method", 0 TSRMLS_CC);
1094 return;
1095 }
1096 } else if (intern->flags & MIT_NEED_ALL) {
1097 if (SPL_MULTIPLE_ITERATOR_GET_ALL_CURRENT == get_type) {
1098 zend_throw_exception(spl_ce_RuntimeException, "Called current() with non valid sub iterator", 0 TSRMLS_CC);
1099 } else {
1100 zend_throw_exception(spl_ce_RuntimeException, "Called key() with non valid sub iterator", 0 TSRMLS_CC);
1101 }
1102 return;
1103 } else {
1104 ALLOC_INIT_ZVAL(retval);
1105 }
1106
1107 if (intern->flags & MIT_KEYS_ASSOC) {
1108 switch (Z_TYPE_P(element->inf)) {
1109 case IS_LONG:
1110 add_index_zval(return_value, Z_LVAL_P(element->inf), retval);
1111 break;
1112 case IS_STRING:
1113 add_assoc_zval_ex(return_value, Z_STRVAL_P(element->inf), Z_STRLEN_P(element->inf)+1U, retval);
1114 break;
1115 default:
1116 zval_ptr_dtor(&retval);
1117 zend_throw_exception(spl_ce_InvalidArgumentException, "Sub-Iterator is associated with NULL", 0 TSRMLS_CC);
1118 return;
1119 }
1120 } else {
1121 add_next_index_zval(return_value, retval);
1122 }
1123
1124 zend_hash_move_forward_ex(&intern->storage, &intern->pos);
1125 }
1126 }
1127 /* }}} */
1128
1129 /* {{{ proto array current() throws RuntimeException throws InvalidArgumentException
1130 Return an array of all registered Iterator instances current() result */
SPL_METHOD(MultipleIterator,current)1131 SPL_METHOD(MultipleIterator, current)
1132 {
1133 spl_SplObjectStorage *intern;
1134 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
1135
1136 if (zend_parse_parameters_none() == FAILURE) {
1137 return;
1138 }
1139
1140 spl_multiple_iterator_get_all(intern, SPL_MULTIPLE_ITERATOR_GET_ALL_CURRENT, return_value TSRMLS_CC);
1141 }
1142 /* }}} */
1143
1144 /* {{{ proto array MultipleIterator::key()
1145 Return an array of all registered Iterator instances key() result */
SPL_METHOD(MultipleIterator,key)1146 SPL_METHOD(MultipleIterator, key)
1147 {
1148 spl_SplObjectStorage *intern;
1149 intern = (spl_SplObjectStorage*)zend_object_store_get_object(getThis() TSRMLS_CC);
1150
1151 if (zend_parse_parameters_none() == FAILURE) {
1152 return;
1153 }
1154
1155 spl_multiple_iterator_get_all(intern, SPL_MULTIPLE_ITERATOR_GET_ALL_KEY, return_value TSRMLS_CC);
1156 }
1157 /* }}} */
1158
1159 ZEND_BEGIN_ARG_INFO_EX(arginfo_MultipleIterator_attachIterator, 0, 0, 1)
1160 ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
1161 ZEND_ARG_INFO(0, infos)
1162 ZEND_END_ARG_INFO();
1163
1164 ZEND_BEGIN_ARG_INFO_EX(arginfo_MultipleIterator_detachIterator, 0, 0, 1)
1165 ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
1166 ZEND_END_ARG_INFO();
1167
1168 ZEND_BEGIN_ARG_INFO_EX(arginfo_MultipleIterator_containsIterator, 0, 0, 1)
1169 ZEND_ARG_OBJ_INFO(0, iterator, Iterator, 0)
1170 ZEND_END_ARG_INFO();
1171
1172 ZEND_BEGIN_ARG_INFO_EX(arginfo_MultipleIterator_setflags, 0, 0, 1)
1173 ZEND_ARG_INFO(0, flags)
1174 ZEND_END_ARG_INFO();
1175
1176 static const zend_function_entry spl_funcs_MultipleIterator[] = {
1177 SPL_ME(MultipleIterator, __construct, arginfo_MultipleIterator_setflags, 0)
1178 SPL_ME(MultipleIterator, getFlags, arginfo_splobject_void, 0)
1179 SPL_ME(MultipleIterator, setFlags, arginfo_MultipleIterator_setflags, 0)
1180 SPL_ME(MultipleIterator, attachIterator, arginfo_MultipleIterator_attachIterator, 0)
1181 SPL_MA(MultipleIterator, detachIterator, SplObjectStorage, detach, arginfo_MultipleIterator_detachIterator, 0)
1182 SPL_MA(MultipleIterator, containsIterator, SplObjectStorage, contains, arginfo_MultipleIterator_containsIterator, 0)
1183 SPL_MA(MultipleIterator, countIterators, SplObjectStorage, count, arginfo_splobject_void, 0)
1184 /* Iterator */
1185 SPL_ME(MultipleIterator, rewind, arginfo_splobject_void, 0)
1186 SPL_ME(MultipleIterator, valid, arginfo_splobject_void, 0)
1187 SPL_ME(MultipleIterator, key, arginfo_splobject_void, 0)
1188 SPL_ME(MultipleIterator, current, arginfo_splobject_void, 0)
1189 SPL_ME(MultipleIterator, next, arginfo_splobject_void, 0)
1190 {NULL, NULL, NULL}
1191 };
1192
1193 /* {{{ PHP_MINIT_FUNCTION(spl_observer) */
PHP_MINIT_FUNCTION(spl_observer)1194 PHP_MINIT_FUNCTION(spl_observer)
1195 {
1196 REGISTER_SPL_INTERFACE(SplObserver);
1197 REGISTER_SPL_INTERFACE(SplSubject);
1198
1199 REGISTER_SPL_STD_CLASS_EX(SplObjectStorage, spl_SplObjectStorage_new, spl_funcs_SplObjectStorage);
1200 memcpy(&spl_handler_SplObjectStorage, zend_get_std_object_handlers(), sizeof(zend_object_handlers));
1201
1202 spl_handler_SplObjectStorage.get_properties = spl_object_storage_get_properties;
1203 spl_handler_SplObjectStorage.get_debug_info = spl_object_storage_debug_info;
1204 spl_handler_SplObjectStorage.compare_objects = spl_object_storage_compare_objects;
1205 spl_handler_SplObjectStorage.clone_obj = spl_object_storage_clone;
1206
1207 REGISTER_SPL_IMPLEMENTS(SplObjectStorage, Countable);
1208 REGISTER_SPL_IMPLEMENTS(SplObjectStorage, Iterator);
1209 REGISTER_SPL_IMPLEMENTS(SplObjectStorage, Serializable);
1210 REGISTER_SPL_IMPLEMENTS(SplObjectStorage, ArrayAccess);
1211
1212 REGISTER_SPL_STD_CLASS_EX(MultipleIterator, spl_SplObjectStorage_new, spl_funcs_MultipleIterator);
1213 REGISTER_SPL_ITERATOR(MultipleIterator);
1214
1215 REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ANY", MIT_NEED_ANY);
1216 REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_NEED_ALL", MIT_NEED_ALL);
1217 REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_KEYS_NUMERIC", MIT_KEYS_NUMERIC);
1218 REGISTER_SPL_CLASS_CONST_LONG(MultipleIterator, "MIT_KEYS_ASSOC", MIT_KEYS_ASSOC);
1219
1220 return SUCCESS;
1221 }
1222 /* }}} */
1223
1224 /*
1225 * Local variables:
1226 * tab-width: 4
1227 * c-basic-offset: 4
1228 * End:
1229 * vim600: fdm=marker
1230 * vim: noet sw=4 ts=4
1231 */
1232
