MFH:

Restored double->long conversion behavior to that of PHP 5.2 (on most platforms) and prior:
 * Out-of-range numbers overflow/preserve least significant bits (no LONG_MAX/MIN limit)
 * See bug #42868 (presumably-rare platform with different results in 5.2)
 * On 32-bit platforms with 64-bit long type, a zend_long64 cast has been added,
    otherwise it's the same as 5.2
 * Use this conversion method everywhere instead of some plain (long) casts

Added 'L' parameter parsing specifier to ensure a LONG_MAX/MIN limit:
 * Essentially what 5.3's new conversion was doing in most cases
 * Functions with "limit" or "length" type params could be updated to use this,
    and prevent confusing overflow behavior with huge numbers (*also* in 5.2)
  - See bug #47854, for example; or even #42868 again

# Test updates coming

diff --git a/README.PARAMETER_PARSING_API b/README.PARAMETER_PARSING_API
index 530b2b560d7e0c9fa38583d489115ee1fff97848..8d297670c65737e89714d45f5d489604891d58e6 100644 (file)
--- a/README.PARAMETER_PARSING_API
+++ b/README.PARAMETER_PARSING_API
@@ -48,6 +48,7 @@ Type specifiers
  h  - array (returned as HashTable*)
  H  - array or HASH_OF(object) (returned as HashTable*)
  l  - long (long)
+ L  - long, limits out-of-range numbers to LONG_MAX/LONG_MIN (long)
  o  - object of any type (zval*)
  O  - object of specific type given by class entry (zval*, zend_class_entry)
  r  - resource (zval*)

diff --git a/Zend/Zend.m4 b/Zend/Zend.m4
index 904f1886816a4642f842ea2c1b89506966757b84..bf9be5c7f84f509d0ad37bb93317caff6c628a67 100644 (file)
--- a/Zend/Zend.m4
+++ b/Zend/Zend.m4
@@ -117,6 +117,38 @@ AC_CHECK_FUNCS(finite isfinite isinf isnan)
 ZEND_FP_EXCEPT
 
 ZEND_CHECK_FLOAT_PRECISION
+
+dnl test whether double cast to long preserves least significant bits
+AC_MSG_CHECKING(whether double cast to long preserves least significant bits)
+
+AC_TRY_RUN([
+#include <limits.h>
+
+int main()
+{
+       if (sizeof(long) == 4) {
+               double d = (double) LONG_MIN * LONG_MIN + 2e9;
+
+               if ((long) d == 2e9 && (long) -d == -2e9) {
+                       exit(0);
+               }
+       } else if (sizeof(long) == 8) {
+               double correct = 18e18 - ((double) LONG_MIN * -2); /* Subtract ULONG_MAX + 1 */
+
+               if ((long) 18e18 == correct) { /* On 64-bit, only check between LONG_MAX and ULONG_MAX */
+                       exit(0);
+               }
+       }
+       exit(1);
+}
+], [
+  AC_DEFINE([ZEND_DVAL_TO_LVAL_CAST_OK], 1, [Define if double cast to long preserves least significant bits])
+  AC_MSG_RESULT(yes)
+], [
+  AC_MSG_RESULT(no)
+], [
+  AC_MSG_RESULT(no)
+])
        
 ])
 

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 0e186691d76924c346016a1807e620d66940756f..d4c1036a743792f6704a902ea113fa3174008b17 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -313,6 +313,7 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
 
        switch (c) {
                case 'l':
+               case 'L':
                        {
                                long *p = va_arg(*va, long *);
                                switch (Z_TYPE_PP(arg)) {
@@ -324,14 +325,33 @@ static char *zend_parse_arg_impl(int arg_num, zval **arg, va_list *va, char **sp
                                                        if ((type = is_numeric_string(Z_STRVAL_PP(arg), Z_STRLEN_PP(arg), p, &d, -1)) == 0) {
                                                                return "long";
                                                        } else if (type == IS_DOUBLE) {
-                                                               *p = (long) d;
+                                                               if (c == 'L') {
+                                                                       if (d > LONG_MAX) {
+                                                                               *p = LONG_MAX;
+                                                                               break;
+                                                                       } else if (d < LONG_MIN) {
+                                                                               *p = LONG_MIN;
+                                                                               break;
+                                                                       }
+                                                               }
+
+                                                               *p = zend_dval_to_lval(d);
                                                        }
                                                }
                                                break;
 
+                                       case IS_DOUBLE:
+                                               if (c == 'L') {
+                                                       if (Z_DVAL_PP(arg) > LONG_MAX) {
+                                                               *p = LONG_MAX;
+                                                               break;
+                                                       } else if (Z_DVAL_PP(arg) < LONG_MIN) {
+                                                               *p = LONG_MIN;
+                                                               break;
+                                                       }
+                                               }
                                        case IS_NULL:
                                        case IS_LONG:
-                                       case IS_DOUBLE:
                                        case IS_BOOL:
                                                convert_to_long_ex(arg);
                                                *p = Z_LVAL_PP(arg);

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index dfe8595b907c7b1c3862588ba5a2dfb073c254c2..96bea45431483b49821d4a2d0abd2893dd62e0f9 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -3997,7 +3997,6 @@ void zend_do_add_static_array_element(znode *result, znode *offset, const znode
        ALLOC_ZVAL(element);
        *element = expr->u.constant;
        if (offset) {
-               long l;
                switch (offset->u.constant.type & IS_CONSTANT_TYPE_MASK) {
                        case IS_CONSTANT:
                                /* Ugly hack to denote that this value has a constant index */
@@ -4020,8 +4019,7 @@ void zend_do_add_static_array_element(znode *result, znode *offset, const znode
                                zend_hash_index_update(Z_ARRVAL(result->u.constant), Z_LVAL(offset->u.constant), &element, sizeof(zval *), NULL);
                                break;
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL(offset->u.constant), l);
-                               zend_hash_index_update(Z_ARRVAL(result->u.constant), l, &element, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL(result->u.constant), zend_dval_to_lval(Z_DVAL(offset->u.constant)), &element, sizeof(zval *), NULL);
                                break;
                        case IS_CONSTANT_ARRAY:
                                zend_error(E_ERROR, "Illegal offset type");

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 1c7636476c0203043467bbbb4d82115cb79c8ccd..9216a6441f32e7aa2f4b00259470aaff7524ba5e 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -823,10 +823,9 @@ fetch_string_dim:
                                }
                        }
                        break;
-               case IS_DOUBLE: {
-                       DVAL_TO_LVAL(Z_DVAL_P(dim), index);
+               case IS_DOUBLE:
+                       index = zend_dval_to_lval(Z_DVAL_P(dim));
                        goto num_index;
-               }
                case IS_RESOURCE:
                        zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_LVAL_P(dim), Z_LVAL_P(dim));
                        /* Fall Through */

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index f113d8fa2974f72093828cac1b52da6f00f4b1e1..fba98d583e3ffec17f8b157abd3e1e376c571d1f 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -662,7 +662,7 @@ ZEND_API int zval_update_constant_ex(zval **pp, void *arg, zend_class_entry *sco
                                        ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, Z_LVAL(const_value), HASH_UPDATE_KEY_IF_BEFORE, NULL);
                                        break;
                                case IS_DOUBLE:
-                                       ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, (long)Z_DVAL(const_value), HASH_UPDATE_KEY_IF_BEFORE, NULL);
+                                       ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, zend_dval_to_lval(Z_DVAL(const_value)), HASH_UPDATE_KEY_IF_BEFORE, NULL);
                                        break;
                                case IS_NULL:
                                        ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_STRING, "", 1, 0, HASH_UPDATE_KEY_IF_BEFORE, NULL);

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 7b4919713fffa9caf32b3c951f4f852cf8825588..ef08807c7d992bb7768280839d6111a9a06e315c 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -225,7 +225,7 @@ ZEND_API void convert_scalar_to_number(zval *op TSRMLS_DC) /* {{{ */
                                Z_LVAL(holder) = 0;                                                                     \
                                break;                                                                                          \
                        case IS_DOUBLE:                                                                                 \
-                               DVAL_TO_LVAL(Z_DVAL_P(op), Z_LVAL(holder));                     \
+                               Z_LVAL(holder) = zend_dval_to_lval(Z_DVAL_P(op));       \
                                break;                                                                                          \
                        case IS_STRING:                                                                                 \
                                Z_LVAL(holder) = strtol(Z_STRVAL_P(op), NULL, 10);      \
@@ -349,7 +349,7 @@ ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
                case IS_LONG:
                        break;
                case IS_DOUBLE:
-                       DVAL_TO_LVAL(Z_DVAL_P(op), Z_LVAL_P(op));
+                       Z_LVAL_P(op) = zend_dval_to_lval(Z_DVAL_P(op));
                        break;
                case IS_STRING:
                        {
@@ -1017,7 +1017,7 @@ ZEND_API int bitwise_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
                ZVAL_LONG(result, ~Z_LVAL_P(op1));
                return SUCCESS;
        } else if (Z_TYPE_P(op1) == IS_DOUBLE) {
-               ZVAL_LONG(result, ~(long) Z_DVAL_P(op1));
+               ZVAL_LONG(result, ~zend_dval_to_lval(Z_DVAL_P(op1)));
                return SUCCESS;
        } else if (Z_TYPE_P(op1) == IS_STRING) {
                int i;

diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 992f267545d02d8399c8fe0c60f9d891619b0bfc..18420ced573351e50e02dec65e0283018bbdbfd0 100644 (file)
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -63,39 +63,24 @@ ZEND_API zend_bool instanceof_function_ex(const zend_class_entry *instance_ce, c
 ZEND_API zend_bool instanceof_function(const zend_class_entry *instance_ce, const zend_class_entry *ce TSRMLS_DC);
 END_EXTERN_C()
 
-/* {{{ DVAL_TO_LVAL */
-#define MAX_UNSIGNED_INT ((double) LONG_MAX * 2) + 1
-#ifdef _WIN64
-# define DVAL_TO_LVAL(d, l) \
-       if ((d) > LONG_MAX) { \
-               (l) = (long)(unsigned long)(__int64) (d); \
-       } else { \
-               (l) = (long) (d); \
-       }
-#elif !defined(_WIN64) && __WORDSIZE == 64
-# define DVAL_TO_LVAL(d, l) \
-       if ((d) >= LONG_MAX) { \
-               (l) = LONG_MAX; \
-       } else if ((d) <= LONG_MIN) { \
-               (l) = LONG_MIN; \
-       } else { \
-               (l) = (long) (d); \
+#if ZEND_DVAL_TO_LVAL_CAST_OK
+# define zend_dval_to_lval(d) ((long) (d))
+#elif SIZEOF_LONG == 4 && defined(HAVE_ZEND_LONG64)
+static zend_always_inline long zend_dval_to_lval(double d)
+{
+       if (d > LONG_MAX || d < LONG_MIN) {
+               return (long)(unsigned long)(zend_long64) d;
        }
+       return (long) d;
+}
 #else
-# define DVAL_TO_LVAL(d, l) \
-       if ((d) > LONG_MAX) { \
-               if ((d) > MAX_UNSIGNED_INT) { \
-                       (l) = LONG_MAX; \
-               } else { \
-                       (l) = (unsigned long) (d); \
-               } \
-       } else { \
-               if((d) < LONG_MIN) { \
-                       (l) = LONG_MIN; \
-               } else { \
-                       (l) = (long) (d); \
-               } \
+static zend_always_inline long zend_dval_to_lval(double d)
+{
+       if (d > LONG_MAX) {
+               return (long)(unsigned long) d;
        }
+       return (long) d;
+}
 #endif
 /* }}} */
 

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index a4ea1b6d7a8ab7fe8adc4df4b205841dfecee0ab..bdd15c8da50552b75b7c7a89a7045619222d1419 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -3085,11 +3085,9 @@ ZEND_VM_HANDLER(72, ZEND_ADD_ARRAY_ELEMENT, CONST|TMP|VAR|CV, CONST|TMP|VAR|UNUS
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -3408,7 +3406,6 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
        zend_free_op free_op1, free_op2;
        zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_UNSET);
        zval *offset = GET_OP2_ZVAL_PTR(BP_VAR_R);
-       long index;
 
        if (OP1_TYPE != IS_VAR || container) {
                if (OP1_TYPE == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -3420,14 +3417,12 @@ ZEND_VM_HANDLER(75, ZEND_UNSET_DIM, VAR|UNUSED|CV, CONST|TMP|VAR|CV)
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
@@ -3907,7 +3902,6 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
        zval **container = GET_OP1_OBJ_ZVAL_PTR_PTR(BP_VAR_IS);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (OP1_TYPE != IS_VAR || container) {
                zend_free_op free_op2;
@@ -3921,16 +3915,14 @@ ZEND_VM_HELPER_EX(zend_isset_isempty_dim_prop_obj_handler, VAR|UNUSED|CV, CONST|
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index bf84924dfce412d856edbe1d198524b74fbc1139..54954dbcaa479f4d8e3a72bec3ebe7c3c64f5eeb 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2850,11 +2850,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CONST_HANDLER(ZEND_O
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -3367,11 +3365,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_TMP_HANDLER(ZEND_OPC
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -3835,11 +3831,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_VAR_HANDLER(ZEND_OPC
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -4027,11 +4021,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_UNUSED_HANDLER(ZEND_
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -4494,11 +4486,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CONST_CV_HANDLER(ZEND_OPCO
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -6086,11 +6076,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CONST_HANDLER(ZEND_OPC
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -6554,11 +6542,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_TMP_HANDLER(ZEND_OPCOD
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -7022,11 +7008,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_VAR_HANDLER(ZEND_OPCOD
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -7117,11 +7101,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_UNUSED_HANDLER(ZEND_OP
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -7582,11 +7564,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_TMP_CV_HANDLER(ZEND_OPCODE
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -10616,11 +10596,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CONST_HANDLER(ZEND_OPC
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -10670,7 +10648,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
        zend_free_op free_op1;
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval *offset = &opline->op2.u.constant;
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
                if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -10682,14 +10659,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAND
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
@@ -10801,7 +10776,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
 
@@ -10815,16 +10789,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CONST(
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -12373,11 +12345,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_TMP_HANDLER(ZEND_OPCOD
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -12427,7 +12397,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE
        zend_free_op free_op1, free_op2;
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
                if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -12439,14 +12408,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLE
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
@@ -12558,7 +12525,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(in
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
                zend_free_op free_op2;
@@ -12572,16 +12538,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_TMP(in
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -14181,11 +14145,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_VAR_HANDLER(ZEND_OPCOD
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -14235,7 +14197,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
        zend_free_op free_op1, free_op2;
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
                if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -14247,14 +14208,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLE
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
@@ -14366,7 +14325,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(in
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
                zend_free_op free_op2;
@@ -14380,16 +14338,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_VAR(in
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -15051,11 +15007,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_UNUSED_HANDLER(ZEND_OP
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -16577,11 +16531,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_VAR_CV_HANDLER(ZEND_OPCODE
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -16631,7 +16583,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER
        zend_free_op free_op1;
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
                if (IS_VAR == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -16643,14 +16594,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_CV == IS_CV || IS_CV == IS_VAR) {
@@ -16762,7 +16711,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int
        zval **container = _get_zval_ptr_ptr_var(&opline->op1, EX(Ts), &free_op1 TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_VAR != IS_VAR || container) {
 
@@ -16776,16 +16724,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_VAR_CV(int
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -17829,7 +17775,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = &opline->op2.u.constant;
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
                if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -17841,14 +17786,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CONST_HANDLER(ZEND_OPCODE_H
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
@@ -17958,7 +17901,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
 
@@ -17972,16 +17914,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CON
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -18892,7 +18832,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
        zend_free_op free_op2;
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
                if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -18904,14 +18843,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_TMP_HANDLER(ZEND_OPCODE_HAN
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
@@ -19021,7 +18958,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
                zend_free_op free_op2;
@@ -19035,16 +18971,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_TMP
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -19955,7 +19889,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
        zend_free_op free_op2;
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
                if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -19967,14 +19900,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_VAR_HANDLER(ZEND_OPCODE_HAN
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
@@ -20084,7 +20015,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
                zend_free_op free_op2;
@@ -20098,16 +20028,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_VAR
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -21277,7 +21205,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
                if (IS_UNUSED == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -21289,14 +21216,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_UNUSED_CV_HANDLER(ZEND_OPCODE_HAND
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_CV == IS_CV || IS_CV == IS_VAR) {
@@ -21406,7 +21331,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(
        zval **container = _get_obj_zval_ptr_ptr_unused(TSRMLS_C);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_UNUSED != IS_VAR || container) {
 
@@ -21420,16 +21344,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_UNUSED_CV(
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -24205,11 +24127,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CONST_HANDLER(ZEND_OPCO
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -24259,7 +24179,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = &opline->op2.u.constant;
-       long index;
 
        if (IS_CV != IS_VAR || container) {
                if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -24271,14 +24190,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDL
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
@@ -24388,7 +24305,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(i
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_CV != IS_VAR || container) {
 
@@ -24402,16 +24318,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CONST(i
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -25853,11 +25767,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_TMP_HANDLER(ZEND_OPCODE
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -25907,7 +25819,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
        zend_free_op free_op2;
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = _get_zval_ptr_tmp(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-       long index;
 
        if (IS_CV != IS_VAR || container) {
                if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -25919,14 +25830,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
@@ -26036,7 +25945,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_CV != IS_VAR || container) {
                zend_free_op free_op2;
@@ -26050,16 +25958,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_TMP(int
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -27551,11 +27457,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_VAR_HANDLER(ZEND_OPCODE
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -27605,7 +27509,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
        zend_free_op free_op2;
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = _get_zval_ptr_var(&opline->op2, EX(Ts), &free_op2 TSRMLS_CC);
-       long index;
 
        if (IS_CV != IS_VAR || container) {
                if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -27617,14 +27520,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
@@ -27734,7 +27635,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_CV != IS_VAR || container) {
                zend_free_op free_op2;
@@ -27748,16 +27648,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_VAR(int
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
@@ -28318,11 +28216,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_UNUSED_HANDLER(ZEND_OPC
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -29738,11 +29634,9 @@ static int ZEND_FASTCALL  ZEND_ADD_ARRAY_ELEMENT_SPEC_CV_CV_HANDLER(ZEND_OPCODE_
                }
        }
        if (offset) {
-               long l;
                switch (Z_TYPE_P(offset)) {
                        case IS_DOUBLE:
-                               DVAL_TO_LVAL(Z_DVAL_P(offset), l);
-                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), l, &expr_ptr, sizeof(zval *), NULL);
+                               zend_hash_index_update(Z_ARRVAL_P(array_ptr), zend_dval_to_lval(Z_DVAL_P(offset)), &expr_ptr, sizeof(zval *), NULL);
                                break;
                        case IS_LONG:
                        case IS_BOOL:
@@ -29792,7 +29686,6 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_UNSET TSRMLS_CC);
        zval *offset = _get_zval_ptr_cv(&opline->op2, EX(Ts), BP_VAR_R TSRMLS_CC);
-       long index;
 
        if (IS_CV != IS_VAR || container) {
                if (IS_CV == IS_CV && container != &EG(uninitialized_zval_ptr)) {
@@ -29804,14 +29697,12 @@ static int ZEND_FASTCALL  ZEND_UNSET_DIM_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_
 
                                switch (Z_TYPE_P(offset)) {
                                        case IS_DOUBLE:
-                                               index = (long) Z_DVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, zend_dval_to_lval(Z_DVAL_P(offset)));
                                                break;
                                        case IS_RESOURCE:
                                        case IS_BOOL:
                                        case IS_LONG:
-                                               index = Z_LVAL_P(offset);
-                                               zend_hash_index_del(ht, index);
+                                               zend_hash_index_del(ht, Z_LVAL_P(offset));
                                                break;
                                        case IS_STRING:
                                                if (IS_CV == IS_CV || IS_CV == IS_VAR) {
@@ -29921,7 +29812,6 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int
        zval **container = _get_zval_ptr_ptr_cv(&opline->op1, EX(Ts), BP_VAR_IS TSRMLS_CC);
        zval **value = NULL;
        int result = 0;
-       long index;
 
        if (IS_CV != IS_VAR || container) {
 
@@ -29935,16 +29825,14 @@ static int ZEND_FASTCALL zend_isset_isempty_dim_prop_obj_handler_SPEC_CV_CV(int
 
                        switch (Z_TYPE_P(offset)) {
                                case IS_DOUBLE:
-                                       index = (long) Z_DVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, zend_dval_to_lval(Z_DVAL_P(offset)), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;
                                case IS_RESOURCE:
                                case IS_BOOL:
                                case IS_LONG:
-                                       index = Z_LVAL_P(offset);
-                                       if (zend_hash_index_find(ht, index, (void **) &value) == SUCCESS) {
+                                       if (zend_hash_index_find(ht, Z_LVAL_P(offset), (void **) &value) == SUCCESS) {
                                                isset = 1;
                                        }
                                        break;

diff --git a/win32/build/config.w32 b/win32/build/config.w32
index 702e332b64d227c64dea4eea2d3c0657c001e580..6042850283d7997724b3bc6b95f4f6c37d62f11f 100644 (file)
--- a/win32/build/config.w32
+++ b/win32/build/config.w32
@@ -324,6 +324,10 @@ ADD_SOURCES("Zend", "zend_language_parser.c zend_language_scanner.c \
        zend_default_classes.c zend_execute.c zend_strtod.c zend_gc.c zend_closures.c \
        zend_float.c");
 
+if (VCVERS == 1200) {
+       AC_DEFINE('ZEND_DVAL_TO_LVAL_CAST_OK', 1);
+}
+
 ADD_SOURCES("main", "main.c snprintf.c spprintf.c safe_mode.c getopt.c fopen_wrappers.c \
        php_scandir.c php_ini.c SAPI.c rfc1867.c php_content_types.c strlcpy.c \
        strlcat.c mergesort.c reentrancy.c php_variables.c php_ticks.c network.c \