Split IS_BOOL into IS_FALSE and IS_TRUE

diff --git a/Zend/zend.c b/Zend/zend.c
index 465446d663fe92466f00b0371259a0c08a1fbfac..f4bab5032c7791219fbbf4a9356ed85464aba758 100644 (file)
--- a/Zend/zend.c
+++ b/Zend/zend.c
@@ -220,19 +220,15 @@ ZEND_API void zend_make_printable_zval(zval *expr, zval *expr_copy, int *use_cop
 
 again:
        switch (Z_TYPE_P(expr)) {
-               case IS_NULL: {
+               case IS_NULL:
+               case IS_FALSE: {
                        TSRMLS_FETCH();
                        ZVAL_EMPTY_STRING(expr_copy);
                        break;
                }
-               case IS_BOOL:
-                       if (Z_LVAL_P(expr)) {
-                               // TODO: use interned string ???
-                               ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
-                       } else {
-                               TSRMLS_FETCH();
-                               ZVAL_EMPTY_STRING(expr_copy);
-                       }
+               case IS_TRUE:
+                       // TODO: use interned string ???
+                       ZVAL_NEW_STR(expr_copy, STR_INIT("1", 1, 0));
                        break;
                case IS_RESOURCE: {
                                char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
@@ -1201,7 +1197,7 @@ ZEND_API void zend_error(int type, const char *format, ...) /* {{{ */
                        ZVAL_UNDEF(&retval);
                        if (call_user_function_ex(CG(function_table), NULL, &orig_user_error_handler, &retval, 5, params, 1, NULL TSRMLS_CC) == SUCCESS) {
                                if (Z_TYPE(retval) != IS_UNDEF) {
-                                       if (Z_TYPE(retval) == IS_BOOL && Z_LVAL(retval) == 0) {
+                                       if (Z_TYPE(retval) == IS_FALSE) {
                                                zend_error_cb(type, error_filename, error_lineno, format, args);
                                        }
                                        zval_ptr_dtor(&retval);

diff --git a/Zend/zend_API.c b/Zend/zend_API.c
index 60ef092bb1fca9ded97901c64db1427b2fb51dca..6c023f474d6e9027df83413f20711f6bb3eaf835 100644 (file)
--- a/Zend/zend_API.c
+++ b/Zend/zend_API.c
@@ -201,7 +201,8 @@ ZEND_API void zend_wrong_param_count(TSRMLS_D) /* {{{ */
 ZEND_API char *zend_get_type_by_const(int type) /* {{{ */
 {
        switch(type) {
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                        return "boolean";
                case IS_LONG:
                        return "integer";
@@ -408,8 +409,9 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
                                                        }
                                                }
                                        case IS_NULL:
+                                       case IS_FALSE:
+                                       case IS_TRUE:
                                        case IS_LONG:
-                                       case IS_BOOL:
                                                convert_to_long_ex(arg);
                                                *p = Z_LVAL_P(arg);
                                                break;
@@ -447,9 +449,10 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
                                                break;
 
                                        case IS_NULL:
+                                       case IS_FALSE:
+                                       case IS_TRUE:
                                        case IS_LONG:
                                        case IS_DOUBLE:
-                                       case IS_BOOL:
                                                convert_to_double_ex(arg);
                                                *p = Z_DVAL_P(arg);
                                                break;
@@ -480,7 +483,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
                                        case IS_STRING:
                                        case IS_LONG:
                                        case IS_DOUBLE:
-                                       case IS_BOOL:
+                                       case IS_FALSE:
+                                       case IS_TRUE:
                                                convert_to_string_ex(arg);
                                                if (UNEXPECTED(Z_ISREF_P(arg))) {
                                                        /* it's dangerous to return pointers to string
@@ -525,7 +529,8 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
                                        case IS_STRING:
                                        case IS_LONG:
                                        case IS_DOUBLE:
-                                       case IS_BOOL:
+                                       case IS_FALSE:
+                                       case IS_TRUE:
                                                convert_to_string_ex(arg);
                                                if (UNEXPECTED(Z_ISREF_P(arg))) {
                                                        /* it's dangerous to return pointers to string
@@ -563,9 +568,10 @@ static const char *zend_parse_arg_impl(int arg_num, zval *arg, va_list *va, cons
                                        case IS_STRING:
                                        case IS_LONG:
                                        case IS_DOUBLE:
-                                       case IS_BOOL:
+                                       case IS_FALSE:
+                                       case IS_TRUE:
                                                convert_to_boolean_ex(arg);
-                                               *p = Z_BVAL_P(arg);
+                                               *p = Z_TYPE_P(arg) == IS_TRUE;
                                                break;
 
                                        case IS_ARRAY:
@@ -1641,7 +1647,12 @@ ZEND_API int array_set_zval_key(HashTable *ht, zval *key, zval *value TSRMLS_DC)
                        zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(key), Z_RES_HANDLE_P(key));
                        result = zend_hash_index_update(ht, Z_RES_HANDLE_P(key), value);
                        break;
-               case IS_BOOL:
+               case IS_FALSE:
+                       result = zend_hash_index_update(ht, 0, value);
+                       break;
+               case IS_TRUE:
+                       result = zend_hash_index_update(ht, 1, value);
+                       break;
                case IS_LONG:
                        result = zend_hash_index_update(ht, Z_LVAL_P(key), value);
                        break;
@@ -3954,8 +3965,9 @@ static int same_zval(zval *zv1, zval *zv2)  /* {{{ */
        switch (Z_TYPE_P(zv1)) {
                case IS_UNDEF:
                case IS_NULL:
+               case IS_FALSE:
+               case IS_TRUE:
                        return 1;
-               case IS_BOOL:
                case IS_LONG:
                        return Z_LVAL_P(zv1) == Z_LVAL_P(zv2);
                case IS_DOUBLE:

diff --git a/Zend/zend_API.h b/Zend/zend_API.h
index ae26375f709d225c61b2a38bad82b895e0b7702b..54402c411daab9b3c04fa29c0df9947a705d817b 100644 (file)
--- a/Zend/zend_API.h
+++ b/Zend/zend_API.h
@@ -594,9 +594,6 @@ END_EXTERN_C()
            }                                                                           \
        } while (0)
 
-#define ZVAL_FALSE(z)                                          ZVAL_BOOL(z, 0)
-#define ZVAL_TRUE(z)                                   ZVAL_BOOL(z, 1)
-
 #define RETVAL_BOOL(b)                                 ZVAL_BOOL(return_value, b)
 #define RETVAL_NULL()                                  ZVAL_NULL(return_value)
 #define RETVAL_LONG(l)                                         ZVAL_LONG(return_value, l)

diff --git a/Zend/zend_builtin_functions.c b/Zend/zend_builtin_functions.c
index 32bd68e58e4c010acbe89994f3fe21dad6d3ff96..80f3818d171c7c2c453e43d1caa1b48356d4f5e0 100644 (file)
--- a/Zend/zend_builtin_functions.c
+++ b/Zend/zend_builtin_functions.c
@@ -686,7 +686,8 @@ repeat:
                case IS_LONG:
                case IS_DOUBLE:
                case IS_STRING:
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                case IS_RESOURCE:
                case IS_NULL:
                        break;

diff --git a/Zend/zend_compile.c b/Zend/zend_compile.c
index 8df612e18b358e621cab3dd017f68feddebb37ed..02dca941baa6849e73f8b305f84dbc02e8021a36 100644 (file)
--- a/Zend/zend_compile.c
+++ b/Zend/zend_compile.c
@@ -3494,14 +3494,12 @@ static char * zend_get_function_declaration(zend_function *fptr TSRMLS_DC) /* {{
 
                                                ZVAL_DUP(&zv, precv->op2.zv);
                                                zval_update_constant_ex(&zv, 1, fptr->common.scope TSRMLS_CC);
-                                               if (Z_TYPE(zv) == IS_BOOL) {
-                                                       if (Z_LVAL(zv)) {
-                                                               memcpy(offset, "true", 4);
-                                                               offset += 4;
-                                                       } else {
-                                                               memcpy(offset, "false", 5);
-                                                               offset += 5;
-                                                       }
+                                               if (Z_TYPE(zv) == IS_FALSE) {
+                                                       memcpy(offset, "false", 5);
+                                                       offset += 5;
+                                               } else if (Z_TYPE(zv) == IS_TRUE) {
+                                                       memcpy(offset, "true", 4);
+                                                       offset += 4;
                                                } else if (Z_TYPE(zv) == IS_NULL) {
                                                        memcpy(offset, "NULL", 4);
                                                        offset += 4;
@@ -5973,9 +5971,14 @@ void zend_do_add_static_array_element(znode *result, znode *offset, znode *expr
                                zend_symtable_update(Z_ARRVAL(result->u.constant), STR_EMPTY_ALLOC(), &element);
                                break;
                        case IS_LONG:
-                       case IS_BOOL:
                                zend_hash_index_update(Z_ARRVAL(result->u.constant), Z_LVAL(offset->u.constant), &element);
                                break;
+                       case IS_FALSE:
+                               zend_hash_index_update(Z_ARRVAL(result->u.constant), 0, &element);
+                               break;
+                       case IS_TRUE:
+                               zend_hash_index_update(Z_ARRVAL(result->u.constant), 1, &element);
+                               break;
                        case IS_DOUBLE:
                                zend_hash_index_update(Z_ARRVAL(result->u.constant), zend_dval_to_lval(Z_DVAL(offset->u.constant)), &element);
                                break;

diff --git a/Zend/zend_exceptions.c b/Zend/zend_exceptions.c
index 137d9c97f8bc31a62daa0fd5e5267e8425a93987..8b897961792654cc8116f3e2157371beed249808 100644 (file)
--- a/Zend/zend_exceptions.c
+++ b/Zend/zend_exceptions.c
@@ -456,12 +456,11 @@ static int _build_trace_args(zval *arg TSRMLS_DC, int num_args, va_list args, ze
                        }
                        break;
                }
-               case IS_BOOL:
-                       if (Z_LVAL_P(arg)) {
-                               TRACE_APPEND_STR("true, ");
-                       } else {
-                               TRACE_APPEND_STR("false, ");
-                       }
+               case IS_FALSE:
+                       TRACE_APPEND_STR("false, ");
+                       break;
+               case IS_TRUE:
+                       TRACE_APPEND_STR("true, ");
                        break;
                case IS_RESOURCE: {
                        long lval = Z_RES_HANDLE_P(arg);

diff --git a/Zend/zend_execute.c b/Zend/zend_execute.c
index 8b3ea40eb6d7242bbeb0722f1fce85d6b0bbdbe3..5ed46788eb63cfa849dcc34c55549d3e12d7bd4b 100644 (file)
--- a/Zend/zend_execute.c
+++ b/Zend/zend_execute.c
@@ -503,7 +503,7 @@ static inline zval* make_real_object(zval *object_ptr TSRMLS_DC)
        ZVAL_DEREF(object);
        if (UNEXPECTED(Z_TYPE_P(object) != IS_OBJECT)) {
                if (Z_TYPE_P(object) == IS_NULL
-                       || (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0)
+                       || Z_TYPE_P(object) == IS_FALSE
                        || (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
                        if (EXPECTED(object == object_ptr)) {
                                /* object_ptr is not a reference */
@@ -678,7 +678,7 @@ static inline void zend_assign_to_object(zval *retval, zval *object_ptr, zval *p
                        return;
                }
                if (Z_TYPE_P(object) == IS_NULL ||
-                   (Z_TYPE_P(object) == IS_BOOL && Z_LVAL_P(object) == 0) ||
+                   Z_TYPE_P(object) == IS_FALSE ||
                    (Z_TYPE_P(object) == IS_STRING && Z_STRLEN_P(object) == 0)) {
 //??? The following block may handle only non-interned empty string,
 //??? but it doesn't work anyway
@@ -1093,8 +1093,11 @@ str_index:
                                zend_error(E_STRICT, "Resource ID#%ld used as offset, casting to integer (%ld)", Z_RES_HANDLE_P(dim), Z_RES_HANDLE_P(dim));
                                hval = Z_RES_HANDLE_P(dim);
                                goto num_index;
-                       case IS_BOOL:
-                               hval = Z_LVAL_P(dim);
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
                                goto num_index;
                        default:
                                zend_error(E_WARNING, "Illegal offset type");
@@ -1162,7 +1165,8 @@ convert_to_array:
                                        break;
                                case IS_DOUBLE:
                                case IS_NULL:
-                               case IS_BOOL:
+                               case IS_FALSE:
+                               case IS_TRUE:
                                        zend_error(E_NOTICE, "String offset cast occurred");
                                        break;
                                default:
@@ -1226,8 +1230,7 @@ convert_to_array:
                }
        } else {
                if (type != BP_VAR_UNSET &&
-                   Z_TYPE_P(container) == IS_BOOL &&
-                   Z_LVAL_P(container)==0) {
+                   Z_TYPE_P(container) == IS_FALSE) {
                        goto convert_to_array;
                }
                if (type == BP_VAR_UNSET) {
@@ -1284,7 +1287,8 @@ static zend_always_inline void zend_fetch_dimension_address_read(zval *result, z
                                        break;
                                case IS_DOUBLE:
                                case IS_NULL:
-                               case IS_BOOL:
+                               case IS_FALSE:
+                               case IS_TRUE:
                                        if (type != BP_VAR_IS) {
                                                zend_error(E_NOTICE, "String offset cast occurred");
                                        }
@@ -1358,8 +1362,8 @@ static void zend_fetch_property_address(zval *result, zval *container_ptr, zval
                /* this should modify object only if it's empty */
                if (type != BP_VAR_UNSET &&
                    ((Z_TYPE_P(container) == IS_NULL ||
-                    (Z_TYPE_P(container) == IS_BOOL && Z_LVAL_P(container)==0) ||
-                    (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
+                     Z_TYPE_P(container) == IS_FALSE ||
+                     (Z_TYPE_P(container) == IS_STRING && Z_STRLEN_P(container)==0)))) {
                        if (container == container_ptr) {
                                SEPARATE_ZVAL(container);
                        }

diff --git a/Zend/zend_execute.h b/Zend/zend_execute.h
index 98e2678f531baf0fd501ae0cedb6a80b20321507..0cdaeabde0ae08da745caf347e024b050ab785b2 100644 (file)
--- a/Zend/zend_execute.h
+++ b/Zend/zend_execute.h
@@ -80,13 +80,18 @@ again:
        switch (Z_TYPE_P(op)) {
                case IS_UNDEF:
                case IS_NULL:
+               case IS_FALSE:
                        result = 0;
                        break;
+               case IS_TRUE:
+                       result = 1;
+                       break;
                case IS_LONG:
-               case IS_BOOL:
-               case IS_RESOURCE:
                        result = (Z_LVAL_P(op)?1:0);
                        break;
+               case IS_RESOURCE:
+                       result = (Z_RES_HANDLE_P(op)?1:0);
+                       break;
                case IS_DOUBLE:
                        result = (Z_DVAL_P(op) ? 1 : 0);
                        break;
@@ -105,8 +110,8 @@ again:
                        if (IS_ZEND_STD_OBJECT(*op)) {
                                if (Z_OBJ_HT_P(op)->cast_object) {
                                        zval tmp;
-                                       if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, IS_BOOL TSRMLS_CC) == SUCCESS) {
-                                               result = Z_LVAL(tmp);
+                                       if (Z_OBJ_HT_P(op)->cast_object(op, &tmp, _IS_BOOL TSRMLS_CC) == SUCCESS) {
+                                               result = Z_TYPE(tmp) == IS_TRUE;
                                                break;
                                        }
                                } else if (Z_OBJ_HT_P(op)->get) {
@@ -115,7 +120,7 @@ again:
                                        if (Z_TYPE_P(tmp) != IS_OBJECT) {
                                                /* for safety - avoid loop */
                                                convert_to_boolean(tmp);
-                                               result = Z_LVAL_P(tmp);
+                                               result = Z_TYPE_P(tmp) == IS_TRUE;
                                                zval_ptr_dtor(tmp);
                                                break;
                                        }

diff --git a/Zend/zend_execute_API.c b/Zend/zend_execute_API.c
index a7d7a948a5152e18f7c1015f0de9687cf8cd8493..7041563704f8c2556a876cc5e3537f4f3c800af9 100644 (file)
--- a/Zend/zend_execute_API.c
+++ b/Zend/zend_execute_API.c
@@ -685,7 +685,12 @@ ZEND_API int zval_update_constant_ex(zval *p, zend_bool inline_change, zend_clas
                                case IS_STRING:
                                        ret = zend_symtable_update_current_key_ex(Z_ARRVAL_P(p), Z_STR_P(const_value), HASH_UPDATE_KEY_IF_BEFORE);
                                        break;
-                               case IS_BOOL:
+                               case IS_FALSE:
+                                       ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 0, HASH_UPDATE_KEY_IF_BEFORE);
+                                       break;
+                               case IS_TRUE:
+                                       ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, 1, HASH_UPDATE_KEY_IF_BEFORE);
+                                       break;
                                case IS_LONG:
                                        ret = zend_hash_update_current_key_ex(Z_ARRVAL_P(p), HASH_KEY_IS_LONG, NULL, Z_LVAL_P(const_value), HASH_UPDATE_KEY_IF_BEFORE);
                                        break;

diff --git a/Zend/zend_language_parser.y b/Zend/zend_language_parser.y
index ace4f6c284a3fbfa9d10b0b73379b9c26ce03a1e..6f39f4d63faec06f92f27f68bec403eff3786834 100644 (file)
--- a/Zend/zend_language_parser.y
+++ b/Zend/zend_language_parser.y
@@ -839,7 +839,7 @@ expr_without_variable:
        |       T_STRING_CAST expr      { zend_do_cast(&$$, &$2, IS_STRING TSRMLS_CC); }
        |       T_ARRAY_CAST expr       { zend_do_cast(&$$, &$2, IS_ARRAY TSRMLS_CC); }
        |       T_OBJECT_CAST expr      { zend_do_cast(&$$, &$2, IS_OBJECT TSRMLS_CC); }
-       |       T_BOOL_CAST expr        { zend_do_cast(&$$, &$2, IS_BOOL TSRMLS_CC); }
+       |       T_BOOL_CAST expr        { zend_do_cast(&$$, &$2, _IS_BOOL TSRMLS_CC); }
        |       T_UNSET_CAST expr       { zend_do_cast(&$$, &$2, IS_NULL TSRMLS_CC); }
        |       T_EXIT exit_expr        { zend_do_exit(&$$, &$2 TSRMLS_CC); }
        |       '@' { zend_do_begin_silence(&$1 TSRMLS_CC); } expr { zend_do_end_silence(&$1 TSRMLS_CC); $$ = $3; }

diff --git a/Zend/zend_list.c b/Zend/zend_list.c
index c9b9ff66dfc8f5ca893687fa43c2800037b18dc1..7892b7057cfe0719cc22b24996ead7ad361221bf 100644 (file)
--- a/Zend/zend_list.c
+++ b/Zend/zend_list.c
@@ -37,6 +37,9 @@ ZEND_API zval *zend_list_insert(void *ptr, int type TSRMLS_DC)
        zval zv;
 
        index = zend_hash_next_free_element(&EG(regular_list));
+       if (index == 0) {
+               index = 1;
+       }
        ZVAL_NEW_RES(&zv, index, ptr, type);
        return zend_hash_index_update(&EG(regular_list), index, &zv);
 }

diff --git a/Zend/zend_object_handlers.c b/Zend/zend_object_handlers.c
index a41452dae88aecd3685fb3280ea68efcf1cff657..64ef01b9778d9e7c12971e4a01c31246e88a3411 100644 (file)
--- a/Zend/zend_object_handlers.c
+++ b/Zend/zend_object_handlers.c
@@ -1570,7 +1570,7 @@ ZEND_API int zend_std_cast_object_tostring(zval *readobj, zval *writeobj, int ty
                                }
                        }
                        return FAILURE;
-               case IS_BOOL:
+               case _IS_BOOL:
                        ZVAL_BOOL(writeobj, 1);
                        return SUCCESS;
                case IS_LONG:

diff --git a/Zend/zend_operators.c b/Zend/zend_operators.c
index 7d4518adbc80bb83543ac2e5ebb56be9985f528f..a72a75b1f347c001634b1508cf958820a24bccee 100644 (file)
--- a/Zend/zend_operators.c
+++ b/Zend/zend_operators.c
@@ -204,8 +204,12 @@ try_again:
                                STR_RELEASE(str);
                                break;
                        }
-               case IS_BOOL:
-                       Z_TYPE_INFO_P(op) = IS_LONG;
+               case IS_NULL:
+               case IS_FALSE:
+                       ZVAL_LONG(op, 0);
+                       break;
+               case IS_TRUE:
+                       ZVAL_LONG(op, 1);
                        break;
                case IS_RESOURCE:
                        {
@@ -217,9 +221,6 @@ try_again:
                case IS_OBJECT:
                        convert_to_long_base(op, 10);
                        break;
-               case IS_NULL:
-                       ZVAL_LONG(op, 0);
-                       break;
        }
 }
 /* }}} */
@@ -240,16 +241,17 @@ try_again:
                                        (op) = &(holder);                                                                               \
                                        break;                                                                                                  \
                                }                                                                                                                       \
-                       case IS_BOOL:                                                                                                   \
-                               ZVAL_LONG(&(holder), Z_LVAL_P(op));                                                     \
+                       case IS_NULL:                                                                                                   \
+                       case IS_FALSE:                                                                                                  \
+                               ZVAL_LONG(&(holder), 0);                                                                        \
                                (op) = &(holder);                                                                                       \
                                break;                                                                                                          \
-                       case IS_RESOURCE:                                                                                               \
-                               ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op));                                       \
+                       case IS_TRUE:                                                                                                   \
+                               ZVAL_LONG(&(holder), 1);                                                                        \
                                (op) = &(holder);                                                                                       \
                                break;                                                                                                          \
-                       case IS_NULL:                                                                                                   \
-                               ZVAL_LONG(&(holder), 0);                                                                        \
+                       case IS_RESOURCE:                                                                                               \
+                               ZVAL_LONG(&(holder), Z_RES_HANDLE_P(op));                                       \
                                (op) = &(holder);                                                                                       \
                                break;                                                                                                          \
                        case IS_OBJECT:                                                                                                 \
@@ -271,7 +273,11 @@ try_again:
        } else if (Z_TYPE_P(op) != IS_LONG) {                                                   \
                switch (Z_TYPE_P(op)) {                                                                         \
                        case IS_NULL:                                                                                   \
-                               ZVAL_LONG(&holder, 0);                                                          \
+                       case IS_FALSE:                                                                                  \
+                               ZVAL_LONG(&(holder), 0);                                                        \
+                               break;                                                                                          \
+                       case IS_TRUE:                                                                                   \
+                               ZVAL_LONG(&(holder), 1);                                                        \
                                break;                                                                                          \
                        case IS_DOUBLE:                                                                                 \
                                ZVAL_LONG(&holder, zend_dval_to_lval(Z_DVAL_P(op)));\
@@ -286,9 +292,6 @@ try_again:
                                ZVAL_DUP(&(holder), (op));                                                      \
                                convert_to_long_base(&(holder), 10);                            \
                                break;                                                                                          \
-                       case IS_BOOL:                                                                                   \
-                               ZVAL_LONG(&(holder), Z_LVAL_P(op));                                     \
-                               break;                                                                                          \
                        case IS_RESOURCE:                                                                               \
                                ZVAL_LONG(&holder, Z_RES_HANDLE_P(op));                         \
                                break;                                                                                          \
@@ -306,7 +309,8 @@ try_again:
 #define zendi_convert_to_boolean(op, holder, result)                           \
        if (op==result) {                                                                                               \
                convert_to_boolean(op);                                                                         \
-       } else if (Z_TYPE_P(op) != IS_BOOL) {                                                   \
+       } else if (Z_TYPE_P(op) != IS_FALSE &&                                                  \
+                  Z_TYPE_P(op) != IS_TRUE) {                                                   \
                switch (Z_TYPE_P(op)) {                                                                         \
                        case IS_NULL:                                                                                   \
                                ZVAL_BOOL(&holder, 0);                                                          \
@@ -378,15 +382,18 @@ ZEND_API void convert_to_long_base(zval *op, int base) /* {{{ */
 
        switch (Z_TYPE_P(op)) {
                case IS_NULL:
+               case IS_FALSE:
                        ZVAL_LONG(op, 0);
                        break;
+               case IS_TRUE:
+                       ZVAL_LONG(op, 1);
+                       break;
                case IS_RESOURCE: {
                                long l = Z_RES_HANDLE_P(op);
                                zval_ptr_dtor(op);
                                ZVAL_LONG(op, l);
                        }
                        /* break missing intentionally */
-               case IS_BOOL:
                        Z_TYPE_INFO_P(op) = IS_LONG;
                        break;
                case IS_LONG:
@@ -439,15 +446,18 @@ ZEND_API void convert_to_double(zval *op) /* {{{ */
 
        switch (Z_TYPE_P(op)) {
                case IS_NULL:
+               case IS_FALSE:
                        ZVAL_DOUBLE(op, 0.0);
                        break;
+               case IS_TRUE:
+                       ZVAL_DOUBLE(op, 1.0);
+                       break;
                case IS_RESOURCE: {
                                double d = (double) Z_RES_HANDLE_P(op);
                                zval_ptr_dtor(op);
                                ZVAL_DOUBLE(op, d);
                        }
                        break;
-               case IS_BOOL:
                case IS_LONG:
                        ZVAL_DOUBLE(op, (double) Z_LVAL_P(op));
                        break;
@@ -518,7 +528,8 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
        int tmp;
 
        switch (Z_TYPE_P(op)) {
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                        break;
                case IS_NULL:
                        ZVAL_BOOL(op, 0);
@@ -559,10 +570,10 @@ ZEND_API void convert_to_boolean(zval *op) /* {{{ */
                                zval dst;
                                TSRMLS_FETCH();
 
-                               convert_object_to_type(op, &dst, IS_BOOL, convert_to_boolean);
+                               convert_object_to_type(op, &dst, _IS_BOOL, convert_to_boolean);
                                zval_dtor(op);
 
-                               if (Z_TYPE(dst) == IS_BOOL) {
+                               if (Z_TYPE(dst) == IS_FALSE || Z_TYPE(dst) == IS_TRUE) {
                                        ZVAL_COPY_VALUE(op, &dst);
                                } else {
                                        ZVAL_BOOL(op, 1);
@@ -589,20 +600,16 @@ ZEND_API void _convert_to_string(zval *op ZEND_FILE_LINE_DC) /* {{{ */
        double dval;
 
        switch (Z_TYPE_P(op)) {
-               case IS_NULL: {
+               case IS_NULL:
+               case IS_FALSE: {
                        TSRMLS_FETCH();
                        ZVAL_EMPTY_STRING(op);
                        break;
                }
-               case IS_STRING:
+               case IS_TRUE:
+                       ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
                        break;
-               case IS_BOOL:
-                       if (Z_LVAL_P(op)) {
-                               ZVAL_NEW_STR(op, STR_INIT("1", 1, 0));
-                       } else {
-                               TSRMLS_FETCH();
-                               ZVAL_EMPTY_STRING(op);
-                       }
+               case IS_STRING:
                        break;
                case IS_RESOURCE: {
                        long tmp = Z_RES_HANDLE_P(op);
@@ -812,10 +819,12 @@ ZEND_API long _zval_get_long_func(zval *op TSRMLS_DC) /* {{{ */
 try_again:
        switch (Z_TYPE_P(op)) {
                case IS_NULL:
+               case IS_FALSE:
                        return 0;
+               case IS_TRUE:
+                       return 1;
                case IS_RESOURCE:
                        return Z_RES_HANDLE_P(op);
-               case IS_BOOL:
                case IS_LONG:
                        return Z_LVAL_P(op);
                case IS_DOUBLE:
@@ -850,10 +859,12 @@ ZEND_API double _zval_get_double_func(zval *op TSRMLS_DC) /* {{{ */
 try_again:
        switch (Z_TYPE_P(op)) {
                case IS_NULL:
+               case IS_FALSE:
                        return 0.0;
+               case IS_TRUE:
+                       return 1.0;
                case IS_RESOURCE:
                        return (double) Z_RES_HANDLE_P(op);
-               case IS_BOOL:
                case IS_LONG:
                        return (double) Z_LVAL_P(op);
                case IS_DOUBLE:
@@ -890,15 +901,12 @@ ZEND_API zend_string *_zval_get_string_func(zval *op TSRMLS_DC) /* {{{ */
 try_again:
        switch (Z_TYPE_P(op)) {
                case IS_NULL:
+               case IS_FALSE:
                        return STR_EMPTY_ALLOC();
                case IS_STRING:
                        return STR_COPY(Z_STR_P(op));
-               case IS_BOOL:
-                       if (Z_BVAL_P(op)) {
-                               return STR_INIT("1", 1, 0);
-                       } else {
-                               return STR_EMPTY_ALLOC();
-                       }
+               case IS_TRUE:
+                       return STR_INIT("1", 1, 0);
                case IS_RESOURCE: {
                        char buf[sizeof("Resource id #") + MAX_LENGTH_OF_LONG];
                        int len;
@@ -1309,17 +1317,18 @@ ZEND_API int boolean_xor_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
        zval op1_copy, op2_copy;
        long op1_lval;
 
-       if (Z_TYPE_P(op1) != IS_BOOL || Z_TYPE_P(op2) != IS_BOOL) {
+       if ((Z_TYPE_P(op1) != IS_FALSE && Z_TYPE_P(op1) != IS_TRUE) ||
+           (Z_TYPE_P(op2) != IS_FALSE && Z_TYPE_P(op2) != IS_TRUE)) {
                ZEND_TRY_BINARY_OBJECT_OPERATION(ZEND_BOOL_XOR);
 
                zendi_convert_to_boolean(op1, op1_copy, result);
-               op1_lval = Z_LVAL_P(op1);
+               op1_lval = Z_TYPE_P(op1) == IS_TRUE;
                zendi_convert_to_boolean(op2, op2_copy, result);
        } else {
-               op1_lval = Z_LVAL_P(op1);
+               op1_lval = Z_TYPE_P(op1) == IS_TRUE;
        }
 
-       ZVAL_BOOL(result, op1_lval ^ Z_LVAL_P(op2));
+       ZVAL_BOOL(result, op1_lval ^ (Z_TYPE_P(op2) == IS_TRUE));
        return SUCCESS;
 }
 /* }}} */
@@ -1328,13 +1337,17 @@ ZEND_API int boolean_not_function(zval *result, zval *op1 TSRMLS_DC) /* {{{ */
 {
        zval op1_copy;
 
-       if (Z_TYPE_P(op1) != IS_BOOL) {
+       if (Z_TYPE_P(op1) == IS_FALSE) {
+               ZVAL_TRUE(result);
+       } else if (Z_TYPE_P(op1) == IS_TRUE) {
+               ZVAL_FALSE(result);
+       } else {
                ZEND_TRY_UNARY_OBJECT_OPERATION(ZEND_BOOL_NOT);
 
                zendi_convert_to_boolean(op1, op1_copy, result);
-       }
 
-       ZVAL_BOOL(result, !Z_LVAL_P(op1));
+               ZVAL_BOOL(result, Z_TYPE_P(op1) == IS_FALSE);
+       }
        return SUCCESS;
 }
 /* }}} */
@@ -1741,19 +1754,19 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
                                return SUCCESS;
 
                        case TYPE_PAIR(IS_NULL, IS_NULL):
+                       case TYPE_PAIR(IS_NULL, IS_FALSE):
+                       case TYPE_PAIR(IS_FALSE, IS_NULL):
+                       case TYPE_PAIR(IS_FALSE, IS_FALSE):
+                       case TYPE_PAIR(IS_TRUE, IS_TRUE):
                                ZVAL_LONG(result, 0);
                                return SUCCESS;
 
-                       case TYPE_PAIR(IS_NULL, IS_BOOL):
-                               ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
-                               return SUCCESS;
-
-                       case TYPE_PAIR(IS_BOOL, IS_NULL):
-                               ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
+                       case TYPE_PAIR(IS_NULL, IS_TRUE):
+                               ZVAL_LONG(result, -1);
                                return SUCCESS;
 
-                       case TYPE_PAIR(IS_BOOL, IS_BOOL):
-                               ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+                       case TYPE_PAIR(IS_TRUE, IS_NULL):
+                               ZVAL_LONG(result, 1);
                                return SUCCESS;
 
                        case TYPE_PAIR(IS_STRING, IS_STRING):
@@ -1803,7 +1816,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
                                                return ret;
                                        } else if (Z_TYPE_P(op2) != IS_OBJECT && Z_OBJ_HT_P(op1)->cast_object) {
                                                ZVAL_UNDEF(&tmp_free);
-                                               if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, Z_TYPE_P(op2) TSRMLS_CC) == FAILURE) {
+                                               if (Z_OBJ_HT_P(op1)->cast_object(op1, &tmp_free, ((Z_TYPE_P(op2) == IS_FALSE || Z_TYPE_P(op2) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op2)) TSRMLS_CC) == FAILURE) {
                                                        ZVAL_LONG(result, 1);
                                                        zend_free_obj_get_result(&tmp_free TSRMLS_CC);
                                                        return SUCCESS;
@@ -1822,7 +1835,7 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
                                                return ret;
                                        } else if (Z_TYPE_P(op1) != IS_OBJECT && Z_OBJ_HT_P(op2)->cast_object) {
                                                ZVAL_UNDEF(&tmp_free);
-                                               if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, Z_TYPE_P(op1) TSRMLS_CC) == FAILURE) {
+                                               if (Z_OBJ_HT_P(op2)->cast_object(op2, &tmp_free, ((Z_TYPE_P(op1) == IS_FALSE || Z_TYPE_P(op1) == IS_TRUE) ? _IS_BOOL : Z_TYPE_P(op1)) TSRMLS_CC) == FAILURE) {
                                                        ZVAL_LONG(result, -1);
                                                        zend_free_obj_get_result(&tmp_free TSRMLS_CC);
                                                        return SUCCESS;
@@ -1840,21 +1853,21 @@ ZEND_API int compare_function(zval *result, zval *op1, zval *op2 TSRMLS_DC) /* {
                                } else if (Z_ISREF_P(op2)) {
                                        op2 = Z_REFVAL_P(op2);
                                } else if (!converted) {
-                                       if (Z_TYPE_P(op1) == IS_NULL) {
+                                       if (Z_TYPE_P(op1) == IS_NULL || Z_TYPE_P(op1) == IS_FALSE) {
                                                zendi_convert_to_boolean(op2, op2_copy, result);
-                                               ZVAL_LONG(result, Z_LVAL_P(op2) ? -1 : 0);
+                                               ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? -1 : 0);
                                                return SUCCESS;
-                                       } else if (Z_TYPE_P(op2) == IS_NULL) {
+                                       } else if (Z_TYPE_P(op2) == IS_NULL || Z_TYPE_P(op2) == IS_FALSE) {
                                                zendi_convert_to_boolean(op1, op1_copy, result);
-                                               ZVAL_LONG(result, Z_LVAL_P(op1) ? 1 : 0);
+                                               ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 1 : 0);
                                                return SUCCESS;
-                                       } else if (Z_TYPE_P(op1) == IS_BOOL) {
+                                       } else if (Z_TYPE_P(op1) == IS_TRUE) {
                                                zendi_convert_to_boolean(op2, op2_copy, result);
-                                               ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+                                               ZVAL_LONG(result, (Z_TYPE_P(op2) == IS_TRUE) ? 0 : 1);
                                                return SUCCESS;
-                                       } else if (Z_TYPE_P(op2) == IS_BOOL) {
+                                       } else if (Z_TYPE_P(op2) == IS_TRUE) {
                                                zendi_convert_to_boolean(op1, op1_copy, result);
-                                               ZVAL_LONG(result, ZEND_NORMALIZE_BOOL(Z_LVAL_P(op1) - Z_LVAL_P(op2)));
+                                               ZVAL_LONG(result, (Z_TYPE_P(op1) == IS_TRUE) ? 0 : -1);
                                                return SUCCESS;
                                        } else {
                                                zendi_convert_scalar_to_number(op1, op1_copy, result);
@@ -1895,7 +1908,7 @@ static int hash_zval_identical_function(zval *z1, zval *z2) /* {{{ */
        if (is_identical_function(&result, z1, z2 TSRMLS_CC)==FAILURE) {
                return 1;
        }
-       return !Z_LVAL(result);
+       return Z_TYPE(result) != IS_TRUE;
 }
 /* }}} */
 
@@ -1907,9 +1920,10 @@ ZEND_API int is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
        }
        switch (Z_TYPE_P(op1)) {
                case IS_NULL:
+               case IS_FALSE:
+               case IS_TRUE:
                        ZVAL_BOOL(result, 1);
                        break;
-               case IS_BOOL:
                case IS_LONG:
                        ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
                        break;
@@ -1951,7 +1965,7 @@ ZEND_API int is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS
        if (is_identical_function(result, op1, op2 TSRMLS_CC) == FAILURE) {
                return FAILURE;
        }
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
+       ZVAL_BOOL(result, Z_TYPE_P(result) != IS_TRUE);
        return SUCCESS;
 }
 /* }}} */
@@ -2242,7 +2256,7 @@ ZEND_API int decrement_function(zval *op1) /* {{{ */
 ZEND_API int zval_is_true(zval *op) /* {{{ */
 {
        convert_to_boolean(op);
-       return (Z_LVAL_P(op) ? 1 : 0);
+       return (Z_TYPE_P(op) == IS_TRUE ? 1 : 0);
 }
 /* }}} */
 

diff --git a/Zend/zend_operators.h b/Zend/zend_operators.h
index 93a79705c8e5eaffaec159d986f6c052746d2901..b7c8c7e7b2c831aa8a92d9a853703a4b27caa17d 100644 (file)
--- a/Zend/zend_operators.h
+++ b/Zend/zend_operators.h
@@ -400,7 +400,7 @@ ZEND_API void zend_locale_sprintf_double(zval *op ZEND_FILE_LINE_DC);
 END_EXTERN_C()
 
 #define convert_to_ex_master(pzv, lower_type, upper_type)      \
-       if (Z_TYPE_P(pzv)!=IS_##upper_type) {                                   \
+       if (Z_TYPE_P(pzv)!=upper_type) {                                        \
                SEPARATE_ZVAL_IF_NOT_REF(pzv);                                          \
                convert_to_##lower_type(pzv);                                           \
        }
@@ -417,7 +417,7 @@ END_EXTERN_C()
                        case IS_DOUBLE:                                         \
                                convert_to_double(pzv);                 \
                                break;                                                  \
-                       case IS_BOOL:                                           \
+                       case _IS_BOOL:                                          \
                                convert_to_boolean(pzv);                \
                                break;                                                  \
                        case IS_ARRAY:                                          \
@@ -441,13 +441,13 @@ END_EXTERN_C()
                convert_to_explicit_type(pzv, str_type);        \
        }
 
-#define convert_to_boolean_ex(pzv)     convert_to_ex_master(pzv, boolean, BOOL)
-#define convert_to_long_ex(pzv)                convert_to_ex_master(pzv, long, LONG)
-#define convert_to_double_ex(pzv)      convert_to_ex_master(pzv, double, DOUBLE)
-#define convert_to_string_ex(pzv)      convert_to_ex_master(pzv, string, STRING)
-#define convert_to_array_ex(pzv)       convert_to_ex_master(pzv, array, ARRAY)
-#define convert_to_object_ex(pzv)      convert_to_ex_master(pzv, object, OBJECT)
-#define convert_to_null_ex(pzv)                convert_to_ex_master(pzv, null, NULL)
+#define convert_to_boolean_ex(pzv)     convert_to_ex_master(pzv, boolean, _IS_BOOL)
+#define convert_to_long_ex(pzv)                convert_to_ex_master(pzv, long, IS_LONG)
+#define convert_to_double_ex(pzv)      convert_to_ex_master(pzv, double, IS_DOUBLE)
+#define convert_to_string_ex(pzv)      convert_to_ex_master(pzv, string, IS_STRING)
+#define convert_to_array_ex(pzv)       convert_to_ex_master(pzv, array, IS_ARRAY)
+#define convert_to_object_ex(pzv)      convert_to_ex_master(pzv, object, IS_OBJECT)
+#define convert_to_null_ex(pzv)                convert_to_ex_master(pzv, null, IS_NULL)
 
 #define convert_scalar_to_number_ex(pzv)                                                       \
        if (Z_TYPE_P(pzv)!=IS_LONG && Z_TYPE_P(pzv)!=IS_DOUBLE) {               \
@@ -816,7 +816,7 @@ static zend_always_inline int fast_mod_function(zval *result, zval *op1, zval *o
        return mod_function(result, op1, op2 TSRMLS_CC);
 }
 
-static zend_always_inline int fast_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline int fast_equal_check_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
@@ -835,61 +835,115 @@ static zend_always_inline int fast_equal_function(zval *result, zval *op1, zval
        return Z_LVAL_P(result) == 0;
 }
 
-static zend_always_inline int fast_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       return Z_LVAL_P(op1) != Z_LVAL_P(op2);
+                       ZVAL_BOOL(result, Z_LVAL_P(op1) == Z_LVAL_P(op2));
+                       return;
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       return ((double)Z_LVAL_P(op1)) != Z_DVAL_P(op2);
+                       ZVAL_BOOL(result, (double)Z_LVAL_P(op1) == Z_DVAL_P(op2));
+                       return;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       return Z_DVAL_P(op1) != Z_DVAL_P(op2);
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) == Z_DVAL_P(op2));
+                       return;
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       return Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2));
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) == ((double)Z_LVAL_P(op2)));
+                       return;
                }
        }
        compare_function(result, op1, op2 TSRMLS_CC);
-       return Z_LVAL_P(result) != 0;
+       ZVAL_BOOL(result, Z_LVAL_P(result) == 0);
 }
 
-static zend_always_inline int fast_is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_not_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       return Z_LVAL_P(op1) < Z_LVAL_P(op2);
+                       ZVAL_BOOL(result, Z_LVAL_P(op1) != Z_LVAL_P(op2));
+                       return;
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       return ((double)Z_LVAL_P(op1)) < Z_DVAL_P(op2);
+                       ZVAL_BOOL(result, (double)Z_LVAL_P(op1) != Z_DVAL_P(op2));
+                       return;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       return Z_DVAL_P(op1) < Z_DVAL_P(op2);
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) != Z_DVAL_P(op2));
+                       return;
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       return Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2));
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) != ((double)Z_LVAL_P(op2)));
+                       return;
                }
        }
        compare_function(result, op1, op2 TSRMLS_CC);
-       return Z_LVAL_P(result) < 0;
+       ZVAL_BOOL(result, Z_LVAL_P(result) != 0);
 }
 
-static zend_always_inline int fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+static zend_always_inline void fast_is_smaller_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
 {
        if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       return Z_LVAL_P(op1) <= Z_LVAL_P(op2);
+                       ZVAL_BOOL(result, Z_LVAL_P(op1) < Z_LVAL_P(op2));
+                       return;
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       return ((double)Z_LVAL_P(op1)) <= Z_DVAL_P(op2);
+                       ZVAL_BOOL(result, (double)Z_LVAL_P(op1) < Z_DVAL_P(op2));
+                       return;
                }
        } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
                if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
-                       return Z_DVAL_P(op1) <= Z_DVAL_P(op2);
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) < Z_DVAL_P(op2));
+                       return;
                } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
-                       return Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2));
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) < ((double)Z_LVAL_P(op2)));
+                       return;
                }
        }
        compare_function(result, op1, op2 TSRMLS_CC);
-       return Z_LVAL_P(result) <= 0;
+       ZVAL_BOOL(result, Z_LVAL_P(result) < 0);
+}
+
+static zend_always_inline void fast_is_smaller_or_equal_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+{
+       if (EXPECTED(Z_TYPE_P(op1) == IS_LONG)) {
+               if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
+                       ZVAL_BOOL(result, Z_LVAL_P(op1) <= Z_LVAL_P(op2));
+                       return;
+               } else if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
+                       ZVAL_BOOL(result, (double)Z_LVAL_P(op1) <= Z_DVAL_P(op2));
+                       return;
+               }
+       } else if (EXPECTED(Z_TYPE_P(op1) == IS_DOUBLE)) {
+               if (EXPECTED(Z_TYPE_P(op2) == IS_DOUBLE)) {
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) <= Z_DVAL_P(op2));
+                       return;
+               } else if (EXPECTED(Z_TYPE_P(op2) == IS_LONG)) {
+                       ZVAL_BOOL(result, Z_DVAL_P(op1) <= ((double)Z_LVAL_P(op2)));
+                       return;
+               }
+       }
+       compare_function(result, op1, op2 TSRMLS_CC);
+       ZVAL_BOOL(result, Z_LVAL_P(result) <= 0);
+}
+
+static zend_always_inline void fast_is_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+{
+       if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
+               ZVAL_BOOL(result, 0);
+               return;
+       }
+       is_identical_function(result, op1, op2 TSRMLS_CC);
+}
+
+static zend_always_inline void fast_is_not_identical_function(zval *result, zval *op1, zval *op2 TSRMLS_DC)
+{
+       if (Z_TYPE_P(op1) != Z_TYPE_P(op2)) {
+               ZVAL_BOOL(result, 1);
+               return;
+       }
+       is_identical_function(result, op1, op2 TSRMLS_CC);
+       ZVAL_BOOL(result, Z_TYPE_P(result) != IS_TRUE);
 }
 
 #define ZEND_TRY_BINARY_OBJECT_OPERATION(opcode)                                                  \

diff --git a/Zend/zend_types.h b/Zend/zend_types.h
index 423672d52d09a4926c67f0f4c4e4cec6d8ec0135..3a339e792f58829893c4dc7b720b2a56524ebf00 100644 (file)
--- a/Zend/zend_types.h
+++ b/Zend/zend_types.h
@@ -204,27 +204,29 @@ struct _zend_ast_ref {
 /* regular data types */
 #define IS_UNDEF                                       0
 #define IS_NULL                                                1
-#define IS_BOOL                                                2
-#define IS_LONG                                                3
-#define IS_DOUBLE                                      4
-#define IS_STRING                                      5
-#define IS_ARRAY                                       6
-#define IS_OBJECT                                      7
-#define IS_RESOURCE                                    8
-#define IS_REFERENCE                           9
+#define IS_FALSE                                       2
+#define IS_TRUE                                                3
+#define IS_LONG                                                4
+#define IS_DOUBLE                                      5
+#define IS_STRING                                      6
+#define IS_ARRAY                                       7
+#define IS_OBJECT                                      8
+#define IS_RESOURCE                                    9
+#define IS_REFERENCE                           10
 
 /* constant expressions */
-#define IS_CONSTANT                                    10
-#define IS_CONSTANT_ARRAY                      11
-#define IS_CONSTANT_AST                                12
+#define IS_CONSTANT                                    11
+#define IS_CONSTANT_ARRAY                      12
+#define IS_CONSTANT_AST                                13
 
-/* type hinting */
-#define IS_CALLABLE                                    13
+/* fake types */
+#define _IS_BOOL                                       14
+#define IS_CALLABLE                                    15
 
 /* internal types */
-#define IS_INDIRECT                    14
-#define IS_STR_OFFSET                          15
-#define IS_PTR                                         16
+#define IS_INDIRECT                    16
+#define IS_STR_OFFSET                          17
+#define IS_PTR                                         18
 
 static inline zend_uchar zval_get_type(const zval* pz) {
        return pz->u1.v.type;
@@ -369,9 +371,6 @@ static inline zend_uchar zval_get_type(const zval* pz) {
 #define Z_ISREF(zval)                          (Z_TYPE(zval) == IS_REFERENCE)
 #define Z_ISREF_P(zval_p)                      Z_ISREF(*(zval_p))
 
-#define Z_BVAL(zval)                           (zend_bool)(zval).value.lval
-#define Z_BVAL_P(zval_p)                       Z_LVAL(*(zval_p))
-
 #define Z_LVAL(zval)                           (zval).value.lval
 #define Z_LVAL_P(zval_p)                       Z_LVAL(*(zval_p))
 
@@ -461,10 +460,17 @@ static inline zend_uchar zval_get_type(const zval* pz) {
                Z_TYPE_INFO_P(z) = IS_NULL;             \
        } while (0)
 
+#define ZVAL_FALSE(z) do {                             \
+               Z_TYPE_INFO_P(z) = IS_FALSE;    \
+       } while (0)
+
+#define ZVAL_TRUE(z) do {                              \
+               Z_TYPE_INFO_P(z) = IS_TRUE;             \
+       } while (0)
+
 #define ZVAL_BOOL(z, b) do {                   \
-               zval *__z = (z);                                \
-               Z_LVAL_P(__z) = ((b) != 0);             \
-               Z_TYPE_INFO_P(__z) = IS_BOOL;   \
+               Z_TYPE_INFO_P(z) =                              \
+                       (b) ? IS_TRUE : IS_FALSE;       \
        } while (0)
 
 #define ZVAL_LONG(z, l) {                              \

diff --git a/Zend/zend_variables.c b/Zend/zend_variables.c
index 5557c7beea61d36c6ef8dbedb1a17bf5b1310431..c05e404c06426f3d68f40dbf1ec0ba4ed8ce332c 100644 (file)
--- a/Zend/zend_variables.c
+++ b/Zend/zend_variables.c
@@ -170,7 +170,8 @@ ZEND_API void _zval_internal_dtor(zval *zvalue ZEND_FILE_LINE_DC)
                        }
                case IS_LONG:
                case IS_DOUBLE:
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                case IS_NULL:
                default:
                        break;
@@ -201,7 +202,8 @@ ZEND_API void _zval_internal_dtor_for_ptr(zval *zvalue ZEND_FILE_LINE_DC)
                        }
                case IS_LONG:
                case IS_DOUBLE:
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                case IS_NULL:
                default:
                        break;

diff --git a/Zend/zend_vm_def.h b/Zend/zend_vm_def.h
index 4c4115b76162e3f7055aabde663904b2f61bd9c1..739906f6c8a27eec400bb5c198af61b7097149a7 100644 (file)
--- a/Zend/zend_vm_def.h
+++ b/Zend/zend_vm_def.h
@@ -151,7 +151,7 @@ ZEND_VM_HANDLER(15, ZEND_IS_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
        zend_free_op free_op1, free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
                GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
        FREE_OP1();
@@ -167,10 +167,9 @@ ZEND_VM_HANDLER(16, ZEND_IS_NOT_IDENTICAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R),
                GET_OP2_ZVAL_PTR_DEREF(BP_VAR_R) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        FREE_OP1();
        FREE_OP2();
        CHECK_EXCEPTION();
@@ -184,9 +183,9 @@ ZEND_VM_HANDLER(17, ZEND_IS_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                GET_OP1_ZVAL_PTR(BP_VAR_R),
-               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
        FREE_OP1();
        FREE_OP2();
        CHECK_EXCEPTION();
@@ -200,9 +199,9 @@ ZEND_VM_HANDLER(18, ZEND_IS_NOT_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                GET_OP1_ZVAL_PTR(BP_VAR_R),
-               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
        FREE_OP1();
        FREE_OP2();
        CHECK_EXCEPTION();
@@ -216,9 +215,9 @@ ZEND_VM_HANDLER(19, ZEND_IS_SMALLER, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                GET_OP1_ZVAL_PTR(BP_VAR_R),
-               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
        FREE_OP1();
        FREE_OP2();
        CHECK_EXCEPTION();
@@ -232,9 +231,9 @@ ZEND_VM_HANDLER(20, ZEND_IS_SMALLER_OR_EQUAL, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                GET_OP1_ZVAL_PTR(BP_VAR_R),
-               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+               GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
        FREE_OP1();
        FREE_OP2();
        CHECK_EXCEPTION();
@@ -2107,8 +2106,8 @@ ZEND_VM_HANDLER(43, ZEND_JMPZ, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
        val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
                FREE_OP1();
@@ -2137,8 +2136,8 @@ ZEND_VM_HANDLER(44, ZEND_JMPNZ, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
        val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
                FREE_OP1();
@@ -2167,8 +2166,8 @@ ZEND_VM_HANDLER(45, ZEND_JMPZNZ, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
        val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                FREE_OP1();
@@ -2201,8 +2200,8 @@ ZEND_VM_HANDLER(46, ZEND_JMPZ_EX, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
        val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                FREE_OP1();
@@ -2231,8 +2230,8 @@ ZEND_VM_HANDLER(47, ZEND_JMPNZ_EX, CONST|TMP|VAR|CV, ANY)
        SAVE_OPLINE();
        val = GET_OP1_ZVAL_PTR_DEREF(BP_VAR_R);
 
-       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (OP1_TYPE == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                FREE_OP1();
@@ -3448,9 +3447,9 @@ ZEND_VM_HANDLER(48, ZEND_CASE, CONST|TMP|VAR|CV, CONST|TMP|VAR|CV)
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                GET_OP1_ZVAL_PTR(BP_VAR_R),
-                                GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC));
+       fast_equal_function(result,
+                GET_OP1_ZVAL_PTR(BP_VAR_R),
+                GET_OP2_ZVAL_PTR(BP_VAR_R) TSRMLS_CC);
 
        FREE_OP2();
        CHECK_EXCEPTION();
@@ -3709,7 +3708,6 @@ ZEND_VM_C_LABEL(add_again):
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                ZEND_VM_C_GOTO(num_index);
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 ZEND_VM_C_LABEL(num_index):
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -3725,6 +3723,12 @@ ZEND_VM_C_LABEL(str_index):
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                ZEND_VM_C_GOTO(str_index);
+                       case IS_FALSE:
+                               hval = 0;
+                               ZEND_VM_C_GOTO(num_index);
+                       case IS_TRUE:
+                               hval = 1;
+                               ZEND_VM_C_GOTO(num_index);
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                ZEND_VM_C_GOTO(add_again);
@@ -3797,7 +3801,7 @@ ZEND_VM_HANDLER(21, ZEND_CAST, CONST|TMP|VAR|CV, ANY)
 
                        ZVAL_NULL(result);
                        break;
-               case IS_BOOL:
+               case _IS_BOOL:
                        ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
                        break;
                case IS_LONG:
@@ -4067,10 +4071,9 @@ ZEND_VM_C_LABEL(offset_again):
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+ZEND_VM_C_LABEL(num_index_dim):
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -4078,7 +4081,7 @@ ZEND_VM_C_LABEL(offset_again):
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (OP2_TYPE != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(num_index_dim));
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, ZEND_VM_C_GOTO(numeric_index_dim));
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -4089,7 +4092,7 @@ ZEND_VM_C_LABEL(offset_again):
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-ZEND_VM_C_LABEL(num_index_dim):
+ZEND_VM_C_LABEL(numeric_index_dim):
                                        zend_hash_index_del(ht, hval);
                                        if (OP2_TYPE == IS_CV || OP2_TYPE == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -4098,6 +4101,15 @@ ZEND_VM_C_LABEL(num_index_dim):
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       ZEND_VM_C_GOTO(num_index_dim);
+                               case IS_TRUE:
+                                       hval = 1;
+                                       ZEND_VM_C_GOTO(num_index_dim);
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       ZEND_VM_C_GOTO(num_index_dim);
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        ZEND_VM_C_GOTO(offset_again);
@@ -4575,8 +4587,6 @@ ZEND_VM_C_LABEL(isset_again):
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                ZEND_VM_C_GOTO(num_index_prop);
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 ZEND_VM_C_LABEL(num_index_prop):
@@ -4594,6 +4604,15 @@ ZEND_VM_C_LABEL(str_index_prop):
                                str = STR_EMPTY_ALLOC();
                                ZEND_VM_C_GOTO(str_index_prop);
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               ZEND_VM_C_GOTO(num_index_prop);
+                       case IS_TRUE:
+                               hval = 0;
+                               ZEND_VM_C_GOTO(num_index_prop);
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               ZEND_VM_C_GOTO(num_index_prop);
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                ZEND_VM_C_GOTO(isset_again);

diff --git a/Zend/zend_vm_execute.h b/Zend/zend_vm_execute.h
index 41b907e8028a0be0f2b9afb2584644c30708a378..ad7d4511d7501c533c10da98bf22a251cfd2b375 100644 (file)
--- a/Zend/zend_vm_execute.h
+++ b/Zend/zend_vm_execute.h
@@ -2391,8 +2391,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = opline->op1.zv;
 
-       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -2421,8 +2421,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        SAVE_OPLINE();
        val = opline->op1.zv;
 
-       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -2451,8 +2451,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARG
        SAVE_OPLINE();
        val = opline->op1.zv;
 
-       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -2485,8 +2485,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
        SAVE_OPLINE();
        val = opline->op1.zv;
 
-       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -2515,8 +2515,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        SAVE_OPLINE();
        val = opline->op1.zv;
 
-       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_CONST == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -2797,7 +2797,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CONST_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
                        ZVAL_NULL(result);
                        break;
-               case IS_BOOL:
+               case _IS_BOOL:
                        ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
                        break;
                case IS_LONG:
@@ -3381,7 +3381,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
 
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                opline->op1.zv,
                opline->op2.zv TSRMLS_CC);
 
@@ -3397,10 +3397,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CONST_HANDLER(ZEND_OP
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                opline->op1.zv,
                opline->op2.zv TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
        CHECK_EXCEPTION();
@@ -3414,9 +3413,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                opline->op1.zv,
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -3430,9 +3429,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                opline->op1.zv,
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -3446,9 +3445,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_H
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                opline->op1.zv,
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -3462,9 +3461,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CONST_HANDLER(ZEND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                opline->op1.zv,
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -3837,9 +3836,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CONST_HANDLER(ZEND_OPCODE_HANDLER
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                opline->op1.zv,
-                                opline->op2.zv TSRMLS_CC));
+       fast_equal_function(result,
+                opline->op1.zv,
+                opline->op2.zv TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -3982,7 +3981,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -3998,6 +3996,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -4505,7 +4509,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H
        zend_free_op free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                opline->op1.zv,
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -4521,10 +4525,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                opline->op1.zv,
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -4538,9 +4541,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -4554,9 +4557,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_H
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -4570,9 +4573,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                opline->op1.zv,
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -4586,9 +4589,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_TMP_HANDLER(ZEND_O
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -4793,9 +4796,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_TMP_HANDLER(ZEND_OPCODE_HANDLER_A
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                opline->op1.zv,
-                                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                opline->op1.zv,
+                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -4847,7 +4850,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -4863,6 +4865,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -5183,7 +5191,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H
        zend_free_op free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                opline->op1.zv,
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -5199,10 +5207,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                opline->op1.zv,
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -5216,9 +5223,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -5232,9 +5239,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_H
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -5248,9 +5255,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                opline->op1.zv,
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -5264,9 +5271,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_VAR_HANDLER(ZEND_O
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -5617,9 +5624,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_VAR_HANDLER(ZEND_OPCODE_HANDLER_A
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                opline->op1.zv,
-                                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                opline->op1.zv,
+                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -5671,7 +5678,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -5687,6 +5693,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -6337,7 +6349,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -6353,6 +6364,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -6827,7 +6844,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
 
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                opline->op1.zv,
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -6843,10 +6860,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CONST_CV_HANDLER(ZEND_OPCOD
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                opline->op1.zv,
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
        CHECK_EXCEPTION();
@@ -6860,9 +6876,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -6876,9 +6892,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HA
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -6892,9 +6908,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HAND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                opline->op1.zv,
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -6908,9 +6924,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CONST_CV_HANDLER(ZEND_OP
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                opline->op1.zv,
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -7168,9 +7184,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CONST_CV_HANDLER(ZEND_OPCODE_HANDLER_AR
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                opline->op1.zv,
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                opline->op1.zv,
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -7221,7 +7237,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -7237,6 +7252,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -7491,8 +7512,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
                zval_dtor(free_op1.var);
@@ -7521,8 +7542,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
                zval_dtor(free_op1.var);
@@ -7551,8 +7572,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                zval_dtor(free_op1.var);
@@ -7585,8 +7606,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        SAVE_OPLINE();
        val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                zval_dtor(free_op1.var);
@@ -7615,8 +7636,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        SAVE_OPLINE();
        val = _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_TMP_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                zval_dtor(free_op1.var);
@@ -7884,7 +7905,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
                        ZVAL_NULL(result);
                        break;
-               case IS_BOOL:
+               case _IS_BOOL:
                        ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
                        break;
                case IS_LONG:
@@ -8518,7 +8539,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                opline->op2.zv TSRMLS_CC);
        zval_dtor(free_op1.var);
@@ -8534,10 +8555,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                opline->op2.zv TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -8551,9 +8571,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -8567,9 +8587,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_H
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -8583,9 +8603,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -8599,9 +8619,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CONST_HANDLER(ZEND_O
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -8967,9 +8987,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                opline->op2.zv TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                opline->op2.zv TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -9020,7 +9040,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -9036,6 +9055,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -9507,7 +9532,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN
        zend_free_op free_op1, free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
@@ -9523,10 +9548,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_dtor(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -9540,9 +9564,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -9556,9 +9580,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -9572,9 +9596,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -9588,9 +9612,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_TMP_HANDLER(ZEND_OPC
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -9795,9 +9819,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -9849,7 +9873,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -9865,6 +9888,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -10185,7 +10214,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN
        zend_free_op free_op1, free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
@@ -10201,10 +10230,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_dtor(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -10218,9 +10246,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -10234,9 +10262,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -10250,9 +10278,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -10266,9 +10294,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_VAR_HANDLER(ZEND_OPC
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -10619,9 +10647,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -10673,7 +10701,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -10689,6 +10716,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -11225,7 +11258,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -11241,6 +11273,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -11697,7 +11735,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
@@ -11713,10 +11751,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -11730,9 +11767,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -11746,9 +11783,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HAND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -11762,9 +11799,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -11778,9 +11815,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_TMP_CV_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_dtor(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -11983,9 +12020,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_TMP_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_tmp(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -12036,7 +12073,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -12052,6 +12088,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -12530,8 +12572,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
@@ -12560,8 +12602,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
@@ -12590,8 +12632,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
@@ -12624,8 +12666,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        SAVE_OPLINE();
        val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
@@ -12654,8 +12696,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        SAVE_OPLINE();
        val = _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC);
 
-       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_VAR == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
                zval_ptr_dtor_nogc(free_op1.var);
@@ -13041,7 +13083,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
                        ZVAL_NULL(result);
                        break;
-               case IS_BOOL:
+               case _IS_BOOL:
                        ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
                        break;
                case IS_LONG:
@@ -13789,7 +13831,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                opline->op2.zv TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
@@ -13805,10 +13847,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                opline->op2.zv TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -13822,9 +13863,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -13838,9 +13879,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_H
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -13854,9 +13895,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -13870,9 +13911,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CONST_HANDLER(ZEND_O
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -15235,9 +15276,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CONST_HANDLER(ZEND_OPCODE_HANDLER_A
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                opline->op2.zv TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                opline->op2.zv TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -15380,7 +15421,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -15396,6 +15436,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -15542,10 +15588,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -15553,7 +15598,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_CONST != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -15564,7 +15609,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -15573,6 +15618,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -15741,8 +15795,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -15760,6 +15812,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -16128,7 +16189,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
        zend_free_op free_op1, free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
@@ -16144,10 +16205,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -16161,9 +16221,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -16177,9 +16237,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -16193,9 +16253,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -16209,9 +16269,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_TMP_HANDLER(ZEND_OPC
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -17435,9 +17495,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -17489,7 +17549,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -17505,6 +17564,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -17579,10 +17644,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -17590,7 +17654,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_TMP_VAR != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -17601,7 +17665,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -17610,6 +17674,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -17699,8 +17772,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -17718,6 +17789,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -18088,7 +18168,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
        zend_free_op free_op1, free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
@@ -18104,10 +18184,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -18121,9 +18200,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -18137,9 +18216,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HAN
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -18153,9 +18232,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -18169,9 +18248,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_VAR_HANDLER(ZEND_OPC
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -19605,9 +19684,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARG
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -19659,7 +19738,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -19675,6 +19753,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -19821,10 +19905,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -19832,7 +19915,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_VAR != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -19843,7 +19926,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -19852,6 +19935,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -20020,8 +20112,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -20039,6 +20129,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -21082,7 +21181,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -21098,6 +21196,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -21578,7 +21682,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
        zend_free_op free_op1;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
@@ -21594,10 +21698,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_var_deref(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -21611,9 +21714,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -21627,9 +21730,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HAND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -21643,9 +21746,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -21659,9 +21762,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_VAR_CV_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
        zval_ptr_dtor_nogc(free_op1.var);
 
        CHECK_EXCEPTION();
@@ -22940,9 +23043,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_VAR_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_var(opline->op1.var, execute_data, &free_op1 TSRMLS_CC),
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -22993,7 +23096,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -23009,6 +23111,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -23083,10 +23191,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -23094,7 +23201,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_CV != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -23105,7 +23212,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_CV == IS_CV || IS_CV == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -23114,6 +23221,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -23203,8 +23319,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -23222,6 +23336,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -24520,10 +24643,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -24531,7 +24653,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_CONST != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -24542,7 +24664,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -24551,6 +24673,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -24640,8 +24771,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -24659,6 +24788,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -25781,10 +25919,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -25792,7 +25929,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_TMP_VAR != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -25803,7 +25940,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -25812,6 +25949,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -25901,8 +26047,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -25920,6 +26064,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -27044,10 +27197,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -27055,7 +27207,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_VAR != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -27066,7 +27218,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -27075,6 +27227,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -27164,8 +27325,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -27183,6 +27342,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -28816,10 +28984,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -28827,7 +28994,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_CV != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -28838,7 +29005,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_CV == IS_CV || IS_CV == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -28847,6 +29014,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -28936,8 +29112,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -28955,6 +29129,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -29460,8 +29643,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -29490,8 +29673,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               ret = Z_LVAL_P(val);
+       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               ret = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                ret = i_zend_is_true(val TSRMLS_CC);
 
@@ -29520,8 +29703,8 @@ static int ZEND_FASTCALL  ZEND_JMPZNZ_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -29554,8 +29737,8 @@ static int ZEND_FASTCALL  ZEND_JMPZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        SAVE_OPLINE();
        val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -29584,8 +29767,8 @@ static int ZEND_FASTCALL  ZEND_JMPNZ_EX_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        SAVE_OPLINE();
        val = _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC);
 
-       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) == IS_BOOL)) {
-               retval = Z_LVAL_P(val);
+       if (IS_CV == IS_TMP_VAR && EXPECTED(Z_TYPE_P(val) <= IS_TRUE)) {
+               retval = (Z_TYPE_P(val) == IS_TRUE);
        } else {
                retval = i_zend_is_true(val TSRMLS_CC);
 
@@ -29944,7 +30127,7 @@ static int ZEND_FASTCALL  ZEND_CAST_SPEC_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
 
                        ZVAL_NULL(result);
                        break;
-               case IS_BOOL:
+               case _IS_BOOL:
                        ZVAL_BOOL(result, zend_is_true(expr TSRMLS_CC));
                        break;
                case IS_LONG:
@@ -30549,7 +30732,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
 
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                opline->op2.zv TSRMLS_CC);
 
@@ -30565,10 +30748,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CONST_HANDLER(ZEND_OPCOD
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                opline->op2.zv TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
        CHECK_EXCEPTION();
@@ -30582,9 +30764,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -30598,9 +30780,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HA
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -30614,9 +30796,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HAND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -30630,9 +30812,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CONST_HANDLER(ZEND_OP
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               opline->op2.zv TSRMLS_CC));
+               opline->op2.zv TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -31879,9 +32061,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CONST_HANDLER(ZEND_OPCODE_HANDLER_AR
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-                                opline->op2.zv TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+                opline->op2.zv TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -31932,7 +32114,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -31948,6 +32129,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -32094,10 +32281,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -32105,7 +32291,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_CONST != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -32116,7 +32302,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_CONST == IS_CV || IS_CONST == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -32125,6 +32311,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -32293,8 +32488,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -32312,6 +32505,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -32679,7 +32881,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
        zend_free_op free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -32695,10 +32897,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -32712,9 +32913,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -32728,9 +32929,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HAND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -32744,9 +32945,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -32760,9 +32961,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_TMP_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -33870,9 +34071,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_TMP_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-                                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+                _get_zval_ptr_tmp(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_dtor(free_op2.var);
        CHECK_EXCEPTION();
@@ -33924,7 +34125,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -33940,6 +34140,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -34014,10 +34220,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -34025,7 +34230,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_TMP_VAR != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -34036,7 +34241,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_TMP_VAR == IS_CV || IS_TMP_VAR == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -34045,6 +34250,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -34134,8 +34348,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -34153,6 +34365,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -34522,7 +34743,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
        zend_free_op free_op2;
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
@@ -34538,10 +34759,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                _get_zval_ptr_var_deref(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -34555,9 +34775,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -34571,9 +34791,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HAND
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -34587,9 +34807,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLE
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -34603,9 +34823,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_VAR_HANDLER(ZEND_OPCO
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -35922,9 +36142,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_VAR_HANDLER(ZEND_OPCODE_HANDLER_ARGS
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-                                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+                _get_zval_ptr_var(opline->op2.var, execute_data, &free_op2 TSRMLS_CC) TSRMLS_CC);
 
        zval_ptr_dtor_nogc(free_op2.var);
        CHECK_EXCEPTION();
@@ -35976,7 +36196,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -35992,6 +36211,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -36138,10 +36363,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -36149,7 +36373,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_VAR != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -36160,7 +36384,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_VAR == IS_CV || IS_VAR == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -36169,6 +36393,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -36337,8 +36570,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -36356,6 +36587,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;
@@ -37283,7 +37523,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -37299,6 +37538,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -37760,7 +38005,7 @@ static int ZEND_FASTCALL  ZEND_IS_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
 
 
        SAVE_OPLINE();
-       is_identical_function(EX_VAR(opline->result.var),
+       fast_is_identical_function(EX_VAR(opline->result.var),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
@@ -37776,10 +38021,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_IDENTICAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_H
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       is_identical_function(result,
+       fast_is_not_identical_function(result,
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
                _get_zval_ptr_cv_deref_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
-       Z_LVAL_P(result) = !Z_LVAL_P(result);
 
 
        CHECK_EXCEPTION();
@@ -37793,9 +38037,9 @@ static int ZEND_FASTCALL  ZEND_IS_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_A
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
+       fast_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -37809,9 +38053,9 @@ static int ZEND_FASTCALL  ZEND_IS_NOT_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDL
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_not_equal_function(result,
+       fast_not_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -37825,9 +38069,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_function(result,
+       fast_is_smaller_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -37841,9 +38085,9 @@ static int ZEND_FASTCALL  ZEND_IS_SMALLER_OR_EQUAL_SPEC_CV_CV_HANDLER(ZEND_OPCOD
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_is_smaller_or_equal_function(result,
+       fast_is_smaller_or_equal_function(result,
                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+               _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
 
        CHECK_EXCEPTION();
@@ -39005,9 +39249,9 @@ static int ZEND_FASTCALL  ZEND_CASE_SPEC_CV_CV_HANDLER(ZEND_OPCODE_HANDLER_ARGS)
        zval *result = EX_VAR(opline->result.var);
 
        SAVE_OPLINE();
-       ZVAL_BOOL(result, fast_equal_function(result,
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
-                                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC));
+       fast_equal_function(result,
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op1.var TSRMLS_CC),
+                _get_zval_ptr_cv_BP_VAR_R(execute_data, opline->op2.var TSRMLS_CC) TSRMLS_CC);
 
        CHECK_EXCEPTION();
        ZEND_VM_NEXT_OPCODE();
@@ -39058,7 +39302,6 @@ add_again:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index;
                        case IS_LONG:
-                       case IS_BOOL:
                                hval = Z_LVAL_P(offset);
 num_index:
                                zend_hash_index_update(Z_ARRVAL_P(EX_VAR(opline->result.var)), hval, expr_ptr);
@@ -39074,6 +39317,12 @@ str_index:
                        case IS_NULL:
                                str = STR_EMPTY_ALLOC();
                                goto str_index;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index;
+                       case IS_TRUE:
+                               hval = 1;
+                               goto num_index;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto add_again;
@@ -39148,10 +39397,9 @@ offset_again:
                                        hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                        zend_hash_index_del(ht, hval);
                                        break;
-                               case IS_RESOURCE:
-                               case IS_BOOL:
                                case IS_LONG:
                                        hval = Z_LVAL_P(offset);
+num_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        break;
                                case IS_STRING:
@@ -39159,7 +39407,7 @@ offset_again:
                                                if (Z_REFCOUNTED_P(offset)) Z_ADDREF_P(offset);
                                        }
                                        if (IS_CV != IS_CONST) {
-                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto num_index_dim);
+                                               ZEND_HANDLE_NUMERIC_EX(Z_STRVAL_P(offset), Z_STRLEN_P(offset)+1, hval, goto numeric_index_dim);
                                        }
                                        if (ht == &EG(symbol_table).ht) {
                                                zend_delete_global_variable(Z_STR_P(offset) TSRMLS_CC);
@@ -39170,7 +39418,7 @@ offset_again:
                                                zval_ptr_dtor(offset);
                                        }
                                        break;
-num_index_dim:
+numeric_index_dim:
                                        zend_hash_index_del(ht, hval);
                                        if (IS_CV == IS_CV || IS_CV == IS_VAR) {
                                                zval_ptr_dtor(offset);
@@ -39179,6 +39427,15 @@ num_index_dim:
                                case IS_NULL:
                                        zend_hash_del(ht, STR_EMPTY_ALLOC());
                                        break;
+                               case IS_FALSE:
+                                       hval = 0;
+                                       goto num_index_dim;
+                               case IS_TRUE:
+                                       hval = 1;
+                                       goto num_index_dim;
+                               case IS_RESOURCE:
+                                       hval = Z_RES_HANDLE_P(offset);
+                                       goto num_index_dim;
                                case IS_REFERENCE:
                                        offset = Z_REFVAL_P(offset);
                                        goto offset_again;
@@ -39268,8 +39525,6 @@ isset_again:
                        case IS_DOUBLE:
                                hval = zend_dval_to_lval(Z_DVAL_P(offset));
                                goto num_index_prop;
-                       case IS_RESOURCE:
-                       case IS_BOOL:
                        case IS_LONG:
                                hval = Z_LVAL_P(offset);
 num_index_prop:
@@ -39287,6 +39542,15 @@ str_index_prop:
                                str = STR_EMPTY_ALLOC();
                                goto str_index_prop;
                                break;
+                       case IS_FALSE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_TRUE:
+                               hval = 0;
+                               goto num_index_prop;
+                       case IS_RESOURCE:
+                               hval = Z_RES_HANDLE_P(offset);
+                               goto num_index_prop;
                        case IS_REFERENCE:
                                offset = Z_REFVAL_P(offset);
                                goto isset_again;

diff --git a/ext/bz2/bz2_filter.c b/ext/bz2/bz2_filter.c
index b31ab3c261ae0824cb89e92383e7a7871918e4cf..b6d8787274814c5d2f9b52629eb668b838fa1ed8 100644 (file)
--- a/ext/bz2/bz2_filter.c
+++ b/ext/bz2/bz2_filter.c
@@ -358,7 +358,7 @@ static php_stream_filter *php_bz2_filter_create(const char *filtername, zval *fi
                                        zval_copy_ctor(&tmp);
                                        tmp2 = &tmp;
                                        convert_to_boolean_ex(&tmp2);
-                                       data->expect_concatenated = Z_LVAL(tmp);
+                                       data->expect_concatenated = Z_TMP(tmp) == IS_TRUE;
                                        tmpzval = NULL;
                                }
 
@@ -374,7 +374,7 @@ static php_stream_filter *php_bz2_filter_create(const char *filtername, zval *fi
                                zval_copy_ctor(&tmp);
                                tmp2 = &tmp;
                                convert_to_boolean_ex(&tmp2);
-                               data->small_footprint = Z_LVAL(tmp);
+                               data->small_footprint = Z_TYPE(tmp) == IS_TRUE;
                        }
                }
 

diff --git a/ext/date/php_date.c b/ext/date/php_date.c
index a0a189bbe475e01ecf698dfbfdf3b69dad08b3a7..439621f5e515b5876f636e62cb24285d51ccf708 100644 (file)
--- a/ext/date/php_date.c
+++ b/ext/date/php_date.c
@@ -4888,8 +4888,8 @@ static int php_date_period_initialize_from_hash(php_period_obj *period_obj, Hash
 
        ht_entry = zend_hash_str_find(myht, "include_start_date", sizeof("include_start_date")-1);
        if (ht_entry &&
-                       Z_TYPE_P(ht_entry) == IS_BOOL) {
-               period_obj->include_start_date = Z_BVAL_P(ht_entry);
+                       (Z_TYPE_P(ht_entry) == IS_FALSE || Z_TYPE_P(ht_entry) == IS_TRUE)) {
+               period_obj->include_start_date = (Z_TYPE_P(ht_entry) == IS_TRUE);
        } else {
                return 0;
        }

diff --git a/ext/dom/xpath.c b/ext/dom/xpath.c
index 32adfe3b6fc8601aab6e70840bcd56c29ade26bb..8a7bf60f3887e0259b0f79f6c0d3279a48907beb 100644 (file)
--- a/ext/dom/xpath.c
+++ b/ext/dom/xpath.c
@@ -215,8 +215,8 @@ static void dom_xpath_ext_function_php(xmlXPathParserContextPtr ctxt, int nargs,
                                obj = Z_XPATHOBJ_P(&retval);
                                nodep = dom_object_get_node(obj);
                                valuePush(ctxt, xmlXPathNewNodeSet(nodep));
-                       } else if (Z_TYPE(retval) == IS_BOOL) {
-                               valuePush(ctxt, xmlXPathNewBoolean(Z_BVAL(retval)));
+                       } else if (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE) {
+                               valuePush(ctxt, xmlXPathNewBoolean(Z_TYPE(retval) == IS_TRUE));
                        } else if (Z_TYPE(retval) == IS_OBJECT) {
                                php_error_docref(NULL TSRMLS_CC, E_WARNING, "A PHP Object cannot be converted to a XPath-string");
                                valuePush(ctxt, xmlXPathNewString((xmlChar *)""));

diff --git a/ext/ldap/ldap.c b/ext/ldap/ldap.c
index 6e698640f72aeeda636e06a6645f53cadeae97e8..eb7d405b638360df429b581ef9b1750f36169eca 100644 (file)
--- a/ext/ldap/ldap.c
+++ b/ext/ldap/ldap.c
@@ -2118,7 +2118,7 @@ PHP_FUNCTION(ldap_set_option)
                {
                        void *val;
                        convert_to_boolean_ex(newval);
-                       val = Z_LVAL_PP(newval)
+                       val = Z_TYPE_PP(newval) == IS_TRUE
                                ? LDAP_OPT_ON : LDAP_OPT_OFF;
                        if (ldap_set_option(ldap, option, val)) {
                                RETURN_FALSE;
@@ -2165,7 +2165,7 @@ PHP_FUNCTION(ldap_set_option)
                                }
                                if (zend_hash_find(Z_ARRVAL_PP(ctrlval), "iscritical", sizeof("iscritical"), (void **) &val) == SUCCESS) {
                                        convert_to_boolean_ex(val);
-                                       ctrl->ldctl_iscritical = Z_BVAL_PP(val);
+                                       ctrl->ldctl_iscritical = Z_TYPE_PP(val) == IS_TRUE;
                                } else {
                                        ctrl->ldctl_iscritical = 0;
                                }

diff --git a/ext/mysql/php_mysql.c b/ext/mysql/php_mysql.c
index 56dcf7b3731f637e86db4c2b0fb961a401f74ada..9f7f07d0386dd50d7dbbc083f8ef819913f00de5 100644 (file)
--- a/ext/mysql/php_mysql.c
+++ b/ext/mysql/php_mysql.c
@@ -2165,7 +2165,7 @@ static void php_mysql_fetch_hash(INTERNAL_FUNCTION_PARAMETERS, long result_type,
 
 #ifdef ZEND_ENGINE_2
        /* mysqlnd might return FALSE if no more rows */
-       if (into_object && Z_TYPE_P(return_value) != IS_BOOL) {
+       if (into_object && Z_TYPE_P(return_value) != IS_FALSE) {
                zval dataset;
                zend_fcall_info fci;
                zend_fcall_info_cache fcc;

diff --git a/ext/mysqli/mysqli.c b/ext/mysqli/mysqli.c
index c3162f6f8ffa024d4b5790d6078fe93e423f2f12..8f5b5c14e42f9f788bdb459f445b2c15b22b0835 100644 (file)
--- a/ext/mysqli/mysqli.c
+++ b/ext/mysqli/mysqli.c
@@ -425,7 +425,7 @@ static int mysqli_object_has_property(zval *object, zval *member, int has_set_ex
                                zval *value = mysqli_read_property(object, member, BP_VAR_IS, key TSRMLS_CC);
                                if (value != EG(uninitialized_zval_ptr)) {
                                        convert_to_boolean(value);
-                                       ret = Z_BVAL_P(value)? 1:0;
+                                       ret = Z_TYPE_P(value) == IS_TRUE ? 1 : 0;
                                        /* refcount is 0 */
                                        Z_ADDREF_P(value);
                                        zval_ptr_dtor(&value);

diff --git a/ext/opcache/Optimizer/block_pass.c b/ext/opcache/Optimizer/block_pass.c
index 51ab3cd97b994a9c2a2c7c7107a6187fdabbc26e..f108012bbd91bde3ee45ad2a8577403b622e16ab 100644 (file)
--- a/ext/opcache/Optimizer/block_pass.c
+++ b/ext/opcache/Optimizer/block_pass.c
@@ -792,16 +792,28 @@ static void zend_optimize_block(zend_code_block *block, zend_op_array *op_array,
                        opline->opcode == ZEND_IS_NOT_EQUAL ||
                        opline->opcode == ZEND_CASE) {
                        if (ZEND_OP1_TYPE(opline) == IS_CONST &&
-                               Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_BOOL) {
+// TODO: Optimization of comparison with null may be not safe ???
+#if 1
+                               (Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_FALSE ||
+                                Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_TRUE)) {
+#else
+                                Z_TYPE(ZEND_OP1_LITERAL(opline)) <= IS_TRUE) {
+#endif
                                opline->opcode =
-                                       ((opline->opcode != ZEND_IS_NOT_EQUAL) == Z_LVAL(ZEND_OP1_LITERAL(opline)))?
+                                       ((opline->opcode != ZEND_IS_NOT_EQUAL) == ((Z_TYPE(ZEND_OP1_LITERAL(opline))) == IS_TRUE)) ?
                                        ZEND_BOOL : ZEND_BOOL_NOT;
                                COPY_NODE(opline->op1, opline->op2);
                                SET_UNUSED(opline->op2);
                        } else if (ZEND_OP2_TYPE(opline) == IS_CONST &&
-                                          Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_BOOL) {
+// TODO: Optimization of comparison with null may be not safe ???
+#if 1
+                                          (Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_FALSE ||
+                                           Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_TRUE)) {
+#else
+                                           Z_TYPE(ZEND_OP2_LITERAL(opline)) <= IS_TRUE) {
+#endif
                                opline->opcode =
-                                       ((opline->opcode != ZEND_IS_NOT_EQUAL) == Z_LVAL(ZEND_OP2_LITERAL(opline)))?
+                                       ((opline->opcode != ZEND_IS_NOT_EQUAL) == ((Z_TYPE(ZEND_OP2_LITERAL(opline))) == IS_TRUE)) ?
                                        ZEND_BOOL : ZEND_BOOL_NOT;
                                SET_UNUSED(opline->op2);
                        }

diff --git a/ext/opcache/Optimizer/compact_literals.c b/ext/opcache/Optimizer/compact_literals.c
index 04183292d62320939bb9d12c0a945b30b63e0961..8c562f887ae9cfb96a98c0e0d92a8283bd2d333f 100644 (file)
--- a/ext/opcache/Optimizer/compact_literals.c
+++ b/ext/opcache/Optimizer/compact_literals.c
@@ -300,28 +300,27 @@ static void optimizer_compact_literals(zend_op_array *op_array TSRMLS_DC)
                                        }
                                        map[i] = l_null;
                                        break;
-                               case IS_BOOL:
-                                       if (Z_LVAL(op_array->literals[i])) {
-                                               if (l_true < 0) {
-                                                       l_true = j;
-                                                       if (i != j) {
-                                                               op_array->literals[j] = op_array->literals[i];
-                                                               info[j] = info[i];
-                                                       }
-                                                       j++;
+                               case IS_FALSE:
+                                       if (l_false < 0) {
+                                               l_false = j;
+                                               if (i != j) {
+                                                       op_array->literals[j] = op_array->literals[i];
+                                                       info[j] = info[i];
                                                }
-                                               map[i] = l_true;
-                                       } else {
-                                               if (l_false < 0) {
-                                                       l_false = j;
-                                                       if (i != j) {
-                                                               op_array->literals[j] = op_array->literals[i];
-                                                               info[j] = info[i];
-                                                       }
-                                                       j++;
+                                               j++;
+                                       }
+                                       map[i] = l_false;
+                                       break;
+                               case IS_TRUE:
+                                       if (l_true < 0) {
+                                               l_true = j;
+                                               if (i != j) {
+                                                       op_array->literals[j] = op_array->literals[i];
+                                                       info[j] = info[i];
                                                }
-                                               map[i] = l_false;
+                                               j++;
                                        }
+                                       map[i] = l_true;
                                        break;
                                case IS_LONG:
                                        if ((pos = (int)zend_hash_index_find_ptr(&hash, Z_LVAL(op_array->literals[i]))) != 0) {

diff --git a/ext/opcache/Optimizer/pass1_5.c b/ext/opcache/Optimizer/pass1_5.c
index cae7e80375a76ac5b94a75c1c97f1e9bb4d2f2c4..2ec39319073dba02dc67d89670d3831cad2c50bb 100644 (file)
--- a/ext/opcache/Optimizer/pass1_5.c
+++ b/ext/opcache/Optimizer/pass1_5.c
@@ -82,7 +82,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
                                        case IS_NULL:
                                                convert_to_null(&res);
                                                break;
-                                       case IS_BOOL:
+                                       case _IS_BOOL:
                                                convert_to_boolean(&res);
                                                break;
                                        case IS_LONG:
@@ -104,7 +104,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
                                } else /* if (opline->result_type == IS_VAR) */ {
                                        replace_var_by_const(op_array, opline + 1, tv, &res TSRMLS_CC);
                                }
-                       } else if (opline->extended_value == IS_BOOL) {
+                       } else if (opline->extended_value == _IS_BOOL) {
                                /* T = CAST(X, IS_BOOL) => T = BOOL(X) */
                                opline->opcode = ZEND_BOOL;
                                opline->extended_value = 0;
@@ -327,8 +327,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
                            zend_binary_strcasecmp(Z_STRVAL(ZEND_OP1_LITERAL(opline)), Z_STRLEN(ZEND_OP1_LITERAL(opline)), "define", sizeof("define")-1) == 0 &&
                            (opline-1)->opcode == ZEND_SEND_VAL &&
                            ZEND_OP1_TYPE(opline-1) == IS_CONST &&
-                           (Z_TYPE(ZEND_OP1_LITERAL(opline-1)) <= IS_BOOL ||
-                            Z_TYPE(ZEND_OP1_LITERAL(opline-1)) == IS_STRING) &&
+                           Z_TYPE(ZEND_OP1_LITERAL(opline-1)) <= IS_STRING &&
                            (opline-2)->opcode == ZEND_SEND_VAL &&
                            ZEND_OP1_TYPE(opline-2) == IS_CONST &&
                            Z_TYPE(ZEND_OP1_LITERAL(opline-2)) == IS_STRING) {
@@ -449,8 +448,7 @@ if (ZEND_OPTIMIZER_PASS_1 & OPTIMIZATION_LEVEL) {
                case ZEND_DECLARE_CONST:
                        if (collect_constants &&
                            Z_TYPE(ZEND_OP1_LITERAL(opline)) == IS_STRING &&
-                           (Z_TYPE(ZEND_OP2_LITERAL(opline)) <= IS_BOOL ||
-                            Z_TYPE(ZEND_OP2_LITERAL(opline)) == IS_STRING)) {
+                           Z_TYPE(ZEND_OP2_LITERAL(opline)) <= IS_STRING) {
                                zend_optimizer_collect_constant(constants, &ZEND_OP1_LITERAL(opline), &ZEND_OP2_LITERAL(opline));
                        }
                        break;

diff --git a/ext/opcache/ZendAccelerator.c b/ext/opcache/ZendAccelerator.c
index bf951ff72a4aa62c76dbb5e8ea2e5a47096396d9..11a1dc2ce776e89e6c0492aa82eec9e761877c02 100644 (file)
--- a/ext/opcache/ZendAccelerator.c
+++ b/ext/opcache/ZendAccelerator.c
@@ -2250,7 +2250,8 @@ static void accel_fast_zval_dtor(zval *zvalue)
                                break;
                        case IS_LONG:
                        case IS_DOUBLE:
-                       case IS_BOOL:
+                       case IS_FALSE:
+                       case IS_TRUE:
                        case IS_NULL:
                        case IS_STRING:
                        case IS_CONSTANT:

diff --git a/ext/pdo/pdo_dbh.c b/ext/pdo/pdo_dbh.c
index 73431049d668dc8af1081b3bab7b33ff51c0b3b4..d75ae21dcdf90b43521b234060f1c18d2948336d 100644 (file)
--- a/ext/pdo/pdo_dbh.c
+++ b/ext/pdo/pdo_dbh.c
@@ -695,7 +695,7 @@ static int pdo_dbh_attribute_set(pdo_dbh_t *dbh, long attr, zval *value TSRMLS_D
 {
 
 #define PDO_LONG_PARAM_CHECK \
-       if (Z_TYPE_P(value) != IS_LONG && Z_TYPE_P(value) != IS_STRING && Z_TYPE_P(value) != IS_BOOL) { \
+       if (Z_TYPE_P(value) != IS_LONG && Z_TYPE_P(value) != IS_STRING && Z_TYPE_P(value) != IS_FALSE && Z_TYPE_P(value) != IS_TRUE) { \
                pdo_raise_impl_error(dbh, NULL, "HY000", "attribute value must be an integer" TSRMLS_CC); \
                PDO_HANDLE_DBH_ERR(); \
                return FAILURE; \

diff --git a/ext/pdo/pdo_sql_parser.c b/ext/pdo/pdo_sql_parser.c
index be2fa35501478e8fa7d3ad56a2a482a8268ae7cb..4420fcf97c3eb60821e8d89995e5969b970981d5 100644 (file)
--- a/ext/pdo/pdo_sql_parser.c
+++ b/ext/pdo/pdo_sql_parser.c
@@ -594,7 +594,8 @@ safe:
                                                        plc->freeq = 0;
                                                        break;
 
-                                               case IS_BOOL:
+                                               case IS_FALSE:
+                                               case IS_TRUE:
                                                        convert_to_long(&tmp_param);
                                                        /* fall through */
                                                case IS_LONG:

diff --git a/ext/pdo/pdo_sql_parser.re b/ext/pdo/pdo_sql_parser.re
index e182bf65d1ac208302ba32696ed2a1676c35589d..883a22c7ff02edf7a945269bf4e77e86ec27fb75 100644 (file)
--- a/ext/pdo/pdo_sql_parser.re
+++ b/ext/pdo/pdo_sql_parser.re
@@ -236,7 +236,8 @@ safe:
                                                        plc->freeq = 0;
                                                        break;
 
-                                               case IS_BOOL:
+                                               case IS_FALSE:
+                                               case IS_TRUE:
                                                        convert_to_long(&tmp_param);
                                                        /* fall through */
                                                case IS_LONG:

diff --git a/ext/pdo/pdo_stmt.c b/ext/pdo/pdo_stmt.c
index 8ec246926c532b5120280f6d0589c38ab442029b..3fbe29cc762557d8bfa85701cb9e52fe475bbe7d 100644 (file)
--- a/ext/pdo/pdo_stmt.c
+++ b/ext/pdo/pdo_stmt.c
@@ -327,7 +327,7 @@ static int really_register_bound_param(struct pdo_bound_param_data *param, pdo_s
                } else {
                        convert_to_string(parameter);
                }
-       } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_INT && Z_TYPE_P(parameter) == IS_BOOL) {
+       } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_INT && (Z_TYPE_P(parameter) == IS_FALSE || Z_TYPE_P(parameter) == IS_TRUE)) {
                convert_to_long(parameter);
        } else if (PDO_PARAM_TYPE(param->param_type) == PDO_PARAM_BOOL && Z_TYPE_P(parameter) == IS_LONG) {
                convert_to_boolean(parameter);

diff --git a/ext/reflection/php_reflection.c b/ext/reflection/php_reflection.c
index c3f02fe079c6f32fceab7cb016347b1e96b8a8fc..f16c39272d190a1ec30c4053b7a11a0b24b2bf16 100644 (file)
--- a/ext/reflection/php_reflection.c
+++ b/ext/reflection/php_reflection.c
@@ -725,12 +725,10 @@ static void _parameter_string(string *str, zend_function *fptr, struct _zend_arg
                        string_write(str, " = ", sizeof(" = ")-1);
                        ZVAL_DUP(&zv, precv->op2.zv);
                        zval_update_constant_ex(&zv, 1, fptr->common.scope TSRMLS_CC);
-                       if (Z_TYPE(zv) == IS_BOOL) {
-                               if (Z_LVAL(zv)) {
-                                       string_write(str, "true", sizeof("true")-1);
-                               } else {
-                                       string_write(str, "false", sizeof("false")-1);
-                               }
+                       if (Z_TYPE(zv) == IS_TRUE) {
+                               string_write(str, "true", sizeof("true")-1);
+                       } else if (Z_TYPE(zv) == IS_FALSE) {
+                               string_write(str, "false", sizeof("false")-1);
                        } else if (Z_TYPE(zv) == IS_NULL) {
                                string_write(str, "NULL", sizeof("NULL")-1);
                        } else if (Z_TYPE(zv) == IS_STRING) {

diff --git a/ext/session/session.c b/ext/session/session.c
index 8784016db615de621ae93664e51163158f660eed..f910d0cf3776d220ec1b82dc378ca6351d0b14d9 100644 (file)
--- a/ext/session/session.c
+++ b/ext/session/session.c
@@ -2598,7 +2598,7 @@ static zend_bool php_check_cancel_upload(php_session_rfc1867_progress *progress
        if ((cancel_upload = zend_hash_str_find(Z_ARRVAL_P(progress_ary), "cancel_upload", sizeof("cancel_upload") - 1)) == NULL) {
                return 0;
        }
-       return Z_TYPE_P(cancel_upload) == IS_BOOL && Z_LVAL_P(cancel_upload);
+       return Z_TYPE_P(cancel_upload) == IS_TRUE;
 } /* }}} */
 
 static void php_session_rfc1867_update(php_session_rfc1867_progress *progress, int force_update TSRMLS_DC) /* {{{ */

diff --git a/ext/simplexml/simplexml.c b/ext/simplexml/simplexml.c
index 31beb1a9f089ad6203a2ee34771d92e298ae8d18..403b7afc4e1ab18184d6b6016526d62f0ef5fe68 100644 (file)
--- a/ext/simplexml/simplexml.c
+++ b/ext/simplexml/simplexml.c
@@ -411,7 +411,8 @@ static void change_node_zval(xmlNodePtr node, zval *value TSRMLS_DC)
        }
        switch (Z_TYPE_P(value)) {
                case IS_LONG:
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                case IS_DOUBLE:
                case IS_NULL:
                        if (Z_REFCOUNT_P(value) > 1) {
@@ -525,7 +526,8 @@ static int sxe_prop_dim_write(zval *object, zval *member, zval *value, zend_bool
        if (value) {
                switch (Z_TYPE_P(value)) {
                        case IS_LONG:
-                       case IS_BOOL:
+                       case IS_FALSE:
+                       case IS_TRUE:
                        case IS_DOUBLE:
                        case IS_NULL:
                                convert_to_string(value);
@@ -1754,7 +1756,7 @@ static int cast_object(zval *object, int type, char *contents TSRMLS_DC)
                case IS_STRING:
                        convert_to_string(object);
                        break;
-               case IS_BOOL:
+               case _IS_BOOL:
                        convert_to_boolean(object);
                        break;
                case IS_LONG:
@@ -1782,7 +1784,7 @@ static int sxe_object_cast(zval *readobj, zval *writeobj, int type TSRMLS_DC)
 
        sxe = Z_SXEOBJ_P(readobj);
 
-       if (type == IS_BOOL) {
+       if (type == _IS_BOOL) {
                node = php_sxe_get_first_node(sxe, NULL TSRMLS_CC);
                prop_hash = sxe_get_prop_hash(readobj, 1 TSRMLS_CC);
                ZVAL_BOOL(writeobj, node != NULL || zend_hash_num_elements(prop_hash) > 0);

diff --git a/ext/sockets/multicast.c b/ext/sockets/multicast.c
index dc3151a137ba9f89437894248831ba2a47d92f80..ec8e16ce45f31893b6e5f660760462811c1a5ea0 100644 (file)
--- a/ext/sockets/multicast.c
+++ b/ext/sockets/multicast.c
@@ -282,6 +282,7 @@ int php_do_setsockopt_ip_mcast(php_socket *php_sock,
 
        case IP_MULTICAST_LOOP:
                convert_to_boolean_ex(arg4);
+               ipv4_mcast_ttl_lback = (unsigned char) (Z_TYPE_PP(arg4) == IS_TRUE);
                goto ipv4_loop_ttl;
 
        case IP_MULTICAST_TTL:
@@ -291,8 +292,8 @@ int php_do_setsockopt_ip_mcast(php_socket *php_sock,
                                        "Expected a value between 0 and 255");
                        return FAILURE;
                }
-ipv4_loop_ttl:
                ipv4_mcast_ttl_lback = (unsigned char) Z_LVAL_PP(arg4);
+ipv4_loop_ttl:
                opt_ptr = &ipv4_mcast_ttl_lback;
                optlen  = sizeof(ipv4_mcast_ttl_lback);
                goto dosockopt;
@@ -347,6 +348,7 @@ int php_do_setsockopt_ipv6_mcast(php_socket *php_sock,
 
        case IPV6_MULTICAST_LOOP:
                convert_to_boolean_ex(arg4);
+               ov = (int) Z_TYPE_PP(arg4) == IS_TRUE;
                goto ipv6_loop_hops;
        case IPV6_MULTICAST_HOPS:
                convert_to_long_ex(arg4);
@@ -355,8 +357,8 @@ int php_do_setsockopt_ipv6_mcast(php_socket *php_sock,
                                        "Expected a value between -1 and 255");
                        return FAILURE;
                }
-ipv6_loop_hops:
                ov = (int) Z_LVAL_PP(arg4);
+ipv6_loop_hops:
                opt_ptr = &ov;
                optlen  = sizeof(ov);
                goto dosockopt;

diff --git a/ext/spl/spl_array.c b/ext/spl/spl_array.c
index 0baba586ced0b339c8f3938ffa8f7a1f92ab826e..67b4f886c67e8c9b212e87e10d22dd8be793b654 100644 (file)
--- a/ext/spl/spl_array.c
+++ b/ext/spl/spl_array.c
@@ -366,7 +366,12 @@ fetch_dim_string:
        case IS_DOUBLE:
                index = (long)Z_DVAL_P(offset);
                goto num_index;
-       case IS_BOOL:
+       case IS_FALSE:
+               index = 0;
+               goto num_index;
+       case IS_TRUE:
+               index = 1;
+               goto num_index;
        case IS_LONG:
                index = Z_LVAL_P(offset);
 num_index:
@@ -488,19 +493,25 @@ static void spl_array_write_dimension_ex(int check_inherited, zval *object, zval
                        zend_symtable_update_ind(ht, Z_STR_P(offset), value);
                        return;
                case IS_DOUBLE:
+                       index = (long)Z_DVAL_P(offset);
+                       goto num_index;
                case IS_RESOURCE:
-               case IS_BOOL:
+                       index = Z_RES_HANDLE_P(offset);
+                       goto num_index;
+               case IS_FALSE:
+                       index = 0;
+                       goto num_index;
+               case IS_TRUE:
+                       index = 1;
+                       goto num_index;
                case IS_LONG:
+                       index = Z_LVAL_P(offset);
+num_index:
                        ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
                        if (ht->u.v.nApplyCount > 0) {
                                zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
                                return;
                        }
-                       if (Z_TYPE_P(offset) == IS_DOUBLE) {
-                               index = (long)Z_DVAL_P(offset);
-                       } else {
-                               index = Z_LVAL_P(offset);
-                       }
                        zend_hash_index_update(ht, index, value);
                        return;
                case IS_NULL:
@@ -574,21 +585,27 @@ static void spl_array_unset_dimension_ex(int check_inherited, zval *object, zval
                }
                break;
        case IS_DOUBLE:
+               index = (long)Z_DVAL_P(offset);
+               goto num_index;
        case IS_RESOURCE:
-       case IS_BOOL:
+               index = Z_RES_HANDLE_P(offset);
+               goto num_index;
+       case IS_FALSE:
+               index = 0;
+               goto num_index;
+       case IS_TRUE:
+               index = 1;
+               goto num_index;
        case IS_LONG:
-               if (Z_TYPE_P(offset) == IS_DOUBLE) {
-                       index = (long)Z_DVAL_P(offset);
-               } else {
-                       index = Z_LVAL_P(offset);
-               }
+               index = Z_LVAL_P(offset);
+num_index:
                ht = spl_array_get_hash_table(intern, 0 TSRMLS_CC);
                if (ht->u.v.nApplyCount > 0) {
                        zend_error(E_WARNING, "Modification of ArrayObject during sorting is prohibited");
                        return;
                }
                if (zend_hash_index_del(ht, index) == FAILURE) {
-                       zend_error(E_NOTICE,"Undefined offset: %ld", Z_LVAL_P(offset));
+                       zend_error(E_NOTICE,"Undefined offset: %ld", index);
                }
                break;
        default:
@@ -646,14 +663,20 @@ static int spl_array_has_dimension_ex(int check_inherited, zval *object, zval *o
                                }
                                break;
                        case IS_DOUBLE:
+                               index = (long)Z_DVAL_P(offset);
+                               goto num_index;
                        case IS_RESOURCE:
-                       case IS_BOOL: 
+                               index = Z_RES_HANDLE_P(offset);
+                               goto num_index;
+                       case IS_FALSE: 
+                               index = 0;
+                               goto num_index;
+                       case IS_TRUE: 
+                               index = 1;
+                               goto num_index;
                        case IS_LONG:
-                               if (Z_TYPE_P(offset) == IS_DOUBLE) {
-                                       index = (long)Z_DVAL_P(offset);
-                               } else {
-                                       index = Z_LVAL_P(offset);
-                               }
+                               index = Z_LVAL_P(offset);
+num_index:
                                if ((tmp = zend_hash_index_find(ht, index)) != NULL) {
                                        if (check_empty == 2) {
                                                return 1;

diff --git a/ext/spl/spl_directory.c b/ext/spl/spl_directory.c
index ca6c4adbb2f527774e75b85a7d786b513e5ef0a4..07d3d83b8e854925af9be99c36e839b86935e638 100644 (file)
--- a/ext/spl/spl_directory.c
+++ b/ext/spl/spl_directory.c
@@ -265,7 +265,7 @@ static int spl_filesystem_file_open(spl_filesystem_object *intern, int use_inclu
        intern->type = SPL_FS_FILE;
 
        php_stat(intern->file_name, intern->file_name_len, FS_IS_DIR, &tmp TSRMLS_CC);
-       if (Z_LVAL(tmp)) {
+       if (Z_TYPE(tmp) == IS_TRUE) {
                intern->u.file.open_mode = NULL;
                intern->file_name = NULL;
                zend_throw_exception_ex(spl_ce_LogicException, 0 TSRMLS_CC, "Cannot use SplFileObject with directories");

diff --git a/ext/spl/spl_engine.c b/ext/spl/spl_engine.c
index 3d12b047993a86dd7590739ae85de5b23c9c864a..a2f36534327114a4346de72ee9fbdcf0147c5f23 100644 (file)
--- a/ext/spl/spl_engine.c
+++ b/ext/spl/spl_engine.c
@@ -48,10 +48,14 @@ PHPAPI long spl_offset_convert_to_long(zval *offset TSRMLS_DC) /* {{{ */
                break;
        case IS_DOUBLE:
                return (long)Z_DVAL_P(offset);
-       case IS_RESOURCE:
-       case IS_BOOL:
        case IS_LONG:
                return Z_LVAL_P(offset);
+       case IS_FALSE:
+               return 0;
+       case IS_TRUE:
+               return 1;
+       case IS_RESOURCE:
+               return Z_RES_HANDLE_P(offset);
        }
        return -1;
 } 

diff --git a/ext/spl/spl_iterators.c b/ext/spl/spl_iterators.c
index cb7024d0a3a9140863eadd76effd9758b850cf8e..6d74169f2463c0147fd7b6e5111b3d7721267863 100644 (file)
--- a/ext/spl/spl_iterators.c
+++ b/ext/spl/spl_iterators.c
@@ -977,7 +977,7 @@ static void spl_recursive_tree_iterator_get_prefix(spl_recursive_it_object *obje
        for (level = 0; level < object->level; ++level) {
                zend_call_method_with_0_params(&object->iterators[level].zobject, object->iterators[level].ce, NULL, "hasnext", &has_next);
                if (Z_TYPE(has_next) != IS_UNDEF) {
-                       if (Z_LVAL(has_next)) {
+                       if (Z_TYPE(has_next) == IS_TRUE) {
                                smart_str_appendl(&str, object->prefix[1].s->val, object->prefix[1].s->len);
                        } else {
                                smart_str_appendl(&str, object->prefix[2].s->val, object->prefix[2].s->len);
@@ -987,7 +987,7 @@ static void spl_recursive_tree_iterator_get_prefix(spl_recursive_it_object *obje
        }
        zend_call_method_with_0_params(&object->iterators[level].zobject, object->iterators[level].ce, NULL, "hasnext", &has_next);
        if (Z_TYPE(has_next) != IS_UNDEF) {
-               if (Z_LVAL(has_next)) {
+               if (Z_TYPE(has_next) == IS_TRUE) {
                        smart_str_appendl(&str, object->prefix[3].s->val, object->prefix[3].s->len);
                } else {
                        smart_str_appendl(&str, object->prefix[4].s->val, object->prefix[4].s->len);
@@ -2041,7 +2041,7 @@ SPL_METHOD(RegexIterator, accept)
        }
 
        if (intern->u.regex.flags & REGIT_INVERTED) {
-               RETVAL_BOOL(! Z_LVAL_P(return_value));
+               RETVAL_BOOL(Z_TYPE_P(return_value) != IS_TRUE);
        }
 
        if (use_copy) {

diff --git a/ext/spl/spl_observer.c b/ext/spl/spl_observer.c
index 4ddd86773e2e5e6d4cb95ee1784185a13a3108b8..110951d01547a109640d044528eaafca14541457 100644 (file)
--- a/ext/spl/spl_observer.c
+++ b/ext/spl/spl_observer.c
@@ -1064,7 +1064,7 @@ SPL_METHOD(MultipleIterator, attachIterator)
                zend_hash_internal_pointer_reset_ex(&intern->storage, &intern->pos);
                while ((element = zend_hash_get_current_data_ptr_ex(&intern->storage, &intern->pos)) != NULL) {
                        is_identical_function(&compare_result, info, &element->inf TSRMLS_CC);
-                       if (Z_LVAL(compare_result)) {
+                       if (Z_TYPE(compare_result) == IS_TRUE) {
                                zend_throw_exception(spl_ce_InvalidArgumentException, "Key duplication error", 0 TSRMLS_CC);
                                return;
                        }
@@ -1149,7 +1149,7 @@ SPL_METHOD(MultipleIterator, valid)
                zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
 
                if (!ZVAL_IS_UNDEF(&retval)) {
-                       valid = Z_LVAL(retval);
+                       valid = (Z_TYPE(retval) == IS_TRUE);
                        zval_ptr_dtor(&retval);
                } else {
                        valid = 0;
@@ -1185,7 +1185,7 @@ static void spl_multiple_iterator_get_all(spl_SplObjectStorage *intern, int get_
                zend_call_method_with_0_params(it, Z_OBJCE_P(it), &Z_OBJCE_P(it)->iterator_funcs.zf_valid, "valid", &retval);
 
                if (!ZVAL_IS_UNDEF(&retval)) {
-                       valid = Z_LVAL(retval);
+                       valid = Z_TYPE(retval) == IS_TRUE;
                        zval_ptr_dtor(&retval);
                } else {
                        valid = 0;

diff --git a/ext/standard/array.c b/ext/standard/array.c
index 3d587fa98ef383272b59eca7efdb3ea7578d49de..eb8a9cd325e50eb3df76ace1f3c3e151db0816d3 100644 (file)
--- a/ext/standard/array.c
+++ b/ext/standard/array.c
@@ -933,7 +933,7 @@ PHP_FUNCTION(min)
 
                for (i = 1; i < argc; i++) {
                        is_smaller_function(&result, &args[i], min TSRMLS_CC);
-                       if (Z_LVAL(result) == 1) {
+                       if (Z_TYPE(result) == IS_TRUE) {
                                min = &args[i];
                        }
                }
@@ -980,7 +980,7 @@ PHP_FUNCTION(max)
 
                for (i = 1; i < argc; i++) {
                        is_smaller_or_equal_function(&result, &args[i], max TSRMLS_CC);
-                       if (Z_LVAL(result) == 0) {
+                       if (Z_TYPE(result) == IS_FALSE) {
                                max = &args[i];
                        }
                }
@@ -1166,7 +1166,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{
        if (strict) {
                ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
                        is_identical_function(&res, value, entry TSRMLS_CC);
-                       if (Z_LVAL(res)) {
+                       if (Z_TYPE(res) == IS_TRUE) {
                                if (behavior == 0) {
                                        RETURN_TRUE;
                                } else {
@@ -1181,7 +1181,7 @@ static void php_search_array(INTERNAL_FUNCTION_PARAMETERS, int behavior) /* {{{
                } ZEND_HASH_FOREACH_END();
        } else {
                ZEND_HASH_FOREACH_KEY_VAL(Z_ARRVAL_P(array), num_idx, str_idx, entry) {
-                       if (fast_equal_function(&res, value, entry TSRMLS_CC)) {
+                       if (fast_equal_check_function(&res, value, entry TSRMLS_CC)) {
                                if (behavior == 0) {
                                        RETURN_TRUE;
                                } else {

diff --git a/ext/standard/assert.c b/ext/standard/assert.c
index dab747c172e3d42557fb8f7b857dface5ccfb63e..3ec73611978eb4559a1e622f10b478be04336f35 100644 (file)
--- a/ext/standard/assert.c
+++ b/ext/standard/assert.c
@@ -183,10 +183,10 @@ PHP_FUNCTION(assert)
                }
 
                convert_to_boolean(&retval);
-               val = Z_LVAL(retval);
+               val = Z_TYPE(retval) == IS_TRUE;
        } else {
                convert_to_boolean_ex(assertion);
-               val = Z_LVAL_P(assertion);
+               val = Z_TYPE_P(assertion) == IS_TRUE;
        }
 
        if (val) {

diff --git a/ext/standard/file.c b/ext/standard/file.c
index c14a0d7f97410b549c16dd35c863266fb8aaaa1c..f8c3e98108c9d106d72414045552dd6938d68268 100644 (file)
--- a/ext/standard/file.c
+++ b/ext/standard/file.c
@@ -634,7 +634,8 @@ PHP_FUNCTION(file_put_contents)
                case IS_NULL:
                case IS_LONG:
                case IS_DOUBLE:
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                        convert_to_string_ex(data);
 
                case IS_STRING:

diff --git a/ext/standard/filters.c b/ext/standard/filters.c
index a77ca7fda6503e5c0fb95efcae6d0d64100f56ba..d40321f959a6dcd9dbd5c2116652f5e8f9f46b42 100644 (file)
--- a/ext/standard/filters.c
+++ b/ext/standard/filters.c
@@ -1289,13 +1289,13 @@ static php_conv_err_t php_conv_get_bool_prop_ex(const HashTable *ht, int *pretva
        if ((tmpval = zend_hash_str_find((HashTable *)ht, field_name, field_name_len-1)) != NULL) {
                zval tmp;
 
-               if (Z_TYPE_P(tmpval) != IS_BOOL) {
+               if (Z_TYPE_P(tmpval) != IS_FALSE || Z_TYPE_P(tmpval) != IS_TRUE) {
                        ZVAL_DUP(&tmp, tmpval);
                        zval_copy_ctor(&tmp);
                        convert_to_boolean(&tmp);
                        tmpval = &tmp;
                }
-               *pretval = Z_BVAL_P(tmpval);
+               *pretval = (Z_TYPE_P(tmpval) == IS_TRUE);
        } else {
                return PHP_CONV_ERR_NOT_FOUND;
        } 

diff --git a/ext/standard/http.c b/ext/standard/http.c
index fbda5ccc9e546dd537808c723a8254584d78d459..20e4023fc7937c6085a5c97de06e69e638f3a4b0 100644 (file)
--- a/ext/standard/http.c
+++ b/ext/standard/http.c
@@ -183,7 +183,6 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
                                        }
                                        break;
                                case IS_LONG:
-                               case IS_BOOL:
                                        {
                                                char *ekey;
                                                int ekey_len;
@@ -192,6 +191,12 @@ PHPAPI int php_url_encode_hash_ex(HashTable *ht, smart_str *formstr,
                                                efree(ekey);
                                        }
                                        break;
+                               case IS_FALSE:
+                                       smart_str_appendl(formstr, "0", sizeof("0")-1);
+                                       break;
+                               case IS_TRUE:
+                                       smart_str_appendl(formstr, "1", sizeof("1")-1);
+                                       break;
                                case IS_DOUBLE:
                                        {
                                                char *ekey;

diff --git a/ext/standard/password.c b/ext/standard/password.c
index 738bdcc7ac06130bcc172c3ecc2f1057b4f0192b..aa50ab1f00008db98a4c8d34639480a52ba47efb 100644 (file)
--- a/ext/standard/password.c
+++ b/ext/standard/password.c
@@ -376,7 +376,8 @@ PHP_FUNCTION(password_hash)
                                }
                                zval_dtor(&cast_option_buffer);
                        }
-                       case IS_BOOL:
+                       case IS_FALSE:
+                       case IS_TRUE:
                        case IS_NULL:
                        case IS_RESOURCE:
                        case IS_ARRAY:

diff --git a/ext/standard/string.c b/ext/standard/string.c
index 67c8001b5b58dca3fd609f171f0124cd533a9c35..ebd667956a91e2b384dc178aab7e93f1290ac1b4 100644 (file)
--- a/ext/standard/string.c
+++ b/ext/standard/string.c
@@ -1146,13 +1146,12 @@ again:
                        }
                                break;
 
-                       case IS_BOOL:
-                               if (Z_LVAL_P(tmp) == 1) {
-                                       smart_str_appendl(&implstr, "1", sizeof("1")-1);
-                               }
+                       case IS_TRUE:
+                               smart_str_appendl(&implstr, "1", sizeof("1")-1);
                                break;
 
                        case IS_NULL:
+                       case IS_FALSE:
                                break;
 
                        case IS_DOUBLE: {
@@ -1648,12 +1647,15 @@ static int php_needle_char(zval *needle, char *target TSRMLS_DC)
 {
        switch (Z_TYPE_P(needle)) {
                case IS_LONG:
-               case IS_BOOL:
                        *target = (char)Z_LVAL_P(needle);
                        return SUCCESS;
                case IS_NULL:
+               case IS_FALSE:
                        *target = '\0';
                        return SUCCESS;
+               case IS_TRUE:
+                       *target = '\1';
+                       return SUCCESS;
                case IS_DOUBLE:
                        *target = (char)(int)Z_DVAL_P(needle);
                        return SUCCESS;

diff --git a/ext/standard/type.c b/ext/standard/type.c
index 1e3572c22f8f3f309f0f73a82043c6315f933a9a..5c7da45ae9821cef37bedfa597f02aa42ed23ef9 100644 (file)
--- a/ext/standard/type.c
+++ b/ext/standard/type.c
@@ -36,7 +36,8 @@ PHP_FUNCTION(gettype)
                        RETVAL_STRING("NULL");
                        break;
 
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                        RETVAL_STRING("boolean");
                        break;
 
@@ -258,7 +259,14 @@ PHP_FUNCTION(is_resource)
    Returns true if variable is a boolean */
 PHP_FUNCTION(is_bool)
 {
-       php_is_type(INTERNAL_FUNCTION_PARAM_PASSTHRU, IS_BOOL);
+       zval *arg;
+
+       if (zend_parse_parameters(ZEND_NUM_ARGS() TSRMLS_CC, "z", &arg) == FAILURE) {
+               RETURN_FALSE;
+       }
+
+       ZVAL_DEREF(arg);
+       RETURN_BOOL(Z_TYPE_P(arg) == IS_FALSE || Z_TYPE_P(arg) == IS_TRUE);
 }
 /* }}} */
 
@@ -344,7 +352,8 @@ PHP_FUNCTION(is_scalar)
        }
 
        switch (Z_TYPE_P(arg)) {
-               case IS_BOOL:
+               case IS_FALSE:
+               case IS_TRUE:
                case IS_DOUBLE:
                case IS_LONG:
                case IS_STRING:

diff --git a/ext/standard/user_filters.c b/ext/standard/user_filters.c
index 69453159030d53046134423193e781662362f360..23efacf5b8af97246c071d71999461a4931f9d24 100644 (file)
--- a/ext/standard/user_filters.c
+++ b/ext/standard/user_filters.c
@@ -363,7 +363,7 @@ static php_stream_filter *user_filter_factory_create(const char *filtername,
                        0, NULL TSRMLS_CC);
 
        if (Z_TYPE(retval) != IS_UNDEF) {
-               if (Z_TYPE(retval) == IS_BOOL && Z_LVAL(retval) == 0) {
+               if (Z_TYPE(retval) == IS_FALSE) {
                        /* User reported filter creation error "return false;" */
                        zval_ptr_dtor(&retval);
 

diff --git a/ext/standard/var.c b/ext/standard/var.c
index 3dbd71abd548371fa0b3939c13da40dfceae20ba..b2e11bc9fc99e75031456a359e576d81bf9575d8 100644 (file)
--- a/ext/standard/var.c
+++ b/ext/standard/var.c
@@ -129,8 +129,11 @@ PHPAPI void php_var_dump(zval *struc, int level TSRMLS_DC) /* {{{ */
 
 again:
        switch (Z_TYPE_P(struc)) {
-               case IS_BOOL:
-                       php_printf("%sbool(%s)\n", COMMON, Z_LVAL_P(struc) ? "true" : "false");
+               case IS_FALSE:
+                       php_printf("%sbool(false)\n", COMMON);
+                       break;
+               case IS_TRUE:
+                       php_printf("%sbool(true)\n", COMMON);
                        break;
                case IS_NULL:
                        php_printf("%sNULL\n", COMMON);
@@ -304,8 +307,11 @@ PHPAPI void php_debug_zval_dump(zval *struc, int level TSRMLS_DC) /* {{{ */
 
 again:
        switch (Z_TYPE_P(struc)) {
-       case IS_BOOL:
-               php_printf("%sbool(%s)\n", COMMON, Z_LVAL_P(struc)?"true":"false");
+       case IS_FALSE:
+               php_printf("%sbool(false)\n", COMMON);
+               break;
+       case IS_TRUE:
+               php_printf("%sbool(true)\n", COMMON);
                break;
        case IS_NULL:
                php_printf("%sNULL\n", COMMON);
@@ -491,12 +497,11 @@ PHPAPI void php_var_export_ex(zval *struc, int level, smart_str *buf TSRMLS_DC)
 
 again:
        switch (Z_TYPE_P(struc)) {
-               case IS_BOOL:
-                       if (Z_LVAL_P(struc)) {
-                               smart_str_appendl(buf, "true", 4);
-                       } else {
-                               smart_str_appendl(buf, "false", 5);
-                       }
+               case IS_FALSE:
+                       smart_str_appendl(buf, "false", 5);
+                       break;
+               case IS_TRUE:
+                       smart_str_appendl(buf, "true", 4);
                        break;
                case IS_NULL:
                        smart_str_appendl(buf, "NULL", 4);
@@ -828,10 +833,12 @@ static void php_var_serialize_intern(smart_str *buf, zval *struc, HashTable *var
 
 again:
        switch (Z_TYPE_P(struc)) {
-               case IS_BOOL:
-                       smart_str_appendl(buf, "b:", 2);
-                       smart_str_append_long(buf, Z_LVAL_P(struc));
-                       smart_str_appendc(buf, ';');
+               case IS_FALSE:
+                       smart_str_appendl(buf, "b:0;", 4);
+                       return;
+
+               case IS_TRUE:
+                       smart_str_appendl(buf, "b:1;", 4);
                        return;
 
                case IS_NULL:

diff --git a/ext/xmlrpc/xmlrpc-epi-php.c b/ext/xmlrpc/xmlrpc-epi-php.c
index 0d5d8b9d4c14a5d4906d62caee070463e9ddada7..3fb2ba6bb663174a246097e2fc52a77009299cc7 100644 (file)
--- a/ext/xmlrpc/xmlrpc-epi-php.c
+++ b/ext/xmlrpc/xmlrpc-epi-php.c
@@ -541,7 +541,7 @@ static XMLRPC_VALUE PHP_to_XMLRPC_worker (const char* key, zval* in_val, int dep
                                        break;
                                case xmlrpc_boolean:
                                        convert_to_boolean(val);
-                                       xReturn = XMLRPC_CreateValueBoolean(key, Z_LVAL_P(val));
+                                       xReturn = XMLRPC_CreateValueBoolean(key, Z_TYPE_P(val) == IS_TRUE);
                                        break;
                                case xmlrpc_int:
                                        convert_to_long(val);

diff --git a/main/output.c b/main/output.c
index 83225107e042e560865c6761360475db51378b5e..3dd647a9b263bb5d869cd5b8b0dd0780ed69be47 100644 (file)
--- a/main/output.c
+++ b/main/output.c
@@ -975,11 +975,11 @@ static inline php_output_handler_status_t php_output_handler_op(php_output_handl
                        ZVAL_LONG(&ob_mode, (long) context->op);
                        zend_fcall_info_argn(&handler->func.user->fci TSRMLS_CC, 2, &ob_data, &ob_mode);
 
-#define PHP_OUTPUT_USER_SUCCESS(retval) ((Z_TYPE(retval) != IS_UNDEF) && !(Z_TYPE(retval) == IS_BOOL && Z_BVAL(retval)==0))
+#define PHP_OUTPUT_USER_SUCCESS(retval) ((Z_TYPE(retval) != IS_UNDEF) && !(Z_TYPE(retval) == IS_FALSE))
                        if (SUCCESS == zend_fcall_info_call(&handler->func.user->fci, &handler->func.user->fcc, &retval, NULL TSRMLS_CC) && PHP_OUTPUT_USER_SUCCESS(retval)) {
                                /* user handler may have returned TRUE */
                                status = PHP_OUTPUT_HANDLER_NO_DATA;
-                               if (Z_TYPE(retval) != IS_BOOL) {
+                               if (Z_TYPE(retval) != IS_FALSE && Z_TYPE(retval) != IS_TRUE) {
                                        convert_to_string_ex(&retval);
                                        if (Z_STRLEN(retval)) {
                                                context->out.data = estrndup(Z_STRVAL(retval), Z_STRLEN(retval));

diff --git a/main/streams/userspace.c b/main/streams/userspace.c
index 7c6aa92316f9b18bff73a8cc6dc3e0cf1a0f784d..86104964fcfdc41207123d6b5625ef067abca027 100644 (file)
--- a/main/streams/userspace.c
+++ b/main/streams/userspace.c
@@ -915,7 +915,7 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
        case PHP_STREAM_OPTION_CHECK_LIVENESS:
                ZVAL_STRINGL(&func_name, USERSTREAM_EOF, sizeof(USERSTREAM_EOF)-1);
                call_result = call_user_function_ex(NULL, ZVAL_IS_UNDEF(&us->object)? NULL : &us->object, &func_name, &retval, 0, NULL, 0, NULL TSRMLS_CC);
-               if (call_result == SUCCESS && Z_TYPE(retval) == IS_BOOL) {
+               if (call_result == SUCCESS && (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE)) {
                        ret = zval_is_true(&retval) ? PHP_STREAM_OPTION_RETURN_ERR : PHP_STREAM_OPTION_RETURN_OK;
                } else {
                        ret = PHP_STREAM_OPTION_RETURN_ERR;
@@ -954,8 +954,8 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
                                                &retval,
                                                1, args, 0, NULL TSRMLS_CC);
 
-               if (call_result == SUCCESS && Z_TYPE(retval) == IS_BOOL) {
-                       ret = !Z_LVAL(retval);
+               if (call_result == SUCCESS && (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE)) {
+                       ret = (Z_TYPE(retval) == IS_FALSE);
                } else if (call_result == FAILURE) {
                        if (value == 0) {
                                /* lock support test (TODO: more check) */
@@ -995,8 +995,8 @@ static int php_userstreamop_set_option(php_stream *stream, int option, int value
                                                                &retval,
                                                                1, args, 0, NULL TSRMLS_CC);
                                if (call_result == SUCCESS && Z_TYPE(retval) != IS_UNDEF) {
-                                       if (Z_TYPE(retval) == IS_BOOL) {
-                                               ret = Z_LVAL(retval) ? PHP_STREAM_OPTION_RETURN_OK :
+                                       if (Z_TYPE(retval) == IS_FALSE || Z_TYPE(retval) == IS_TRUE) {
+                                               ret = (Z_TYPE(retval) == IS_TRUE) ? PHP_STREAM_OPTION_RETURN_OK :
                                                                                           PHP_STREAM_OPTION_RETURN_ERR;
                                        } else {
                                                php_error_docref(NULL TSRMLS_CC, E_WARNING,
@@ -1110,8 +1110,8 @@ static int user_wrapper_unlink(php_stream_wrapper *wrapper, const char *url, int
                        1, args,
                        0, NULL TSRMLS_CC);
 
-       if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
-               ret = Z_LVAL(zretval);
+       if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
+               ret = (Z_TYPE(zretval) == IS_TRUE);
        } else if (call_result == FAILURE) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_UNLINK " is not implemented!", uwrap->classname);
        }
@@ -1156,8 +1156,8 @@ static int user_wrapper_rename(php_stream_wrapper *wrapper, const char *url_from
                        2, args,
                        0, NULL TSRMLS_CC);
 
-       if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
-               ret = Z_LVAL(zretval);
+       if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
+               ret = (Z_TYPE(zretval) == IS_TRUE);
        } else if (call_result == FAILURE) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_RENAME " is not implemented!", uwrap->classname);
        }
@@ -1203,8 +1203,8 @@ static int user_wrapper_mkdir(php_stream_wrapper *wrapper, const char *url, int
                        3, args,
                        0, NULL TSRMLS_CC);
 
-       if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
-               ret = Z_LVAL(zretval);
+       if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
+               ret = (Z_TYPE(zretval) == IS_TRUE);
        } else if (call_result == FAILURE) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_MKDIR " is not implemented!", uwrap->classname);
        }
@@ -1250,8 +1250,8 @@ static int user_wrapper_rmdir(php_stream_wrapper *wrapper, const char *url,
                        2, args,
                        0, NULL TSRMLS_CC);
 
-       if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
-               ret = Z_LVAL(zretval);
+       if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
+               ret = (Z_TYPE(zretval) == IS_TRUE);
        } else if (call_result == FAILURE) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_RMDIR " is not implemented!", uwrap->classname);
        }
@@ -1321,8 +1321,8 @@ static int user_wrapper_metadata(php_stream_wrapper *wrapper, const char *url, i
                        3, args,
                        0, NULL TSRMLS_CC);
 
-       if (call_result == SUCCESS && Z_TYPE(zretval) == IS_BOOL) {
-               ret = Z_LVAL(zretval);
+       if (call_result == SUCCESS && (Z_TYPE(zretval) == IS_FALSE || Z_TYPE(zretval) == IS_TRUE)) {
+               ret = Z_TYPE(zretval) == IS_TRUE;
        } else if (call_result == FAILURE) {
                php_error_docref(NULL TSRMLS_CC, E_WARNING, "%s::" USERSTREAM_METADATA " is not implemented!", uwrap->classname);
        }
@@ -1414,7 +1414,7 @@ static size_t php_userstreamop_readdir(php_stream *stream, char *buf, size_t cou
                        0, NULL,
                        0, NULL TSRMLS_CC);
 
-       if (call_result == SUCCESS && Z_TYPE(retval) != IS_BOOL) {
+       if (call_result == SUCCESS && Z_TYPE(retval) != IS_FALSE && Z_TYPE(retval) != IS_TRUE) {
                convert_to_string(&retval);
                PHP_STRLCPY(ent->d_name, Z_STRVAL(retval), sizeof(ent->d_name), Z_STRLEN(retval));
 

diff --git a/sapi/cli/php_cli_server.c b/sapi/cli/php_cli_server.c
index ccbbf0521bacb1110a850505c92e9edcdedb918c..5a83693f56fefe9607beed8c02c10f7b6d164123 100644 (file)
--- a/sapi/cli/php_cli_server.c
+++ b/sapi/cli/php_cli_server.c
@@ -2128,7 +2128,7 @@ static int php_cli_server_dispatch_router(php_cli_server *server, php_cli_server
                zval retval;
                if (SUCCESS == zend_execute_scripts(ZEND_REQUIRE TSRMLS_CC, &retval, 1, &zfd)) {
                        if (Z_TYPE(retval) != IS_UNDEF) {
-                               decline = Z_TYPE(retval) == IS_BOOL && !Z_LVAL(retval);
+                               decline = Z_TYPE(retval) == IS_FALSE;
                                zval_ptr_dtor(&retval);
                        }
                } else {