/*

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

| 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: Andi Gutmans <andi@php.net> |

| Zeev Suraski <zeev@php.net> |

| Rasmus Lerdorf <rasmus@php.net> |

| Andrei Zmievski <andrei@php.net> |

| Stig Venaas <venaas@php.net> |

| Jason Greene <jason@php.net> |

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

*/

#include "php.h"

#include "php_ini.h"

#include <stdarg.h>

#include <stdlib.h>

#include <math.h>

#include <time.h>

#include <string.h>

#include "zend_globals.h"

#include "zend_interfaces.h"

#include "php_array.h"

#include "basic_functions.h"

#include "php_string.h"

#include "php_math.h"

#include "zend_smart_str.h"

#include "zend_bitset.h"

#include "zend_exceptions.h"

#include "ext/random/php_random.h"

#include "zend_frameless_function.h"

/* {{{ defines */

#define DIFF_NORMAL 1

#define DIFF_KEY 2

#define DIFF_ASSOC 6

#define DIFF_COMP_DATA_NONE -1

#define DIFF_COMP_DATA_INTERNAL 0

#define DIFF_COMP_DATA_USER 1

#define DIFF_COMP_KEY_INTERNAL 0

#define DIFF_COMP_KEY_USER 1

#define INTERSECT_NORMAL 1

#define INTERSECT_KEY 2

#define INTERSECT_ASSOC 6

#define INTERSECT_COMP_DATA_NONE -1

#define INTERSECT_COMP_DATA_INTERNAL 0

#define INTERSECT_COMP_DATA_USER 1

#define INTERSECT_COMP_KEY_INTERNAL 0

#define INTERSECT_COMP_KEY_USER 1

/* }}} */

ZEND_DECLARE_MODULE_GLOBALS(array)

PHPAPI zend_class_entry *sort_direction_ce;

/* {{{ php_array_init_globals */

static void php_array_init_globals(zend_array_globals *array_globals)

{

memset(array_globals, 0, sizeof(zend_array_globals));

}

/* }}} */

PHP_MINIT_FUNCTION(array) /* {{{ */

{

ZEND_INIT_MODULE_GLOBALS(array, php_array_init_globals, NULL);

return SUCCESS;

}

/* }}} */

PHP_MSHUTDOWN_FUNCTION(array) /* {{{ */

{

#ifdef ZTS

ts_free_id(array_globals_id);

#endif

return SUCCESS;

}

/* }}} */

static zend_never_inline ZEND_COLD int stable_sort_fallback(Bucket *a, Bucket *b) {

if (Z_EXTRA(a->val) > Z_EXTRA(b->val)) {

return 1;

} else if (Z_EXTRA(a->val) < Z_EXTRA(b->val)) {

return -1;

} else {

return 0;

}

}

#define RETURN_STABLE_SORT(a, b, result) do { \

int _result = (result); \

if (EXPECTED(_result)) { \

return _result; \

} \

return stable_sort_fallback((a), (b)); \

} while (0)

/* Generate inlined unstable and stable variants, and non-inlined reversed variants. */

#define DEFINE_SORT_VARIANTS(name) \

static zend_never_inline int php_array_##name##_unstable(Bucket *a, Bucket *b) { \

return php_array_##name##_unstable_i(a, b); \

} \

static zend_never_inline int php_array_##name(Bucket *a, Bucket *b) { \

RETURN_STABLE_SORT(a, b, php_array_##name##_unstable_i(a, b)); \

} \

static zend_never_inline int php_array_reverse_##name##_unstable(Bucket *a, Bucket *b) { \

return php_array_##name##_unstable(a, b) * -1; \

} \

static zend_never_inline int php_array_reverse_##name(Bucket *a, Bucket *b) { \

RETURN_STABLE_SORT(a, b, php_array_reverse_##name##_unstable(a, b)); \

} \

static zend_always_inline int php_array_key_compare_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

zval first;

zval second;

if (f->key == NULL && s->key == NULL) {

return (zend_long)f->h > (zend_long)s->h ? 1 : -1;

} else if (f->key && s->key) {

return zendi_smart_strcmp(f->key, s->key);

}

if (f->key) {

ZVAL_STR(&first, f->key);

} else {

ZVAL_LONG(&first, f->h);

}

if (s->key) {

ZVAL_STR(&second, s->key);

} else {

ZVAL_LONG(&second, s->h);

}

return zend_compare(&first, &second);

}

/* }}} */

static zend_always_inline int php_array_key_compare_numeric_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

if (f->key == NULL && s->key == NULL) {

return (zend_long)f->h > (zend_long)s->h ? 1 : -1;

} else {

double d1, d2;

if (f->key) {

d1 = zend_strtod(f->key->val, NULL);

} else {

d1 = (double)(zend_long)f->h;

}

if (s->key) {

d2 = zend_strtod(s->key->val, NULL);

} else {

d2 = (double)(zend_long)s->h;

}

return ZEND_THREEWAY_COMPARE(d1, d2);

}

}

/* }}} */

static zend_always_inline int php_array_key_compare_string_case_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

const char *s1, *s2;

size_t l1, l2;

char buf1[MAX_LENGTH_OF_LONG + 1];

char buf2[MAX_LENGTH_OF_LONG + 1];

if (f->key) {

s1 = f->key->val;

l1 = f->key->len;

} else {

s1 = zend_print_long_to_buf(buf1 + sizeof(buf1) - 1, f->h);

l1 = buf1 + sizeof(buf1) - 1 - s1;

}

if (s->key) {

s2 = s->key->val;

l2 = s->key->len;

} else {

s2 = zend_print_long_to_buf(buf2 + sizeof(buf2) - 1, s->h);

l2 = buf2 + sizeof(buf2) - 1 - s2;

}

return zend_binary_strcasecmp_l(s1, l1, s2, l2);

}

/* }}} */

static zend_always_inline int php_array_key_compare_string_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

const char *s1, *s2;

size_t l1, l2;

char buf1[MAX_LENGTH_OF_LONG + 1];

char buf2[MAX_LENGTH_OF_LONG + 1];

if (f->key) {

s1 = f->key->val;

l1 = f->key->len;

} else {

s1 = zend_print_long_to_buf(buf1 + sizeof(buf1) - 1, f->h);

l1 = buf1 + sizeof(buf1) - 1 - s1;

}

if (s->key) {

s2 = s->key->val;

l2 = s->key->len;

} else {

s2 = zend_print_long_to_buf(buf2 + sizeof(buf2) - 1, s->h);

l2 = buf2 + sizeof(buf2) - 1 - s2;

}

return zend_binary_strcmp(s1, l1, s2, l2);

}

/* }}} */

static int php_array_key_compare_string_natural_general(Bucket *f, Bucket *s, bool fold_case) /* {{{ */

{

const char *s1, *s2;

size_t l1, l2;

char buf1[MAX_LENGTH_OF_LONG + 1];

char buf2[MAX_LENGTH_OF_LONG + 1];

if (f->key) {

s1 = f->key->val;

l1 = f->key->len;

} else {

s1 = zend_print_long_to_buf(buf1 + sizeof(buf1) - 1, f->h);

l1 = buf1 + sizeof(buf1) - 1 - s1;

}

if (s->key) {

s2 = s->key->val;

l2 = s->key->len;

} else {

s2 = zend_print_long_to_buf(buf2 + sizeof(buf2) - 1, s->h);

l2 = buf2 + sizeof(buf2) - 1 - s2;

}

return strnatcmp_ex(s1, l1, s2, l2, fold_case);

}

/* }}} */

static int php_array_key_compare_string_natural_case(Bucket *a, Bucket *b) /* {{{ */

{

RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(a, b, true));

}

/* }}} */

static int php_array_reverse_key_compare_string_natural_case(Bucket *a, Bucket *b) /* {{{ */

{

RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(b, a, true));

}

/* }}} */

static int php_array_key_compare_string_natural(Bucket *a, Bucket *b) /* {{{ */

{

RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(a, b, false));

}

/* }}} */

static int php_array_reverse_key_compare_string_natural(Bucket *a, Bucket *b) /* {{{ */

{

RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(b, a, false));

}

/* }}} */

static zend_always_inline int php_array_key_compare_string_locale_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

const char *s1, *s2;

char buf1[MAX_LENGTH_OF_LONG + 1];

char buf2[MAX_LENGTH_OF_LONG + 1];

if (f->key) {

s1 = f->key->val;

} else {

s1 = zend_print_long_to_buf(buf1 + sizeof(buf1) - 1, f->h);

}

if (s->key) {

s2 = s->key->val;

} else {

s2 = zend_print_long_to_buf(buf2 + sizeof(buf2) - 1, s->h);

}

return strcoll(s1, s2);

}

/* }}} */

static zend_always_inline int php_array_data_compare_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

int result = zend_compare(&f->val, &s->val);

/* Special enums handling for array_unique. We don't want to add this logic to zend_compare as

* that would be observable via comparison operators. */

zval *rhs = &s->val;

ZVAL_DEREF(rhs);

if (UNEXPECTED(Z_TYPE_P(rhs) == IS_OBJECT)

&& result == ZEND_UNCOMPARABLE

&& (Z_OBJCE_P(rhs)->ce_flags & ZEND_ACC_ENUM)) {

zval *lhs = &f->val;

ZVAL_DEREF(lhs);

if (Z_TYPE_P(lhs) == IS_OBJECT && (Z_OBJCE_P(lhs)->ce_flags & ZEND_ACC_ENUM)) {

// Order doesn't matter, we just need to group the same enum values

uintptr_t lhs_uintptr = (uintptr_t)Z_OBJ_P(lhs);

uintptr_t rhs_uintptr = (uintptr_t)Z_OBJ_P(rhs);

return lhs_uintptr == rhs_uintptr ? 0 : (lhs_uintptr < rhs_uintptr ? -1 : 1);

} else {

// Shift enums to the end of the array

return -1;

}

}

return result;

}

/* }}} */

static zend_always_inline int php_array_data_compare_numeric_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

return numeric_compare_function(&f->val, &s->val);

}

/* }}} */

static zend_always_inline int php_array_data_compare_string_case_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

return string_case_compare_function(&f->val, &s->val);

}

/* }}} */

static zend_always_inline int php_array_data_compare_string_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

return string_compare_function(&f->val, &s->val);

}

/* }}} */

static int php_array_natural_general_compare(Bucket *f, Bucket *s, bool fold_case) /* {{{ */

{

zend_string *tmp_str1, *tmp_str2;

zend_string *str1 = zval_get_tmp_string(&f->val, &tmp_str1);

zend_string *str2 = zval_get_tmp_string(&s->val, &tmp_str2);

int result = strnatcmp_ex(ZSTR_VAL(str1), ZSTR_LEN(str1), ZSTR_VAL(str2), ZSTR_LEN(str2), fold_case);

zend_tmp_string_release(tmp_str1);

zend_tmp_string_release(tmp_str2);

return result;

}

/* }}} */

static zend_always_inline int php_array_natural_compare_unstable_i(Bucket *a, Bucket *b) /* {{{ */

{

return php_array_natural_general_compare(a, b, false);

}

/* }}} */

static zend_always_inline int php_array_natural_case_compare_unstable_i(Bucket *a, Bucket *b) /* {{{ */

{

return php_array_natural_general_compare(a, b, true);

}

/* }}} */

static int php_array_data_compare_string_locale_unstable_i(Bucket *f, Bucket *s) /* {{{ */

{

return string_locale_compare_function(&f->val, &s->val);

}

/* }}} */

DEFINE_SORT_VARIANTS(key_compare);

DEFINE_SORT_VARIANTS(key_compare_numeric);

DEFINE_SORT_VARIANTS(key_compare_string_case);

DEFINE_SORT_VARIANTS(key_compare_string);

DEFINE_SORT_VARIANTS(key_compare_string_locale);

DEFINE_SORT_VARIANTS(data_compare);

DEFINE_SORT_VARIANTS(data_compare_numeric);

DEFINE_SORT_VARIANTS(data_compare_string_case);

DEFINE_SORT_VARIANTS(data_compare_string);

DEFINE_SORT_VARIANTS(data_compare_string_locale);

DEFINE_SORT_VARIANTS(natural_compare);

DEFINE_SORT_VARIANTS(natural_case_compare);

static bucket_compare_func_t php_get_key_compare_func(zend_long sort_type)

{

switch (sort_type & ~PHP_SORT_FLAG_CASE) {

case PHP_SORT_NUMERIC:

return php_array_key_compare_numeric;

case PHP_SORT_STRING:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_key_compare_string_case;

} else {

return php_array_key_compare_string;

}

case PHP_SORT_NATURAL:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_key_compare_string_natural_case;

} else {

return php_array_key_compare_string_natural;

}

case PHP_SORT_LOCALE_STRING:

return php_array_key_compare_string_locale;

case PHP_SORT_REGULAR:

default:

return php_array_key_compare;

}

return NULL;

}

static bucket_compare_func_t php_get_key_reverse_compare_func(zend_long sort_type)

{

switch (sort_type & ~PHP_SORT_FLAG_CASE) {

case PHP_SORT_NUMERIC:

return php_array_reverse_key_compare_numeric;

case PHP_SORT_STRING:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_reverse_key_compare_string_case;

} else {

return php_array_reverse_key_compare_string;

}

case PHP_SORT_NATURAL:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_reverse_key_compare_string_natural_case;

} else {

return php_array_reverse_key_compare_string_natural;

}

case PHP_SORT_LOCALE_STRING:

return php_array_reverse_key_compare_string_locale;

case PHP_SORT_REGULAR:

default:

return php_array_reverse_key_compare;

}

return NULL;

}

static bucket_compare_func_t php_get_data_compare_func(zend_long sort_type) /* {{{ */

{

switch (sort_type & ~PHP_SORT_FLAG_CASE) {

case PHP_SORT_NUMERIC:

return php_array_data_compare_numeric;

case PHP_SORT_STRING:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_data_compare_string_case;

} else {

return php_array_data_compare_string;

}

case PHP_SORT_NATURAL:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_natural_case_compare;

} else {

return php_array_natural_compare;

}

case PHP_SORT_LOCALE_STRING:

return php_array_data_compare_string_locale;

case PHP_SORT_REGULAR:

default:

return php_array_data_compare;

}

return NULL;

}

static bucket_compare_func_t php_get_data_reverse_compare_func(zend_long sort_type) /* {{{ */

{

switch (sort_type & ~PHP_SORT_FLAG_CASE) {

case PHP_SORT_NUMERIC:

return php_array_reverse_data_compare_numeric;

case PHP_SORT_STRING:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_reverse_data_compare_string_case;

} else {

return php_array_reverse_data_compare_string;

}

case PHP_SORT_NATURAL:

if (sort_type & PHP_SORT_FLAG_CASE) {

return php_array_reverse_natural_case_compare;

} else {

return php_array_reverse_natural_compare;

}

case PHP_SORT_LOCALE_STRING:

return php_array_reverse_data_compare_string_locale;

case PHP_SORT_REGULAR:

default:

return php_array_reverse_data_compare;

}

return NULL;

}

static bucket_compare_func_t php_get_data_compare_func_unstable(zend_long sort_type, bool reverse) /* {{{ */

{

switch (sort_type & ~PHP_SORT_FLAG_CASE) {

case PHP_SORT_NUMERIC:

if (reverse) {

return php_array_reverse_data_compare_numeric_unstable;

} else {

return php_array_data_compare_numeric_unstable;

}

break;

case PHP_SORT_STRING:

if (sort_type & PHP_SORT_FLAG_CASE) {

if (reverse) {

return php_array_reverse_data_compare_string_case_unstable;

} else {

return php_array_data_compare_string_case_unstable;

}

} else {

if (reverse) {

return php_array_reverse_data_compare_string_unstable;

} else {

return php_array_data_compare_string_unstable;

}

}

break;

case PHP_SORT_NATURAL:

if (sort_type & PHP_SORT_FLAG_CASE) {

if (reverse) {

return php_array_reverse_natural_case_compare_unstable;

} else {

return php_array_natural_case_compare_unstable;

}

} else {

if (reverse) {

return php_array_reverse_natural_compare_unstable;

} else {

return php_array_natural_compare_unstable;

}

}

break;

case PHP_SORT_LOCALE_STRING:

if (reverse) {

return php_array_reverse_data_compare_string_locale_unstable;

} else {

return php_array_data_compare_string_locale_unstable;

}

break;

case PHP_SORT_REGULAR:

default:

if (reverse) {

return php_array_reverse_data_compare_unstable;

} else {

return php_array_data_compare_unstable;

}

break;

}

return NULL;

}

/* }}} */

PHPAPI zend_long php_count_recursive(HashTable *ht) /* {{{ */

{

zend_long cnt = 0;

zval *element;

if (!(GC_FLAGS(ht) & GC_IMMUTABLE)) {

if (GC_IS_RECURSIVE(ht)) {

php_error_docref(NULL, E_WARNING, "Recursion detected");

return 0;

}

GC_PROTECT_RECURSION(ht);

}

cnt = zend_hash_num_elements(ht);

ZEND_HASH_FOREACH_VAL(ht, element) {

ZVAL_DEREF(element);

if (Z_TYPE_P(element) == IS_ARRAY) {

cnt += php_count_recursive(Z_ARRVAL_P(element));

}

} ZEND_HASH_FOREACH_END();

GC_TRY_UNPROTECT_RECURSION(ht);

return cnt;

}

/* }}} */

/* Consumes `zv` */

static zend_always_inline zend_long php_get_long(zval *zv)

{

if (EXPECTED(Z_TYPE_P(zv) == IS_LONG)) {

return Z_LVAL_P(zv);

} else {

zend_long ret = zval_get_long_func(zv, false);

zval_ptr_dtor(zv);

return ret;

}

}

/* {{{ Count the number of elements in a variable (usually an array) */

PHP_FUNCTION(count)

{

zval *array;

zend_long mode = PHP_COUNT_NORMAL;

zend_long cnt;

ZEND_PARSE_PARAMETERS_START(1, 2)

Z_PARAM_ZVAL(array)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(mode)

ZEND_PARSE_PARAMETERS_END();

if (mode != PHP_COUNT_NORMAL && mode != PHP_COUNT_RECURSIVE) {

zend_argument_value_error(2, "must be either COUNT_NORMAL or COUNT_RECURSIVE");

RETURN_THROWS();

}

switch (Z_TYPE_P(array)) {

case IS_ARRAY:

if (mode != PHP_COUNT_RECURSIVE) {

cnt = zend_hash_num_elements(Z_ARRVAL_P(array));

} else {

cnt = php_count_recursive(Z_ARRVAL_P(array));

}

RETURN_LONG(cnt);

case IS_OBJECT: {

zval retval;

/* first, we check if the handler is defined */

zend_object *zobj = Z_OBJ_P(array);

if (zobj->handlers->count_elements) {

RETVAL_LONG(1);

if (SUCCESS == zobj->handlers->count_elements(zobj, &Z_LVAL_P(return_value))) {

return;

}

if (EG(exception)) {

RETURN_THROWS();

}

}

/* if not and the object implements Countable we call its count() method */

if (instanceof_function(zobj->ce, zend_ce_countable)) {

zend_function *count_fn = zend_hash_find_ptr(&zobj->ce->function_table, ZSTR_KNOWN(ZEND_STR_COUNT));

zend_call_known_instance_method_with_0_params(count_fn, zobj, &retval);

if (Z_TYPE(retval) != IS_UNDEF) {

RETVAL_LONG(php_get_long(&retval));

}

return;

}

}

ZEND_FALLTHROUGH;

default:

zend_argument_type_error(1, "must be of type Countable|array, %s given", zend_zval_value_name(array));

RETURN_THROWS();

}

}

/* }}} */

static void php_natsort(INTERNAL_FUNCTION_PARAMETERS, bucket_compare_func_t sort_fn)

{

HashTable *array;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_ARRAY_HT_EX(array, 0, 1)

ZEND_PARSE_PARAMETERS_END();

zend_array_sort(array, sort_fn, false);

RETURN_TRUE;

}

/* {{{ Sort an array using natural sort */

PHP_FUNCTION(natsort)

{

php_natsort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_array_natural_compare);

}

/* }}} */

/* {{{ Sort an array using case-insensitive natural sort */

PHP_FUNCTION(natcasesort)

{

php_natsort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_array_natural_case_compare);

}

/* }}} */

typedef bucket_compare_func_t(*get_compare_function)(zend_long);

static zend_always_inline void php_sort(INTERNAL_FUNCTION_PARAMETERS, get_compare_function get_cmp, bool renumber) {

HashTable *array;

zend_long sort_type = PHP_SORT_REGULAR;

bucket_compare_func_t cmp;

ZEND_PARSE_PARAMETERS_START(1, 2)

Z_PARAM_ARRAY_HT_EX(array, 0, 1)

Z_PARAM_OPTIONAL

Z_PARAM_LONG(sort_type)

ZEND_PARSE_PARAMETERS_END();

cmp = get_cmp(sort_type);

zend_array_sort(array, cmp, renumber);

RETURN_TRUE;

}

/* {{{ Sort an array and maintain index association */

PHP_FUNCTION(asort)

{

php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_data_compare_func, false);

}

/* }}} */

/* {{{ Sort an array in reverse order and maintain index association */

PHP_FUNCTION(arsort)

{

php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_data_reverse_compare_func, false);

}

/* }}} */

/* {{{ Sort an array */

PHP_FUNCTION(sort)

{

php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_data_compare_func, true);

}

/* }}} */

/* {{{ Sort an array in reverse order */

PHP_FUNCTION(rsort)

{

php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_data_reverse_compare_func, true);

}

/* }}} */

/* {{{ Sort an array by key value in reverse order */

PHP_FUNCTION(krsort)

{

php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_key_reverse_compare_func, false);

}

/* }}} */

/* {{{ Sort an array by key */

PHP_FUNCTION(ksort)

{

php_sort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_get_key_compare_func, false);

}

/* }}} */

static inline int php_array_user_compare_unstable(Bucket *f, Bucket *s) /* {{{ */

{

zval args[2];

zval retval;

ZVAL_COPY_VALUE(&args[0], &f->val);

ZVAL_COPY_VALUE(&args[1], &s->val);

BG(user_compare_fci).param_count = 2;

BG(user_compare_fci).params = args;

BG(user_compare_fci).retval = &retval;

zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache));

if (UNEXPECTED(Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE)) {

if (!ARRAYG(compare_deprecation_thrown)) {

php_error_docref(NULL, E_DEPRECATED,

"Returning bool from comparison function is deprecated, "

"return an integer less than, equal to, or greater than zero");

ARRAYG(compare_deprecation_thrown) = 1;

}

if (Z_TYPE(retval) == IS_FALSE) {

/* Retry with swapped operands. */

ZVAL_COPY_VALUE(&args[0], &s->val);

ZVAL_COPY_VALUE(&args[1], &f->val);

zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache));

zend_long ret = php_get_long(&retval);

return -ZEND_NORMALIZE_BOOL(ret);

}

}

zend_long ret = php_get_long(&retval);

return ZEND_NORMALIZE_BOOL(ret);

}

/* }}} */

static int php_array_user_compare(Bucket *a, Bucket *b) /* {{{ */

{

RETURN_STABLE_SORT(a, b, php_array_user_compare_unstable(a, b));

}

/* }}} */

#define PHP_ARRAY_CMP_FUNC_VARS \

zend_fcall_info old_user_compare_fci; \

zend_fcall_info_cache old_user_compare_fci_cache \

#define PHP_ARRAY_CMP_FUNC_BACKUP() \

old_user_compare_fci = BG(user_compare_fci); \

old_user_compare_fci_cache = BG(user_compare_fci_cache); \

ARRAYG(compare_deprecation_thrown) = 0; \

BG(user_compare_fci_cache) = empty_fcall_info_cache; \

#define PHP_ARRAY_CMP_FUNC_RESTORE() \

BG(user_compare_fci) = old_user_compare_fci; \

BG(user_compare_fci_cache) = old_user_compare_fci_cache; \

static void php_usort(INTERNAL_FUNCTION_PARAMETERS, bucket_compare_func_t compare_func, bool renumber) /* {{{ */

{

zval *array;

zend_array *arr;

PHP_ARRAY_CMP_FUNC_VARS;

PHP_ARRAY_CMP_FUNC_BACKUP();

ZEND_PARSE_PARAMETERS_START(2, 2)

Z_PARAM_ARRAY_EX2(array, 0, 1, 0)

Z_PARAM_FUNC(BG(user_compare_fci), BG(user_compare_fci_cache))

ZEND_PARSE_PARAMETERS_END_EX( PHP_ARRAY_CMP_FUNC_RESTORE(); return );

arr = Z_ARR_P(array);

if (zend_hash_num_elements(arr) == 0) {

PHP_ARRAY_CMP_FUNC_RESTORE();

RETURN_TRUE;

}

/* Copy array, so the in-place modifications will not be visible to the callback function */

arr = zend_array_dup(arr);

zend_array_sort(arr, compare_func, renumber);

zval garbage;

ZVAL_COPY_VALUE(&garbage, array);

ZVAL_ARR(array, arr);

zval_ptr_dtor(&garbage);

PHP_ARRAY_CMP_FUNC_RESTORE();

RETURN_TRUE;

}

/* }}} */

/* {{{ Sort an array by values using a user-defined comparison function */

PHP_FUNCTION(usort)

{

php_usort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_array_user_compare, true);

}

/* }}} */

/* {{{ Sort an array with a user-defined comparison function and maintain index association */

PHP_FUNCTION(uasort)

{

php_usort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_array_user_compare, false);

}

/* }}} */

static inline int php_array_user_key_compare_unstable(Bucket *f, Bucket *s) /* {{{ */

{

zval args[2];

zval retval;

if (f->key == NULL) {

ZVAL_LONG(&args[0], f->h);

} else {

ZVAL_STR(&args[0], f->key);

}

if (s->key == NULL) {

ZVAL_LONG(&args[1], s->h);

} else {

ZVAL_STR(&args[1], s->key);

}

BG(user_compare_fci).param_count = 2;

BG(user_compare_fci).params = args;

BG(user_compare_fci).retval = &retval;

zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache));

if (UNEXPECTED(Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE)) {

if (!ARRAYG(compare_deprecation_thrown)) {

php_error_docref(NULL, E_DEPRECATED,

"Returning bool from comparison function is deprecated, "

"return an integer less than, equal to, or greater than zero");

ARRAYG(compare_deprecation_thrown) = 1;

}

if (Z_TYPE(retval) == IS_FALSE) {

/* Retry with swapped operands. */

if (s->key == NULL) {

ZVAL_LONG(&args[0], s->h);

} else {

ZVAL_STR(&args[0], s->key);

}

if (f->key == NULL) {

ZVAL_LONG(&args[1], f->h);

} else {

ZVAL_STR(&args[1], f->key);

}

zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache));

zend_long ret = php_get_long(&retval);

return -ZEND_NORMALIZE_BOOL(ret);

}

}

zend_long result = php_get_long(&retval);

return ZEND_NORMALIZE_BOOL(result);

}

/* }}} */

static int php_array_user_key_compare(Bucket *a, Bucket *b) /* {{{ */

{

RETURN_STABLE_SORT(a, b, php_array_user_key_compare_unstable(a, b));

}

/* }}} */

/* {{{ Sort an array by keys using a user-defined comparison function */

PHP_FUNCTION(uksort)

{

php_usort(INTERNAL_FUNCTION_PARAM_PASSTHRU, php_array_user_key_compare, false);

}

/* }}} */

static inline HashTable *get_ht_for_iap(zval *zv, bool separate) {

if (EXPECTED(Z_TYPE_P(zv) == IS_ARRAY)) {

return Z_ARRVAL_P(zv);

}

ZEND_ASSERT(Z_TYPE_P(zv) == IS_OBJECT);

php_error_docref(NULL, E_DEPRECATED,

"Calling %s() on an object is deprecated", get_active_function_name());

zend_object *zobj = Z_OBJ_P(zv);

if (separate && zobj->properties && UNEXPECTED(GC_REFCOUNT(zobj->properties) > 1)) {

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

GC_DELREF(zobj->properties);

}

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

}

return zobj->handlers->get_properties(zobj);

}

static zval *php_array_iter_seek_current(HashTable *array, bool forward_direction)

{

zval *entry;

while (true) {

if ((entry = zend_hash_get_current_data(array)) == NULL) {

return NULL;

}

ZVAL_DEINDIRECT(entry);

/* Possible with an uninitialized typed property */

if (UNEXPECTED(Z_TYPE_P(entry) == IS_UNDEF)) {

zend_result result;

if (forward_direction) {

result = zend_hash_move_forward(array);

} else {

result = zend_hash_move_backwards(array);

}

if (result != SUCCESS) {

return NULL;

}

} else {

break;

}

}

return entry;

}

static void php_array_iter_return_current(zval *return_value, HashTable *array, bool forward_direction)

{

zval *entry = php_array_iter_seek_current(array, forward_direction);

if (EXPECTED(entry)) {

RETURN_COPY_DEREF(entry);

} else {

RETURN_FALSE;

}

}

/* {{{ Advances array argument's internal pointer to the last element and return it */

PHP_FUNCTION(end)

{

zval *array_zv;

ZEND_PARSE_PARAMETERS_START(1, 1)

Z_PARAM_ARRAY_OR_OBJECT_EX(array_zv, 0, 1)

ZEND_PARSE_PARAMETERS_END();

HashTable *array = get_ht_for_iap(array_zv, /* separate */ true);

if (zend_hash_num_elements(array) == 0) {

/* array->nInternalPointer is already 0 if the array is empty, even after removing elements */

RETURN_FALSE;

}

zend_hash_internal_pointer_end(array);

if (USED_RET()) {

php_array_iter_return_current(return_value, array, false);

}

}

/* }}} */

/* {{{ Move array argument's internal pointer to the previous element and return it */

PHP_FUNCTION(prev)

{

zval *array_zv;

ZEND_PARSE_PARAMETERS_START(1, 1)