Mirrors
/
php
mirror of https://github.com/php/php-src
3
0
Fork 0
Code Releases Activity
Browse Source

first shot for 64 bit array indexes, more broken things to fix

pull/535/head
Anatol Belski 13 years ago
parent
dd360d6336
commit
98c6e0d535
8 changed files with 165 additions and 165 deletions
Whitespace
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Split View
Diff Options
Show Stats Download Patch File Download Diff File
  1. 32
      Zend/zend_API.c
  2. 28
      Zend/zend_API.h
  3. 8
      Zend/zend_execute_API.c
  4. 32
      Zend/zend_hash.c
  5. 44
      Zend/zend_hash.h
  6. 16
      Zend/zend_vm_def.h
  7. 148
      Zend/zend_vm_execute.h
  8. 22
      ext/standard/array.c

32
Zend/zend_API.c
View File

@ -1336,7 +1336,7 @@ ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, zend_str_size_uint ke
}
/* }}} */
ZEND_API int add_index_long(zval *arg, ulong index, long n) /* {{{ */
ZEND_API int add_index_long(zval *arg, zend_uint_t index, long n) /* {{{ */
{
zval *tmp;
@ -1347,7 +1347,7 @@ ZEND_API int add_index_long(zval *arg, ulong index, long n) /* {{{ */
}
/* }}} */
ZEND_API int add_index_null(zval *arg, ulong index) /* {{{ */
ZEND_API int add_index_null(zval *arg, zend_uint_t index) /* {{{ */
{
zval *tmp;
@ -1358,7 +1358,7 @@ ZEND_API int add_index_null(zval *arg, ulong index) /* {{{ */
}
/* }}} */
ZEND_API int add_index_bool(zval *arg, ulong index, int b) /* {{{ */
ZEND_API int add_index_bool(zval *arg, zend_uint_t index, int b) /* {{{ */
{
zval *tmp;
@ -1369,7 +1369,7 @@ ZEND_API int add_index_bool(zval *arg, ulong index, int b) /* {{{ */
}
/* }}} */
ZEND_API int add_index_resource(zval *arg, ulong index, int r) /* {{{ */
ZEND_API int add_index_resource(zval *arg, zend_uint_t index, int r) /* {{{ */
{
zval *tmp;
@ -1380,7 +1380,7 @@ ZEND_API int add_index_resource(zval *arg, ulong index, int r) /* {{{ */
}
/* }}} */
ZEND_API int add_index_double(zval *arg, ulong index, double d) /* {{{ */
ZEND_API int add_index_double(zval *arg, zend_uint_t index, double d) /* {{{ */
{
zval *tmp;
@ -1391,7 +1391,7 @@ ZEND_API int add_index_double(zval *arg, ulong index, double d) /* {{{ */
}
/* }}} */
ZEND_API int add_index_string(zval *arg, ulong index, const char *str, int duplicate) /* {{{ */
ZEND_API int add_index_string(zval *arg, zend_uint_t index, const char *str, int duplicate) /* {{{ */
{
zval *tmp;
@ -1402,7 +1402,7 @@ ZEND_API int add_index_string(zval *arg, ulong index, const char *str, int dupli
}
/* }}} */
ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, zend_str_size_uint length, int duplicate) /* {{{ */
ZEND_API int add_index_stringl(zval *arg, zend_uint_t index, const char *str, zend_str_size_uint length, int duplicate) /* {{{ */
{
zval *tmp;
@ -1413,7 +1413,7 @@ ZEND_API int add_index_stringl(zval *arg, ulong index, const char *str, zend_str
}
/* }}} */
ZEND_API int add_index_zval(zval *arg, ulong index, zval *value) /* {{{ */
ZEND_API int add_index_zval(zval *arg, zend_uint_t index, zval *value) /* {{{ */
{
return zend_hash_index_update(Z_ARRVAL_P(arg), index, (void *) &value, sizeof(zval *), NULL);
}
@ -1524,7 +1524,7 @@ ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, zend_str_size_
}
/* }}} */
ZEND_API int add_get_index_long(zval *arg, ulong index, long l, void **dest) /* {{{ */
ZEND_API int add_get_index_long(zval *arg, zend_uint_t index, long l, void **dest) /* {{{ */
{
zval *tmp;
@ -1535,7 +1535,7 @@ ZEND_API int add_get_index_long(zval *arg, ulong index, long l, void **dest) /*
}
/* }}} */
ZEND_API int add_get_index_double(zval *arg, ulong index, double d, void **dest) /* {{{ */
ZEND_API int add_get_index_double(zval *arg, zend_uint_t index, double d, void **dest) /* {{{ */
{
zval *tmp;
@ -1546,7 +1546,7 @@ ZEND_API int add_get_index_double(zval *arg, ulong index, double d, void **dest)
}
/* }}} */
ZEND_API int add_get_index_string(zval *arg, ulong index, const char *str, void **dest, int duplicate) /* {{{ */
ZEND_API int add_get_index_string(zval *arg, zend_uint_t index, const char *str, void **dest, int duplicate) /* {{{ */
{
zval *tmp;
@ -1557,7 +1557,7 @@ ZEND_API int add_get_index_string(zval *arg, ulong index, const char *str, void
}
/* }}} */
ZEND_API int add_get_index_stringl(zval *arg, ulong index, const char *str, zend_str_size_uint length, void **dest, int duplicate) /* {{{ */
ZEND_API int add_get_index_stringl(zval *arg, zend_uint_t index, const char *str, zend_str_size_uint length, void **dest, int duplicate) /* {{{ */
{
zval *tmp;
@ -2068,7 +2068,7 @@ ZEND_API int zend_register_functions(zend_class_entry *scope, const zend_functio
zend_str_size fname_len;
const char *lc_class_name = NULL;
zend_str_size class_name_len = 0;
zend_ulong hash;
zend_uint_t hash;
if (type==MODULE_PERSISTENT) {
error_type = E_CORE_WARNING;
@ -2517,7 +2517,7 @@ static zend_class_entry *do_register_internal_class(zend_class_entry *orig_class
{
zend_class_entry *class_entry = malloc(sizeof(zend_class_entry));
char *lowercase_name = emalloc(orig_class_entry->name_length + 1);
zend_ulong hash;
zend_uint_t hash;
*class_entry = *orig_class_entry;
class_entry->type = ZEND_INTERNAL_CLASS;
@ -3437,7 +3437,7 @@ ZEND_API int zend_declare_property_ex(zend_class_entry *ce, const char *name, ze
{
zend_property_info property_info, *property_info_ptr;
const char *interned_name;
ulong h = zend_get_hash_value(name, name_length+1);
zend_uint_t h = zend_get_hash_value(name, name_length+1);
if (!(access_type & ZEND_ACC_PPP_MASK)) {
access_type |= ZEND_ACC_PUBLIC;
@ -4042,7 +4042,7 @@ ZEND_API const char* zend_resolve_method_name(zend_class_entry *ce, zend_functio
if (func == f) {
char *name;
zend_str_size len;
ulong idx;
zend_uint_t idx;
if (zend_hash_get_current_key_ex(function_table, &name, &len, &idx, 0, &iterator) != HASH_KEY_IS_STRING) {
return f->common.function_name;

28
Zend/zend_API.h
View File

@ -399,14 +399,14 @@ ZEND_API int add_assoc_zval_ex(zval *arg, const char *key, zend_str_size_uint ke
#define add_next_index_unset(__arg) add_next_index_null(__arg)
#define add_property_unset(__arg, __key) add_property_null(__arg, __key)
ZEND_API int add_index_long(zval *arg, ulong idx, long n);
ZEND_API int add_index_null(zval *arg, ulong idx);
ZEND_API int add_index_bool(zval *arg, ulong idx, int b);
ZEND_API int add_index_resource(zval *arg, ulong idx, int r);
ZEND_API int add_index_double(zval *arg, ulong idx, double d);
ZEND_API int add_index_string(zval *arg, ulong idx, const char *str, int duplicate);
ZEND_API int add_index_stringl(zval *arg, ulong idx, const char *str, zend_str_size_uint length, int duplicate);
ZEND_API int add_index_zval(zval *arg, ulong index, zval *value);
ZEND_API int add_index_long(zval *arg, zend_uint_t idx, long n);
ZEND_API int add_index_null(zval *arg, zend_uint_t idx);
ZEND_API int add_index_bool(zval *arg, zend_uint_t idx, int b);
ZEND_API int add_index_resource(zval *arg, zend_uint_t idx, int r);
ZEND_API int add_index_double(zval *arg, zend_uint_t idx, double d);
ZEND_API int add_index_string(zval *arg, zend_uint_t idx, const char *str, int duplicate);
ZEND_API int add_index_stringl(zval *arg, zend_uint_t idx, const char *str, zend_str_size_uint length, int duplicate);
ZEND_API int add_index_zval(zval *arg, zend_uint_t index, zval *value);
ZEND_API int add_next_index_long(zval *arg, long n);
ZEND_API int add_next_index_null(zval *arg);
@ -423,10 +423,10 @@ ZEND_API int add_get_assoc_stringl_ex(zval *arg, const char *key, zend_str_size_
#define add_get_assoc_string(__arg, __key, __str, __dest, __duplicate) add_get_assoc_string_ex(__arg, __key, strlen(__key)+1, __str, __dest, __duplicate)
#define add_get_assoc_stringl(__arg, __key, __str, __length, __dest, __duplicate) add_get_assoc_stringl_ex(__arg, __key, strlen(__key)+1, __str, __length, __dest, __duplicate)
ZEND_API int add_get_index_long(zval *arg, ulong idx, long l, void **dest);
ZEND_API int add_get_index_double(zval *arg, ulong idx, double d, void **dest);
ZEND_API int add_get_index_string(zval *arg, ulong idx, const char *str, void **dest, int duplicate);
ZEND_API int add_get_index_stringl(zval *arg, ulong idx, const char *str, zend_str_size_uint length, void **dest, int duplicate);
ZEND_API int add_get_index_long(zval *arg, zend_uint_t idx, long l, void **dest);
ZEND_API int add_get_index_double(zval *arg, zend_uint_t idx, double d, void **dest);
ZEND_API int add_get_index_string(zval *arg, zend_uint_t idx, const char *str, void **dest, int duplicate);
ZEND_API int add_get_index_stringl(zval *arg, zend_uint_t idx, const char *str, zend_str_size_uint length, void **dest, int duplicate);
ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value);
@ -513,11 +513,11 @@ ZEND_API int zend_call_function(zend_fcall_info *fci, zend_fcall_info_cache *fci
ZEND_API int zend_set_hash_symbol(zval *symbol, const char *name, zend_str_size_int name_length, zend_bool is_ref, int num_symbol_tables, ...);
ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, zend_str_size_int name_len, ulong hash_value TSRMLS_DC);
ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, zend_str_size_int name_len, zend_uint_t hash_value TSRMLS_DC);
ZEND_API int zend_delete_global_variable(const char *name, zend_str_size_int name_len TSRMLS_DC);
ZEND_API int zend_delete_global_variable_ex(const char *name, zend_str_size_int name_len, ulong hash_value TSRMLS_DC);
ZEND_API int zend_delete_global_variable_ex(const char *name, zend_str_size_int name_len, zend_uint_t hash_value TSRMLS_DC);
ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC);

8
Zend/zend_execute_API.c
View File

@ -563,7 +563,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
zval **element, *new_val;
char *str_index;
zend_str_size str_index_len;
ulong num_index;
zend_uint_t num_index;
int ret;
SEPARATE_ZVAL_IF_NOT_REF(pp);
@ -1024,7 +1024,7 @@ ZEND_API int zend_lookup_class_ex(const char *name, zend_str_size_int name_lengt
zend_fcall_info fcall_info;
zend_fcall_info_cache fcall_cache;
char dummy = 1;
ulong hash;
zend_uint_t hash;
ALLOCA_FLAG(use_heap)
if (key) {
@ -1676,7 +1676,7 @@ ZEND_API void zend_reset_all_cv(HashTable *symbol_table TSRMLS_DC) /* {{{ */
}
/* }}} */
ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, zend_str_size_int name_len, ulong hash_value TSRMLS_DC) /* {{{ */
ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const char *name, zend_str_size_int name_len, zend_uint_t hash_value TSRMLS_DC) /* {{{ */
{
if (zend_hash_quick_del(ht, name, name_len, hash_value) == SUCCESS) {
name_len--;
@ -1699,7 +1699,7 @@ ZEND_API void zend_delete_variable(zend_execute_data *ex, HashTable *ht, const c
}
/* }}} */
ZEND_API int zend_delete_global_variable_ex(const char *name, zend_str_size_int name_len, ulong hash_value TSRMLS_DC) /* {{{ */
ZEND_API int zend_delete_global_variable_ex(const char *name, zend_str_size_int name_len, zend_uint_t hash_value TSRMLS_DC) /* {{{ */
{
zend_execute_data *ex;

32
Zend/zend_hash.c
View File

@ -98,7 +98,7 @@ static void _zend_is_inconsistent(const HashTable *ht, const char *file, zend_st
static void zend_hash_do_resize(HashTable *ht);
ZEND_API ulong zend_hash_func(const char *arKey, zend_str_size_uint nKeyLength)
ZEND_API zend_uint_t zend_hash_func(const char *arKey, zend_str_size_uint nKeyLength)
{
return zend_inline_hash_func(arKey, nKeyLength);
}
@ -190,7 +190,7 @@ ZEND_API void zend_hash_set_apply_protection(HashTable *ht, zend_bool bApplyProt
ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
{
ulong h;
zend_uint_t h;
uint nIndex;
Bucket *p;
#ifdef ZEND_SIGNALS
@ -265,7 +265,7 @@ ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, zend_str
return SUCCESS;
}
ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
{
uint nIndex;
Bucket *p;
@ -348,7 +348,7 @@ ZEND_API int zend_hash_add_empty_element(HashTable *ht, const char *arKey, zend_
}
ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, zend_uint_t h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC)
{
uint nIndex;
Bucket *p;
@ -459,7 +459,7 @@ ZEND_API int zend_hash_rehash(HashTable *ht)
return SUCCESS;
}
ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h, int flag)
ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h, int flag)
{
uint nIndex;
Bucket *p;
@ -876,7 +876,7 @@ ZEND_API void zend_hash_merge_ex(HashTable *target, HashTable *source, copy_ctor
}
ZEND_API ulong zend_get_hash_value(const char *arKey, zend_str_size_uint nKeyLength)
ZEND_API zend_uint_t zend_get_hash_value(const char *arKey, zend_str_size_uint nKeyLength)
{
return zend_inline_hash_func(arKey, nKeyLength);
}
@ -888,7 +888,7 @@ ZEND_API ulong zend_get_hash_value(const char *arKey, zend_str_size_uint nKeyLen
*/
ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, void **pData)
{
ulong h;
zend_uint_t h;
uint nIndex;
Bucket *p;
@ -910,7 +910,7 @@ ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, zend_str_siz
}
ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h, void **pData)
ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h, void **pData)
{
uint nIndex;
Bucket *p;
@ -938,7 +938,7 @@ ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_s
ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength)
{
ulong h;
zend_uint_t h;
uint nIndex;
Bucket *p;
@ -959,7 +959,7 @@ ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, zend_str_s
}
ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h)
ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h)
{
uint nIndex;
Bucket *p;
@ -985,7 +985,7 @@ ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend
}
ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)
ZEND_API int zend_hash_index_find(const HashTable *ht, zend_uint_t h, void **pData)
{
uint nIndex;
Bucket *p;
@ -1006,7 +1006,7 @@ ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData)
}
ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h)
ZEND_API int zend_hash_index_exists(const HashTable *ht, zend_uint_t h)
{
uint nIndex;
Bucket *p;
@ -1120,7 +1120,7 @@ ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos)
/* This function should be made binary safe */
ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, zend_str_size_uint *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos)
ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, zend_str_size_uint *str_length, zend_uint_t *num_index, zend_bool duplicate, HashPosition *pos)
{
Bucket *p;
@ -1204,10 +1204,10 @@ ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosi
/* This function changes key of current element without changing elements'
* order. If element with target key already exists, it will be deleted first.
*/
ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, zend_str_size_uint str_length, ulong num_index, int mode, HashPosition *pos)
ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, zend_str_size_uint str_length, zend_uint_t num_index, int mode, HashPosition *pos)
{
Bucket *p, *q;
ulong h;
zend_uint_t h;
#ifdef ZEND_SIGNALS
TSRMLS_FETCH();
#endif
@ -1585,7 +1585,7 @@ ZEND_API int zend_hash_minmax(const HashTable *ht, compare_func_t compar, int fl
return SUCCESS;
}
ZEND_API ulong zend_hash_next_free_element(const HashTable *ht)
ZEND_API zend_uint_t zend_hash_next_free_element(const HashTable *ht)
{
IS_CONSISTENT(ht);

44
Zend/zend_hash.h
View File

@ -43,7 +43,7 @@
#define HASH_UPDATE_KEY_IF_AFTER 2
#define HASH_UPDATE_KEY_ANYWAY 3
typedef ulong (*hash_func_t)(const char *arKey, zend_str_size_uint nKeyLength);
typedef zend_uint_t (*hash_func_t)(const char *arKey, zend_str_size_uint nKeyLength);
typedef int (*compare_func_t)(const void *, const void * TSRMLS_DC);
typedef void (*sort_func_t)(void *, size_t, register size_t, compare_func_t TSRMLS_DC);
typedef void (*dtor_func_t)(void *pDest);
@ -53,7 +53,7 @@ typedef void (*copy_ctor_param_func_t)(void *pElement, void *pParam);
struct _hashtable;
typedef struct bucket {
ulong h; /* Used for numeric indexing */
zend_uint_t h; /* Used for numeric indexing */
zend_str_size_uint nKeyLength;
void *pData;
void *pDataPtr;
@ -68,7 +68,7 @@ typedef struct _hashtable {
uint nTableSize;
uint nTableMask;
uint nNumOfElements;
ulong nNextFreeElement;
zend_uint_t nNextFreeElement;
Bucket *pInternalPointer; /* Used for element traversal */
Bucket *pListHead;
Bucket *pListTail;
@ -86,7 +86,7 @@ typedef struct _hashtable {
typedef struct _zend_hash_key {
const char *arKey;
zend_str_size_uint nKeyLength;
ulong h;
zend_uint_t h;
} zend_hash_key;
@ -111,13 +111,13 @@ ZEND_API int _zend_hash_add_or_update(HashTable *ht, const char *arKey, zend_str
#define zend_hash_add(ht, arKey, nKeyLength, pData, nDataSize, pDest) \
_zend_hash_add_or_update(ht, arKey, nKeyLength, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
ZEND_API int _zend_hash_quick_add_or_update(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
#define zend_hash_quick_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
#define zend_hash_quick_add(ht, arKey, nKeyLength, h, pData, nDataSize, pDest) \
_zend_hash_quick_add_or_update(ht, arKey, nKeyLength, h, pData, nDataSize, pDest, HASH_ADD ZEND_FILE_LINE_CC)
ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, ulong h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
ZEND_API int _zend_hash_index_update_or_next_insert(HashTable *ht, zend_uint_t h, void *pData, uint nDataSize, void **pDest, int flag ZEND_FILE_LINE_DC);
#define zend_hash_index_update(ht, h, pData, nDataSize, pDest) \
_zend_hash_index_update_or_next_insert(ht, h, pData, nDataSize, pDest, HASH_UPDATE ZEND_FILE_LINE_CC)
#define zend_hash_next_index_insert(ht, pData, nDataSize, pDest) \
@ -150,7 +150,7 @@ ZEND_API void zend_hash_reverse_apply(HashTable *ht, apply_func_t apply_func TSR
/* Deletes */
ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h, int flag);
ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h, int flag);
#define zend_hash_del(ht, arKey, nKeyLength) \
zend_hash_del_key_or_index(ht, arKey, nKeyLength, 0, HASH_DEL_KEY)
#define zend_hash_quick_del(ht, arKey, nKeyLength, h) \
@ -158,35 +158,35 @@ ZEND_API int zend_hash_del_key_or_index(HashTable *ht, const char *arKey, zend_s
#define zend_hash_index_del(ht, h) \
zend_hash_del_key_or_index(ht, NULL, 0, h, HASH_DEL_INDEX)
ZEND_API ulong zend_get_hash_value(const char *arKey, zend_str_size_uint nKeyLength);
ZEND_API zend_uint_t zend_get_hash_value(const char *arKey, zend_str_size_uint nKeyLength);
/* Data retreival */
ZEND_API int zend_hash_find(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, void **pData);
ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h, void **pData);
ZEND_API int zend_hash_index_find(const HashTable *ht, ulong h, void **pData);
ZEND_API int zend_hash_quick_find(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h, void **pData);
ZEND_API int zend_hash_index_find(const HashTable *ht, zend_uint_t h, void **pData);
/* Misc */
ZEND_API int zend_hash_exists(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength);
ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, ulong h);
ZEND_API int zend_hash_index_exists(const HashTable *ht, ulong h);
ZEND_API ulong zend_hash_next_free_element(const HashTable *ht);
ZEND_API int zend_hash_quick_exists(const HashTable *ht, const char *arKey, zend_str_size_uint nKeyLength, zend_uint_t h);
ZEND_API int zend_hash_index_exists(const HashTable *ht, zend_uint_t h);
ZEND_API zend_uint_t zend_hash_next_free_element(const HashTable *ht);
/* traversing */
#define zend_hash_has_more_elements_ex(ht, pos) \
(zend_hash_get_current_key_type_ex(ht, pos) == HASH_KEY_NON_EXISTENT ? FAILURE : SUCCESS)
ZEND_API int zend_hash_move_forward_ex(HashTable *ht, HashPosition *pos);
ZEND_API int zend_hash_move_backwards_ex(HashTable *ht, HashPosition *pos);
ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, zend_str_size_uint *str_length, ulong *num_index, zend_bool duplicate, HashPosition *pos);
ZEND_API int zend_hash_get_current_key_ex(const HashTable *ht, char **str_index, zend_str_size_uint *str_length, zend_uint_t *num_index, zend_bool duplicate, HashPosition *pos);
ZEND_API void zend_hash_get_current_key_zval_ex(const HashTable *ht, zval *key, HashPosition *pos);
ZEND_API int zend_hash_get_current_key_type_ex(HashTable *ht, HashPosition *pos);
ZEND_API int zend_hash_get_current_data_ex(HashTable *ht, void **pData, HashPosition *pos);
ZEND_API void zend_hash_internal_pointer_reset_ex(HashTable *ht, HashPosition *pos);
ZEND_API void zend_hash_internal_pointer_end_ex(HashTable *ht, HashPosition *pos);
ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, zend_str_size_uint str_length, ulong num_index, int mode, HashPosition *pos);
ZEND_API int zend_hash_update_current_key_ex(HashTable *ht, int key_type, const char *str_index, zend_str_size_uint str_length, zend_uint_t num_index, int mode, HashPosition *pos);
typedef struct _HashPointer {
HashPosition pos;
ulong h;
zend_uint_t h;
} HashPointer;
ZEND_API int zend_hash_get_pointer(const HashTable *ht, HashPointer *ptr);
@ -261,9 +261,9 @@ ZEND_API int zend_hash_rehash(HashTable *ht);
* -- Ralf S. Engelschall <rse@engelschall.com>
*/
static inline ulong zend_inline_hash_func(const char *arKey, zend_str_size_uint nKeyLength)
static inline zend_uint_t zend_inline_hash_func(const char *arKey, zend_str_size_uint nKeyLength)
{
register ulong hash = 5381;
register zend_uint_t hash = 5381;
/* variant with the hash unrolled eight times */
for (; nKeyLength >= 8; nKeyLength -= 8) {
@ -291,7 +291,7 @@ EMPTY_SWITCH_DEFAULT_CASE()
}
ZEND_API ulong zend_hash_func(const char *arKey, zend_str_size_uint nKeyLength);
ZEND_API zend_uint_t zend_hash_func(const char *arKey, zend_str_size_uint nKeyLength);
#if ZEND_DEBUG
/* debug */
@ -330,11 +330,11 @@ END_EXTERN_C()
} \
if (tmp == end) { \
if (*key == '-') { \
if (idx-1 > LONG_MAX) { /* overflow */ \
if (idx-1 > ZEND_INT_MAX) { /* overflow */ \
break; \
} \
idx = 0 - idx; \
} else if (idx > LONG_MAX) { /* overflow */ \
} else if (idx > ZEND_INT_MAX) { /* overflow */ \
break; \
} \
func; \
@ -343,7 +343,7 @@ END_EXTERN_C()
} while (0)
#define ZEND_HANDLE_NUMERIC(key, length, func) do { \
ulong idx; \
zend_uint_t idx; \
\
ZEND_HANDLE_NUMERIC_EX(key, length, idx, return func); \
} while (0)

16
Zend/zend_vm_def.h
View File

@ -1005,7 +1005,7 @@ ZEND_VM_HELPER_EX(zend_fetch_var_address_helper, CONST|TMP|VAR|CV, UNUSED|CONST|
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = GET_OP1_ZVAL_PTR(BP_VAR_R);
@ -1965,7 +1965,7 @@ ZEND_VM_HELPER(zend_do_fcall_common_helper, ANY, ANY)
if (fbc->common.arg_info) {
zend_uint i=0;
zval **p = (zval**)EX(function_state).arguments;
ulong arg_count = opline->extended_value;
zend_uint_t arg_count = opline->extended_value;
while (arg_count>0) {
zend_verify_arg_type(fbc, ++i, *(p-arg_count), 0 TSRMLS_CC);
@ -3647,7 +3647,7 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
if (OP2_TYPE != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -3957,7 +3957,7 @@ ZEND_VM_HANDLER(74, ZEND_UNSET_VAR, CONST|TMP|VAR|CV, UNUSED|CONST|VAR)
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((OP1_TYPE == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -3979,7 +3979,7 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
zend_free_op free_op1, free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
@ -4242,7 +4242,7 @@ ZEND_VM_HANDLER(77, ZEND_FE_RESET, CONST|TMP|VAR|CV, ANY)
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
char *str_key;
zend_str_size_uint str_key_len;
ulong int_key;
zend_uint_t int_key;
zend_uchar key_type;
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
@ -4299,7 +4299,7 @@ ZEND_VM_HANDLER(78, ZEND_FE_FETCH, VAR, ANY)
int key_type;
char *str_key;
zend_str_size_uint str_key_len;
zend_ulong int_key;
zend_uint_t int_key;
fe_ht = Z_OBJPROP_P(array);
zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
@ -4495,7 +4495,7 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();

148
Zend/zend_vm_execute.h
View File

@ -533,7 +533,7 @@ static int ZEND_FASTCALL zend_do_fcall_common_helper_SPEC(ZEND_OPCODE_HANDLER_AR
if (fbc->common.arg_info) {
zend_uint i=0;
zval **p = (zval**)EX(function_state).arguments;
ulong arg_count = opline->extended_value;
zend_uint_t arg_count = opline->extended_value;
while (arg_count>0) {
zend_verify_arg_type(fbc, ++i, *(p-arg_count), 0 TSRMLS_CC);
@ -2941,7 +2941,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
char *str_key;
zend_str_size_uint str_key_len;
ulong int_key;
zend_uint_t int_key;
zend_uchar key_type;
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
@ -3381,7 +3381,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_CONST(int type
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = opline->op1.zv;
@ -3859,7 +3859,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O
if (IS_CONST != IS_UNUSED) {
zval *offset = opline->op2.zv;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -3976,7 +3976,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HA
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -4752,7 +4752,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC
if (IS_TMP_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -5246,7 +5246,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_VAR(int type,
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = opline->op1.zv;
@ -5604,7 +5604,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC
if (IS_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -5721,7 +5721,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAND
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -5986,7 +5986,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CONST_UNUSED(int typ
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = opline->op1.zv;
@ -6303,7 +6303,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_
if (IS_UNUSED != IS_UNUSED) {
zval *offset = NULL;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -6420,7 +6420,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CONST_UNUSED_HANDLER(ZEND_OPCODE_H
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_CONST == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -7233,7 +7233,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO
if (IS_CV != IS_UNUSED) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -8244,7 +8244,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
char *str_key;
zend_str_size_uint str_key_len;
ulong int_key;
zend_uint_t int_key;
zend_uchar key_type;
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
@ -8736,7 +8736,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_CONST(int type,
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -9119,7 +9119,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC
if (IS_CONST != IS_UNUSED) {
zval *offset = opline->op2.zv;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -9236,7 +9236,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAND
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -9974,7 +9974,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD
if (IS_TMP_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -10468,7 +10468,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_VAR(int type, ZE
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -10828,7 +10828,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
if (IS_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -10945,7 +10945,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLE
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -11210,7 +11210,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_TMP_UNUSED(int type,
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -11404,7 +11404,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
if (IS_UNUSED != IS_UNUSED) {
zval *offset = NULL;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -11521,7 +11521,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_TMP_UNUSED_HANDLER(ZEND_OPCODE_HAN
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_TMP_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -12256,7 +12256,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE
if (IS_CV != IS_UNUSED) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -13557,7 +13557,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
char *str_key;
zend_str_size_uint str_key_len;
ulong int_key;
zend_uint_t int_key;
zend_uchar key_type;
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
@ -13614,7 +13614,7 @@ static int ZEND_FASTCALL ZEND_FE_FETCH_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
int key_type;
char *str_key;
zend_str_size_uint str_key_len;
zend_ulong int_key;
zend_uint_t int_key;
fe_ht = Z_OBJPROP_P(array);
zend_hash_set_pointer(fe_ht, &EX_T(opline->op1.var).fe.fe_pos);
@ -14614,7 +14614,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_CONST(int type,
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -15702,7 +15702,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC
if (IS_CONST != IS_UNUSED) {
zval *offset = opline->op2.zv;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -15819,7 +15819,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -15841,7 +15841,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
zend_free_op free_op1;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -16064,7 +16064,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -17939,7 +17939,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD
if (IS_TMP_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -18000,7 +18000,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE
zend_free_op free_op1, free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -18138,7 +18138,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(in
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -19181,7 +19181,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_VAR(int type, ZE
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -20230,7 +20230,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
if (IS_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -20347,7 +20347,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -20369,7 +20369,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
zend_free_op free_op1, free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -20592,7 +20592,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(in
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -21153,7 +21153,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_VAR_UNUSED(int type,
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -21638,7 +21638,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
if (IS_UNUSED != IS_UNUSED) {
zval *offset = NULL;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -21755,7 +21755,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_VAR_UNUSED_HANDLER(ZEND_OPCODE_HAN
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_VAR == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -23661,7 +23661,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE
if (IS_CV != IS_UNUSED) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -23722,7 +23722,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER
zend_free_op free_op1;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
@ -23860,7 +23860,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -25218,7 +25218,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
@ -25354,7 +25354,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -26525,7 +26525,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
zend_free_op free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
@ -26661,7 +26661,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -27832,7 +27832,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
zend_free_op free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
@ -27968,7 +27968,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -29561,7 +29561,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
@ -29697,7 +29697,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -31049,7 +31049,7 @@ static int ZEND_FASTCALL ZEND_FE_RESET_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
while (zend_hash_has_more_elements(fe_ht) == SUCCESS) {
char *str_key;
zend_str_size_uint str_key_len;
ulong int_key;
zend_uint_t int_key;
zend_uchar key_type;
key_type = zend_hash_get_current_key_ex(fe_ht, &str_key, &str_key_len, &int_key, 0, NULL);
@ -31971,7 +31971,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_CONST(int type, Z
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
@ -32831,7 +32831,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO
if (IS_CONST != IS_UNUSED) {
zval *offset = opline->op2.zv;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -32948,7 +32948,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -32970,7 +32970,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
@ -33191,7 +33191,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(i
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -34931,7 +34931,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE
if (IS_TMP_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -34992,7 +34992,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
zend_free_op free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
@ -35128,7 +35128,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -36167,7 +36167,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_VAR(int type, ZEN
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
@ -37084,7 +37084,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
if (IS_VAR != IS_UNUSED) {
zend_free_op free_op2;
zval *offset = _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -37201,7 +37201,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -37223,7 +37223,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
zend_free_op free_op2;
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
@ -37444,7 +37444,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();
@ -38001,7 +38001,7 @@ static int ZEND_FASTCALL zend_fetch_var_address_helper_SPEC_CV_UNUSED(int type,
zval **retval;
zval tmp_varname;
HashTable *target_symbol_table;
ulong hash_value;
zend_uint_t hash_value;
SAVE_OPLINE();
varname = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
@ -38362,7 +38362,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
if (IS_UNUSED != IS_UNUSED) {
zval *offset = NULL;
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -38479,7 +38479,7 @@ static int ZEND_FASTCALL ZEND_UNSET_VAR_SPEC_CV_UNUSED_HANDLER(ZEND_OPCODE_HAND
}
zend_std_unset_static_property(ce, Z_STRVAL_P(varname), Z_STRSIZE_P(varname), ((IS_CV == IS_CONST) ? opline->op1.literal : NULL) TSRMLS_CC);
} else {
ulong hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
zend_uint_t hash_value = zend_inline_hash_func(varname->value.str.val, varname->value.str.len+1);
target_symbol_table = zend_get_target_symbol_table(opline->extended_value & ZEND_FETCH_TYPE_MASK TSRMLS_CC);
zend_delete_variable(execute_data, target_symbol_table, varname->value.str.val, varname->value.str.len+1, hash_value TSRMLS_CC);
@ -40230,7 +40230,7 @@ static int ZEND_FASTCALL ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_
if (IS_CV != IS_UNUSED) {
zval *offset = _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC);
ulong hval;
zend_uint_t hval;
switch (Z_TYPE_P(offset)) {
case IS_DOUBLE:
@ -40291,7 +40291,7 @@ static int ZEND_FASTCALL ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
zval **container;
zval *offset;
ulong hval;
zend_uint_t hval;
SAVE_OPLINE();
container = _get_zval_ptr_ptr_cv_BP_VAR_UNSET(execute_data, opline->op1.var TSRMLS_CC);
@ -40427,7 +40427,7 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int
zval *container;
zval **value = NULL;
int result = 0;
ulong hval;
zend_uint_t hval;
zval *offset;
SAVE_OPLINE();

22
ext/standard/array.c
View File

@ -1290,7 +1290,7 @@ PHP_FUNCTION(extract)
php_int_t extract_type = EXTR_OVERWRITE;
zval **entry, *data;
char *var_name;
ulong num_key;
zend_uint_t num_key;
zend_str_size_uint var_name_len;
int var_exists, key_type, count = 0;
int extract_refs = 0;
@ -1943,7 +1943,7 @@ static void _phpi_pop(INTERNAL_FUNCTION_PARAMETERS, int off_the_end)
**val; /* Value to be popped */
char *key = NULL;
zend_str_size key_len = 0;
ulong index;
zend_uint_t index;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a", &stack) == FAILURE) {
return;
@ -2141,7 +2141,7 @@ PHP_FUNCTION(array_slice)
pos; /* Current position in the array */
char *string_key;
zend_str_size string_key_len;
ulong num_key;
zend_uint_t num_key;
HashPosition hpos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "ai|Zb", &input, &offset, &z_length, &preserve_keys) == FAILURE) {
@ -2218,7 +2218,7 @@ PHPAPI int php_array_merge(HashTable *dest, HashTable *src, int recursive TSRMLS
zval **src_entry, **dest_entry;
char *string_key;
zend_str_size string_key_len;
ulong num_key;
zend_uint_t num_key;
HashPosition pos;
zend_hash_internal_pointer_reset_ex(src, &pos);
@ -2293,7 +2293,7 @@ PHPAPI int php_array_replace_recursive(HashTable *dest, HashTable *src TSRMLS_DC
zval **src_entry, **dest_entry;
char *string_key;
zend_str_size string_key_len;
ulong num_key;
zend_uint_t num_key;
HashPosition pos;
for (zend_hash_internal_pointer_reset_ex(src, &pos);
@ -2642,7 +2642,7 @@ PHP_FUNCTION(array_reverse)
**entry; /* An entry in the input array */
char *string_key;
zend_str_size string_key_len;
ulong num_key;
zend_uint_t num_key;
zend_bool preserve_keys = 0; /* whether to preserve keys */
HashPosition pos;
@ -2787,7 +2787,7 @@ PHP_FUNCTION(array_change_key_case)
char *string_key;
char *new_key;
zend_str_size str_key_len;
ulong num_key;
zend_uint_t num_key;
php_int_t change_to_upper=0;
HashPosition pos;
@ -4011,7 +4011,7 @@ PHP_FUNCTION(array_rand)
int num_avail, key_type;
char *string_key;
zend_str_size string_key_len;
ulong num_key;
zend_uint_t num_key;
HashPosition pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|i", &input, &num_req) == FAILURE) {
@ -4219,7 +4219,7 @@ PHP_FUNCTION(array_filter)
zend_fcall_info fci = empty_fcall_info;
zend_fcall_info_cache fci_cache = empty_fcall_info_cache;
zend_str_size string_key_len;
ulong num_key;
zend_uint_t num_key;
HashPosition pos;
if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "a|fi", &array, &fci, &fci_cache, &use_type) == FAILURE) {
@ -4368,7 +4368,7 @@ PHP_FUNCTION(array_map)
/* We iterate through all the arrays at once. */
for (k = 0; k < maxlen; k++) {
zend_str_size str_key_len;
ulong num_key;
zend_uint_t num_key;
char *str_key;
int key_type = 0;
@ -4481,7 +4481,7 @@ PHP_FUNCTION(array_chunk)
php_int_t size, current = 0;
char *str_key;
zend_str_size str_key_len;
ulong num_key;
zend_uint_t num_key;
zend_bool preserve_keys = 0;
zval *input = NULL;
zval *chunk = NULL;

Write Preview
Loading…
Cancel
Save