1/*
2   +----------------------------------------------------------------------+
3   | Zend Engine                                                          |
4   +----------------------------------------------------------------------+
5   | Copyright (c) 1998-2018 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: Andi Gutmans <andi@php.net>                                 |
16   |          Zeev Suraski <zeev@php.net>                                 |
17   |          Dmitry Stogov <dmitry@php.net>                              |
18   +----------------------------------------------------------------------+
19*/
20
21#include "zend.h"
22#include "zend_globals.h"
23#include "zend_variables.h"
24#include "zend_API.h"
25#include "zend_objects.h"
26#include "zend_objects_API.h"
27#include "zend_object_handlers.h"
28#include "zend_interfaces.h"
29#include "zend_exceptions.h"
30#include "zend_closures.h"
31#include "zend_compile.h"
32#include "zend_hash.h"
33
34#define DEBUG_OBJECT_HANDLERS 0
35
36#define ZEND_WRONG_PROPERTY_OFFSET   0
37
38/* guard flags */
39#define IN_GET		(1<<0)
40#define IN_SET		(1<<1)
41#define IN_UNSET	(1<<2)
42#define IN_ISSET	(1<<3)
43
44/*
45  __X accessors explanation:
46
47  if we have __get and property that is not part of the properties array is
48  requested, we call __get handler. If it fails, we return uninitialized.
49
50  if we have __set and property that is not part of the properties array is
51  set, we call __set handler. If it fails, we do not change the array.
52
53  for both handlers above, when we are inside __get/__set, no further calls for
54  __get/__set for this property of this object will be made, to prevent endless
55  recursion and enable accessors to change properties array.
56
57  if we have __call and method which is not part of the class function table is
58  called, we cal __call handler.
59*/
60
61ZEND_API void rebuild_object_properties(zend_object *zobj) /* {{{ */
62{
63	if (!zobj->properties) {
64		zend_property_info *prop_info;
65		zend_class_entry *ce = zobj->ce;
66
67		zobj->properties = zend_new_array(ce->default_properties_count);
68		if (ce->default_properties_count) {
69			zend_hash_real_init_mixed(zobj->properties);
70			ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
71				if (/*prop_info->ce == ce &&*/
72				    (prop_info->flags & ZEND_ACC_STATIC) == 0) {
73
74					if (UNEXPECTED(Z_TYPE_P(OBJ_PROP(zobj, prop_info->offset)) == IS_UNDEF)) {
75						HT_FLAGS(zobj->properties) |= HASH_FLAG_HAS_EMPTY_IND;
76					}
77
78					_zend_hash_append_ind(zobj->properties, prop_info->name,
79						OBJ_PROP(zobj, prop_info->offset));
80				}
81			} ZEND_HASH_FOREACH_END();
82			while (ce->parent && ce->parent->default_properties_count) {
83				ce = ce->parent;
84				ZEND_HASH_FOREACH_PTR(&ce->properties_info, prop_info) {
85					if (prop_info->ce == ce &&
86					    (prop_info->flags & ZEND_ACC_STATIC) == 0 &&
87					    (prop_info->flags & ZEND_ACC_PRIVATE) != 0) {
88						zval zv;
89
90						if (UNEXPECTED(Z_TYPE_P(OBJ_PROP(zobj, prop_info->offset)) == IS_UNDEF)) {
91							HT_FLAGS(zobj->properties) |= HASH_FLAG_HAS_EMPTY_IND;
92						}
93
94						ZVAL_INDIRECT(&zv, OBJ_PROP(zobj, prop_info->offset));
95						zend_hash_add(zobj->properties, prop_info->name, &zv);
96					}
97				} ZEND_HASH_FOREACH_END();
98			}
99		}
100	}
101}
102/* }}} */
103
104ZEND_API HashTable *zend_std_get_properties(zval *object) /* {{{ */
105{
106	zend_object *zobj;
107	zobj = Z_OBJ_P(object);
108	if (!zobj->properties) {
109		rebuild_object_properties(zobj);
110	}
111	return zobj->properties;
112}
113/* }}} */
114
115ZEND_API HashTable *zend_std_get_gc(zval *object, zval **table, int *n) /* {{{ */
116{
117	if (Z_OBJ_HANDLER_P(object, get_properties) != zend_std_get_properties) {
118		*table = NULL;
119		*n = 0;
120		return Z_OBJ_HANDLER_P(object, get_properties)(object);
121	} else {
122		zend_object *zobj = Z_OBJ_P(object);
123
124		if (zobj->properties) {
125			*table = NULL;
126			*n = 0;
127			if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)
128			 && EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
129				GC_DELREF(zobj->properties);
130				zobj->properties = zend_array_dup(zobj->properties);
131			}
132			return zobj->properties;
133		} else {
134			*table = zobj->properties_table;
135			*n = zobj->ce->default_properties_count;
136			return NULL;
137		}
138	}
139}
140/* }}} */
141
142ZEND_API HashTable *zend_std_get_debug_info(zval *object, int *is_temp) /* {{{ */
143{
144	zend_class_entry *ce = Z_OBJCE_P(object);
145	zval retval;
146	HashTable *ht;
147
148	if (!ce->__debugInfo) {
149		*is_temp = 0;
150		return Z_OBJ_HANDLER_P(object, get_properties)
151			? Z_OBJ_HANDLER_P(object, get_properties)(object)
152			: NULL;
153	}
154
155	zend_call_method_with_0_params(object, ce, &ce->__debugInfo, ZEND_DEBUGINFO_FUNC_NAME, &retval);
156	if (Z_TYPE(retval) == IS_ARRAY) {
157		if (!Z_REFCOUNTED(retval)) {
158			*is_temp = 1;
159			return zend_array_dup(Z_ARRVAL(retval));
160		} else if (Z_REFCOUNT(retval) <= 1) {
161			*is_temp = 1;
162			ht = Z_ARR(retval);
163			return ht;
164		} else {
165			*is_temp = 0;
166			zval_ptr_dtor(&retval);
167			return Z_ARRVAL(retval);
168		}
169	} else if (Z_TYPE(retval) == IS_NULL) {
170		*is_temp = 1;
171		ht = zend_new_array(0);
172		return ht;
173	}
174
175	zend_error_noreturn(E_ERROR, ZEND_DEBUGINFO_FUNC_NAME "() must return an array");
176
177	return NULL; /* Compilers are dumb and don't understand that noreturn means that the function does NOT need a return value... */
178}
179/* }}} */
180
181static void zend_std_call_getter(zend_object *zobj, zend_string *prop_name, zval *retval) /* {{{ */
182{
183	zend_class_entry *ce = zobj->ce;
184	zend_class_entry *orig_fake_scope = EG(fake_scope);
185	zend_fcall_info fci;
186	zend_fcall_info_cache fcic;
187	zval member;
188
189	EG(fake_scope) = NULL;
190
191	/* __get handler is called with one argument:
192	      property name
193
194	   it should return whether the call was successful or not
195	*/
196
197	ZVAL_STR(&member, prop_name);
198
199	fci.size = sizeof(fci);
200	fci.object = zobj;
201	fci.retval = retval;
202	fci.param_count = 1;
203	fci.params = &member;
204	fci.no_separation = 1;
205	ZVAL_UNDEF(&fci.function_name); /* Unused */
206
207	fcic.function_handler = ce->__get;
208	fcic.called_scope = ce;
209	fcic.object = zobj;
210
211	zend_call_function(&fci, &fcic);
212
213	EG(fake_scope) = orig_fake_scope;
214}
215/* }}} */
216
217static void zend_std_call_setter(zend_object *zobj, zend_string *prop_name, zval *value) /* {{{ */
218{
219	zend_class_entry *ce = zobj->ce;
220	zend_class_entry *orig_fake_scope = EG(fake_scope);
221	zend_fcall_info fci;
222	zend_fcall_info_cache fcic;
223	zval args[2], ret;
224
225	EG(fake_scope) = NULL;
226
227	/* __set handler is called with two arguments:
228	     property name
229	     value to be set
230	*/
231
232	ZVAL_STR(&args[0], prop_name);
233	ZVAL_COPY_VALUE(&args[1], value);
234	ZVAL_UNDEF(&ret);
235
236	fci.size = sizeof(fci);
237	fci.object = zobj;
238	fci.retval = &ret;
239	fci.param_count = 2;
240	fci.params = args;
241	fci.no_separation = 1;
242	ZVAL_UNDEF(&fci.function_name); /* Unused */
243
244	fcic.function_handler = ce->__set;
245	fcic.called_scope = ce;
246	fcic.object = zobj;
247
248	zend_call_function(&fci, &fcic);
249	zval_ptr_dtor(&ret);
250
251	EG(fake_scope) = orig_fake_scope;
252}
253/* }}} */
254
255static void zend_std_call_unsetter(zend_object *zobj, zend_string *prop_name) /* {{{ */
256{
257	zend_class_entry *ce = zobj->ce;
258	zend_class_entry *orig_fake_scope = EG(fake_scope);
259	zend_fcall_info fci;
260	zend_fcall_info_cache fcic;
261	zval ret, member;
262
263	EG(fake_scope) = NULL;
264
265	/* __unset handler is called with one argument:
266	      property name
267	*/
268
269	ZVAL_STR(&member, prop_name);
270	ZVAL_UNDEF(&ret);
271
272	fci.size = sizeof(fci);
273	fci.object = zobj;
274	fci.retval = &ret;
275	fci.param_count = 1;
276	fci.params = &member;
277	fci.no_separation = 1;
278	ZVAL_UNDEF(&fci.function_name); /* Unused */
279
280	fcic.function_handler = ce->__unset;
281	fcic.called_scope = ce;
282	fcic.object = zobj;
283
284	zend_call_function(&fci, &fcic);
285	zval_ptr_dtor(&ret);
286
287	EG(fake_scope) = orig_fake_scope;
288}
289/* }}} */
290
291static void zend_std_call_issetter(zend_object *zobj, zend_string *prop_name, zval *retval) /* {{{ */
292{
293	zend_class_entry *ce = zobj->ce;
294	zend_class_entry *orig_fake_scope = EG(fake_scope);
295	zend_fcall_info fci;
296	zend_fcall_info_cache fcic;
297	zval member;
298
299	EG(fake_scope) = NULL;
300
301	/* __isset handler is called with one argument:
302	      property name
303
304	   it should return whether the property is set or not
305	*/
306
307	ZVAL_STR(&member, prop_name);
308
309	fci.size = sizeof(fci);
310	fci.object = zobj;
311	fci.retval = retval;
312	fci.param_count = 1;
313	fci.params = &member;
314	fci.no_separation = 1;
315	ZVAL_UNDEF(&fci.function_name); /* Unused */
316
317	fcic.function_handler = ce->__isset;
318	fcic.called_scope = ce;
319	fcic.object = zobj;
320
321	zend_call_function(&fci, &fcic);
322
323	EG(fake_scope) = orig_fake_scope;
324}
325/* }}} */
326
327static zend_always_inline int zend_verify_property_access(zend_property_info *property_info, zend_class_entry *ce) /* {{{ */
328{
329	zend_class_entry *scope;
330
331	if (property_info->flags & ZEND_ACC_PUBLIC) {
332		return 1;
333	} else if (property_info->flags & ZEND_ACC_PRIVATE) {
334		if (EG(fake_scope)) {
335			scope = EG(fake_scope);
336		} else {
337			scope = zend_get_executed_scope();
338		}
339		return (ce == scope || property_info->ce == scope);
340	} else if (property_info->flags & ZEND_ACC_PROTECTED) {
341		if (EG(fake_scope)) {
342			scope = EG(fake_scope);
343		} else {
344			scope = zend_get_executed_scope();
345		}
346		return zend_check_protected(property_info->ce, scope);
347	}
348	return 0;
349}
350/* }}} */
351
352static zend_always_inline zend_bool is_derived_class(zend_class_entry *child_class, zend_class_entry *parent_class) /* {{{ */
353{
354	child_class = child_class->parent;
355	while (child_class) {
356		if (child_class == parent_class) {
357			return 1;
358		}
359		child_class = child_class->parent;
360	}
361
362	return 0;
363}
364/* }}} */
365
366static zend_always_inline uintptr_t zend_get_property_offset(zend_class_entry *ce, zend_string *member, int silent, void **cache_slot) /* {{{ */
367{
368	zval *zv;
369	zend_property_info *property_info = NULL;
370	uint32_t flags;
371	zend_class_entry *scope;
372
373	if (cache_slot && EXPECTED(ce == CACHED_PTR_EX(cache_slot))) {
374		return (uintptr_t)CACHED_PTR_EX(cache_slot + 1);
375	}
376
377	if (UNEXPECTED(zend_hash_num_elements(&ce->properties_info) == 0)) {
378		goto exit_dynamic;
379	}
380
381	zv = zend_hash_find(&ce->properties_info, member);
382	if (EXPECTED(zv != NULL)) {
383		property_info = (zend_property_info*)Z_PTR_P(zv);
384		flags = property_info->flags;
385		if (UNEXPECTED((flags & ZEND_ACC_SHADOW) != 0)) {
386			/* if it's a shadow - go to access it's private */
387			property_info = NULL;
388		} else {
389			if (EXPECTED(zend_verify_property_access(property_info, ce) != 0)) {
390				if (UNEXPECTED(!(flags & ZEND_ACC_CHANGED))
391					|| UNEXPECTED((flags & ZEND_ACC_PRIVATE))) {
392					if (UNEXPECTED((flags & ZEND_ACC_STATIC) != 0)) {
393						if (!silent) {
394							zend_error(E_NOTICE, "Accessing static property %s::$%s as non static", ZSTR_VAL(ce->name), ZSTR_VAL(member));
395						}
396						return ZEND_DYNAMIC_PROPERTY_OFFSET;
397					}
398					goto exit;
399				}
400			} else {
401				/* Try to look in the scope instead */
402				property_info = ZEND_WRONG_PROPERTY_INFO;
403			}
404		}
405	}
406
407	if (EG(fake_scope)) {
408		scope = EG(fake_scope);
409	} else {
410		scope = zend_get_executed_scope();
411	}
412
413	if (scope != ce
414		&& scope
415		&& is_derived_class(ce, scope)
416		&& (zv = zend_hash_find(&scope->properties_info, member)) != NULL
417		&& ((zend_property_info*)Z_PTR_P(zv))->flags & ZEND_ACC_PRIVATE) {
418		property_info = (zend_property_info*)Z_PTR_P(zv);
419		if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) != 0)) {
420			return ZEND_DYNAMIC_PROPERTY_OFFSET;
421		}
422	} else if (UNEXPECTED(property_info == NULL)) {
423exit_dynamic:
424		if (UNEXPECTED(ZSTR_VAL(member)[0] == '\0' && ZSTR_LEN(member) != 0)) {
425			if (!silent) {
426				zend_throw_error(NULL, "Cannot access property started with '\\0'");
427			}
428			return ZEND_WRONG_PROPERTY_OFFSET;
429		}
430		if (cache_slot) {
431			CACHE_POLYMORPHIC_PTR_EX(cache_slot, ce, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
432		}
433		return ZEND_DYNAMIC_PROPERTY_OFFSET;
434	} else if (UNEXPECTED(property_info == ZEND_WRONG_PROPERTY_INFO)) {
435		/* Information was available, but we were denied access.  Error out. */
436		if (!silent) {
437			zend_throw_error(NULL, "Cannot access %s property %s::$%s", zend_visibility_string(flags), ZSTR_VAL(ce->name), ZSTR_VAL(member));
438		}
439		return ZEND_WRONG_PROPERTY_OFFSET;
440	}
441
442exit:
443	if (cache_slot) {
444		CACHE_POLYMORPHIC_PTR_EX(cache_slot, ce, (void*)(uintptr_t)property_info->offset);
445	}
446	return property_info->offset;
447}
448/* }}} */
449
450ZEND_API zend_property_info *zend_get_property_info(zend_class_entry *ce, zend_string *member, int silent) /* {{{ */
451{
452	zval *zv;
453	zend_property_info *property_info = NULL;
454	uint32_t flags;
455	zend_class_entry *scope;
456
457	if (UNEXPECTED(zend_hash_num_elements(&ce->properties_info) == 0)) {
458		goto exit_dynamic;
459	}
460
461	zv = zend_hash_find(&ce->properties_info, member);
462	if (EXPECTED(zv != NULL)) {
463		property_info = (zend_property_info*)Z_PTR_P(zv);
464		flags = property_info->flags;
465		if (UNEXPECTED((flags & ZEND_ACC_SHADOW) != 0)) {
466			/* if it's a shadow - go to access it's private */
467			property_info = NULL;
468		} else {
469			if (EXPECTED(zend_verify_property_access(property_info, ce) != 0)) {
470				if (UNEXPECTED(!(flags & ZEND_ACC_CHANGED))
471					|| UNEXPECTED((flags & ZEND_ACC_PRIVATE))) {
472					if (UNEXPECTED((flags & ZEND_ACC_STATIC) != 0)) {
473						if (!silent) {
474							zend_error(E_NOTICE, "Accessing static property %s::$%s as non static", ZSTR_VAL(ce->name), ZSTR_VAL(member));
475						}
476					}
477					goto exit;
478				}
479			} else {
480				/* Try to look in the scope instead */
481				property_info = ZEND_WRONG_PROPERTY_INFO;
482			}
483		}
484	}
485
486	if (EG(fake_scope)) {
487		scope = EG(fake_scope);
488	} else {
489		scope = zend_get_executed_scope();
490	}
491
492	if (scope != ce
493		&& scope
494		&& is_derived_class(ce, scope)
495		&& (zv = zend_hash_find(&scope->properties_info, member)) != NULL
496		&& ((zend_property_info*)Z_PTR_P(zv))->flags & ZEND_ACC_PRIVATE) {
497		property_info = (zend_property_info*)Z_PTR_P(zv);
498	} else if (UNEXPECTED(property_info == NULL)) {
499exit_dynamic:
500		if (UNEXPECTED(ZSTR_VAL(member)[0] == '\0' && ZSTR_LEN(member) != 0)) {
501			if (!silent) {
502				zend_throw_error(NULL, "Cannot access property started with '\\0'");
503			}
504			return ZEND_WRONG_PROPERTY_INFO;
505		}
506		return NULL;
507	} else if (UNEXPECTED(property_info == ZEND_WRONG_PROPERTY_INFO)) {
508		/* Information was available, but we were denied access.  Error out. */
509		if (!silent) {
510			zend_throw_error(NULL, "Cannot access %s property %s::$%s", zend_visibility_string(flags), ZSTR_VAL(ce->name), ZSTR_VAL(member));
511		}
512		return ZEND_WRONG_PROPERTY_INFO;
513	}
514
515exit:
516	return property_info;
517}
518/* }}} */
519
520ZEND_API int zend_check_property_access(zend_object *zobj, zend_string *prop_info_name) /* {{{ */
521{
522	zend_property_info *property_info;
523	const char *class_name = NULL;
524	const char *prop_name;
525	zend_string *member;
526	size_t prop_name_len;
527
528	if (ZSTR_VAL(prop_info_name)[0] == 0) {
529		zend_unmangle_property_name_ex(prop_info_name, &class_name, &prop_name, &prop_name_len);
530		member = zend_string_init(prop_name, prop_name_len, 0);
531	} else {
532		member = zend_string_copy(prop_info_name);
533	}
534	property_info = zend_get_property_info(zobj->ce, member, 1);
535	zend_string_release_ex(member, 0);
536	if (property_info == NULL) {
537		/* undefined public property */
538		if (class_name && class_name[0] != '*') {
539			/* we we're looking for a private prop */
540			return FAILURE;
541		}
542		return SUCCESS;
543	} else if (property_info == ZEND_WRONG_PROPERTY_INFO) {
544		return FAILURE;
545	}
546	if (class_name && class_name[0] != '*') {
547		if (!(property_info->flags & ZEND_ACC_PRIVATE)) {
548			/* we we're looking for a private prop but found a non private one of the same name */
549			return FAILURE;
550		} else if (strcmp(ZSTR_VAL(prop_info_name)+1, ZSTR_VAL(property_info->name)+1)) {
551			/* we we're looking for a private prop but found a private one of the same name but another class */
552			return FAILURE;
553		}
554	}
555	return zend_verify_property_access(property_info, zobj->ce) ? SUCCESS : FAILURE;
556}
557/* }}} */
558
559static void zend_property_guard_dtor(zval *el) /* {{{ */ {
560	uint32_t *ptr = (uint32_t*)Z_PTR_P(el);
561	if (EXPECTED(!(((zend_uintptr_t)ptr) & 1))) {
562		efree_size(ptr, sizeof(uint32_t));
563	}
564}
565/* }}} */
566
567ZEND_API uint32_t *zend_get_property_guard(zend_object *zobj, zend_string *member) /* {{{ */
568{
569	HashTable *guards;
570	zval *zv;
571	uint32_t *ptr;
572
573	ZEND_ASSERT(zobj->ce->ce_flags & ZEND_ACC_USE_GUARDS);
574	zv = zobj->properties_table + zobj->ce->default_properties_count;
575	if (EXPECTED(Z_TYPE_P(zv) == IS_STRING)) {
576		zend_string *str = Z_STR_P(zv);
577		if (EXPECTED(str == member) ||
578		     /* hash values are always pred-calculated here */
579		    (EXPECTED(ZSTR_H(str) == ZSTR_H(member)) &&
580		     EXPECTED(zend_string_equal_content(str, member)))) {
581			return &Z_PROPERTY_GUARD_P(zv);
582		} else if (EXPECTED(Z_PROPERTY_GUARD_P(zv) == 0)) {
583			zval_ptr_dtor_str(zv);
584			ZVAL_STR_COPY(zv, member);
585			return &Z_PROPERTY_GUARD_P(zv);
586		} else {
587			ALLOC_HASHTABLE(guards);
588			zend_hash_init(guards, 8, NULL, zend_property_guard_dtor, 0);
589			/* mark pointer as "special" using low bit */
590			zend_hash_add_new_ptr(guards, str,
591				(void*)(((zend_uintptr_t)&Z_PROPERTY_GUARD_P(zv)) | 1));
592			zval_ptr_dtor_str(zv);
593			ZVAL_ARR(zv, guards);
594		}
595	} else if (EXPECTED(Z_TYPE_P(zv) == IS_ARRAY)) {
596		guards = Z_ARRVAL_P(zv);
597		ZEND_ASSERT(guards != NULL);
598		zv = zend_hash_find(guards, member);
599		if (zv != NULL) {
600			return (uint32_t*)(((zend_uintptr_t)Z_PTR_P(zv)) & ~1);
601		}
602	} else {
603		ZEND_ASSERT(Z_TYPE_P(zv) == IS_UNDEF);
604		ZVAL_STR_COPY(zv, member);
605		Z_PROPERTY_GUARD_P(zv) = 0;
606		return &Z_PROPERTY_GUARD_P(zv);
607	}
608	/* we have to allocate uint32_t separately because ht->arData may be reallocated */
609	ptr = (uint32_t*)emalloc(sizeof(uint32_t));
610	*ptr = 0;
611	return (uint32_t*)zend_hash_add_new_ptr(guards, member, ptr);
612}
613/* }}} */
614
615ZEND_API zval *zend_std_read_property(zval *object, zval *member, int type, void **cache_slot, zval *rv) /* {{{ */
616{
617	zend_object *zobj;
618	zend_string *name, *tmp_name;
619	zval *retval;
620	uintptr_t property_offset;
621	uint32_t *guard = NULL;
622
623	zobj = Z_OBJ_P(object);
624	name = zval_get_tmp_string(member, &tmp_name);
625
626#if DEBUG_OBJECT_HANDLERS
627	fprintf(stderr, "Read object #%d property: %s\n", Z_OBJ_HANDLE_P(object), ZSTR_VAL(name));
628#endif
629
630	/* make zend_get_property_info silent if we have getter - we may want to use it */
631	property_offset = zend_get_property_offset(zobj->ce, name, (type == BP_VAR_IS) || (zobj->ce->__get != NULL), cache_slot);
632
633	if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
634		retval = OBJ_PROP(zobj, property_offset);
635		if (EXPECTED(Z_TYPE_P(retval) != IS_UNDEF)) {
636			goto exit;
637		}
638	} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
639		if (EXPECTED(zobj->properties != NULL)) {
640			if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(property_offset)) {
641				uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(property_offset);
642
643				if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
644					Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
645
646					if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
647				        (EXPECTED(p->key == name) ||
648				         (EXPECTED(p->h == ZSTR_H(name)) &&
649				          EXPECTED(p->key != NULL) &&
650				          EXPECTED(zend_string_equal_content(p->key, name))))) {
651						retval = &p->val;
652						goto exit;
653					}
654				}
655				CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
656			}
657			retval = zend_hash_find(zobj->properties, name);
658			if (EXPECTED(retval)) {
659				if (cache_slot) {
660					uintptr_t idx = (char*)retval - (char*)zobj->properties->arData;
661					CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
662				}
663				goto exit;
664			}
665		}
666	} else if (UNEXPECTED(EG(exception))) {
667		retval = &EG(uninitialized_zval);
668		goto exit;
669	}
670
671	/* magic isset */
672	if ((type == BP_VAR_IS) && zobj->ce->__isset) {
673		zval tmp_result;
674		guard = zend_get_property_guard(zobj, name);
675
676		if (!((*guard) & IN_ISSET)) {
677			if (!tmp_name && !ZSTR_IS_INTERNED(name)) {
678				tmp_name = zend_string_copy(name);
679			}
680			GC_ADDREF(zobj);
681			ZVAL_UNDEF(&tmp_result);
682
683			*guard |= IN_ISSET;
684			zend_std_call_issetter(zobj, name, &tmp_result);
685			*guard &= ~IN_ISSET;
686
687			if (!zend_is_true(&tmp_result)) {
688				retval = &EG(uninitialized_zval);
689				OBJ_RELEASE(zobj);
690				zval_ptr_dtor(&tmp_result);
691				goto exit;
692			}
693
694			zval_ptr_dtor(&tmp_result);
695			if (zobj->ce->__get && !((*guard) & IN_GET)) {
696				goto call_getter;
697			}
698			OBJ_RELEASE(zobj);
699		} else if (zobj->ce->__get && !((*guard) & IN_GET)) {
700			goto call_getter_addref;
701		}
702	} else if (zobj->ce->__get) {
703		/* magic get */
704		guard = zend_get_property_guard(zobj, name);
705		if (!((*guard) & IN_GET)) {
706			/* have getter - try with it! */
707call_getter_addref:
708			GC_ADDREF(zobj);
709call_getter:
710			*guard |= IN_GET; /* prevent circular getting */
711			zend_std_call_getter(zobj, name, rv);
712			*guard &= ~IN_GET;
713
714			if (Z_TYPE_P(rv) != IS_UNDEF) {
715				retval = rv;
716				if (!Z_ISREF_P(rv) &&
717				    (type == BP_VAR_W || type == BP_VAR_RW  || type == BP_VAR_UNSET)) {
718					if (UNEXPECTED(Z_TYPE_P(rv) != IS_OBJECT)) {
719						zend_error(E_NOTICE, "Indirect modification of overloaded property %s::$%s has no effect", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
720					}
721				}
722			} else {
723				retval = &EG(uninitialized_zval);
724			}
725			OBJ_RELEASE(zobj);
726			goto exit;
727		} else if (ZSTR_VAL(name)[0] == '\0' && ZSTR_LEN(name) != 0) {
728			zend_throw_error(NULL, "Cannot access property started with '\\0'");
729			retval = &EG(uninitialized_zval);
730			goto exit;
731		}
732	}
733
734	if ((type != BP_VAR_IS)) {
735		zend_error(E_NOTICE,"Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
736	}
737	retval = &EG(uninitialized_zval);
738
739exit:
740	zend_tmp_string_release(tmp_name);
741
742	return retval;
743}
744/* }}} */
745
746ZEND_API void zend_std_write_property(zval *object, zval *member, zval *value, void **cache_slot) /* {{{ */
747{
748	zend_object *zobj;
749	zend_string *name, *tmp_name;
750	zval *variable_ptr;
751	uintptr_t property_offset;
752
753	zobj = Z_OBJ_P(object);
754	name = zval_get_tmp_string(member, &tmp_name);
755
756	property_offset = zend_get_property_offset(zobj->ce, name, (zobj->ce->__set != NULL), cache_slot);
757
758	if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
759		variable_ptr = OBJ_PROP(zobj, property_offset);
760		if (Z_TYPE_P(variable_ptr) != IS_UNDEF) {
761			goto found;
762		}
763	} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
764		if (EXPECTED(zobj->properties != NULL)) {
765			if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
766				if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
767					GC_DELREF(zobj->properties);
768				}
769				zobj->properties = zend_array_dup(zobj->properties);
770			}
771			if ((variable_ptr = zend_hash_find(zobj->properties, name)) != NULL) {
772found:
773				zend_assign_to_variable(variable_ptr, value, IS_CV);
774				goto exit;
775			}
776		}
777	} else if (UNEXPECTED(EG(exception))) {
778		goto exit;
779	}
780
781	/* magic set */
782	if (zobj->ce->__set) {
783		uint32_t *guard = zend_get_property_guard(zobj, name);
784
785	    if (!((*guard) & IN_SET)) {
786			GC_ADDREF(zobj);
787			(*guard) |= IN_SET; /* prevent circular setting */
788			zend_std_call_setter(zobj, name, value);
789			(*guard) &= ~IN_SET;
790			OBJ_RELEASE(zobj);
791		} else if (EXPECTED(!IS_WRONG_PROPERTY_OFFSET(property_offset))) {
792			goto write_std_property;
793		} else {
794			if (ZSTR_VAL(name)[0] == '\0' && ZSTR_LEN(name) != 0) {
795				zend_throw_error(NULL, "Cannot access property started with '\\0'");
796				goto exit;
797			}
798		}
799	} else if (EXPECTED(!IS_WRONG_PROPERTY_OFFSET(property_offset))) {
800write_std_property:
801		if (Z_REFCOUNTED_P(value)) {
802			if (Z_ISREF_P(value)) {
803				/* if we assign referenced variable, we should separate it */
804				value = Z_REFVAL_P(value);
805				if (Z_REFCOUNTED_P(value)) {
806					Z_ADDREF_P(value);
807				}
808			} else {
809				Z_ADDREF_P(value);
810			}
811		}
812		if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
813			ZVAL_COPY_VALUE(OBJ_PROP(zobj, property_offset), value);
814		} else {
815			if (!zobj->properties) {
816				rebuild_object_properties(zobj);
817			}
818			zend_hash_add_new(zobj->properties, name, value);
819		}
820	}
821
822exit:
823	zend_tmp_string_release(tmp_name);
824}
825/* }}} */
826
827ZEND_API zval *zend_std_read_dimension(zval *object, zval *offset, int type, zval *rv) /* {{{ */
828{
829	zend_class_entry *ce = Z_OBJCE_P(object);
830	zval tmp_offset, tmp_object;
831
832	if (EXPECTED(instanceof_function_ex(ce, zend_ce_arrayaccess, 1) != 0)) {
833		if (offset == NULL) {
834			/* [] construct */
835			ZVAL_NULL(&tmp_offset);
836		} else {
837			ZVAL_COPY_DEREF(&tmp_offset, offset);
838		}
839
840		ZVAL_COPY(&tmp_object, object);
841		if (type == BP_VAR_IS) {
842			zend_call_method_with_1_params(&tmp_object, ce, NULL, "offsetexists", rv, &tmp_offset);
843			if (UNEXPECTED(Z_ISUNDEF_P(rv))) {
844				zval_ptr_dtor(&tmp_object);
845				zval_ptr_dtor(&tmp_offset);
846				return NULL;
847			}
848			if (!i_zend_is_true(rv)) {
849				zval_ptr_dtor(&tmp_object);
850				zval_ptr_dtor(&tmp_offset);
851				zval_ptr_dtor(rv);
852				return &EG(uninitialized_zval);
853			}
854			zval_ptr_dtor(rv);
855		}
856
857		zend_call_method_with_1_params(&tmp_object, ce, NULL, "offsetget", rv, &tmp_offset);
858
859		zval_ptr_dtor(&tmp_object);
860		zval_ptr_dtor(&tmp_offset);
861
862		if (UNEXPECTED(Z_TYPE_P(rv) == IS_UNDEF)) {
863			if (UNEXPECTED(!EG(exception))) {
864				zend_throw_error(NULL, "Undefined offset for object of type %s used as array", ZSTR_VAL(ce->name));
865			}
866			return NULL;
867		}
868		return rv;
869	} else {
870		zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->name));
871		return NULL;
872	}
873}
874/* }}} */
875
876ZEND_API void zend_std_write_dimension(zval *object, zval *offset, zval *value) /* {{{ */
877{
878	zend_class_entry *ce = Z_OBJCE_P(object);
879	zval tmp_offset, tmp_object;
880
881	if (EXPECTED(instanceof_function_ex(ce, zend_ce_arrayaccess, 1) != 0)) {
882		if (!offset) {
883			ZVAL_NULL(&tmp_offset);
884		} else {
885			ZVAL_COPY_DEREF(&tmp_offset, offset);
886		}
887		ZVAL_COPY(&tmp_object, object);
888		zend_call_method_with_2_params(&tmp_object, ce, NULL, "offsetset", NULL, &tmp_offset, value);
889		zval_ptr_dtor(&tmp_object);
890		zval_ptr_dtor(&tmp_offset);
891	} else {
892		zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->name));
893	}
894}
895/* }}} */
896
897ZEND_API int zend_std_has_dimension(zval *object, zval *offset, int check_empty) /* {{{ */
898{
899	zend_class_entry *ce = Z_OBJCE_P(object);
900	zval retval, tmp_offset, tmp_object;
901	int result;
902
903	if (EXPECTED(instanceof_function_ex(ce, zend_ce_arrayaccess, 1) != 0)) {
904		ZVAL_COPY_DEREF(&tmp_offset, offset);
905		ZVAL_COPY(&tmp_object, object);
906		zend_call_method_with_1_params(&tmp_object, ce, NULL, "offsetexists", &retval, &tmp_offset);
907		result = i_zend_is_true(&retval);
908		zval_ptr_dtor(&retval);
909		if (check_empty && result && EXPECTED(!EG(exception))) {
910			zend_call_method_with_1_params(&tmp_object, ce, NULL, "offsetget", &retval, &tmp_offset);
911			result = i_zend_is_true(&retval);
912			zval_ptr_dtor(&retval);
913		}
914		zval_ptr_dtor(&tmp_object);
915		zval_ptr_dtor(&tmp_offset);
916	} else {
917		zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->name));
918		return 0;
919	}
920	return result;
921}
922/* }}} */
923
924ZEND_API zval *zend_std_get_property_ptr_ptr(zval *object, zval *member, int type, void **cache_slot) /* {{{ */
925{
926	zend_object *zobj;
927	zend_string *name, *tmp_name;
928	zval *retval = NULL;
929	uintptr_t property_offset;
930
931	zobj = Z_OBJ_P(object);
932	name = zval_get_tmp_string(member, &tmp_name);
933
934#if DEBUG_OBJECT_HANDLERS
935	fprintf(stderr, "Ptr object #%d property: %s\n", Z_OBJ_HANDLE_P(object), ZSTR_VAL(name));
936#endif
937
938	property_offset = zend_get_property_offset(zobj->ce, name, (zobj->ce->__get != NULL), cache_slot);
939
940	if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
941		retval = OBJ_PROP(zobj, property_offset);
942		if (UNEXPECTED(Z_TYPE_P(retval) == IS_UNDEF)) {
943			if (EXPECTED(!zobj->ce->__get) ||
944			    UNEXPECTED((*zend_get_property_guard(zobj, name)) & IN_GET)) {
945				ZVAL_NULL(retval);
946				/* Notice is thrown after creation of the property, to avoid EG(std_property_info)
947				 * being overwritten in an error handler. */
948				if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
949					zend_error(E_NOTICE, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
950				}
951			} else {
952				/* we do have getter - fail and let it try again with usual get/set */
953				retval = NULL;
954			}
955		}
956	} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
957		if (EXPECTED(zobj->properties)) {
958			if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
959				if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
960					GC_DELREF(zobj->properties);
961				}
962				zobj->properties = zend_array_dup(zobj->properties);
963			}
964		    if (EXPECTED((retval = zend_hash_find(zobj->properties, name)) != NULL)) {
965				zend_tmp_string_release(tmp_name);
966				return retval;
967		    }
968		}
969		if (EXPECTED(!zobj->ce->__get) ||
970		    UNEXPECTED((*zend_get_property_guard(zobj, name)) & IN_GET)) {
971			if (UNEXPECTED(!zobj->properties)) {
972				rebuild_object_properties(zobj);
973			}
974			retval = zend_hash_update(zobj->properties, name, &EG(uninitialized_zval));
975			/* Notice is thrown after creation of the property, to avoid EG(std_property_info)
976			 * being overwritten in an error handler. */
977			if (UNEXPECTED(type == BP_VAR_RW || type == BP_VAR_R)) {
978				zend_error(E_NOTICE, "Undefined property: %s::$%s", ZSTR_VAL(zobj->ce->name), ZSTR_VAL(name));
979			}
980		}
981	}
982
983	zend_tmp_string_release(tmp_name);
984	return retval;
985}
986/* }}} */
987
988ZEND_API void zend_std_unset_property(zval *object, zval *member, void **cache_slot) /* {{{ */
989{
990	zend_object *zobj;
991	zend_string *name, *tmp_name;
992	uintptr_t property_offset;
993
994	zobj = Z_OBJ_P(object);
995	name = zval_get_tmp_string(member, &tmp_name);
996
997	property_offset = zend_get_property_offset(zobj->ce, name, (zobj->ce->__unset != NULL), cache_slot);
998
999	if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
1000		zval *slot = OBJ_PROP(zobj, property_offset);
1001
1002		if (Z_TYPE_P(slot) != IS_UNDEF) {
1003			zval_ptr_dtor(slot);
1004			ZVAL_UNDEF(slot);
1005			if (zobj->properties) {
1006				HT_FLAGS(zobj->properties) |= HASH_FLAG_HAS_EMPTY_IND;
1007			}
1008			goto exit;
1009		}
1010	} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))
1011	 && EXPECTED(zobj->properties != NULL)) {
1012		if (UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {
1013			if (EXPECTED(!(GC_FLAGS(zobj->properties) & IS_ARRAY_IMMUTABLE))) {
1014				GC_DELREF(zobj->properties);
1015			}
1016			zobj->properties = zend_array_dup(zobj->properties);
1017		}
1018		if (EXPECTED(zend_hash_del(zobj->properties, name) != FAILURE)) {
1019			goto exit;
1020		}
1021	} else if (UNEXPECTED(EG(exception))) {
1022		goto exit;
1023	}
1024
1025	/* magic unset */
1026	if (zobj->ce->__unset) {
1027		uint32_t *guard = zend_get_property_guard(zobj, name);
1028		if (!((*guard) & IN_UNSET)) {
1029			/* have unseter - try with it! */
1030			(*guard) |= IN_UNSET; /* prevent circular unsetting */
1031			zend_std_call_unsetter(zobj, name);
1032			(*guard) &= ~IN_UNSET;
1033		} else {
1034			if (ZSTR_VAL(name)[0] == '\0' && ZSTR_LEN(name) != 0) {
1035				zend_throw_error(NULL, "Cannot access property started with '\\0'");
1036				goto exit;
1037			}
1038		}
1039	}
1040
1041exit:
1042	zend_tmp_string_release(tmp_name);
1043}
1044/* }}} */
1045
1046ZEND_API void zend_std_unset_dimension(zval *object, zval *offset) /* {{{ */
1047{
1048	zend_class_entry *ce = Z_OBJCE_P(object);
1049	zval tmp_offset, tmp_object;
1050
1051	if (instanceof_function_ex(ce, zend_ce_arrayaccess, 1)) {
1052		ZVAL_COPY_DEREF(&tmp_offset, offset);
1053		ZVAL_COPY(&tmp_object, object);
1054		zend_call_method_with_1_params(&tmp_object, ce, NULL, "offsetunset", NULL, &tmp_offset);
1055		zval_ptr_dtor(&tmp_object);
1056		zval_ptr_dtor(&tmp_offset);
1057	} else {
1058		zend_throw_error(NULL, "Cannot use object of type %s as array", ZSTR_VAL(ce->name));
1059	}
1060}
1061/* }}} */
1062
1063static zend_always_inline zend_function *zend_get_parent_private(zend_class_entry *scope, zend_class_entry *ce, zend_string *function_name) /* {{{ */
1064{
1065	zval *func;
1066	zend_function *fbc;
1067
1068	ce = ce->parent;
1069	while (ce) {
1070		if (ce == scope) {
1071			if ((func = zend_hash_find(&ce->function_table, function_name))) {
1072				fbc = Z_FUNC_P(func);
1073				if (fbc->common.fn_flags & ZEND_ACC_PRIVATE
1074				 && fbc->common.scope == scope) {
1075					return fbc;
1076				}
1077			}
1078			break;
1079		}
1080		ce = ce->parent;
1081	}
1082	return NULL;
1083}
1084/* }}} */
1085
1086/* Ensures that we're allowed to call a private method.
1087 * Returns the function address that should be called, or NULL
1088 * if no such function exists.
1089 */
1090ZEND_API int zend_check_private(zend_function *fbc, zend_class_entry *ce, zend_string *function_name) /* {{{ */
1091{
1092    zend_class_entry *scope;
1093
1094	if (!ce) {
1095		return 0;
1096	}
1097
1098	/* We may call a private function if:
1099	 * 1.  The class of our object is the same as the scope, and the private
1100	 *     function (EX(fbc)) has the same scope.
1101	 * 2.  One of our parent classes are the same as the scope, and it contains
1102	 *     a private function with the same name that has the same scope.
1103	 */
1104	scope = zend_get_executed_scope();
1105	if (fbc->common.scope == ce && scope == ce) {
1106		/* rule #1 checks out ok, allow the function call */
1107		return 1;
1108	}
1109
1110
1111	/* Check rule #2 */
1112	return zend_get_parent_private(scope, ce, function_name) != NULL;
1113}
1114/* }}} */
1115
1116/* Ensures that we're allowed to call a protected method.
1117 */
1118ZEND_API int zend_check_protected(zend_class_entry *ce, zend_class_entry *scope) /* {{{ */
1119{
1120	zend_class_entry *fbc_scope = ce;
1121
1122	/* Is the context that's calling the function, the same as one of
1123	 * the function's parents?
1124	 */
1125	while (fbc_scope) {
1126		if (fbc_scope==scope) {
1127			return 1;
1128		}
1129		fbc_scope = fbc_scope->parent;
1130	}
1131
1132	/* Is the function's scope the same as our current object context,
1133	 * or any of the parents of our context?
1134	 */
1135	while (scope) {
1136		if (scope==ce) {
1137			return 1;
1138		}
1139		scope = scope->parent;
1140	}
1141	return 0;
1142}
1143/* }}} */
1144
1145ZEND_API zend_function *zend_get_call_trampoline_func(zend_class_entry *ce, zend_string *method_name, int is_static) /* {{{ */
1146{
1147	size_t mname_len;
1148	zend_op_array *func;
1149	zend_function *fbc = is_static ? ce->__callstatic : ce->__call;
1150
1151	ZEND_ASSERT(fbc);
1152
1153	if (EXPECTED(EG(trampoline).common.function_name == NULL)) {
1154		func = &EG(trampoline).op_array;
1155	} else {
1156		func = ecalloc(1, sizeof(zend_op_array));
1157	}
1158
1159	func->type = ZEND_USER_FUNCTION;
1160	func->arg_flags[0] = 0;
1161	func->arg_flags[1] = 0;
1162	func->arg_flags[2] = 0;
1163	func->fn_flags = ZEND_ACC_CALL_VIA_TRAMPOLINE | ZEND_ACC_PUBLIC;
1164	if (is_static) {
1165		func->fn_flags |= ZEND_ACC_STATIC;
1166	}
1167	func->opcodes = &EG(call_trampoline_op);
1168	func->run_time_cache = (void*)(intptr_t)-1;
1169	func->scope = fbc->common.scope;
1170	/* reserve space for arguments, local and temorary variables */
1171	func->T = (fbc->type == ZEND_USER_FUNCTION)? MAX(fbc->op_array.last_var + fbc->op_array.T, 2) : 2;
1172	func->filename = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.filename : ZSTR_EMPTY_ALLOC();
1173	func->line_start = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_start : 0;
1174	func->line_end = (fbc->type == ZEND_USER_FUNCTION)? fbc->op_array.line_end : 0;
1175
1176	//??? keep compatibility for "\0" characters
1177	//??? see: Zend/tests/bug46238.phpt
1178	if (UNEXPECTED((mname_len = strlen(ZSTR_VAL(method_name))) != ZSTR_LEN(method_name))) {
1179		func->function_name = zend_string_init(ZSTR_VAL(method_name), mname_len, 0);
1180	} else {
1181		func->function_name = zend_string_copy(method_name);
1182	}
1183
1184	return (zend_function*)func;
1185}
1186/* }}} */
1187
1188static zend_always_inline zend_function *zend_get_user_call_function(zend_class_entry *ce, zend_string *method_name) /* {{{ */
1189{
1190	return zend_get_call_trampoline_func(ce, method_name, 0);
1191}
1192/* }}} */
1193
1194ZEND_API zend_function *zend_std_get_method(zend_object **obj_ptr, zend_string *method_name, const zval *key) /* {{{ */
1195{
1196	zend_object *zobj = *obj_ptr;
1197	zval *func;
1198	zend_function *fbc;
1199	zend_string *lc_method_name;
1200	zend_class_entry *scope = NULL;
1201	ALLOCA_FLAG(use_heap);
1202
1203	if (EXPECTED(key != NULL)) {
1204		lc_method_name = Z_STR_P(key);
1205#ifdef ZEND_ALLOCA_MAX_SIZE
1206		use_heap = 0;
1207#endif
1208	} else {
1209		ZSTR_ALLOCA_ALLOC(lc_method_name, ZSTR_LEN(method_name), use_heap);
1210		zend_str_tolower_copy(ZSTR_VAL(lc_method_name), ZSTR_VAL(method_name), ZSTR_LEN(method_name));
1211	}
1212
1213	if (UNEXPECTED((func = zend_hash_find(&zobj->ce->function_table, lc_method_name)) == NULL)) {
1214		if (UNEXPECTED(!key)) {
1215			ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
1216		}
1217		if (zobj->ce->__call) {
1218			return zend_get_user_call_function(zobj->ce, method_name);
1219		} else {
1220			return NULL;
1221		}
1222	}
1223
1224	fbc = Z_FUNC_P(func);
1225	/* Check access level */
1226	if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
1227		/* Ensure that if we're calling a private function, we're allowed to do so.
1228		 * If we're not and __call() handler exists, invoke it, otherwise error out.
1229		 */
1230		scope = zend_get_executed_scope();
1231		if (fbc->common.scope != scope || zobj->ce != scope) {
1232			zend_function *updated_fbc = zend_get_parent_private(scope, zobj->ce, lc_method_name);
1233			if (EXPECTED(updated_fbc != NULL)) {
1234				fbc = updated_fbc;
1235			} else {
1236				if (zobj->ce->__call) {
1237					fbc = zend_get_user_call_function(zobj->ce, method_name);
1238				} else {
1239					scope = zend_get_executed_scope();
1240					zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), scope ? ZSTR_VAL(scope->name) : "");
1241					fbc = NULL;
1242				}
1243			}
1244		}
1245	} else if (fbc->op_array.fn_flags & (ZEND_ACC_CHANGED|ZEND_ACC_PROTECTED)) {
1246		/* Ensure that we haven't overridden a private function and end up calling
1247		 * the overriding public function...
1248		 */
1249
1250		scope = zend_get_executed_scope();
1251		do {
1252			if (fbc->op_array.fn_flags & ZEND_ACC_CHANGED) {
1253				zend_function *priv_fbc = zend_get_parent_private(scope, fbc->common.scope, lc_method_name);
1254				if (priv_fbc) {
1255					fbc = priv_fbc;
1256					break;
1257				} else if (!(fbc->op_array.fn_flags & ZEND_ACC_PROTECTED)) {
1258					break;
1259				}
1260			}
1261
1262			/* Ensure that if we're calling a protected function, we're allowed to do so.
1263			 * If we're not and __call() handler exists, invoke it, otherwise error out.
1264			 */
1265			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), scope))) {
1266				if (zobj->ce->__call) {
1267					fbc = zend_get_user_call_function(zobj->ce, method_name);
1268				} else {
1269					zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(method_name), scope ? ZSTR_VAL(scope->name) : "");
1270					fbc = NULL;
1271				}
1272			}
1273		} while (0);
1274	}
1275
1276	if (UNEXPECTED(!key)) {
1277		ZSTR_ALLOCA_FREE(lc_method_name, use_heap);
1278	}
1279	return fbc;
1280}
1281/* }}} */
1282
1283static zend_always_inline zend_function *zend_get_user_callstatic_function(zend_class_entry *ce, zend_string *method_name) /* {{{ */
1284{
1285	return zend_get_call_trampoline_func(ce, method_name, 1);
1286}
1287/* }}} */
1288
1289ZEND_API zend_function *zend_std_get_static_method(zend_class_entry *ce, zend_string *function_name, const zval *key) /* {{{ */
1290{
1291	zend_function *fbc = NULL;
1292	zend_string *lc_function_name;
1293	zend_object *object;
1294	zend_class_entry *scope;
1295
1296	if (EXPECTED(key != NULL)) {
1297		lc_function_name = Z_STR_P(key);
1298	} else {
1299		lc_function_name = zend_string_tolower(function_name);
1300	}
1301
1302	do {
1303		zval *func = zend_hash_find(&ce->function_table, lc_function_name);
1304		if (EXPECTED(func != NULL)) {
1305			fbc = Z_FUNC_P(func);
1306		} else if (ce->constructor
1307			&& ZSTR_LEN(lc_function_name) == ZSTR_LEN(ce->name)
1308			&& zend_binary_strncasecmp(ZSTR_VAL(lc_function_name), ZSTR_LEN(lc_function_name), ZSTR_VAL(ce->name), ZSTR_LEN(lc_function_name), ZSTR_LEN(lc_function_name)) == 0
1309			/* Only change the method to the constructor if the constructor isn't called __construct
1310			 * we check for __ so we can be binary safe for lowering, we should use ZEND_CONSTRUCTOR_FUNC_NAME
1311			 */
1312			&& (ZSTR_VAL(ce->constructor->common.function_name)[0] != '_'
1313				|| ZSTR_VAL(ce->constructor->common.function_name)[1] != '_')) {
1314			fbc = ce->constructor;
1315		} else {
1316			if (UNEXPECTED(!key)) {
1317				zend_string_release_ex(lc_function_name, 0);
1318			}
1319			if (ce->__call &&
1320				(object = zend_get_this_object(EG(current_execute_data))) != NULL &&
1321			    instanceof_function(object->ce, ce)) {
1322				/* Call the top-level defined __call().
1323				 * see: tests/classes/__call_004.phpt  */
1324
1325				zend_class_entry *call_ce = object->ce;
1326
1327				while (!call_ce->__call) {
1328					call_ce = call_ce->parent;
1329				}
1330				return zend_get_user_call_function(call_ce, function_name);
1331			} else if (ce->__callstatic) {
1332				return zend_get_user_callstatic_function(ce, function_name);
1333			} else {
1334	   			return NULL;
1335			}
1336		}
1337	} while (0);
1338
1339#if MBO_0
1340	/* right now this function is used for non static method lookup too */
1341	/* Is the function static */
1342	if (UNEXPECTED(!(fbc->common.fn_flags & ZEND_ACC_STATIC))) {
1343		zend_error_noreturn(E_ERROR, "Cannot call non static method %s::%s() without object", ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(fbc->common.function_name));
1344	}
1345#endif
1346	if (fbc->op_array.fn_flags & ZEND_ACC_PUBLIC) {
1347		/* No further checks necessary, most common case */
1348	} else if (fbc->op_array.fn_flags & ZEND_ACC_PRIVATE) {
1349		/* Ensure that if we're calling a private function, we're allowed to do so.
1350		 */
1351		scope = zend_get_executed_scope();
1352		if (UNEXPECTED(fbc->common.scope != scope)) {
1353			if (ce->__callstatic) {
1354				fbc = zend_get_user_callstatic_function(ce, function_name);
1355			} else {
1356				zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(function_name), scope ? ZSTR_VAL(scope->name) : "");
1357				fbc = NULL;
1358			}
1359		}
1360	} else if ((fbc->common.fn_flags & ZEND_ACC_PROTECTED)) {
1361		/* Ensure that if we're calling a protected function, we're allowed to do so.
1362		 */
1363		scope = zend_get_executed_scope();
1364		if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(fbc), scope))) {
1365			if (ce->__callstatic) {
1366				fbc = zend_get_user_callstatic_function(ce, function_name);
1367			} else {
1368				zend_throw_error(NULL, "Call to %s method %s::%s() from context '%s'", zend_visibility_string(fbc->common.fn_flags), ZEND_FN_SCOPE_NAME(fbc), ZSTR_VAL(function_name), scope ? ZSTR_VAL(scope->name) : "");
1369				fbc = NULL;
1370			}
1371		}
1372	}
1373
1374	if (UNEXPECTED(!key)) {
1375		zend_string_release_ex(lc_function_name, 0);
1376	}
1377
1378	return fbc;
1379}
1380/* }}} */
1381
1382ZEND_API void zend_class_init_statics(zend_class_entry *class_type) /* {{{ */
1383{
1384	int i;
1385	zval *p;
1386
1387	if (!CE_STATIC_MEMBERS(class_type) && class_type->default_static_members_count) {
1388		if (class_type->parent) {
1389			zend_class_init_statics(class_type->parent);
1390		}
1391
1392#if ZTS
1393		CG(static_members_table)[(zend_intptr_t)(class_type->static_members_table)] = emalloc(sizeof(zval) * class_type->default_static_members_count);
1394#else
1395		class_type->static_members_table = emalloc(sizeof(zval) * class_type->default_static_members_count);
1396#endif
1397		for (i = 0; i < class_type->default_static_members_count; i++) {
1398			p = &class_type->default_static_members_table[i];
1399			if (Z_TYPE_P(p) == IS_INDIRECT) {
1400				zval *q = &CE_STATIC_MEMBERS(class_type->parent)[i];
1401				ZVAL_DEINDIRECT(q);
1402				ZVAL_INDIRECT(&CE_STATIC_MEMBERS(class_type)[i], q);
1403			} else {
1404				ZVAL_COPY_OR_DUP(&CE_STATIC_MEMBERS(class_type)[i], p);
1405			}
1406		}
1407	}
1408} /* }}} */
1409
1410ZEND_API zval *zend_std_get_static_property(zend_class_entry *ce, zend_string *property_name, zend_bool silent) /* {{{ */
1411{
1412	zend_property_info *property_info = zend_hash_find_ptr(&ce->properties_info, property_name);
1413	zval *ret;
1414
1415	if (UNEXPECTED(property_info == NULL)) {
1416		goto undeclared_property;
1417	}
1418
1419	if (UNEXPECTED(!zend_verify_property_access(property_info, ce))) {
1420		if (!silent) {
1421			zend_throw_error(NULL, "Cannot access %s property %s::$%s", zend_visibility_string(property_info->flags), ZSTR_VAL(ce->name), ZSTR_VAL(property_name));
1422		}
1423		return NULL;
1424	}
1425
1426	if (UNEXPECTED((property_info->flags & ZEND_ACC_STATIC) == 0)) {
1427		goto undeclared_property;
1428	}
1429
1430	if (UNEXPECTED(!(ce->ce_flags & ZEND_ACC_CONSTANTS_UPDATED))) {
1431		if (UNEXPECTED(zend_update_class_constants(ce)) != SUCCESS) {
1432			return NULL;
1433		}
1434	}
1435
1436	/* check if static properties were destoyed */
1437	if (UNEXPECTED(CE_STATIC_MEMBERS(ce) == NULL)) {
1438		if (ce->type == ZEND_INTERNAL_CLASS) {
1439			zend_class_init_statics(ce);
1440		} else {
1441undeclared_property:
1442			if (!silent) {
1443				zend_throw_error(NULL, "Access to undeclared static property: %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(property_name));
1444			}
1445			return NULL;
1446		}
1447	}
1448
1449	ret = CE_STATIC_MEMBERS(ce) + property_info->offset;
1450	ZVAL_DEINDIRECT(ret);
1451	return ret;
1452}
1453/* }}} */
1454
1455ZEND_API ZEND_COLD zend_bool zend_std_unset_static_property(zend_class_entry *ce, zend_string *property_name) /* {{{ */
1456{
1457	zend_throw_error(NULL, "Attempt to unset static property %s::$%s", ZSTR_VAL(ce->name), ZSTR_VAL(property_name));
1458	return 0;
1459}
1460/* }}} */
1461
1462ZEND_API zend_function *zend_std_get_constructor(zend_object *zobj) /* {{{ */
1463{
1464	zend_function *constructor = zobj->ce->constructor;
1465	zend_class_entry *scope;
1466
1467	if (constructor) {
1468		if (constructor->op_array.fn_flags & ZEND_ACC_PUBLIC) {
1469			/* No further checks necessary */
1470		} else if (constructor->op_array.fn_flags & ZEND_ACC_PRIVATE) {
1471			/* Ensure that if we're calling a private function, we're allowed to do so.
1472			 */
1473			if (EG(fake_scope)) {
1474				scope = EG(fake_scope);
1475			} else {
1476				scope = zend_get_executed_scope();
1477			}
1478			if (UNEXPECTED(constructor->common.scope != scope)) {
1479				if (scope) {
1480					zend_throw_error(NULL, "Call to private %s::%s() from context '%s'", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(scope->name));
1481					constructor = NULL;
1482				} else {
1483					zend_throw_error(NULL, "Call to private %s::%s() from invalid context", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name));
1484					constructor = NULL;
1485				}
1486			}
1487		} else if ((constructor->common.fn_flags & ZEND_ACC_PROTECTED)) {
1488			/* Ensure that if we're calling a protected function, we're allowed to do so.
1489			 * Constructors only have prototype if they are defined by an interface but
1490			 * it is the compilers responsibility to take care of the prototype.
1491			 */
1492			if (EG(fake_scope)) {
1493				scope = EG(fake_scope);
1494			} else {
1495				scope = zend_get_executed_scope();
1496			}
1497			if (UNEXPECTED(!zend_check_protected(zend_get_function_root_class(constructor), scope))) {
1498				if (scope) {
1499					zend_throw_error(NULL, "Call to protected %s::%s() from context '%s'", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name), ZSTR_VAL(scope->name));
1500					constructor = NULL;
1501				} else {
1502					zend_throw_error(NULL, "Call to protected %s::%s() from invalid context", ZSTR_VAL(constructor->common.scope->name), ZSTR_VAL(constructor->common.function_name));
1503					constructor = NULL;
1504				}
1505			}
1506		}
1507	}
1508
1509	return constructor;
1510}
1511/* }}} */
1512
1513ZEND_API int zend_std_compare_objects(zval *o1, zval *o2) /* {{{ */
1514{
1515	zend_object *zobj1, *zobj2;
1516
1517	zobj1 = Z_OBJ_P(o1);
1518	zobj2 = Z_OBJ_P(o2);
1519
1520	if (zobj1 == zobj2) {
1521		return 0; /* the same object */
1522	}
1523	if (zobj1->ce != zobj2->ce) {
1524		return 1; /* different classes */
1525	}
1526	if (!zobj1->properties && !zobj2->properties) {
1527		zend_property_info *info;
1528
1529		if (!zobj1->ce->default_properties_count) {
1530			return 0;
1531		}
1532
1533		/* It's enough to protect only one of the objects.
1534		 * The second one may be referenced from the first and this may cause
1535		 * false recursion detection.
1536		 */
1537		/* use bitwise OR to make only one conditional jump */
1538		if (UNEXPECTED(Z_IS_RECURSIVE_P(o1))) {
1539			zend_error_noreturn(E_ERROR, "Nesting level too deep - recursive dependency?");
1540		}
1541		Z_PROTECT_RECURSION_P(o1);
1542
1543		ZEND_HASH_FOREACH_PTR(&zobj1->ce->properties_info, info) {
1544			zval *p1 = OBJ_PROP(zobj1, info->offset);
1545			zval *p2 = OBJ_PROP(zobj2, info->offset);
1546
1547			if (info->flags & ZEND_ACC_STATIC) {
1548				continue;
1549			}
1550
1551			if (Z_TYPE_P(p1) != IS_UNDEF) {
1552				if (Z_TYPE_P(p2) != IS_UNDEF) {
1553					zval result;
1554
1555					if (compare_function(&result, p1, p2)==FAILURE) {
1556						Z_UNPROTECT_RECURSION_P(o1);
1557						return 1;
1558					}
1559					if (Z_LVAL(result) != 0) {
1560						Z_UNPROTECT_RECURSION_P(o1);
1561						return Z_LVAL(result);
1562					}
1563				} else {
1564					Z_UNPROTECT_RECURSION_P(o1);
1565					return 1;
1566				}
1567			} else {
1568				if (Z_TYPE_P(p2) != IS_UNDEF) {
1569					Z_UNPROTECT_RECURSION_P(o1);
1570					return 1;
1571				}
1572			}
1573		} ZEND_HASH_FOREACH_END();
1574
1575		Z_UNPROTECT_RECURSION_P(o1);
1576		return 0;
1577	} else {
1578		if (!zobj1->properties) {
1579			rebuild_object_properties(zobj1);
1580		}
1581		if (!zobj2->properties) {
1582			rebuild_object_properties(zobj2);
1583		}
1584		return zend_compare_symbol_tables(zobj1->properties, zobj2->properties);
1585	}
1586}
1587/* }}} */
1588
1589ZEND_API int zend_std_has_property(zval *object, zval *member, int has_set_exists, void **cache_slot) /* {{{ */
1590{
1591	zend_object *zobj;
1592	int result;
1593	zval *value = NULL;
1594	zend_string *name, *tmp_name;
1595	uintptr_t property_offset;
1596
1597	zobj = Z_OBJ_P(object);
1598	name = zval_get_tmp_string(member, &tmp_name);
1599
1600	property_offset = zend_get_property_offset(zobj->ce, name, 1, cache_slot);
1601
1602	if (EXPECTED(IS_VALID_PROPERTY_OFFSET(property_offset))) {
1603		value = OBJ_PROP(zobj, property_offset);
1604		if (Z_TYPE_P(value) != IS_UNDEF) {
1605			goto found;
1606		}
1607	} else if (EXPECTED(IS_DYNAMIC_PROPERTY_OFFSET(property_offset))) {
1608		if (EXPECTED(zobj->properties != NULL)) {
1609			if (!IS_UNKNOWN_DYNAMIC_PROPERTY_OFFSET(property_offset)) {
1610				uintptr_t idx = ZEND_DECODE_DYN_PROP_OFFSET(property_offset);
1611
1612				if (EXPECTED(idx < zobj->properties->nNumUsed * sizeof(Bucket))) {
1613					Bucket *p = (Bucket*)((char*)zobj->properties->arData + idx);
1614
1615					if (EXPECTED(Z_TYPE(p->val) != IS_UNDEF) &&
1616				        (EXPECTED(p->key == name) ||
1617				         (EXPECTED(p->h == ZSTR_H(name)) &&
1618				          EXPECTED(p->key != NULL) &&
1619				          EXPECTED(zend_string_equal_content(p->key, name))))) {
1620						value = &p->val;
1621						goto found;
1622					}
1623				}
1624				CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_DYNAMIC_PROPERTY_OFFSET);
1625			}
1626			value = zend_hash_find(zobj->properties, name);
1627			if (value) {
1628				if (cache_slot) {
1629					uintptr_t idx = (char*)value - (char*)zobj->properties->arData;
1630					CACHE_PTR_EX(cache_slot + 1, (void*)ZEND_ENCODE_DYN_PROP_OFFSET(idx));
1631				}
1632found:
1633				if (has_set_exists == ZEND_PROPERTY_NOT_EMPTY) {
1634					result = zend_is_true(value);
1635				} else if (has_set_exists < ZEND_PROPERTY_NOT_EMPTY) {
1636					ZEND_ASSERT(has_set_exists == ZEND_PROPERTY_ISSET);
1637					ZVAL_DEREF(value);
1638					result = (Z_TYPE_P(value) != IS_NULL);
1639				} else {
1640					ZEND_ASSERT(has_set_exists == ZEND_PROPERTY_EXISTS);
1641					result = 1;
1642				}
1643				goto exit;
1644			}
1645		}
1646	} else if (UNEXPECTED(EG(exception))) {
1647		result = 0;
1648		goto exit;
1649	}
1650
1651	result = 0;
1652	if ((has_set_exists != ZEND_PROPERTY_EXISTS) && zobj->ce->__isset) {
1653		uint32_t *guard = zend_get_property_guard(zobj, name);
1654
1655		if (!((*guard) & IN_ISSET)) {
1656			zval rv;
1657
1658			/* have issetter - try with it! */
1659			if (!tmp_name && !ZSTR_IS_INTERNED(name)) {
1660				tmp_name = zend_string_copy(name);
1661			}
1662			GC_ADDREF(zobj);
1663			(*guard) |= IN_ISSET; /* prevent circular getting */
1664			zend_std_call_issetter(zobj, name, &rv);
1665			result = zend_is_true(&rv);
1666			zval_ptr_dtor(&rv);
1667			if (has_set_exists == ZEND_PROPERTY_NOT_EMPTY && result) {
1668				if (EXPECTED(!EG(exception)) && zobj->ce->__get && !((*guard) & IN_GET)) {
1669					(*guard) |= IN_GET;
1670					zend_std_call_getter(zobj, name, &rv);
1671					(*guard) &= ~IN_GET;
1672					result = i_zend_is_true(&rv);
1673					zval_ptr_dtor(&rv);
1674				} else {
1675					result = 0;
1676				}
1677			}
1678			(*guard) &= ~IN_ISSET;
1679			OBJ_RELEASE(zobj);
1680		}
1681	}
1682
1683exit:
1684	zend_tmp_string_release(tmp_name);
1685	return result;
1686}
1687/* }}} */
1688
1689ZEND_API zend_string *zend_std_get_class_name(const zend_object *zobj) /* {{{ */
1690{
1691	return zend_string_copy(zobj->ce->name);
1692}
1693/* }}} */
1694
1695ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int type) /* {{{ */
1696{
1697	zval retval;
1698	zend_class_entry *ce;
1699
1700	switch (type) {
1701		case IS_STRING:
1702			ce = Z_OBJCE_P(readobj);
1703			if (ce->__tostring &&
1704				(zend_call_method_with_0_params(readobj, ce, &ce->__tostring, "__tostring", &retval) || EG(exception))) {
1705				if (UNEXPECTED(EG(exception) != NULL)) {
1706					zval *msg, ex, rv;
1707					zval_ptr_dtor(&retval);
1708					ZVAL_OBJ(&ex, EG(exception));
1709					EG(exception) = NULL;
1710					msg = zend_read_property(Z_OBJCE(ex), &ex, "message", sizeof("message") - 1, 1, &rv);
1711					if (UNEXPECTED(Z_TYPE_P(msg) != IS_STRING)) {
1712						ZVAL_EMPTY_STRING(&rv);
1713						msg = &rv;
1714					}
1715					zend_error_noreturn(E_ERROR,
1716							"Method %s::__toString() must not throw an exception, caught %s: %s",
1717							ZSTR_VAL(ce->name), ZSTR_VAL(Z_OBJCE(ex)->name), Z_STRVAL_P(msg));
1718					return FAILURE;
1719				}
1720				if (EXPECTED(Z_TYPE(retval) == IS_STRING)) {
1721					ZVAL_COPY_VALUE(writeobj, &retval);
1722					return SUCCESS;
1723				} else {
1724					zval_ptr_dtor(&retval);
1725					ZVAL_EMPTY_STRING(writeobj);
1726					zend_error(E_RECOVERABLE_ERROR, "Method %s::__toString() must return a string value", ZSTR_VAL(ce->name));
1727					return SUCCESS;
1728				}
1729			}
1730			return FAILURE;
1731		case _IS_BOOL:
1732			ZVAL_TRUE(writeobj);
1733			return SUCCESS;
1734		case IS_LONG:
1735			ce = Z_OBJCE_P(readobj);
1736			zend_error(E_NOTICE, "Object of class %s could not be converted to int", ZSTR_VAL(ce->name));
1737			ZVAL_LONG(writeobj, 1);
1738			return SUCCESS;
1739		case IS_DOUBLE:
1740			ce = Z_OBJCE_P(readobj);
1741			zend_error(E_NOTICE, "Object of class %s could not be converted to float", ZSTR_VAL(ce->name));
1742			ZVAL_DOUBLE(writeobj, 1);
1743			return SUCCESS;
1744		case _IS_NUMBER:
1745			ce = Z_OBJCE_P(readobj);
1746			zend_error(E_NOTICE, "Object of class %s could not be converted to number", ZSTR_VAL(ce->name));
1747			ZVAL_LONG(writeobj, 1);
1748			return SUCCESS;
1749		default:
1750			ZVAL_NULL(writeobj);
1751			break;
1752	}
1753	return FAILURE;
1754}
1755/* }}} */
1756
1757ZEND_API int zend_std_get_closure(zval *obj, zend_class_entry **ce_ptr, zend_function **fptr_ptr, zend_object **obj_ptr) /* {{{ */
1758{
1759	zval *func;
1760	zend_class_entry *ce = Z_OBJCE_P(obj);
1761
1762	if ((func = zend_hash_find_ex(&ce->function_table, ZSTR_KNOWN(ZEND_STR_MAGIC_INVOKE), 1)) == NULL) {
1763		return FAILURE;
1764	}
1765	*fptr_ptr = Z_FUNC_P(func);
1766
1767	*ce_ptr = ce;
1768	if ((*fptr_ptr)->common.fn_flags & ZEND_ACC_STATIC) {
1769		if (obj_ptr) {
1770			*obj_ptr = NULL;
1771		}
1772	} else {
1773		if (obj_ptr) {
1774			*obj_ptr = Z_OBJ_P(obj);
1775		}
1776	}
1777	return SUCCESS;
1778}
1779/* }}} */
1780
1781ZEND_API const zend_object_handlers std_object_handlers = {
1782	0,										/* offset */
1783
1784	zend_object_std_dtor,					/* free_obj */
1785	zend_objects_destroy_object,			/* dtor_obj */
1786	zend_objects_clone_obj,					/* clone_obj */
1787
1788	zend_std_read_property,					/* read_property */
1789	zend_std_write_property,				/* write_property */
1790	zend_std_read_dimension,				/* read_dimension */
1791	zend_std_write_dimension,				/* write_dimension */
1792	zend_std_get_property_ptr_ptr,			/* get_property_ptr_ptr */
1793	NULL,									/* get */
1794	NULL,									/* set */
1795	zend_std_has_property,					/* has_property */
1796	zend_std_unset_property,				/* unset_property */
1797	zend_std_has_dimension,					/* has_dimension */
1798	zend_std_unset_dimension,				/* unset_dimension */
1799	zend_std_get_properties,				/* get_properties */
1800	zend_std_get_method,					/* get_method */
1801	NULL,									/* call_method */
1802	zend_std_get_constructor,				/* get_constructor */
1803	zend_std_get_class_name,				/* get_class_name */
1804	zend_std_compare_objects,				/* compare_objects */
1805	zend_std_cast_object_tostring,			/* cast_object */
1806	NULL,									/* count_elements */
1807	zend_std_get_debug_info,				/* get_debug_info */
1808	zend_std_get_closure,					/* get_closure */
1809	zend_std_get_gc,						/* get_gc */
1810	NULL,									/* do_operation */
1811	NULL,									/* compare */
1812};
1813
1814/*
1815 * Local variables:
1816 * tab-width: 4
1817 * c-basic-offset: 4
1818 * indent-tabs-mode: t
1819 * End:
1820 * vim600: sw=4 ts=4 fdm=marker
1821 * vim<600: sw=4 ts=4
1822 */
1823