1 /*
2 +----------------------------------------------------------------------+
3 | Zend Engine |
4 +----------------------------------------------------------------------+
5 | Copyright (c) 1998-2017 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 /* $Id$ */
20
21 #include "zend.h"
22 #include "zend_API.h"
23 #include "zend_interfaces.h"
24 #include "zend_exceptions.h"
25
26 ZEND_API zend_class_entry *zend_ce_traversable;
27 ZEND_API zend_class_entry *zend_ce_aggregate;
28 ZEND_API zend_class_entry *zend_ce_iterator;
29 ZEND_API zend_class_entry *zend_ce_arrayaccess;
30 ZEND_API zend_class_entry *zend_ce_serializable;
31
32 /* {{{ zend_call_method
33 Only returns the returned zval if retval_ptr != NULL */
zend_call_method(zval * object,zend_class_entry * obj_ce,zend_function ** fn_proxy,const char * function_name,size_t function_name_len,zval * retval_ptr,int param_count,zval * arg1,zval * arg2)34 ZEND_API zval* zend_call_method(zval *object, zend_class_entry *obj_ce, zend_function **fn_proxy, const char *function_name, size_t function_name_len, zval *retval_ptr, int param_count, zval* arg1, zval* arg2)
35 {
36 int result;
37 zend_fcall_info fci;
38 zval retval;
39 HashTable *function_table;
40
41 zval params[2];
42
43 if (param_count > 0) {
44 ZVAL_COPY_VALUE(¶ms[0], arg1);
45 }
46 if (param_count > 1) {
47 ZVAL_COPY_VALUE(¶ms[1], arg2);
48 }
49
50 fci.size = sizeof(fci);
51 /*fci.function_table = NULL; will be read form zend_class_entry of object if needed */
52 fci.object = (object && Z_TYPE_P(object) == IS_OBJECT) ? Z_OBJ_P(object) : NULL;
53 ZVAL_STRINGL(&fci.function_name, function_name, function_name_len);
54 fci.retval = retval_ptr ? retval_ptr : &retval;
55 fci.param_count = param_count;
56 fci.params = params;
57 fci.no_separation = 1;
58 fci.symbol_table = NULL;
59
60 if (!fn_proxy && !obj_ce) {
61 /* no interest in caching and no information already present that is
62 * needed later inside zend_call_function. */
63 fci.function_table = !object ? EG(function_table) : NULL;
64 result = zend_call_function(&fci, NULL);
65 zval_ptr_dtor(&fci.function_name);
66 } else {
67 zend_fcall_info_cache fcic;
68
69 fcic.initialized = 1;
70 if (!obj_ce) {
71 obj_ce = object ? Z_OBJCE_P(object) : NULL;
72 }
73 if (obj_ce) {
74 function_table = &obj_ce->function_table;
75 } else {
76 function_table = EG(function_table);
77 }
78 if (!fn_proxy || !*fn_proxy) {
79 if ((fcic.function_handler = zend_hash_find_ptr(function_table, Z_STR(fci.function_name))) == NULL) {
80 /* error at c-level */
81 zend_error_noreturn(E_CORE_ERROR, "Couldn't find implementation for method %s%s%s", obj_ce ? ZSTR_VAL(obj_ce->name) : "", obj_ce ? "::" : "", function_name);
82 }
83 if (fn_proxy) {
84 *fn_proxy = fcic.function_handler;
85 }
86 } else {
87 fcic.function_handler = *fn_proxy;
88 }
89 fcic.calling_scope = obj_ce;
90 if (object) {
91 fcic.called_scope = Z_OBJCE_P(object);
92 } else {
93 zend_class_entry *called_scope = zend_get_called_scope(EG(current_execute_data));
94
95 if (obj_ce &&
96 (!called_scope ||
97 !instanceof_function(called_scope, obj_ce))) {
98 fcic.called_scope = obj_ce;
99 } else {
100 fcic.called_scope = called_scope;
101 }
102 }
103 fcic.object = object ? Z_OBJ_P(object) : NULL;
104 result = zend_call_function(&fci, &fcic);
105 zval_ptr_dtor(&fci.function_name);
106 }
107 if (result == FAILURE) {
108 /* error at c-level */
109 if (!obj_ce) {
110 obj_ce = object ? Z_OBJCE_P(object) : NULL;
111 }
112 if (!EG(exception)) {
113 zend_error_noreturn(E_CORE_ERROR, "Couldn't execute method %s%s%s", obj_ce ? ZSTR_VAL(obj_ce->name) : "", obj_ce ? "::" : "", function_name);
114 }
115 }
116 /* copy arguments back, they might be changed by references */
117 if (param_count > 0 && Z_ISREF(params[0]) && !Z_ISREF_P(arg1)) {
118 ZVAL_COPY_VALUE(arg1, ¶ms[0]);
119 }
120 if (param_count > 1 && Z_ISREF(params[1]) && !Z_ISREF_P(arg2)) {
121 ZVAL_COPY_VALUE(arg2, ¶ms[1]);
122 }
123 if (!retval_ptr) {
124 zval_ptr_dtor(&retval);
125 return NULL;
126 }
127 return retval_ptr;
128 }
129 /* }}} */
130
131 /* iterator interface, c-level functions used by engine */
132
133 /* {{{ zend_user_it_new_iterator */
zend_user_it_new_iterator(zend_class_entry * ce,zval * object,zval * retval)134 ZEND_API void zend_user_it_new_iterator(zend_class_entry *ce, zval *object, zval *retval)
135 {
136 zend_call_method_with_0_params(object, ce, &ce->iterator_funcs.zf_new_iterator, "getiterator", retval);
137 }
138 /* }}} */
139
140 /* {{{ zend_user_it_invalidate_current */
zend_user_it_invalidate_current(zend_object_iterator * _iter)141 ZEND_API void zend_user_it_invalidate_current(zend_object_iterator *_iter)
142 {
143 zend_user_iterator *iter = (zend_user_iterator*)_iter;
144
145 if (!Z_ISUNDEF(iter->value)) {
146 zval_ptr_dtor(&iter->value);
147 ZVAL_UNDEF(&iter->value);
148 }
149 }
150 /* }}} */
151
152 /* {{{ zend_user_it_dtor */
zend_user_it_dtor(zend_object_iterator * _iter)153 static void zend_user_it_dtor(zend_object_iterator *_iter)
154 {
155 zend_user_iterator *iter = (zend_user_iterator*)_iter;
156 zval *object = &iter->it.data;
157
158 zend_user_it_invalidate_current(_iter);
159 zval_ptr_dtor(object);
160 }
161 /* }}} */
162
163 /* {{{ zend_user_it_valid */
zend_user_it_valid(zend_object_iterator * _iter)164 ZEND_API int zend_user_it_valid(zend_object_iterator *_iter)
165 {
166 if (_iter) {
167 zend_user_iterator *iter = (zend_user_iterator*)_iter;
168 zval *object = &iter->it.data;
169 zval more;
170 int result;
171
172 zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_valid, "valid", &more);
173 if (Z_TYPE(more) != IS_UNDEF) {
174 result = i_zend_is_true(&more);
175 zval_ptr_dtor(&more);
176 return result ? SUCCESS : FAILURE;
177 }
178 }
179 return FAILURE;
180 }
181 /* }}} */
182
183 /* {{{ zend_user_it_get_current_data */
zend_user_it_get_current_data(zend_object_iterator * _iter)184 ZEND_API zval *zend_user_it_get_current_data(zend_object_iterator *_iter)
185 {
186 zend_user_iterator *iter = (zend_user_iterator*)_iter;
187 zval *object = &iter->it.data;
188
189 if (Z_ISUNDEF(iter->value)) {
190 zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_current, "current", &iter->value);
191 }
192 return &iter->value;
193 }
194 /* }}} */
195
196 /* {{{ zend_user_it_get_current_key_default */
197 #if 0
198 static int zend_user_it_get_current_key_default(zend_object_iterator *_iter, char **str_key, uint *str_key_len, ulong *int_key)
199 {
200 *int_key = _iter->index;
201 return HASH_KEY_IS_LONG;
202 }
203 #endif
204 /* }}} */
205
206 /* {{{ zend_user_it_get_current_key */
zend_user_it_get_current_key(zend_object_iterator * _iter,zval * key)207 ZEND_API void zend_user_it_get_current_key(zend_object_iterator *_iter, zval *key)
208 {
209 zend_user_iterator *iter = (zend_user_iterator*)_iter;
210 zval *object = &iter->it.data;
211 zval retval;
212
213 zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_key, "key", &retval);
214
215 if (Z_TYPE(retval) != IS_UNDEF) {
216 ZVAL_ZVAL(key, &retval, 1, 1);
217 } else {
218 if (!EG(exception)) {
219 zend_error(E_WARNING, "Nothing returned from %s::key()", ZSTR_VAL(iter->ce->name));
220 }
221
222 ZVAL_LONG(key, 0);
223 }
224 }
225 /* }}} */
226
227 /* {{{ zend_user_it_move_forward */
zend_user_it_move_forward(zend_object_iterator * _iter)228 ZEND_API void zend_user_it_move_forward(zend_object_iterator *_iter)
229 {
230 zend_user_iterator *iter = (zend_user_iterator*)_iter;
231 zval *object = &iter->it.data;
232
233 zend_user_it_invalidate_current(_iter);
234 zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_next, "next", NULL);
235 }
236 /* }}} */
237
238 /* {{{ zend_user_it_rewind */
zend_user_it_rewind(zend_object_iterator * _iter)239 ZEND_API void zend_user_it_rewind(zend_object_iterator *_iter)
240 {
241 zend_user_iterator *iter = (zend_user_iterator*)_iter;
242 zval *object = &iter->it.data;
243
244 zend_user_it_invalidate_current(_iter);
245 zend_call_method_with_0_params(object, iter->ce, &iter->ce->iterator_funcs.zf_rewind, "rewind", NULL);
246 }
247 /* }}} */
248
249 zend_object_iterator_funcs zend_interface_iterator_funcs_iterator = {
250 zend_user_it_dtor,
251 zend_user_it_valid,
252 zend_user_it_get_current_data,
253 zend_user_it_get_current_key,
254 zend_user_it_move_forward,
255 zend_user_it_rewind,
256 zend_user_it_invalidate_current
257 };
258
259 /* {{{ zend_user_it_get_iterator */
zend_user_it_get_iterator(zend_class_entry * ce,zval * object,int by_ref)260 static zend_object_iterator *zend_user_it_get_iterator(zend_class_entry *ce, zval *object, int by_ref)
261 {
262 zend_user_iterator *iterator;
263
264 if (by_ref) {
265 zend_throw_error(NULL, "An iterator cannot be used with foreach by reference");
266 return NULL;
267 }
268
269 iterator = emalloc(sizeof(zend_user_iterator));
270
271 zend_iterator_init((zend_object_iterator*)iterator);
272
273 ZVAL_COPY(&iterator->it.data, object);
274 iterator->it.funcs = ce->iterator_funcs.funcs;
275 iterator->ce = Z_OBJCE_P(object);
276 ZVAL_UNDEF(&iterator->value);
277 return (zend_object_iterator*)iterator;
278 }
279 /* }}} */
280
281 /* {{{ zend_user_it_get_new_iterator */
zend_user_it_get_new_iterator(zend_class_entry * ce,zval * object,int by_ref)282 ZEND_API zend_object_iterator *zend_user_it_get_new_iterator(zend_class_entry *ce, zval *object, int by_ref)
283 {
284 zval iterator;
285 zend_object_iterator *new_iterator;
286 zend_class_entry *ce_it;
287
288 zend_user_it_new_iterator(ce, object, &iterator);
289 ce_it = (Z_TYPE(iterator) == IS_OBJECT) ? Z_OBJCE(iterator) : NULL;
290
291 if (!ce_it || !ce_it->get_iterator || (ce_it->get_iterator == zend_user_it_get_new_iterator && Z_OBJ(iterator) == Z_OBJ_P(object))) {
292 if (!EG(exception)) {
293 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));
294 }
295 zval_ptr_dtor(&iterator);
296 return NULL;
297 }
298
299 new_iterator = ce_it->get_iterator(ce_it, &iterator, by_ref);
300 zval_ptr_dtor(&iterator);
301 return new_iterator;
302 }
303 /* }}} */
304
305 /* {{{ zend_implement_traversable */
zend_implement_traversable(zend_class_entry * interface,zend_class_entry * class_type)306 static int zend_implement_traversable(zend_class_entry *interface, zend_class_entry *class_type)
307 {
308 /* check that class_type is traversable at c-level or implements at least one of 'aggregate' and 'Iterator' */
309 uint32_t i;
310
311 if (class_type->get_iterator || (class_type->parent && class_type->parent->get_iterator)) {
312 return SUCCESS;
313 }
314 for (i = 0; i < class_type->num_interfaces; i++) {
315 if (class_type->interfaces[i] == zend_ce_aggregate || class_type->interfaces[i] == zend_ce_iterator) {
316 return SUCCESS;
317 }
318 }
319 zend_error_noreturn(E_CORE_ERROR, "Class %s must implement interface %s as part of either %s or %s",
320 ZSTR_VAL(class_type->name),
321 ZSTR_VAL(zend_ce_traversable->name),
322 ZSTR_VAL(zend_ce_iterator->name),
323 ZSTR_VAL(zend_ce_aggregate->name));
324 return FAILURE;
325 }
326 /* }}} */
327
328 /* {{{ zend_implement_aggregate */
zend_implement_aggregate(zend_class_entry * interface,zend_class_entry * class_type)329 static int zend_implement_aggregate(zend_class_entry *interface, zend_class_entry *class_type)
330 {
331 uint32_t i;
332 int t = -1;
333
334 if (class_type->get_iterator) {
335 if (class_type->type == ZEND_INTERNAL_CLASS) {
336 /* inheritance ensures the class has necessary userland methods */
337 return SUCCESS;
338 } else if (class_type->get_iterator != zend_user_it_get_new_iterator) {
339 /* c-level get_iterator cannot be changed (exception being only Traversable is implmented) */
340 if (class_type->num_interfaces) {
341 for (i = 0; i < class_type->num_interfaces; i++) {
342 if (class_type->interfaces[i] == zend_ce_iterator) {
343 zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
344 ZSTR_VAL(class_type->name),
345 ZSTR_VAL(interface->name),
346 ZSTR_VAL(zend_ce_iterator->name));
347 return FAILURE;
348 }
349 if (class_type->interfaces[i] == zend_ce_traversable) {
350 t = i;
351 }
352 }
353 }
354 if (t == -1) {
355 return FAILURE;
356 }
357 }
358 }
359 class_type->iterator_funcs.zf_new_iterator = NULL;
360 class_type->get_iterator = zend_user_it_get_new_iterator;
361 return SUCCESS;
362 }
363 /* }}} */
364
365 /* {{{ zend_implement_iterator */
zend_implement_iterator(zend_class_entry * interface,zend_class_entry * class_type)366 static int zend_implement_iterator(zend_class_entry *interface, zend_class_entry *class_type)
367 {
368 if (class_type->get_iterator && class_type->get_iterator != zend_user_it_get_iterator) {
369 if (class_type->type == ZEND_INTERNAL_CLASS) {
370 /* inheritance ensures the class has the necessary userland methods */
371 return SUCCESS;
372 } else {
373 /* c-level get_iterator cannot be changed */
374 if (class_type->get_iterator == zend_user_it_get_new_iterator) {
375 zend_error_noreturn(E_ERROR, "Class %s cannot implement both %s and %s at the same time",
376 ZSTR_VAL(class_type->name),
377 ZSTR_VAL(interface->name),
378 ZSTR_VAL(zend_ce_aggregate->name));
379 }
380 return FAILURE;
381 }
382 }
383 class_type->get_iterator = zend_user_it_get_iterator;
384 class_type->iterator_funcs.zf_valid = NULL;
385 class_type->iterator_funcs.zf_current = NULL;
386 class_type->iterator_funcs.zf_key = NULL;
387 class_type->iterator_funcs.zf_next = NULL;
388 class_type->iterator_funcs.zf_rewind = NULL;
389 if (!class_type->iterator_funcs.funcs) {
390 class_type->iterator_funcs.funcs = &zend_interface_iterator_funcs_iterator;
391 }
392 return SUCCESS;
393 }
394 /* }}} */
395
396 /* {{{ zend_implement_arrayaccess */
zend_implement_arrayaccess(zend_class_entry * interface,zend_class_entry * class_type)397 static int zend_implement_arrayaccess(zend_class_entry *interface, zend_class_entry *class_type)
398 {
399 #if 0
400 /* get ht from ce */
401 if (ht->read_dimension != zend_std_read_dimension
402 || ht->write_dimension != zend_std_write_dimension
403 || ht->has_dimension != zend_std_has_dimension
404 || ht->unset_dimension != zend_std_unset_dimension) {
405 return FAILURE;
406 }
407 #endif
408 return SUCCESS;
409 }
410 /* }}}*/
411
412 /* {{{ zend_user_serialize */
zend_user_serialize(zval * object,unsigned char ** buffer,size_t * buf_len,zend_serialize_data * data)413 ZEND_API int zend_user_serialize(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data)
414 {
415 zend_class_entry * ce = Z_OBJCE_P(object);
416 zval retval;
417 int result;
418
419 zend_call_method_with_0_params(object, ce, &ce->serialize_func, "serialize", &retval);
420
421
422 if (Z_TYPE(retval) == IS_UNDEF || EG(exception)) {
423 result = FAILURE;
424 } else {
425 switch(Z_TYPE(retval)) {
426 case IS_NULL:
427 /* we could also make this '*buf_len = 0' but this allows to skip variables */
428 zval_ptr_dtor(&retval);
429 return FAILURE;
430 case IS_STRING:
431 *buffer = (unsigned char*)estrndup(Z_STRVAL(retval), Z_STRLEN(retval));
432 *buf_len = Z_STRLEN(retval);
433 result = SUCCESS;
434 break;
435 default: /* failure */
436 result = FAILURE;
437 break;
438 }
439 zval_ptr_dtor(&retval);
440 }
441
442 if (result == FAILURE && !EG(exception)) {
443 zend_throw_exception_ex(NULL, 0, "%s::serialize() must return a string or NULL", ZSTR_VAL(ce->name));
444 }
445 return result;
446 }
447 /* }}} */
448
449 /* {{{ zend_user_unserialize */
zend_user_unserialize(zval * object,zend_class_entry * ce,const unsigned char * buf,size_t buf_len,zend_unserialize_data * data)450 ZEND_API int zend_user_unserialize(zval *object, zend_class_entry *ce, const unsigned char *buf, size_t buf_len, zend_unserialize_data *data)
451 {
452 zval zdata;
453
454 if (UNEXPECTED(object_init_ex(object, ce) != SUCCESS)) {
455 return FAILURE;
456 }
457
458 ZVAL_STRINGL(&zdata, (char*)buf, buf_len);
459
460 zend_call_method_with_1_params(object, ce, &ce->unserialize_func, "unserialize", NULL, &zdata);
461
462 zval_ptr_dtor(&zdata);
463
464 if (EG(exception)) {
465 return FAILURE;
466 } else {
467 return SUCCESS;
468 }
469 }
470 /* }}} */
471
zend_class_serialize_deny(zval * object,unsigned char ** buffer,size_t * buf_len,zend_serialize_data * data)472 ZEND_API int zend_class_serialize_deny(zval *object, unsigned char **buffer, size_t *buf_len, zend_serialize_data *data) /* {{{ */
473 {
474 zend_class_entry *ce = Z_OBJCE_P(object);
475 zend_throw_exception_ex(NULL, 0, "Serialization of '%s' is not allowed", ZSTR_VAL(ce->name));
476 return FAILURE;
477 }
478 /* }}} */
479
zend_class_unserialize_deny(zval * object,zend_class_entry * ce,const unsigned char * buf,size_t buf_len,zend_unserialize_data * data)480 ZEND_API int zend_class_unserialize_deny(zval *object, zend_class_entry *ce, const unsigned char *buf, size_t buf_len, zend_unserialize_data *data) /* {{{ */
481 {
482 zend_throw_exception_ex(NULL, 0, "Unserialization of '%s' is not allowed", ZSTR_VAL(ce->name));
483 return FAILURE;
484 }
485 /* }}} */
486
487 /* {{{ zend_implement_serializable */
zend_implement_serializable(zend_class_entry * interface,zend_class_entry * class_type)488 static int zend_implement_serializable(zend_class_entry *interface, zend_class_entry *class_type)
489 {
490 if (class_type->parent
491 && (class_type->parent->serialize || class_type->parent->unserialize)
492 && !instanceof_function_ex(class_type->parent, zend_ce_serializable, 1)) {
493 return FAILURE;
494 }
495 if (!class_type->serialize) {
496 class_type->serialize = zend_user_serialize;
497 }
498 if (!class_type->unserialize) {
499 class_type->unserialize = zend_user_unserialize;
500 }
501 return SUCCESS;
502 }
503 /* }}}*/
504
505 /* {{{ function tables */
506 const zend_function_entry zend_funcs_aggregate[] = {
507 ZEND_ABSTRACT_ME(iterator, getIterator, NULL)
508 ZEND_FE_END
509 };
510
511 const zend_function_entry zend_funcs_iterator[] = {
512 ZEND_ABSTRACT_ME(iterator, current, NULL)
513 ZEND_ABSTRACT_ME(iterator, next, NULL)
514 ZEND_ABSTRACT_ME(iterator, key, NULL)
515 ZEND_ABSTRACT_ME(iterator, valid, NULL)
516 ZEND_ABSTRACT_ME(iterator, rewind, NULL)
517 ZEND_FE_END
518 };
519
520 const zend_function_entry *zend_funcs_traversable = NULL;
521
522 ZEND_BEGIN_ARG_INFO_EX(arginfo_arrayaccess_offset, 0, 0, 1)
523 ZEND_ARG_INFO(0, offset)
524 ZEND_END_ARG_INFO()
525
526 ZEND_BEGIN_ARG_INFO_EX(arginfo_arrayaccess_offset_get, 0, 0, 1) /* actually this should be return by ref but atm cannot be */
527 ZEND_ARG_INFO(0, offset)
528 ZEND_END_ARG_INFO()
529
530 ZEND_BEGIN_ARG_INFO_EX(arginfo_arrayaccess_offset_value, 0, 0, 2)
531 ZEND_ARG_INFO(0, offset)
532 ZEND_ARG_INFO(0, value)
533 ZEND_END_ARG_INFO()
534
535 const zend_function_entry zend_funcs_arrayaccess[] = {
536 ZEND_ABSTRACT_ME(arrayaccess, offsetExists, arginfo_arrayaccess_offset)
537 ZEND_ABSTRACT_ME(arrayaccess, offsetGet, arginfo_arrayaccess_offset_get)
538 ZEND_ABSTRACT_ME(arrayaccess, offsetSet, arginfo_arrayaccess_offset_value)
539 ZEND_ABSTRACT_ME(arrayaccess, offsetUnset, arginfo_arrayaccess_offset)
540 ZEND_FE_END
541 };
542
543 ZEND_BEGIN_ARG_INFO(arginfo_serializable_serialize, 0)
544 ZEND_ARG_INFO(0, serialized)
545 ZEND_END_ARG_INFO()
546
547 const zend_function_entry zend_funcs_serializable[] = {
548 ZEND_ABSTRACT_ME(serializable, serialize, NULL)
549 ZEND_FENTRY(unserialize, NULL, arginfo_serializable_serialize, ZEND_ACC_PUBLIC|ZEND_ACC_ABSTRACT|ZEND_ACC_CTOR)
550 ZEND_FE_END
551 };
552 /* }}} */
553
554 /* {{{ zend_register_interfaces */
zend_register_interfaces(void)555 ZEND_API void zend_register_interfaces(void)
556 {
557 REGISTER_MAGIC_INTERFACE(traversable, Traversable);
558
559 REGISTER_MAGIC_INTERFACE(aggregate, IteratorAggregate);
560 REGISTER_MAGIC_IMPLEMENT(aggregate, traversable);
561
562 REGISTER_MAGIC_INTERFACE(iterator, Iterator);
563 REGISTER_MAGIC_IMPLEMENT(iterator, traversable);
564
565 REGISTER_MAGIC_INTERFACE(arrayaccess, ArrayAccess);
566
567 REGISTER_MAGIC_INTERFACE(serializable, Serializable);
568 }
569 /* }}} */
570
571 /*
572 * Local variables:
573 * tab-width: 4
574 * c-basic-offset: 4
575 * indent-tabs-mode: t
576 * End:
577 */
578
