/*

+----------------------------------------------------------------------+

| Copyright © The PHP Group and Contributors. |

+----------------------------------------------------------------------+

| This source file is subject to the Modified BSD License that is |

| bundled with this package in the file LICENSE, and is available |

| through the World Wide Web at <https://www.php.net/license/>. |

| |

| SPDX-License-Identifier: BSD-3-Clause |

+----------------------------------------------------------------------+

| Authors: Marcus Boerger <helly@php.net> |

+----------------------------------------------------------------------+

*/

#ifdef HAVE_CONFIG_H

# include "config.h"

#endif

#include "php.h"

#include "ext/standard/php_var.h"

#include "zend_smart_str.h"

#include "zend_interfaces.h"

#include "zend_exceptions.h"

#include "spl_iterators.h"

#include "spl_array.h"

#include "spl_array_arginfo.h"

#include "spl_exceptions.h"

#include "spl_functions.h" /* For spl_set_private_debug_info_property() */

/* Defined later in the file */

PHPAPI zend_class_entry *spl_ce_ArrayIterator;

PHPAPI zend_class_entry *spl_ce_RecursiveArrayIterator;

/* ArrayObject class */

static zend_object_handlers spl_handler_ArrayObject;

PHPAPI zend_class_entry *spl_ce_ArrayObject;

typedef struct _spl_array_object {

zval array;

HashTable *sentinel_array;

uint32_t ht_iter;

int ar_flags;

unsigned char nApplyCount;

zend_function *fptr_offset_get;

zend_function *fptr_offset_set;

zend_function *fptr_offset_has;

zend_function *fptr_offset_del;

zend_function *fptr_count;

zend_class_entry* ce_get_iterator;

zend_object std;

} spl_array_object;

#define spl_array_from_obj(obj) ZEND_CONTAINER_OF(obj, spl_array_object, std)

#define Z_SPLARRAY_P(zv) spl_array_from_obj(Z_OBJ_P((zv)))

static inline HashTable **spl_array_get_hash_table_ptr(spl_array_object* intern) { /* {{{ */

//??? TODO: Delay duplication for arrays; only duplicate for write operations

if (intern->ar_flags & SPL_ARRAY_IS_SELF) {

/* rebuild properties */

zend_std_get_properties_ex(&intern->std);

return &intern->std.properties;

} else if (intern->ar_flags & SPL_ARRAY_USE_OTHER) {

spl_array_object *other = Z_SPLARRAY_P(&intern->array);

return spl_array_get_hash_table_ptr(other);

} else if (Z_TYPE(intern->array) == IS_ARRAY) {

return &Z_ARRVAL(intern->array);

} else {

zend_object *obj = Z_OBJ(intern->array);

/* Since we're directly playing with the properties table, we shall initialize the lazy object directly.

* If we don't, it's possible to continue working with the wrong object in case we're using a proxy. */

if (UNEXPECTED(zend_lazy_object_must_init(obj))) {

obj = zend_lazy_object_init(obj);

if (UNEXPECTED(!obj)) {

if (!intern->sentinel_array) {

intern->sentinel_array = zend_new_array(0);

}

return &intern->sentinel_array;

}

}

/* should no longer be lazy */

ZEND_ASSERT(!zend_lazy_object_must_init(obj));

/* rebuild properties */

zend_std_get_properties_ex(obj);

if (GC_REFCOUNT(obj->properties) > 1) {

if (EXPECTED(!(GC_FLAGS(obj->properties) & IS_ARRAY_IMMUTABLE))) {

GC_DELREF(obj->properties);

}

obj->properties = zend_array_dup(obj->properties);

}

return &obj->properties;

}

}

/* }}} */

static inline HashTable *spl_array_get_hash_table(spl_array_object* intern) { /* {{{ */

return *spl_array_get_hash_table_ptr(intern);

}

/* }}} */

static inline bool spl_array_is_object(spl_array_object *intern) /* {{{ */

{

while (intern->ar_flags & SPL_ARRAY_USE_OTHER) {

intern = Z_SPLARRAY_P(&intern->array);

}

return (intern->ar_flags & SPL_ARRAY_IS_SELF) || Z_TYPE(intern->array) == IS_OBJECT;

}

/* }}} */

static zend_result spl_array_skip_protected(spl_array_object *intern, HashTable *aht);

static zend_never_inline void spl_array_create_ht_iter(HashTable *ht, spl_array_object* intern) /* {{{ */

{

intern->ht_iter = zend_hash_iterator_add(ht, zend_hash_get_current_pos(ht));

zend_hash_internal_pointer_reset_ex(ht, &EG(ht_iterators)[intern->ht_iter].pos);

spl_array_skip_protected(intern, ht);

}

/* }}} */

static zend_always_inline uint32_t *spl_array_get_pos_ptr(HashTable *ht, spl_array_object* intern) /* {{{ */

{

if (UNEXPECTED(intern->ht_iter == (uint32_t)-1)) {

spl_array_create_ht_iter(ht, intern);

}

return &EG(ht_iterators)[intern->ht_iter].pos;

}

/* }}} */

/* {{{ spl_array_object_free_storage */

static void spl_array_object_free_storage(zend_object *object)

{

spl_array_object *intern = spl_array_from_obj(object);

if (intern->ht_iter != (uint32_t) -1) {

zend_hash_iterator_del(intern->ht_iter);

}

if (UNEXPECTED(intern->sentinel_array)) {

zend_array_release(intern->sentinel_array);

}

zend_object_std_dtor(&intern->std);

zval_ptr_dtor(&intern->array);

}

/* }}} */

/* {{{ spl_array_object_new_ex */

static zend_object *spl_array_object_new_ex(zend_class_entry *class_type, zend_object *orig, int clone_orig)

{

spl_array_object *intern;

const zend_class_entry *parent = class_type;

int inherited = 0;

intern = zend_object_alloc(sizeof(spl_array_object), parent);

zend_object_std_init(&intern->std, class_type);

object_properties_init(&intern->std, class_type);

intern->ar_flags = 0;

intern->ce_get_iterator = spl_ce_ArrayIterator;

if (orig) {

spl_array_object *other = spl_array_from_obj(orig);

intern->ar_flags &= ~ SPL_ARRAY_CLONE_MASK;

intern->ar_flags |= (other->ar_flags & SPL_ARRAY_CLONE_MASK);

intern->ce_get_iterator = other->ce_get_iterator;

if (clone_orig) {

if (other->ar_flags & SPL_ARRAY_IS_SELF) {

ZVAL_UNDEF(&intern->array);

} else if (instanceof_function(class_type, spl_ce_ArrayObject)) {

ZVAL_ARR(&intern->array,

zend_array_dup(spl_array_get_hash_table(other)));

} else {

#if ZEND_DEBUG

/* This is because the call to instanceof_function will remain because

* the compiler can't prove in this compile unit that this function is

* side-effect-free.

* See https://github.com/php/php-src/pull/14518#discussion_r1638740932 */

ZEND_ASSERT(instanceof_function(class_type, spl_ce_ArrayIterator));

#endif

ZVAL_OBJ_COPY(&intern->array, orig);

intern->ar_flags |= SPL_ARRAY_USE_OTHER;

}

} else {

ZVAL_OBJ_COPY(&intern->array, orig);

intern->ar_flags |= SPL_ARRAY_USE_OTHER;

}

} else {

array_init(&intern->array);

}

while (parent) {

if (parent == spl_ce_ArrayIterator || parent == spl_ce_RecursiveArrayIterator || parent == spl_ce_ArrayObject) {

break;

}

parent = parent->parent;

inherited = 1;

}

ZEND_ASSERT(parent);

if (inherited) {

intern->fptr_offset_get = zend_hash_str_find_ptr(&class_type->function_table, "offsetget", sizeof("offsetget") - 1);

if (intern->fptr_offset_get->common.scope == parent) {

intern->fptr_offset_get = NULL;

}

intern->fptr_offset_set = zend_hash_str_find_ptr(&class_type->function_table, "offsetset", sizeof("offsetset") - 1);

if (intern->fptr_offset_set->common.scope == parent) {

intern->fptr_offset_set = NULL;

}

intern->fptr_offset_has = zend_hash_str_find_ptr(&class_type->function_table, "offsetexists", sizeof("offsetexists") - 1);

if (intern->fptr_offset_has->common.scope == parent) {

intern->fptr_offset_has = NULL;

}

intern->fptr_offset_del = zend_hash_str_find_ptr(&class_type->function_table, "offsetunset", sizeof("offsetunset") - 1);

if (intern->fptr_offset_del->common.scope == parent) {

intern->fptr_offset_del = NULL;

}

/* Find count() method */

intern->fptr_count = zend_hash_find_ptr(&class_type->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));

if (intern->fptr_count->common.scope == parent) {

intern->fptr_count = NULL;

}

}

intern->ht_iter = (uint32_t)-1;

return &intern->std;

}

/* }}} */

/* {{{ spl_array_object_new */

static zend_object *spl_array_object_new(zend_class_entry *class_type)

{

return spl_array_object_new_ex(class_type, NULL, 0);

}

/* }}} */

/* {{{ spl_array_object_clone */

static zend_object *spl_array_object_clone(zend_object *old_object)

{

zend_object *new_object;

new_object = spl_array_object_new_ex(old_object->ce, old_object, 1);

zend_objects_clone_members(new_object, old_object);

return new_object;

}

/* }}} */

typedef struct {

zend_string *key;

zend_ulong h;

bool release_key;

} spl_hash_key;

static void spl_hash_key_release(spl_hash_key *key) {

if (key->release_key) {

zend_string_release_ex(key->key, 0);

}

}

/* This function does not throw any exceptions for illegal offsets, calls to

* zend_illegal_container_offset(); need to be made if the return value is FAILURE */

static zend_result get_hash_key(spl_hash_key *key, spl_array_object *intern, zval *offset)

{

key->release_key = false;

try_again:

switch (Z_TYPE_P(offset)) {

case IS_NULL:

zend_error(E_DEPRECATED, "Using null as an array offset is deprecated, use an empty string instead");

key->key = ZSTR_EMPTY_ALLOC();

return SUCCESS;

case IS_STRING:

key->key = Z_STR_P(offset);

if (ZEND_HANDLE_NUMERIC(key->key, key->h)) {

key->key = NULL;

break;

}

return SUCCESS;

case IS_RESOURCE:

zend_use_resource_as_offset(offset);

key->key = NULL;

key->h = Z_RES_P(offset)->handle;

break;

case IS_DOUBLE:

key->key = NULL;

key->h = zend_dval_to_lval_safe(Z_DVAL_P(offset));

break;

case IS_FALSE:

key->key = NULL;

key->h = 0;

break;

case IS_TRUE:

key->key = NULL;

key->h = 1;

break;

case IS_LONG:

key->key = NULL;

key->h = Z_LVAL_P(offset);

break;

case IS_REFERENCE:

ZVAL_DEREF(offset);

goto try_again;

default:

return FAILURE;

}

if (spl_array_is_object(intern)) {

key->key = zend_long_to_str(key->h);

key->release_key = true;

}

return SUCCESS;

}

static zval *spl_array_get_dimension_ptr(bool check_inherited, spl_array_object *intern, const zend_string *ce_name,

zval *offset, int type) /* {{{ */

{

zval *retval;

spl_hash_key key;

HashTable *ht = spl_array_get_hash_table(intern);

if (!offset || Z_ISUNDEF_P(offset) || !ht) {

return &EG(uninitialized_zval);

}

if ((type == BP_VAR_W || type == BP_VAR_RW) && intern->nApplyCount > 0) {

zend_throw_error(NULL, "Modification of ArrayObject during sorting is prohibited");

return &EG(error_zval);

}

if (get_hash_key(&key, intern, offset) == FAILURE) {

zend_illegal_container_offset(ce_name, offset, type);

return (type == BP_VAR_W || type == BP_VAR_RW) ?

&EG(error_zval) : &EG(uninitialized_zval);

}

if (key.key) {

retval = zend_hash_find(ht, key.key);

if (retval) {

if (Z_TYPE_P(retval) == IS_INDIRECT) {

retval = Z_INDIRECT_P(retval);

if (Z_TYPE_P(retval) == IS_UNDEF) {

switch (type) {

case BP_VAR_R:

zend_error(E_WARNING, "Undefined array key \"%s\"", ZSTR_VAL(key.key));

ZEND_FALLTHROUGH;

case BP_VAR_UNSET:

case BP_VAR_IS:

retval = &EG(uninitialized_zval);

break;

case BP_VAR_RW:

zend_error(E_WARNING,"Undefined array key \"%s\"", ZSTR_VAL(key.key));

ZEND_FALLTHROUGH;

case BP_VAR_W: {

ZVAL_NULL(retval);

}

}

}

}

} else {

switch (type) {

case BP_VAR_R:

zend_error(E_WARNING, "Undefined array key \"%s\"", ZSTR_VAL(key.key));

ZEND_FALLTHROUGH;

case BP_VAR_UNSET:

case BP_VAR_IS:

retval = &EG(uninitialized_zval);

break;

case BP_VAR_RW:

zend_error(E_WARNING,"Undefined array key \"%s\"", ZSTR_VAL(key.key));

ZEND_FALLTHROUGH;

case BP_VAR_W: {

zval value;

ZVAL_NULL(&value);

retval = zend_hash_update(ht, key.key, &value);

}

}

}

spl_hash_key_release(&key);

} else {

if ((retval = zend_hash_index_find(ht, key.h)) == NULL) {

switch (type) {

case BP_VAR_R:

zend_error(E_WARNING, "Undefined array key " ZEND_LONG_FMT, key.h);

ZEND_FALLTHROUGH;

case BP_VAR_UNSET:

case BP_VAR_IS:

retval = &EG(uninitialized_zval);

break;

case BP_VAR_RW:

zend_error(E_WARNING, "Undefined array key " ZEND_LONG_FMT, key.h);

ZEND_FALLTHROUGH;

case BP_VAR_W: {

zval value;

ZVAL_NULL(&value);

retval = zend_hash_index_update(ht, key.h, &value);

}

}

}

}

return retval;

} /* }}} */

static int spl_array_has_dimension(zend_object *object, zval *offset, int check_empty);

static zval *spl_array_read_dimension_ex(int check_inherited, zend_object *object, zval *offset, int type, zval *rv) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

zval *ret;

if (check_inherited &&

(intern->fptr_offset_get || (type == BP_VAR_IS && intern->fptr_offset_has))) {

if (type == BP_VAR_IS) {

if (!spl_array_has_dimension(object, offset, 0)) {

return &EG(uninitialized_zval);

}

}

if (intern->fptr_offset_get) {

zval tmp;

if (!offset) {

ZVAL_UNDEF(&tmp);

offset = &tmp;

}

zend_call_method_with_1_params(object, object->ce, &intern->fptr_offset_get, "offsetGet", rv, offset);

if (!Z_ISUNDEF_P(rv)) {

return rv;

}

return &EG(uninitialized_zval);

}

}

ret = spl_array_get_dimension_ptr(check_inherited, intern, object->ce->name, offset, type);

/* When in a write context,

* ZE has to be fooled into thinking this is in a reference set

* by separating (if necessary) and returning as IS_REFERENCE (with refcount == 1)

*/

if ((type == BP_VAR_W || type == BP_VAR_RW || type == BP_VAR_UNSET) &&

!Z_ISREF_P(ret) &&

EXPECTED(ret != &EG(uninitialized_zval))) {

ZVAL_NEW_REF(ret, ret);

}

return ret;

} /* }}} */

static zval *spl_array_read_dimension(zend_object *object, zval *offset, int type, zval *rv) /* {{{ */

{

return spl_array_read_dimension_ex(1, object, offset, type, rv);

} /* }}} */

static void spl_array_write_dimension_ex(int check_inherited, zend_object *object, zval *offset, zval *value) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

HashTable *ht;

spl_hash_key key;

if (check_inherited && intern->fptr_offset_set) {

zval tmp;

if (!offset) {

ZVAL_NULL(&tmp);

offset = &tmp;

}

zend_call_method_with_2_params(object, object->ce, &intern->fptr_offset_set, "offsetSet", NULL, offset, value);

return;

}

if (intern->nApplyCount > 0) {

zend_throw_error(NULL, "Modification of ArrayObject during sorting is prohibited");

return;

}

Z_TRY_ADDREF_P(value);

if (!offset || Z_TYPE_P(offset) == IS_NULL) {

ht = spl_array_get_hash_table(intern);

if (UNEXPECTED(ht == intern->sentinel_array)) {

return;

}

zend_hash_next_index_insert(ht, value);

return;

}

if (get_hash_key(&key, intern, offset) == FAILURE) {

zend_illegal_container_offset(object->ce->name, offset, BP_VAR_W);

zval_ptr_dtor(value);

return;

}

ht = spl_array_get_hash_table(intern);

if (UNEXPECTED(ht == intern->sentinel_array)) {

spl_hash_key_release(&key);

return;

}

if (key.key) {

zend_hash_update_ind(ht, key.key, value);

spl_hash_key_release(&key);

} else {

zend_hash_index_update(ht, key.h, value);

}

} /* }}} */

static void spl_array_write_dimension(zend_object *object, zval *offset, zval *value) /* {{{ */

{

spl_array_write_dimension_ex(1, object, offset, value);

} /* }}} */

static void spl_array_unset_dimension_ex(int check_inherited, zend_object *object, zval *offset) /* {{{ */

{

HashTable *ht;

spl_array_object *intern = spl_array_from_obj(object);

spl_hash_key key;

if (check_inherited && intern->fptr_offset_del) {

zend_call_method_with_1_params(object, object->ce, &intern->fptr_offset_del, "offsetUnset", NULL, offset);

return;

}

if (intern->nApplyCount > 0) {

zend_throw_error(NULL, "Modification of ArrayObject during sorting is prohibited");

return;

}

if (get_hash_key(&key, intern, offset) == FAILURE) {

zend_illegal_container_offset(object->ce->name, offset, BP_VAR_UNSET);

return;

}

ht = spl_array_get_hash_table(intern);

if (key.key) {

zval *data = zend_hash_find(ht, key.key);

if (data) {

if (Z_TYPE_P(data) == IS_INDIRECT) {

data = Z_INDIRECT_P(data);

if (Z_TYPE_P(data) != IS_UNDEF) {

zval garbage;

ZVAL_COPY_VALUE(&garbage, data);

ZVAL_UNDEF(data);

HT_FLAGS(ht) |= HASH_FLAG_HAS_EMPTY_IND;

zend_hash_move_forward_ex(ht, spl_array_get_pos_ptr(ht, intern));

if (spl_array_is_object(intern)) {

spl_array_skip_protected(intern, ht);

}

zval_ptr_dtor(&garbage);

}

} else {

zend_hash_del(ht, key.key);

}

}

spl_hash_key_release(&key);

} else {

zend_hash_index_del(ht, key.h);

}

} /* }}} */

static void spl_array_unset_dimension(zend_object *object, zval *offset) /* {{{ */

{

spl_array_unset_dimension_ex(1, object, offset);

} /* }}} */

/* check_empty can take value 0, 1, or 2

* 0/1 are used as normal boolean, but 2 is used for the case when this function is called from

* the offsetExists() method, in which case it needs to report the offset exist even if the value is null */

static bool spl_array_has_dimension_ex(bool check_inherited, zend_object *object, zval *offset, int check_empty) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

zval rv, *value = NULL, *tmp;

if (check_inherited && intern->fptr_offset_has) {

zend_call_method_with_1_params(object, object->ce, &intern->fptr_offset_has, "offsetExists", &rv, offset);

if (!zend_is_true(&rv)) {

zval_ptr_dtor(&rv);

return false;

}

zval_ptr_dtor(&rv);

/* For isset calls we don't need to check the value, so return early */

if (!check_empty) {

return true;

} else if (intern->fptr_offset_get) {

value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R, &rv);

}

}

if (!value) {

HashTable *ht = spl_array_get_hash_table(intern);

spl_hash_key key;

if (get_hash_key(&key, intern, offset) == FAILURE) {

zend_illegal_container_offset(object->ce->name, offset, BP_VAR_IS);

return false;

}

if (key.key) {

tmp = zend_hash_find(ht, key.key);

spl_hash_key_release(&key);

} else {

tmp = zend_hash_index_find(ht, key.h);

}

if (!tmp) {

return false;

}

/* check_empty is only equal to 2 if it is called from offsetExists on this class,

* where it needs to report an offset exists even if the value is null */

if (check_empty == 2) {

return true;

}

if (check_empty && check_inherited && intern->fptr_offset_get) {

value = spl_array_read_dimension_ex(1, object, offset, BP_VAR_R, &rv);

} else {

value = tmp;

}

}

/* empty() check the value is not falsy, isset() only check it is not null */

bool result = check_empty ? zend_is_true(value) : Z_TYPE_P(value) != IS_NULL;

if (value == &rv) {

zval_ptr_dtor(&rv);

}

return result;

} /* }}} */

static int spl_array_has_dimension(zend_object *object, zval *offset, int check_empty) /* {{{ */

{

return spl_array_has_dimension_ex(/* check_inherited */ true, object, offset, check_empty);

} /* }}} */

/* {{{ Returns whether the requested $index exists. */

PHP_METHOD(ArrayObject, offsetExists)

{

zval *index;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {

RETURN_THROWS();

}

RETURN_BOOL(spl_array_has_dimension_ex(/* check_inherited */ false, Z_OBJ_P(ZEND_THIS), index, 2));

} /* }}} */

/* {{{ Returns the value at the specified $index. */

PHP_METHOD(ArrayObject, offsetGet)

{

zval *value, *index;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {

RETURN_THROWS();

}

value = spl_array_read_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index, BP_VAR_R, return_value);

if (value != return_value) {

RETURN_COPY_DEREF(value);

}

} /* }}} */

/* {{{ Sets the value at the specified $index to $newval. */

PHP_METHOD(ArrayObject, offsetSet)

{

zval *index, *value;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "zz", &index, &value) == FAILURE) {

RETURN_THROWS();

}

spl_array_write_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index, value);

} /* }}} */

void spl_array_iterator_append(zval *object, zval *append_value) /* {{{ */

{

spl_array_object *intern = Z_SPLARRAY_P(object);

if (spl_array_is_object(intern)) {

zend_throw_error(NULL, "Cannot append properties to objects, use %s::offsetSet() instead", ZSTR_VAL(Z_OBJCE_P(object)->name));

return;

}

spl_array_write_dimension(Z_OBJ_P(object), NULL, append_value);

} /* }}} */

/* {{{ Appends the value (cannot be called for objects). */

PHP_METHOD(ArrayObject, append)

{

zval *value;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &value) == FAILURE) {

RETURN_THROWS();

}

spl_array_iterator_append(ZEND_THIS, value);

} /* }}} */

/* {{{ Unsets the value at the specified $index. */

PHP_METHOD(ArrayObject, offsetUnset)

{

zval *index;

if (zend_parse_parameters(ZEND_NUM_ARGS(), "z", &index) == FAILURE) {

RETURN_THROWS();

}

spl_array_unset_dimension_ex(0, Z_OBJ_P(ZEND_THIS), index);

} /* }}} */

/* {{{ Return a copy of the contained array */

PHP_METHOD(ArrayObject, getArrayCopy)

{

zval *object = ZEND_THIS;

spl_array_object *intern = Z_SPLARRAY_P(object);

ZEND_PARSE_PARAMETERS_NONE();

RETURN_ARR(zend_array_dup(spl_array_get_hash_table(intern)));

} /* }}} */

static HashTable *spl_array_get_properties_for(zend_object *object, zend_prop_purpose purpose) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

HashTable *ht;

bool dup;

if (intern->ar_flags & SPL_ARRAY_STD_PROP_LIST) {

return zend_std_get_properties_for(object, purpose);

}

/* We are supposed to be the only owner of the internal hashtable.

* The "dup" flag decides whether this is a "long-term" use where

* we need to duplicate, or a "temporary" one, where we can expect

* that no operations on the ArrayObject will be performed in the

* meantime. */

switch (purpose) {

case ZEND_PROP_PURPOSE_ARRAY_CAST:

dup = true;

break;

case ZEND_PROP_PURPOSE_VAR_EXPORT:

case ZEND_PROP_PURPOSE_JSON:

dup = false;

break;

default:

return zend_std_get_properties_for(object, purpose);

}

ht = spl_array_get_hash_table(intern);

if (dup) {

ht = zend_array_dup(ht);

} else {

GC_ADDREF(ht);

}

return ht;

} /* }}} */

static inline HashTable* spl_array_get_debug_info(zend_object *obj) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(obj);

HashTable *properties = zend_std_get_properties_ex(&intern->std);

if (intern->ar_flags & SPL_ARRAY_IS_SELF) {

return zend_array_dup(properties);

} else {

HashTable *debug_info;

debug_info = zend_new_array(zend_hash_num_elements(properties) + 1);

zend_hash_copy(debug_info, properties, (copy_ctor_func_t) zval_add_ref);

zval *storage = &intern->array;

Z_TRY_ADDREF_P(storage);

const zend_class_entry *base_class_ce = instanceof_function(obj->ce, spl_ce_ArrayIterator)

? spl_ce_ArrayIterator : spl_ce_ArrayObject;

spl_set_private_debug_info_property(base_class_ce, "storage", strlen("storage"), debug_info, storage);

return debug_info;

}

}

/* }}} */

static HashTable *spl_array_get_gc(zend_object *obj, zval **gc_data, int *gc_data_count) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(obj);

*gc_data = &intern->array;

*gc_data_count = 1;

return zend_std_get_properties(obj);

}

/* }}} */

static zval *spl_array_read_property(zend_object *object, zend_string *name, int type, void **cache_slot, zval *rv) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !zend_std_has_property(object, name, ZEND_PROPERTY_EXISTS, NULL)) {

zval member;

ZVAL_STR(&member, name);

return spl_array_read_dimension(object, &member, type, rv);

}

return zend_std_read_property(object, name, type, cache_slot, rv);

} /* }}} */

static zval *spl_array_write_property(zend_object *object, zend_string *name, zval *value, void **cache_slot) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !zend_std_has_property(object, name, ZEND_PROPERTY_EXISTS, NULL)) {

zval member;

ZVAL_STR(&member, name);

spl_array_write_dimension(object, &member, value);

return value;

}

return zend_std_write_property(object, name, value, cache_slot);

} /* }}} */

static zval *spl_array_get_property_ptr_ptr(zend_object *object, zend_string *name, int type, void **cache_slot) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !zend_std_has_property(object, name, ZEND_PROPERTY_EXISTS, NULL)) {

if (cache_slot) {

cache_slot[0] = cache_slot[1] = cache_slot[2] = NULL;

}

/* If object has offsetGet() overridden, then fallback to read_property,

* which will call offsetGet(). */

zval member;

if (intern->fptr_offset_get) {

return NULL;

}

ZVAL_STR(&member, name);

return spl_array_get_dimension_ptr(true, intern, object->ce->name, &member, type);

}

return zend_std_get_property_ptr_ptr(object, name, type, cache_slot);

} /* }}} */

static int spl_array_has_property(zend_object *object, zend_string *name, int has_set_exists, void **cache_slot) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !zend_std_has_property(object, name, ZEND_PROPERTY_EXISTS, NULL)) {

zval member;

ZVAL_STR(&member, name);

return spl_array_has_dimension(object, &member, has_set_exists);

}

return zend_std_has_property(object, name, has_set_exists, cache_slot);

} /* }}} */

static void spl_array_unset_property(zend_object *object, zend_string *name, void **cache_slot) /* {{{ */

{

spl_array_object *intern = spl_array_from_obj(object);

if ((intern->ar_flags & SPL_ARRAY_ARRAY_AS_PROPS) != 0

&& !zend_std_has_property(object, name, ZEND_PROPERTY_EXISTS, NULL)) {

zval member;

ZVAL_STR(&member, name);

spl_array_unset_dimension(object, &member);

return;

}

zend_std_unset_property(object, name, cache_slot);

} /* }}} */

static int spl_array_compare_objects(zval *o1, zval *o2) /* {{{ */

{

HashTable *ht1,

*ht2;

spl_array_object *intern1,

*intern2;

int result = 0;

ZEND_COMPARE_OBJECTS_FALLBACK(o1, o2);

intern1 = Z_SPLARRAY_P(o1);

intern2 = Z_SPLARRAY_P(o2);

ht1 = spl_array_get_hash_table(intern1);

ht2 = spl_array_get_hash_table(intern2);

result = zend_compare_symbol_tables(ht1, ht2);

/* if we just compared std.properties, don't do it again */

if (result == 0 &&

!(ht1 == intern1->std.properties && ht2 == intern2->std.properties)) {

result = zend_std_compare_objects(o1, o2);

}

return result;

} /* }}} */

static zend_result spl_array_skip_protected(spl_array_object *intern, HashTable *aht) /* {{{ */

{

zend_string *string_key;

zend_ulong num_key;

zval *data;

if (spl_array_is_object(intern)) {

uint32_t *pos_ptr = spl_array_get_pos_ptr(aht, intern);

do {

if (zend_hash_get_current_key_ex(aht, &string_key, &num_key, pos_ptr) == HASH_KEY_IS_STRING) {

data = zend_hash_get_current_data_ex(aht, pos_ptr);

if (data && Z_TYPE_P(data) == IS_INDIRECT &&

Z_TYPE_P(data = Z_INDIRECT_P(data)) == IS_UNDEF) {

/* skip */

} else if (!ZSTR_LEN(string_key) || ZSTR_VAL(string_key)[0]) {

return SUCCESS;

}

} else {

return SUCCESS;

}

if (zend_hash_has_more_elements_ex(aht, pos_ptr) != SUCCESS) {

return FAILURE;

}

zend_hash_move_forward_ex(aht, pos_ptr);

} while (1);

}

return FAILURE;

} /* }}} */

/* {{{ spl_array_set_array */

static void spl_array_set_array(zval *object, spl_array_object *intern, zval *array, zend_long ar_flags, bool just_array) {

/* Handled by ZPP prior to this, or for __unserialize() before passing to here */

ZEND_ASSERT(Z_TYPE_P(array) == IS_ARRAY || Z_TYPE_P(array) == IS_OBJECT);

if (intern->nApplyCount > 0) {

zend_throw_error(NULL, "Modification of ArrayObject during sorting is prohibited");

return;

}

zval garbage;

ZVAL_UNDEF(&garbage);

if (Z_TYPE_P(array) == IS_ARRAY) {

ZVAL_COPY_VALUE(&garbage, &intern->array);

if (Z_REFCOUNT_P(array) == 1) {

ZVAL_COPY(&intern->array, array);

} else {

//??? TODO: try to avoid array duplication

ZVAL_ARR(&intern->array, zend_array_dup(Z_ARR_P(array)));

}

} else {

php_error_docref(NULL, E_DEPRECATED,

"Using an object as a backing array for %s is deprecated, as it allows violating class constraints and invariants",

instanceof_function(Z_OBJCE_P(object), spl_ce_ArrayIterator) ? "ArrayIterator" : "ArrayObject");

if (UNEXPECTED(EG(exception))) {

return;

}

if (Z_OBJ_HT_P(array) == &spl_handler_ArrayObject) {

ZVAL_COPY_VALUE(&garbage, &intern->array);

if (just_array) {

spl_array_object *other = Z_SPLARRAY_P(array);

ar_flags = other->ar_flags & ~SPL_ARRAY_INT_MASK;

}

if (Z_OBJ_P(object) == Z_OBJ_P(array)) {

ar_flags |= SPL_ARRAY_IS_SELF;

ZVAL_UNDEF(&intern->array);

} else {

ar_flags |= SPL_ARRAY_USE_OTHER;

ZVAL_COPY(&intern->array, array);

}

} else {

zend_object_get_properties_t handler = Z_OBJ_HANDLER_P(array, get_properties);

if (handler != zend_std_get_properties || Z_OBJ_HANDLER_P(array, get_properties_for)) {

zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0,

"Overloaded object of type %s is not compatible with %s",

ZSTR_VAL(Z_OBJCE_P(array)->name), ZSTR_VAL(intern->std.ce->name));

ZEND_ASSERT(Z_TYPE(garbage) == IS_UNDEF);

return;

}

if (UNEXPECTED(Z_OBJCE_P(array)->ce_flags & ZEND_ACC_ENUM)) {

zend_throw_exception_ex(spl_ce_InvalidArgumentException, 0,

"Enums are not compatible with %s",

ZSTR_VAL(intern->std.ce->name));

ZEND_ASSERT(Z_TYPE(garbage) == IS_UNDEF);

return;

}

ZVAL_COPY_VALUE(&garbage, &intern->array);

ZVAL_COPY(&intern->array, array);

}

}

intern->ar_flags &= ~SPL_ARRAY_IS_SELF & ~SPL_ARRAY_USE_OTHER;

intern->ar_flags |= ar_flags;

if (intern->ht_iter != (uint32_t)-1) {

zend_hash_iterator_del(intern->ht_iter);

intern->ht_iter = (uint32_t)-1;

}

zval_ptr_dtor(&garbage);

}

/* }}} */

/* {{{ Constructs a new array object from an array or object. */

PHP_METHOD(ArrayObject, __construct)

{

zval *object = ZEND_THIS;

spl_array_object *intern;

zval *array;

zend_long ar_flags = 0;

zend_class_entry *ce_get_iterator = spl_ce_ArrayIterator;

if (ZEND_NUM_ARGS() == 0) {

return; /* nothing to do */