/src/php-src/Zend/zend_property_hooks.c

Source
/*
   +----------------------------------------------------------------------+
   | Zend Engine                                                          |
   +----------------------------------------------------------------------+
   | Copyright (c) Zend Technologies Ltd. (http://www.zend.com)           |
   +----------------------------------------------------------------------+
   | This source file is subject to version 2.00 of the Zend license,     |
   | that is bundled with this package in the file LICENSE, and is        |
   | available through the world-wide-web at the following url:           |
   | http://www.zend.com/license/2_00.txt.                                |
   | If you did not receive a copy of the Zend license and are unable to  |
   | obtain it through the world-wide-web, please send a note to          |
   | license@zend.com so we can mail you a copy immediately.              |
   +----------------------------------------------------------------------+
   | Authors: Ilija Tovilo <ilutov@php.net>                               |
   +----------------------------------------------------------------------+
*/

#include "zend.h"
#include "zend_API.h"
#include "zend_hash.h"
#include "zend_lazy_objects.h"
#include "zend_property_hooks.h"

typedef struct {
  zend_object_iterator it;
  bool by_ref;
  bool declared_props_done;
  zval declared_props;
  bool dynamic_props_done;
  uint32_t dynamic_prop_offset;
  uint32_t dynamic_prop_it;
  zval current_key;
  zval current_data;
} zend_hooked_object_iterator;

static zend_result zho_it_valid(zend_object_iterator *iter);
static void zho_it_move_forward(zend_object_iterator *iter);

static uint32_t zho_find_dynamic_prop_offset(zend_array *properties)
{
  uint32_t offset = 0;
  zval *value;

  ZEND_HASH_MAP_FOREACH_VAL(properties, value) {
    if (Z_TYPE_P(value) != IS_INDIRECT) {
      break;
    }
    offset++;
  } ZEND_HASH_FOREACH_END();

  return offset;
}

static zend_array *zho_build_properties_ex(zend_object *zobj, bool check_access, bool force_ptr, bool include_dynamic_props)
{
  zend_class_entry *ce = zobj->ce;
  zend_array *properties = zend_new_array(include_dynamic_props && zobj->properties
    ? zend_hash_num_elements(zobj->properties)
    : ce->default_properties_count);
  zend_hash_real_init_mixed(properties);

  /* Build list of parents */
  int32_t parent_count = 0;
  for (zend_class_entry *pce = ce; pce; pce = pce->parent) {
    parent_count++;
  }
  zend_class_entry **parents = emalloc(sizeof(zend_class_entry*) * parent_count);
  int32_t i = 0;
  for (zend_class_entry *pce = ce; pce; pce = pce->parent) {
    parents[i++] = pce;
  }

  /* Iterate parents top to bottom */
  i--;
  for (; i >= 0; i--) {
    zend_class_entry *pce = parents[i];

    zend_property_info *prop_info;
    ZEND_HASH_MAP_FOREACH_PTR(&pce->properties_info, prop_info) {
      if (prop_info->flags & ZEND_ACC_STATIC) {
        continue;
      }
      zend_string *property_name = prop_info->name;
      /* When promoting properties from protected to public, use the unmangled name to preserve order. */
      if (prop_info->flags & ZEND_ACC_PROTECTED) {
        const char *tmp = zend_get_unmangled_property_name(property_name);
        zend_string *unmangled_name = zend_string_init(tmp, strlen(tmp), false);
        zend_property_info *child_prop_info = zend_hash_find_ptr(&ce->properties_info, unmangled_name);
        if (child_prop_info && (child_prop_info->flags & ZEND_ACC_PUBLIC)) {
          property_name = unmangled_name;
        } else {
          zend_string_release(unmangled_name);
        }
      }
      if (check_access && zend_check_property_access(zobj, property_name, false) == FAILURE) {
        goto skip_property;
      }
      if (prop_info->hooks || force_ptr) {
        zend_hash_update_ptr(properties, property_name, prop_info);
      } else {
        if (UNEXPECTED(Z_TYPE_P(OBJ_PROP(zobj, prop_info->offset)) == IS_UNDEF)) {
          HT_FLAGS(properties) |= HASH_FLAG_HAS_EMPTY_IND;
        }
        zval *tmp = zend_hash_lookup(properties, property_name);
        ZVAL_INDIRECT(tmp, OBJ_PROP(zobj, prop_info->offset));
      }
skip_property:
      if (property_name != prop_info->name) {
        zend_string_release(property_name);
      }
    } ZEND_HASH_FOREACH_END();
  }

  efree(parents);

  if (include_dynamic_props && zobj->properties) {
    zend_string *prop_name;
    zval *prop_value;
    ZEND_HASH_FOREACH_STR_KEY_VAL(zobj->properties, prop_name, prop_value) {
      if (Z_TYPE_P(prop_value) == IS_INDIRECT) {
        continue;
      }
      zval *tmp = _zend_hash_append(properties, prop_name, prop_value);
      Z_TRY_ADDREF_P(tmp);
    } ZEND_HASH_FOREACH_END();
  }

  return properties;
}

ZEND_API zend_array *zend_hooked_object_build_properties(zend_object *zobj)
{
  if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
    zobj = zend_lazy_object_init(zobj);
    if (UNEXPECTED(!zobj)) {
      return (zend_array*) &zend_empty_array;
    }
  }

  return zho_build_properties_ex(zobj, false, false, true);
}

static void zho_dynamic_it_init(zend_hooked_object_iterator *hooked_iter)
{
  zend_object *zobj = Z_OBJ_P(&hooked_iter->it.data);
  zend_array *properties = zobj->handlers->get_properties(zobj);
  hooked_iter->dynamic_props_done = false;
  hooked_iter->dynamic_prop_offset = zho_find_dynamic_prop_offset(properties);
  hooked_iter->dynamic_prop_it = zend_hash_iterator_add(properties, hooked_iter->dynamic_prop_offset);
}

static void zho_it_get_current_key(zend_object_iterator *iter, zval *key);

static void zho_declared_it_fetch_current(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zend_object *zobj = Z_OBJ_P(&iter->data);
  zend_array *properties = Z_ARR(hooked_iter->declared_props);

  zend_property_info *prop_info = Z_PTR_P(zend_hash_get_current_data(properties));
  if (prop_info->hooks) {
    zend_function *get = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
    if (!get && (prop_info->flags & ZEND_ACC_VIRTUAL)) {
      return;
    }
    if (hooked_iter->by_ref
     && (get == NULL
      || !(get->common.fn_flags & ZEND_ACC_RETURN_REFERENCE))) {
      zend_throw_error(NULL, "Cannot create reference to property %s::$%s",
        ZSTR_VAL(zobj->ce->name), zend_get_unmangled_property_name(prop_info->name));
      return;
    }
    zend_string *unmangled_name = prop_info->name;
    if (ZSTR_VAL(unmangled_name)[0] == '\0') {
      const char *tmp = zend_get_unmangled_property_name(unmangled_name);
      unmangled_name = zend_string_init(tmp, strlen(tmp), false);
    }
    zval *value = zend_read_property_ex(prop_info->ce, zobj, unmangled_name, /* silent */ true, &hooked_iter->current_data);
    if (unmangled_name != prop_info->name) {
      zend_string_release(unmangled_name);
    }
    if (value == &EG(uninitialized_zval)) {
      return;
    } else if (value != &hooked_iter->current_data) {
      ZVAL_COPY(&hooked_iter->current_data, value);
    }
  } else {
    zval *property = OBJ_PROP(zobj, prop_info->offset);
    ZVAL_DEINDIRECT(property);
    if (Z_TYPE_P(property) == IS_UNDEF) {
      return;
    }
    if (!hooked_iter->by_ref) {
      ZVAL_DEREF(property);
    } else if (Z_TYPE_P(property) != IS_REFERENCE) {
      if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
        zend_throw_error(NULL,
          "Cannot acquire reference to readonly property %s::$%s",
          ZSTR_VAL(prop_info->ce->name), zend_get_unmangled_property_name(prop_info->name));
        return;
      }
      ZVAL_MAKE_REF(property);
      if (ZEND_TYPE_IS_SET(prop_info->type)) {
        ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(property), prop_info);
      }
    }
    ZVAL_COPY(&hooked_iter->current_data, property);
  }

  if (ZSTR_VAL(prop_info->name)[0] == '\0') {
    const char *tmp = zend_get_unmangled_property_name(prop_info->name);
    ZVAL_STR(&hooked_iter->current_key, zend_string_init(tmp, strlen(tmp), false));
  } else {
    ZVAL_STR_COPY(&hooked_iter->current_key, prop_info->name);
  }
}

static void zho_dynamic_it_fetch_current(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zend_array *properties = Z_OBJ(iter->data)->properties;
  HashPosition pos = zend_hash_iterator_pos(hooked_iter->dynamic_prop_it, properties);

  if (pos >= properties->nNumUsed) {
    hooked_iter->dynamic_props_done = true;
    return;
  }

  Bucket *bucket = properties->arData + pos;

  if (UNEXPECTED(Z_TYPE(bucket->val) == IS_UNDEF)) {
    return;
  }

  zend_object *zobj = Z_OBJ_P(&hooked_iter->it.data);
  if (bucket->key && zend_check_property_access(zobj, bucket->key, true) != SUCCESS) {
    return;
  }

  if (hooked_iter->by_ref && Z_TYPE(bucket->val) != IS_REFERENCE) {
    ZVAL_MAKE_REF(&bucket->val);
  }
  ZVAL_COPY(&hooked_iter->current_data, &bucket->val);

  if (bucket->key) {
    ZVAL_STR_COPY(&hooked_iter->current_key, bucket->key);
  } else {
    ZVAL_LONG(&hooked_iter->current_key, bucket->h);
  }
}

static void zho_it_fetch_current(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  if (Z_TYPE(hooked_iter->current_data) != IS_UNDEF) {
    return;
  }

  while (true) {
    if (!hooked_iter->declared_props_done) {
      zho_declared_it_fetch_current(iter);
    } else if (!hooked_iter->dynamic_props_done) {
      zho_dynamic_it_fetch_current(iter);
    } else {
      break;
    }
    if (Z_TYPE(hooked_iter->current_data) != IS_UNDEF || EG(exception)) {
      break;
    }
    zho_it_move_forward(iter);
  }
}

static void zho_it_dtor(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zval_ptr_dtor(&iter->data);
  zval_ptr_dtor(&hooked_iter->declared_props);
  zval_ptr_dtor_nogc(&hooked_iter->current_key);
  zval_ptr_dtor(&hooked_iter->current_data);
  zend_hash_iterator_del(hooked_iter->dynamic_prop_it);
}

static zend_result zho_it_valid(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zho_it_fetch_current(iter);
  return Z_TYPE(hooked_iter->current_data) != IS_UNDEF ? SUCCESS : FAILURE;
}

static zval *zho_it_get_current_data(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zho_it_fetch_current(iter);
  return &hooked_iter->current_data;
}

static void zho_it_get_current_key(zend_object_iterator *iter, zval *key)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zho_it_fetch_current(iter);
  ZVAL_COPY(key, &hooked_iter->current_key);
}

static void zho_it_move_forward(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;

  zval_ptr_dtor(&hooked_iter->current_data);
  ZVAL_UNDEF(&hooked_iter->current_data);
  zval_ptr_dtor_nogc(&hooked_iter->current_key);
  ZVAL_UNDEF(&hooked_iter->current_key);

  if (!hooked_iter->declared_props_done) {
    zend_array *properties = Z_ARR(hooked_iter->declared_props);
    zend_hash_move_forward(properties);
    if (zend_hash_has_more_elements(properties) != SUCCESS) {
      hooked_iter->declared_props_done = true;
    }
  } else if (!hooked_iter->dynamic_props_done) {
    zend_array *properties = Z_OBJ(iter->data)->properties;
    HashPosition pos = zend_hash_iterator_pos(hooked_iter->dynamic_prop_it, properties);
    pos++;
    EG(ht_iterators)[hooked_iter->dynamic_prop_it].pos = pos;
  }
}

static void zho_it_rewind(zend_object_iterator *iter)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;

  zval_ptr_dtor(&hooked_iter->current_data);
  ZVAL_UNDEF(&hooked_iter->current_data);
  zval_ptr_dtor_nogc(&hooked_iter->current_key);
  ZVAL_UNDEF(&hooked_iter->current_key);

  zend_array *properties = Z_ARR(hooked_iter->declared_props);
  zend_hash_internal_pointer_reset(properties);
  hooked_iter->declared_props_done = !zend_hash_num_elements(properties);
  hooked_iter->dynamic_props_done = false;
  EG(ht_iterators)[hooked_iter->dynamic_prop_it].pos = hooked_iter->dynamic_prop_offset;
}

static HashTable *zho_it_get_gc(zend_object_iterator *iter, zval **table, int *n)
{
  zend_hooked_object_iterator *hooked_iter = (zend_hooked_object_iterator*)iter;
  zend_get_gc_buffer *gc_buffer = zend_get_gc_buffer_create();
  zend_get_gc_buffer_add_zval(gc_buffer, &iter->data);
  zend_get_gc_buffer_add_zval(gc_buffer, &hooked_iter->declared_props);
  zend_get_gc_buffer_add_zval(gc_buffer, &hooked_iter->current_data);
  zend_get_gc_buffer_use(gc_buffer, table, n);
  return NULL;
}

static const zend_object_iterator_funcs zend_hooked_object_it_funcs = {
  zho_it_dtor,
  zho_it_valid,
  zho_it_get_current_data,
  zho_it_get_current_key,
  zho_it_move_forward,
  zho_it_rewind,
  NULL,
  zho_it_get_gc,
};

ZEND_API zend_object_iterator *zend_hooked_object_get_iterator(zend_class_entry *ce, zval *object, int by_ref)
{
  zend_object *zobj = Z_OBJ_P(object);
  if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
    zobj = zend_lazy_object_init(zobj);
    if (UNEXPECTED(!zobj)) {
      return NULL;
    }
  }

  zend_hooked_object_iterator *iterator = emalloc(sizeof(zend_hooked_object_iterator));
  zend_iterator_init(&iterator->it);

  ZVAL_OBJ_COPY(&iterator->it.data, zobj);
  iterator->it.funcs = &zend_hooked_object_it_funcs;
  iterator->by_ref = by_ref;
  zend_array *properties = zho_build_properties_ex(zobj, true, true, false);
  ZVAL_ARR(&iterator->declared_props, properties);
  iterator->declared_props_done = !zend_hash_num_elements(properties);
  zho_dynamic_it_init(iterator);
  ZVAL_UNDEF(&iterator->current_key);
  ZVAL_UNDEF(&iterator->current_data);

  return &iterator->it;
}

Coverage Report

Created: 2025-12-14 06:05

Line	Count	Source
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: Ilija Tovilo <ilutov@php.net> \|
16		+----------------------------------------------------------------------+
17		*/
18
19		#include "zend.h"
20		#include "zend_API.h"
21		#include "zend_hash.h"
22		#include "zend_lazy_objects.h"
23		#include "zend_property_hooks.h"
24
25		typedef struct {
26		zend_object_iterator it;
27		bool by_ref;
28		bool declared_props_done;
29		zval declared_props;
30		bool dynamic_props_done;
31		uint32_t dynamic_prop_offset;
32		uint32_t dynamic_prop_it;
33		zval current_key;
34		zval current_data;
35		} zend_hooked_object_iterator;
36
37		static zend_result zho_it_valid(zend_object_iterator *iter);
38		static void zho_it_move_forward(zend_object_iterator *iter);
39
40		static uint32_t zho_find_dynamic_prop_offset(zend_array *properties)
41	0	{
42	0	uint32_t offset = 0;
43	0	zval *value;
44
45	0	ZEND_HASH_MAP_FOREACH_VAL(properties, value) {
46	0	if (Z_TYPE_P(value) != IS_INDIRECT) {
47	0	break;
48	0	}
49	0	offset++;
50	0	} ZEND_HASH_FOREACH_END();
51
52	0	return offset;
53	0	}
54
55		static zend_array zho_build_properties_ex(zend_object zobj, bool check_access, bool force_ptr, bool include_dynamic_props)
56	0	{
57	0	zend_class_entry *ce = zobj->ce;
58	0	zend_array *properties = zend_new_array(include_dynamic_props && zobj->properties
59	0	? zend_hash_num_elements(zobj->properties)
60	0	: ce->default_properties_count);
61	0	zend_hash_real_init_mixed(properties);
62
63		/* Build list of parents */
64	0	int32_t parent_count = 0;
65	0	for (zend_class_entry *pce = ce; pce; pce = pce->parent) {
66	0	parent_count++;
67	0	}
68	0	zend_class_entry *parents = emalloc(sizeof(zend_class_entry) * parent_count);
69	0	int32_t i = 0;
70	0	for (zend_class_entry *pce = ce; pce; pce = pce->parent) {
71	0	parents[i++] = pce;
72	0	}
73
74		/* Iterate parents top to bottom */
75	0	i--;
76	0	for (; i >= 0; i--) {
77	0	zend_class_entry *pce = parents[i];
78
79	0	zend_property_info *prop_info;
80	0	ZEND_HASH_MAP_FOREACH_PTR(&pce->properties_info, prop_info) {
81	0	if (prop_info->flags & ZEND_ACC_STATIC) {
82	0	continue;
83	0	}
84	0	zend_string *property_name = prop_info->name;
85		/* When promoting properties from protected to public, use the unmangled name to preserve order. */
86	0	if (prop_info->flags & ZEND_ACC_PROTECTED) {
87	0	const char *tmp = zend_get_unmangled_property_name(property_name);
88	0	zend_string *unmangled_name = zend_string_init(tmp, strlen(tmp), false);
89	0	zend_property_info *child_prop_info = zend_hash_find_ptr(&ce->properties_info, unmangled_name);
90	0	if (child_prop_info && (child_prop_info->flags & ZEND_ACC_PUBLIC)) {
91	0	property_name = unmangled_name;
92	0	} else {
93	0	zend_string_release(unmangled_name);
94	0	}
95	0	}
96	0	if (check_access && zend_check_property_access(zobj, property_name, false) == FAILURE) {
97	0	goto skip_property;
98	0	}
99	0	if (prop_info->hooks \|\| force_ptr) {
100	0	zend_hash_update_ptr(properties, property_name, prop_info);
101	0	} else {
102	0	if (UNEXPECTED(Z_TYPE_P(OBJ_PROP(zobj, prop_info->offset)) == IS_UNDEF)) {
103	0	HT_FLAGS(properties) \|= HASH_FLAG_HAS_EMPTY_IND;
104	0	}
105	0	zval *tmp = zend_hash_lookup(properties, property_name);
106	0	ZVAL_INDIRECT(tmp, OBJ_PROP(zobj, prop_info->offset));
107	0	}
108	0	skip_property:
109	0	if (property_name != prop_info->name) {
110	0	zend_string_release(property_name);
111	0	}
112	0	} ZEND_HASH_FOREACH_END();
113	0	}
114
115	0	efree(parents);
116
117	0	if (include_dynamic_props && zobj->properties) {
118	0	zend_string *prop_name;
119	0	zval *prop_value;
120	0	ZEND_HASH_FOREACH_STR_KEY_VAL(zobj->properties, prop_name, prop_value) {
121	0	if (Z_TYPE_P(prop_value) == IS_INDIRECT) {
122	0	continue;
123	0	}
124	0	zval *tmp = _zend_hash_append(properties, prop_name, prop_value);
125	0	Z_TRY_ADDREF_P(tmp);
126	0	} ZEND_HASH_FOREACH_END();
127	0	}
128
129	0	return properties;
130	0	}
131
132		ZEND_API zend_array zend_hooked_object_build_properties(zend_object zobj)
133	0	{
134	0	if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
135	0	zobj = zend_lazy_object_init(zobj);
136	0	if (UNEXPECTED(!zobj)) {
137	0	return (zend_array*) &zend_empty_array;
138	0	}
139	0	}
140
141	0	return zho_build_properties_ex(zobj, false, false, true);
142	0	}
143
144		static void zho_dynamic_it_init(zend_hooked_object_iterator *hooked_iter)
145	0	{
146	0	zend_object *zobj = Z_OBJ_P(&hooked_iter->it.data);
147	0	zend_array *properties = zobj->handlers->get_properties(zobj);
148	0	hooked_iter->dynamic_props_done = false;
149	0	hooked_iter->dynamic_prop_offset = zho_find_dynamic_prop_offset(properties);
150	0	hooked_iter->dynamic_prop_it = zend_hash_iterator_add(properties, hooked_iter->dynamic_prop_offset);
151	0	}
152
153		static void zho_it_get_current_key(zend_object_iterator iter, zval key);
154
155		static void zho_declared_it_fetch_current(zend_object_iterator *iter)
156	0	{
157	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
158	0	zend_object *zobj = Z_OBJ_P(&iter->data);
159	0	zend_array *properties = Z_ARR(hooked_iter->declared_props);
160
161	0	zend_property_info *prop_info = Z_PTR_P(zend_hash_get_current_data(properties));
162	0	if (prop_info->hooks) {
163	0	zend_function *get = prop_info->hooks[ZEND_PROPERTY_HOOK_GET];
164	0	if (!get && (prop_info->flags & ZEND_ACC_VIRTUAL)) {
165	0	return;
166	0	}
167	0	if (hooked_iter->by_ref
168	0	&& (get == NULL
169	0	\|\| !(get->common.fn_flags & ZEND_ACC_RETURN_REFERENCE))) {
170	0	zend_throw_error(NULL, "Cannot create reference to property %s::$%s",
171	0	ZSTR_VAL(zobj->ce->name), zend_get_unmangled_property_name(prop_info->name));
172	0	return;
173	0	}
174	0	zend_string *unmangled_name = prop_info->name;
175	0	if (ZSTR_VAL(unmangled_name)[0] == '\0') {
176	0	const char *tmp = zend_get_unmangled_property_name(unmangled_name);
177	0	unmangled_name = zend_string_init(tmp, strlen(tmp), false);
178	0	}
179	0	zval value = zend_read_property_ex(prop_info->ce, zobj, unmangled_name, / silent */ true, &hooked_iter->current_data);
180	0	if (unmangled_name != prop_info->name) {
181	0	zend_string_release(unmangled_name);
182	0	}
183	0	if (value == &EG(uninitialized_zval)) {
184	0	return;
185	0	} else if (value != &hooked_iter->current_data) {
186	0	ZVAL_COPY(&hooked_iter->current_data, value);
187	0	}
188	0	} else {
189	0	zval *property = OBJ_PROP(zobj, prop_info->offset);
190	0	ZVAL_DEINDIRECT(property);
191	0	if (Z_TYPE_P(property) == IS_UNDEF) {
192	0	return;
193	0	}
194	0	if (!hooked_iter->by_ref) {
195	0	ZVAL_DEREF(property);
196	0	} else if (Z_TYPE_P(property) != IS_REFERENCE) {
197	0	if (UNEXPECTED(prop_info->flags & ZEND_ACC_READONLY)) {
198	0	zend_throw_error(NULL,
199	0	"Cannot acquire reference to readonly property %s::$%s",
200	0	ZSTR_VAL(prop_info->ce->name), zend_get_unmangled_property_name(prop_info->name));
201	0	return;
202	0	}
203	0	ZVAL_MAKE_REF(property);
204	0	if (ZEND_TYPE_IS_SET(prop_info->type)) {
205	0	ZEND_REF_ADD_TYPE_SOURCE(Z_REF_P(property), prop_info);
206	0	}
207	0	}
208	0	ZVAL_COPY(&hooked_iter->current_data, property);
209	0	}
210
211	0	if (ZSTR_VAL(prop_info->name)[0] == '\0') {
212	0	const char *tmp = zend_get_unmangled_property_name(prop_info->name);
213	0	ZVAL_STR(&hooked_iter->current_key, zend_string_init(tmp, strlen(tmp), false));
214	0	} else {
215	0	ZVAL_STR_COPY(&hooked_iter->current_key, prop_info->name);
216	0	}
217	0	}
218
219		static void zho_dynamic_it_fetch_current(zend_object_iterator *iter)
220	0	{
221	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
222	0	zend_array *properties = Z_OBJ(iter->data)->properties;
223	0	HashPosition pos = zend_hash_iterator_pos(hooked_iter->dynamic_prop_it, properties);
224
225	0	if (pos >= properties->nNumUsed) {
226	0	hooked_iter->dynamic_props_done = true;
227	0	return;
228	0	}
229
230	0	Bucket *bucket = properties->arData + pos;
231
232	0	if (UNEXPECTED(Z_TYPE(bucket->val) == IS_UNDEF)) {
233	0	return;
234	0	}
235
236	0	zend_object *zobj = Z_OBJ_P(&hooked_iter->it.data);
237	0	if (bucket->key && zend_check_property_access(zobj, bucket->key, true) != SUCCESS) {
238	0	return;
239	0	}
240
241	0	if (hooked_iter->by_ref && Z_TYPE(bucket->val) != IS_REFERENCE) {
242	0	ZVAL_MAKE_REF(&bucket->val);
243	0	}
244	0	ZVAL_COPY(&hooked_iter->current_data, &bucket->val);
245
246	0	if (bucket->key) {
247	0	ZVAL_STR_COPY(&hooked_iter->current_key, bucket->key);
248	0	} else {
249	0	ZVAL_LONG(&hooked_iter->current_key, bucket->h);
250	0	}
251	0	}
252
253		static void zho_it_fetch_current(zend_object_iterator *iter)
254	0	{
255	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
256	0	if (Z_TYPE(hooked_iter->current_data) != IS_UNDEF) {
257	0	return;
258	0	}
259
260	0	while (true) {
261	0	if (!hooked_iter->declared_props_done) {
262	0	zho_declared_it_fetch_current(iter);
263	0	} else if (!hooked_iter->dynamic_props_done) {
264	0	zho_dynamic_it_fetch_current(iter);
265	0	} else {
266	0	break;
267	0	}
268	0	if (Z_TYPE(hooked_iter->current_data) != IS_UNDEF \|\| EG(exception)) {
269	0	break;
270	0	}
271	0	zho_it_move_forward(iter);
272	0	}
273	0	}
274
275		static void zho_it_dtor(zend_object_iterator *iter)
276	0	{
277	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
278	0	zval_ptr_dtor(&iter->data);
279	0	zval_ptr_dtor(&hooked_iter->declared_props);
280	0	zval_ptr_dtor_nogc(&hooked_iter->current_key);
281	0	zval_ptr_dtor(&hooked_iter->current_data);
282	0	zend_hash_iterator_del(hooked_iter->dynamic_prop_it);
283	0	}
284
285		static zend_result zho_it_valid(zend_object_iterator *iter)
286	0	{
287	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
288	0	zho_it_fetch_current(iter);
289	0	return Z_TYPE(hooked_iter->current_data) != IS_UNDEF ? SUCCESS : FAILURE;
290	0	}
291
292		static zval zho_it_get_current_data(zend_object_iterator iter)
293	0	{
294	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
295	0	zho_it_fetch_current(iter);
296	0	return &hooked_iter->current_data;
297	0	}
298
299		static void zho_it_get_current_key(zend_object_iterator iter, zval key)
300	0	{
301	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
302	0	zho_it_fetch_current(iter);
303	0	ZVAL_COPY(key, &hooked_iter->current_key);
304	0	}
305
306		static void zho_it_move_forward(zend_object_iterator *iter)
307	0	{
308	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
309
310	0	zval_ptr_dtor(&hooked_iter->current_data);
311	0	ZVAL_UNDEF(&hooked_iter->current_data);
312	0	zval_ptr_dtor_nogc(&hooked_iter->current_key);
313	0	ZVAL_UNDEF(&hooked_iter->current_key);
314
315	0	if (!hooked_iter->declared_props_done) {
316	0	zend_array *properties = Z_ARR(hooked_iter->declared_props);
317	0	zend_hash_move_forward(properties);
318	0	if (zend_hash_has_more_elements(properties) != SUCCESS) {
319	0	hooked_iter->declared_props_done = true;
320	0	}
321	0	} else if (!hooked_iter->dynamic_props_done) {
322	0	zend_array *properties = Z_OBJ(iter->data)->properties;
323	0	HashPosition pos = zend_hash_iterator_pos(hooked_iter->dynamic_prop_it, properties);
324	0	pos++;
325	0	EG(ht_iterators)[hooked_iter->dynamic_prop_it].pos = pos;
326	0	}
327	0	}
328
329		static void zho_it_rewind(zend_object_iterator *iter)
330	0	{
331	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
332
333	0	zval_ptr_dtor(&hooked_iter->current_data);
334	0	ZVAL_UNDEF(&hooked_iter->current_data);
335	0	zval_ptr_dtor_nogc(&hooked_iter->current_key);
336	0	ZVAL_UNDEF(&hooked_iter->current_key);
337
338	0	zend_array *properties = Z_ARR(hooked_iter->declared_props);
339	0	zend_hash_internal_pointer_reset(properties);
340	0	hooked_iter->declared_props_done = !zend_hash_num_elements(properties);
341	0	hooked_iter->dynamic_props_done = false;
342	0	EG(ht_iterators)[hooked_iter->dynamic_prop_it].pos = hooked_iter->dynamic_prop_offset;
343	0	}
344
345		static HashTable zho_it_get_gc(zend_object_iterator iter, zval *table, int n)
346	0	{
347	0	zend_hooked_object_iterator hooked_iter = (zend_hooked_object_iterator)iter;
348	0	zend_get_gc_buffer *gc_buffer = zend_get_gc_buffer_create();
349	0	zend_get_gc_buffer_add_zval(gc_buffer, &iter->data);
350	0	zend_get_gc_buffer_add_zval(gc_buffer, &hooked_iter->declared_props);
351	0	zend_get_gc_buffer_add_zval(gc_buffer, &hooked_iter->current_data);
352	0	zend_get_gc_buffer_use(gc_buffer, table, n);
353	0	return NULL;
354	0	}
355
356		static const zend_object_iterator_funcs zend_hooked_object_it_funcs = {
357		zho_it_dtor,
358		zho_it_valid,
359		zho_it_get_current_data,
360		zho_it_get_current_key,
361		zho_it_move_forward,
362		zho_it_rewind,
363		NULL,
364		zho_it_get_gc,
365		};
366
367		ZEND_API zend_object_iterator zend_hooked_object_get_iterator(zend_class_entry ce, zval *object, int by_ref)
368	0	{
369	0	zend_object *zobj = Z_OBJ_P(object);
370	0	if (UNEXPECTED(zend_lazy_object_must_init(zobj))) {
371	0	zobj = zend_lazy_object_init(zobj);
372	0	if (UNEXPECTED(!zobj)) {
373	0	return NULL;
374	0	}
375	0	}
376
377	0	zend_hooked_object_iterator *iterator = emalloc(sizeof(zend_hooked_object_iterator));
378	0	zend_iterator_init(&iterator->it);
379
380	0	ZVAL_OBJ_COPY(&iterator->it.data, zobj);
381	0	iterator->it.funcs = &zend_hooked_object_it_funcs;
382	0	iterator->by_ref = by_ref;
383	0	zend_array *properties = zho_build_properties_ex(zobj, true, true, false);
384	0	ZVAL_ARR(&iterator->declared_props, properties);
385	0	iterator->declared_props_done = !zend_hash_num_elements(properties);
386	0	zho_dynamic_it_init(iterator);
387	0	ZVAL_UNDEF(&iterator->current_key);
388	0	ZVAL_UNDEF(&iterator->current_data);
389
390	0	return &iterator->it;
391	0	}