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