move HANDLE_NUMERIC() from the hash table implementation upstream to the

places that actually need to use it.

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 23b1448098d79d1797dac18a82b0bd6b80be473a..1416ce95d91aff128ec9be5d343675062b732a09 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -727,6 +727,7 @@ static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, znode *op
        zval **retval;
        char *offset_key;
        int offset_key_length;
+       long index;
 
        switch (dim->type) {
                case IS_NULL:
@@ -734,9 +735,13 @@ static inline zval **zend_fetch_dimension_address_inner(HashTable *ht, znode *op
                        offset_key_length = 0;
                        goto fetch_string_dim;
                case IS_STRING:
+                       if (zend_is_numeric_key(dim, &index)) {
+                               goto fetch_int_dim;
+                       } 
+                       
                        offset_key = dim->value.str.val;
                        offset_key_length = dim->value.str.len;
-
+                       
 fetch_string_dim:
                        if (zend_hash_find(ht, offset_key, offset_key_length+1, (void **) &retval) == FAILURE) {
                                switch (type) {
@@ -762,33 +767,31 @@ fetch_string_dim:
                case IS_DOUBLE:
                case IS_RESOURCE:
                case IS_BOOL: 
-               case IS_LONG: {
-                               long index;
+               case IS_LONG: 
+                       if (dim->type == IS_DOUBLE) {
+                               index = (long)dim->value.dval;
+                       } else {
+                               index = dim->value.lval;
+                       }
+fetch_int_dim:
+                       if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) {
+                               switch (type) {
+                                       case BP_VAR_R: 
+                                               zend_error(E_NOTICE,"Undefined offset:  %d", index);
+                                               /* break missing intentionally */
+                                       case BP_VAR_IS:
+                                               retval = &EG(uninitialized_zval_ptr);
+                                               break;
+                                       case BP_VAR_RW:
+                                               zend_error(E_NOTICE,"Undefined offset:  %d", index);
+                                               /* break missing intentionally */
+                                       case BP_VAR_W: {
+                                               zval *new_zval = &EG(uninitialized_zval);
 
-                               if (dim->type == IS_DOUBLE) {
-                                       index = (long)dim->value.dval;
-                               } else {
-                                       index = dim->value.lval;
-                               }
-                               if (zend_hash_index_find(ht, index, (void **) &retval) == FAILURE) {
-                                       switch (type) {
-                                               case BP_VAR_R: 
-                                                       zend_error(E_NOTICE,"Undefined offset:  %d", index);
-                                                       /* break missing intentionally */
-                                               case BP_VAR_IS:
-                                                       retval = &EG(uninitialized_zval_ptr);
-                                                       break;
-                                               case BP_VAR_RW:
-                                                       zend_error(E_NOTICE,"Undefined offset:  %d", index);
-                                                       /* break missing intentionally */
-                                               case BP_VAR_W: {
-                                                               zval *new_zval = &EG(uninitialized_zval);
-
-                                                               new_zval->refcount++;
-                                                               zend_hash_index_update(ht, index, &new_zval, sizeof(zval *), (void **) &retval);
-                                                       }
-                                                       break;
+                                               new_zval->refcount++;
+                                               zend_hash_index_update(ht, index, &new_zval, sizeof(zval *), (void **) &retval);
                                        }
+                                       break;
                                }
                        }
                        break;
@@ -3286,9 +3289,16 @@ inline int zend_init_add_array_helper(ZEND_OPCODE_HANDLER_ARGS)
                        case IS_BOOL:
                                zend_hash_index_update(array_ptr->value.ht, offset->value.lval, &expr_ptr, sizeof(zval *), NULL);
                                break;
-                       case IS_STRING:
-                               zend_hash_update(array_ptr->value.ht, offset->value.str.val, offset->value.str.len+1, &expr_ptr, sizeof(zval *), NULL);
+                       case IS_STRING: {
+                               long idx;
+
+                               if (zend_is_numeric_key(offset, &idx)) {
+                                       zend_hash_index_update(array_ptr->value.ht, idx, &expr_ptr, sizeof(zval *), NULL);
+                               } else {
+                                       zend_hash_update(array_ptr->value.ht, offset->value.str.val, offset->value.str.len+1, &expr_ptr, sizeof(zval *), NULL);
+                               }
                                break;
+                       }
                        case IS_NULL:
                                zend_hash_update(array_ptr->value.ht, "", sizeof(""), &expr_ptr, sizeof(zval *), NULL);
                                break;
@@ -3508,6 +3518,7 @@ int zend_unset_dim_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
 {
        zval **container = get_obj_zval_ptr_ptr(&EX(opline)->op1, EX(Ts), BP_VAR_R TSRMLS_CC);
        zval *offset = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
+       long index;
        
        if (container) {
                HashTable *ht;
@@ -3526,20 +3537,20 @@ int zend_unset_dim_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
                                case IS_RESOURCE:
                                case IS_BOOL: 
                                case IS_LONG:
-                                       {
-                                               long index;
-
-                                               if (offset->type == IS_DOUBLE) {
-                                                       index = (long) offset->value.lval;
-                                               } else {
-                                                       index = offset->value.lval;
-                                               }
+                                       if (offset->type == IS_DOUBLE) {
+                                               index = (long) offset->value.lval;
+                                       } else {
+                                               index = offset->value.lval;
+                                       }
        
+                                       zend_hash_index_del(ht, index);
+                                       break;
+                               case IS_STRING:
+                                       if (zend_is_numeric_key(offset, &index)) {
                                                zend_hash_index_del(ht, index);
-                                               break;
+                                       } else {
+                                               zend_hash_del(ht, offset->value.str.val, offset->value.str.len+1);
                                        }
-                               case IS_STRING:
-                                       zend_hash_del(ht, offset->value.str.val, offset->value.str.len+1);
                                        break;
                                case IS_NULL:
                                        zend_hash_del(ht, "", sizeof(""));
@@ -3730,6 +3741,7 @@ int zend_isset_isempty_dim_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
        zval *offset = get_zval_ptr(&EX(opline)->op2, EX(Ts), &EG(free_op2), BP_VAR_R);
        zval **value = NULL;
        int result = 0;
+       long index;
 
        if (container) {
                if ((*container)->type == IS_ARRAY) {
@@ -3743,21 +3755,21 @@ int zend_isset_isempty_dim_obj_handler(ZEND_OPCODE_HANDLER_ARGS)
                                case IS_RESOURCE:
                                case IS_BOOL: 
                                case IS_LONG:
-                                       {
-                                               long index;
-
-                                               if (offset->type == IS_DOUBLE) {
-                                                       index = (long) offset->value.lval;
-                                               } else {
-                                                       index = offset->value.lval;
-                                               }
+                                       if (offset->type == IS_DOUBLE) {
+                                               index = (long) offset->value.lval;
+                                       } else {
+                                               index = offset->value.lval;
+                                       }
+                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                               isset = 1;
+                                       }
+                                       break;
+                               case IS_STRING:
+                                       if (zend_is_numeric_key(offset, &index)) {
                                                if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
                                                        isset = 1;
                                                }
-                                               break;
-                                       }
-                               case IS_STRING:
-                                       if (zend_hash_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
+                                       } else if (zend_hash_find(ht, offset->value.str.val, offset->value.str.len+1, (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;

diff --git a/Zend/zend_hash.c b/Zend/zend_hash.c
index 6ec60239ad8d7962c53fe5d2b84d35cd6a6ed642..44acd2624aa8ef3097ba25ad4aa3f18affbd52d8 100644 (file)
--- a/Zend/zend_hash.c
+++ b/Zend/zend_hash.c
@@ -21,32 +21,6 @@
 
 #include "zend.h"
 
-#define HANDLE_NUMERIC(key, length, func) {                                                                                            \
-       register char *tmp=key;                                                                                                                         \
-                                                                                                                                                                               \
-       if ((*tmp>='0' && *tmp<='9')) do { /* possibly a numeric index */                                       \
-               char *end=tmp+length-1;                                                                                                                 \
-               ulong idx;                                                                                                                                              \
-                                                                                                                                                                               \
-               if (*tmp++=='0' && length>2) { /* don't accept numbers with leading zeros */    \
-                       break;                                                                                                                                          \
-               }                                                                                                                                                               \
-               while (tmp<end) {                                                                                                                               \
-                       if (!(*tmp>='0' && *tmp<='9')) {                                                                                        \
-                               break;                                                                                                                                  \
-                       }                                                                                                                                                       \
-                       tmp++;                                                                                                                                          \
-               }                                                                                                                                                               \
-               if (tmp==end && *tmp=='\0') { /* a numeric index */                                                             \
-                       idx = strtol(key, NULL, 10);                                                                                                    \
-                       if (idx!=LONG_MAX) {                                                                                                            \
-                               return func;                                                                                                                    \
-                       }                                                                                                                                                       \
-               }                                                                                                                                                               \
-       } while (0);                                                                                                                                                    \
-}
-
-
 #define CONNECT_TO_BUCKET_DLLIST(element, list_head)           \
        (element)->pNext = (list_head);                                                 \
        (element)->pLast = NULL;                                                                \
@@ -224,8 +198,6 @@ ZEND_API int zend_hash_add_or_update(HashTable *ht, char *arKey, uint nKeyLength
                return FAILURE;
        }
 
-       HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_update_or_next_insert(ht, idx, pData, nDataSize, pDest, flag));
-       
        h = zend_inline_hash_func(arKey, nKeyLength);
        nIndex = h & ht->nTableMask;
 
@@ -474,7 +446,6 @@ ZEND_API int zend_hash_del_key_or_index(HashTable *ht, char *arKey, uint nKeyLen
        IS_CONSISTENT(ht);
 
        if (flag == HASH_DEL_KEY) {
-               HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_del_key_or_index(ht, arKey, nKeyLength, idx, HASH_DEL_INDEX));
                h = zend_inline_hash_func(arKey, nKeyLength);
        }
        nIndex = h & ht->nTableMask;
@@ -866,8 +837,6 @@ ZEND_API int zend_hash_find(HashTable *ht, char *arKey, uint nKeyLength, void **
 
        IS_CONSISTENT(ht);
 
-       HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_find(ht, idx, pData));
-
        h = zend_inline_hash_func(arKey, nKeyLength);
        nIndex = h & ht->nTableMask;
 
@@ -920,8 +889,6 @@ ZEND_API int zend_hash_exists(HashTable *ht, char *arKey, uint nKeyLength)
 
        IS_CONSISTENT(ht);
 
-       HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
-
        h = zend_inline_hash_func(arKey, nKeyLength);
        nIndex = h & ht->nTableMask;
 
@@ -949,8 +916,6 @@ ZEND_API int zend_hash_quick_exists(HashTable *ht, char *arKey, uint nKeyLength,
 
        IS_CONSISTENT(ht);
 
-       HANDLE_NUMERIC(arKey, nKeyLength, zend_hash_index_exists(ht, idx));
-
        nIndex = h & ht->nTableMask;
 
        p = ht->arBuckets[nIndex];

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 2904eeab07102db3f14c99f7f4ab155cdd36b7b0..18408fed7285bcd9cad8b61b9cdfb4cae932db04 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -33,6 +33,41 @@
 #include "ext/bcmath/number.h"
 #endif
 
+ZEND_API zend_bool zend_is_numeric_key(zval *zvalue, long *val)
+{
+       char *tmp; 
+       long length; 
+       
+       tmp = zvalue->value.str.val;
+       length = zvalue->value.str.len;
+
+       if ((*tmp>='0' && *tmp<='9')) { /* possibly a numeric index */
+               char *end=tmp+length;   
+               ulong idx;
+               
+               if (*tmp++=='0' && length>2) { /* don't accept numbers with leading zeros */
+                       return 0;
+               }
+               
+               while (tmp<end) {
+                       if (!(*tmp>='0' && *tmp<='9')) {
+                               break;
+                       }
+                       tmp++;
+               }
+
+               if (tmp==end && *tmp=='\0') { /* a numeric index */
+                       idx = strtol(zvalue->value.str.val, NULL, 10);
+                       if (idx!=LONG_MAX) {
+                               *val = idx;
+                               return 1;
+                       }
+               }
+       }
+
+       return 0;
+}
+
 ZEND_API int zend_atoi(const char *str, int str_len)
 {
        int retval;

diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 871870f2db03b5831fb05459168bcd679e0121b1..8fc2e26ae883073e6b80465954e636893ecb59ca 100644 (file)
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -60,6 +60,7 @@ ZEND_API int is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
 ZEND_API int is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC);
 
 ZEND_API zend_bool instanceof_function(zend_class_entry *instance_ce, zend_class_entry *ce TSRMLS_DC);
+ZEND_API zend_bool zend_is_numeric_key(zval *, long *);
 
 static inline zend_bool is_numeric_string(char *str, int length, long *lval, double *dval, zend_bool allow_errors)
 {