array.c

/*
 +----------------------------------------------------------------------+
 | Copyright (c) The PHP Group |
 +----------------------------------------------------------------------+
 | This source file is subject to version 3.01 of the PHP license, |
 | that is bundled with this package in the file LICENSE, and is |
 | available through the world-wide-web at the following url: |
 | https://www.php.net/license/3_01.txt |
 | If you did not receive a copy of the PHP license and are unable to |
 | obtain it through the world-wide-web, please send a note to |
 | license@php.net so we can mail you a copy immediately. |
 +----------------------------------------------------------------------+
 | 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 */

#defineDIFF_NORMAL 1
#defineDIFF_KEY 2
#defineDIFF_ASSOC 6
#defineDIFF_COMP_DATA_NONE -1
#defineDIFF_COMP_DATA_INTERNAL 0
#defineDIFF_COMP_DATA_USER 1
#defineDIFF_COMP_KEY_INTERNAL 0
#defineDIFF_COMP_KEY_USER 1

#defineINTERSECT_NORMAL 1
#defineINTERSECT_KEY 2
#defineINTERSECT_ASSOC 6
#defineINTERSECT_COMP_DATA_NONE -1
#defineINTERSECT_COMP_DATA_INTERNAL 0
#defineINTERSECT_COMP_DATA_USER 1
#defineINTERSECT_COMP_KEY_INTERNAL 0
#defineINTERSECT_COMP_KEY_USER 1
/* }}} */

ZEND_DECLARE_MODULE_GLOBALS(array)

/* {{{ php_array_init_globals */
staticvoidphp_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);

returnSUCCESS;
}
/* }}} */

PHP_MSHUTDOWN_FUNCTION(array) /* {{{ */
{
#ifdefZTS
ts_free_id(array_globals_id);
#endif

returnSUCCESS;
}
/* }}} */

staticzend_never_inlineZEND_COLDintstable_sort_fallback(Bucket*a, Bucket*b) {
if (Z_EXTRA(a->val) >Z_EXTRA(b->val)) {
return1;
 } elseif (Z_EXTRA(a->val) <Z_EXTRA(b->val)) {
return-1;
 } else {
return0;
 }
}

#defineRETURN_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. */
#defineDEFINE_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)); \
 } \

staticzend_always_inlineintphp_array_key_compare_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
zvalfirst;
zvalsecond;

if (f->key==NULL&&s->key==NULL) {
return (zend_long)f->h> (zend_long)s->h ? 1 : -1;
 } elseif (f->key&&s->key) {
returnzendi_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);
 }
returnzend_compare(&first, &second);
}
/* }}} */

staticzend_always_inlineintphp_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 {
doubled1, 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;
 }
returnZEND_THREEWAY_COMPARE(d1, d2);
 }
}
/* }}} */

staticzend_always_inlineintphp_array_key_compare_string_case_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
constchar*s1, *s2;
size_tl1, l2;
charbuf1[MAX_LENGTH_OF_LONG+1];
charbuf2[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;
 }
returnzend_binary_strcasecmp_l(s1, l1, s2, l2);
}
/* }}} */

staticzend_always_inlineintphp_array_key_compare_string_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
constchar*s1, *s2;
size_tl1, l2;
charbuf1[MAX_LENGTH_OF_LONG+1];
charbuf2[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;
 }
returnzend_binary_strcmp(s1, l1, s2, l2);
}
/* }}} */

staticintphp_array_key_compare_string_natural_general(Bucket*f, Bucket*s, intfold_case) /* {{{ */
{
constchar*s1, *s2;
size_tl1, l2;
charbuf1[MAX_LENGTH_OF_LONG+1];
charbuf2[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;
 }
returnstrnatcmp_ex(s1, l1, s2, l2, fold_case);
}
/* }}} */

staticintphp_array_key_compare_string_natural_case(Bucket*a, Bucket*b) /* {{{ */
{
RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(a, b, 1));
}
/* }}} */

staticintphp_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, 1));
}
/* }}} */

staticintphp_array_key_compare_string_natural(Bucket*a, Bucket*b) /* {{{ */
{
RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(a, b, 0));
}
/* }}} */

staticintphp_array_reverse_key_compare_string_natural(Bucket*a, Bucket*b) /* {{{ */
{
RETURN_STABLE_SORT(a, b, php_array_key_compare_string_natural_general(b, a, 0));
}
/* }}} */

staticzend_always_inlineintphp_array_key_compare_string_locale_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
constchar*s1, *s2;
charbuf1[MAX_LENGTH_OF_LONG+1];
charbuf2[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);
 }
returnstrcoll(s1, s2);
}
/* }}} */

staticzend_always_inlineintphp_array_data_compare_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
intresult=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_tlhs_uintptr= (uintptr_t)Z_OBJ_P(lhs);
uintptr_trhs_uintptr= (uintptr_t)Z_OBJ_P(rhs);
returnlhs_uintptr==rhs_uintptr ? 0 : (lhs_uintptr<rhs_uintptr ? -1 : 1);
 } else {
// Shift enums to the end of the array
return-1;
 }
 }
returnresult;
}
/* }}} */

staticzend_always_inlineintphp_array_data_compare_numeric_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
returnnumeric_compare_function(&f->val, &s->val);
}
/* }}} */

staticzend_always_inlineintphp_array_data_compare_string_case_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
returnstring_case_compare_function(&f->val, &s->val);
}
/* }}} */

staticzend_always_inlineintphp_array_data_compare_string_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
returnstring_compare_function(&f->val, &s->val);
}
/* }}} */

staticintphp_array_natural_general_compare(Bucket*f, Bucket*s, intfold_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);

intresult=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);
returnresult;
}
/* }}} */

staticzend_always_inlineintphp_array_natural_compare_unstable_i(Bucket*a, Bucket*b) /* {{{ */
{
returnphp_array_natural_general_compare(a, b, 0);
}
/* }}} */

staticzend_always_inlineintphp_array_natural_case_compare_unstable_i(Bucket*a, Bucket*b) /* {{{ */
{
returnphp_array_natural_general_compare(a, b, 1);
}
/* }}} */

staticintphp_array_data_compare_string_locale_unstable_i(Bucket*f, Bucket*s) /* {{{ */
{
returnstring_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);

staticbucket_compare_func_tphp_get_key_compare_func(zend_longsort_type, intreverse) /* {{{ */
{
switch (sort_type& ~PHP_SORT_FLAG_CASE) {
casePHP_SORT_NUMERIC:
if (reverse) {
returnphp_array_reverse_key_compare_numeric;
 } else {
returnphp_array_key_compare_numeric;
 }
break;

casePHP_SORT_STRING:
if (sort_type&PHP_SORT_FLAG_CASE) {
if (reverse) {
returnphp_array_reverse_key_compare_string_case;
 } else {
returnphp_array_key_compare_string_case;
 }
 } else {
if (reverse) {
returnphp_array_reverse_key_compare_string;
 } else {
returnphp_array_key_compare_string;
 }
 }
break;

casePHP_SORT_NATURAL:
if (sort_type&PHP_SORT_FLAG_CASE) {
if (reverse) {
returnphp_array_reverse_key_compare_string_natural_case;
 } else {
returnphp_array_key_compare_string_natural_case;
 }
 } else {
if (reverse) {
returnphp_array_reverse_key_compare_string_natural;
 } else {
returnphp_array_key_compare_string_natural;
 }
 }
break;

casePHP_SORT_LOCALE_STRING:
if (reverse) {
returnphp_array_reverse_key_compare_string_locale;
 } else {
returnphp_array_key_compare_string_locale;
 }
break;

casePHP_SORT_REGULAR:
default:
if (reverse) {
returnphp_array_reverse_key_compare;
 } else {
returnphp_array_key_compare;
 }
break;
 }
returnNULL;
}
/* }}} */

staticbucket_compare_func_tphp_get_data_compare_func(zend_longsort_type, intreverse) /* {{{ */
{
switch (sort_type& ~PHP_SORT_FLAG_CASE) {
casePHP_SORT_NUMERIC:
if (reverse) {
returnphp_array_reverse_data_compare_numeric;
 } else {
returnphp_array_data_compare_numeric;
 }
break;

casePHP_SORT_STRING:
if (sort_type&PHP_SORT_FLAG_CASE) {
if (reverse) {
returnphp_array_reverse_data_compare_string_case;
 } else {
returnphp_array_data_compare_string_case;
 }
 } else {
if (reverse) {
returnphp_array_reverse_data_compare_string;
 } else {
returnphp_array_data_compare_string;
 }
 }
break;

casePHP_SORT_NATURAL:
if (sort_type&PHP_SORT_FLAG_CASE) {
if (reverse) {
returnphp_array_reverse_natural_case_compare;
 } else {
returnphp_array_natural_case_compare;
 }
 } else {
if (reverse) {
returnphp_array_reverse_natural_compare;
 } else {
returnphp_array_natural_compare;
 }
 }
break;

casePHP_SORT_LOCALE_STRING:
if (reverse) {
returnphp_array_reverse_data_compare_string_locale;
 } else {
returnphp_array_data_compare_string_locale;
 }
break;

casePHP_SORT_REGULAR:
default:
if (reverse) {
returnphp_array_reverse_data_compare;
 } else {
returnphp_array_data_compare;
 }
break;
 }
returnNULL;
}
/* }}} */

staticbucket_compare_func_tphp_get_data_compare_func_unstable(zend_longsort_type, intreverse) /* {{{ */
{
switch (sort_type& ~PHP_SORT_FLAG_CASE) {
casePHP_SORT_NUMERIC:
if (reverse) {
returnphp_array_reverse_data_compare_numeric_unstable;
 } else {
returnphp_array_data_compare_numeric_unstable;
 }
break;

casePHP_SORT_STRING:
if (sort_type&PHP_SORT_FLAG_CASE) {
if (reverse) {
returnphp_array_reverse_data_compare_string_case_unstable;
 } else {
returnphp_array_data_compare_string_case_unstable;
 }
 } else {
if (reverse) {
returnphp_array_reverse_data_compare_string_unstable;
 } else {
returnphp_array_data_compare_string_unstable;
 }
 }
break;

casePHP_SORT_NATURAL:
if (sort_type&PHP_SORT_FLAG_CASE) {
if (reverse) {
returnphp_array_reverse_natural_case_compare_unstable;
 } else {
returnphp_array_natural_case_compare_unstable;
 }
 } else {
if (reverse) {
returnphp_array_reverse_natural_compare_unstable;
 } else {
returnphp_array_natural_compare_unstable;
 }
 }
break;

casePHP_SORT_LOCALE_STRING:
if (reverse) {
returnphp_array_reverse_data_compare_string_locale_unstable;
 } else {
returnphp_array_data_compare_string_locale_unstable;
 }
break;

casePHP_SORT_REGULAR:
default:
if (reverse) {
returnphp_array_reverse_data_compare_unstable;
 } else {
returnphp_array_data_compare_unstable;
 }
break;
 }
returnNULL;
}
/* }}} */

/* {{{ Sort an array by key value in reverse order */
PHP_FUNCTION(krsort)
{
zval*array;
zend_longsort_type=PHP_SORT_REGULAR;
bucket_compare_func_tcmp;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ARRAY_EX(array, 0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sort_type)
ZEND_PARSE_PARAMETERS_END();

cmp=php_get_key_compare_func(sort_type, 1);

zend_hash_sort(Z_ARRVAL_P(array), cmp, 0);

RETURN_TRUE;
}
/* }}} */

/* {{{ Sort an array by key */
PHP_FUNCTION(ksort)
{
zval*array;
zend_longsort_type=PHP_SORT_REGULAR;
bucket_compare_func_tcmp;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ARRAY_EX(array, 0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sort_type)
ZEND_PARSE_PARAMETERS_END();

cmp=php_get_key_compare_func(sort_type, 0);

zend_hash_sort(Z_ARRVAL_P(array), cmp, 0);

RETURN_TRUE;
}
/* }}} */

PHPAPIzend_longphp_count_recursive(HashTable*ht) /* {{{ */
{
zend_longcnt=0;
zval*element;

if (!(GC_FLAGS(ht) &GC_IMMUTABLE)) {
if (GC_IS_RECURSIVE(ht)) {
php_error_docref(NULL, E_WARNING, "Recursion detected");
return0;
 }
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);
returncnt;
}
/* }}} */

/* {{{ Count the number of elements in a variable (usually an array) */
PHP_FUNCTION(count)
{
zval*array;
zend_longmode=PHP_COUNT_NORMAL;
zend_longcnt;

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)) {
caseIS_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);
break;
caseIS_OBJECT: {
zvalretval;
/* 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(zval_get_long(&retval));
zval_ptr_dtor(&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();
 }
}
/* }}} */

staticvoidphp_natsort(INTERNAL_FUNCTION_PARAMETERS, intfold_case) /* {{{ */
{
zval*array;

ZEND_PARSE_PARAMETERS_START(1, 1)
Z_PARAM_ARRAY_EX(array, 0, 1)
ZEND_PARSE_PARAMETERS_END();

if (fold_case) {
zend_array_sort(Z_ARRVAL_P(array), php_array_natural_case_compare, 0);
 } else {
zend_array_sort(Z_ARRVAL_P(array), php_array_natural_compare, 0);
 }

RETURN_TRUE;
}
/* }}} */

/* {{{ Sort an array using natural sort */
PHP_FUNCTION(natsort)
{
php_natsort(INTERNAL_FUNCTION_PARAM_PASSTHRU, 0);
}
/* }}} */

/* {{{ Sort an array using case-insensitive natural sort */
PHP_FUNCTION(natcasesort)
{
php_natsort(INTERNAL_FUNCTION_PARAM_PASSTHRU, 1);
}
/* }}} */

/* {{{ Sort an array and maintain index association */
PHP_FUNCTION(asort)
{
zval*array;
zend_longsort_type=PHP_SORT_REGULAR;
bucket_compare_func_tcmp;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ARRAY_EX(array, 0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sort_type)
ZEND_PARSE_PARAMETERS_END();

cmp=php_get_data_compare_func(sort_type, 0);

zend_array_sort(Z_ARRVAL_P(array), cmp, 0);

RETURN_TRUE;
}
/* }}} */

/* {{{ Sort an array in reverse order and maintain index association */
PHP_FUNCTION(arsort)
{
zval*array;
zend_longsort_type=PHP_SORT_REGULAR;
bucket_compare_func_tcmp;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ARRAY_EX(array, 0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sort_type)
ZEND_PARSE_PARAMETERS_END();

cmp=php_get_data_compare_func(sort_type, 1);

zend_array_sort(Z_ARRVAL_P(array), cmp, 0);

RETURN_TRUE;
}
/* }}} */

/* {{{ Sort an array */
PHP_FUNCTION(sort)
{
zval*array;
zend_longsort_type=PHP_SORT_REGULAR;
bucket_compare_func_tcmp;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ARRAY_EX(array, 0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sort_type)
ZEND_PARSE_PARAMETERS_END();

cmp=php_get_data_compare_func(sort_type, 0);

zend_array_sort(Z_ARRVAL_P(array), cmp, 1);

RETURN_TRUE;
}
/* }}} */

/* {{{ Sort an array in reverse order */
PHP_FUNCTION(rsort)
{
zval*array;
zend_longsort_type=PHP_SORT_REGULAR;
bucket_compare_func_tcmp;

ZEND_PARSE_PARAMETERS_START(1, 2)
Z_PARAM_ARRAY_EX(array, 0, 1)
Z_PARAM_OPTIONAL
Z_PARAM_LONG(sort_type)
ZEND_PARSE_PARAMETERS_END();

cmp=php_get_data_compare_func(sort_type, 1);

zend_array_sort(Z_ARRVAL_P(array), cmp, 1);

RETURN_TRUE;
}
/* }}} */

staticinlineintphp_array_user_compare_unstable(Bucket*f, Bucket*s) /* {{{ */
{
zvalargs[2];
zvalretval;
boolcall_failed;

ZVAL_COPY(&args[0], &f->val);
ZVAL_COPY(&args[1], &s->val);

BG(user_compare_fci).param_count=2;
BG(user_compare_fci).params=args;
BG(user_compare_fci).retval=&retval;
call_failed=zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache)) ==FAILURE||Z_TYPE(retval) ==IS_UNDEF;
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
if (UNEXPECTED(call_failed)) {
return0;
 }

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(&args[0], &s->val);
ZVAL_COPY(&args[1], &f->val);
call_failed=zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache)) ==FAILURE||Z_TYPE(retval) ==IS_UNDEF;
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
if (call_failed) {
return0;
 }

zend_longret=zval_get_long(&retval);
zval_ptr_dtor(&retval);
return-ZEND_NORMALIZE_BOOL(ret);
 }
 }

zend_longret=zval_get_long(&retval);
zval_ptr_dtor(&retval);
returnZEND_NORMALIZE_BOOL(ret);
}
/* }}} */

staticintphp_array_user_compare(Bucket*a, Bucket*b) /* {{{ */
{
RETURN_STABLE_SORT(a, b, php_array_user_compare_unstable(a, b));
}
/* }}} */

#definePHP_ARRAY_CMP_FUNC_VARS \
 zend_fcall_info old_user_compare_fci; \
 zend_fcall_info_cache old_user_compare_fci_cache \

#definePHP_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; \

#definePHP_ARRAY_CMP_FUNC_RESTORE() \
 BG(user_compare_fci) = old_user_compare_fci; \
 BG(user_compare_fci_cache) = old_user_compare_fci_cache; \

staticvoidphp_usort(INTERNAL_FUNCTION_PARAMETERS, bucket_compare_func_tcompare_func, boolrenumber) /* {{{ */
{
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);

zvalgarbage;
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, 1);
}
/* }}} */

/* {{{ 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, 0);
}
/* }}} */

staticinlineintphp_array_user_key_compare_unstable(Bucket*f, Bucket*s) /* {{{ */
{
zvalargs[2];
zvalretval;
boolcall_failed;

if (f->key==NULL) {
ZVAL_LONG(&args[0], f->h);
 } else {
ZVAL_STR_COPY(&args[0], f->key);
 }
if (s->key==NULL) {
ZVAL_LONG(&args[1], s->h);
 } else {
ZVAL_STR_COPY(&args[1], s->key);
 }

BG(user_compare_fci).param_count=2;
BG(user_compare_fci).params=args;
BG(user_compare_fci).retval=&retval;
call_failed=zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache)) ==FAILURE||Z_TYPE(retval) ==IS_UNDEF;
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
if (UNEXPECTED(call_failed)) {
return0;
 }

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_COPY(&args[0], s->key);
 }
if (f->key==NULL) {
ZVAL_LONG(&args[1], f->h);
 } else {
ZVAL_STR_COPY(&args[1], f->key);
 }

call_failed=zend_call_function(&BG(user_compare_fci), &BG(user_compare_fci_cache)) ==FAILURE||Z_TYPE(retval) ==IS_UNDEF;
zval_ptr_dtor(&args[1]);
zval_ptr_dtor(&args[0]);
if (call_failed) {
return0;
 }

zend_longret=zval_get_long(&retval);
zval_ptr_dtor(&retval);
return-ZEND_NORMALIZE_BOOL(ret);
 }
 }

zend_longresult=zval_get_long(&retval);
zval_ptr_dtor(&retval);
returnZEND_NORMALIZE_BOOL(result);
}
/* }}} */

staticintphp_array_user_key_compare(Bucket*a, Bucket*b) /* {{{ */
{
RETURN_STABLE_SORT(a, b, php_array_user_key_compare_unstable(a, b));
}
/* }}} */